Eliminate usages of old sugared call syntax

278 files changed, 1538 insertions, 1537 deletions

diff --git a/src/cargo/cargo.rs b/src/cargo/cargo.rs
index 3a12e42f626..e8cc605fbdd 100644
--- a/src/cargo/cargo.rs
+++ b/src/cargo/cargo.rs
@@ -1469,10 +1469,10 @@ fn print_source(s: source) {
     }, copy s.packages);
     let l = vec::len(pks);
 
-    print(io::with_str_writer() { |writer|
+    print(io::with_str_writer({ |writer|
         let mut list = "   >> ";
 
-        vec::iteri(pks) { |i, pk|
+        do vec::iteri(pks) { |i, pk|
             if str::len(list) > 78u {
                 writer.write_line(list);
                 list = "   >> ";
@@ -1481,14 +1481,14 @@ fn print_source(s: source) {
         }
 
         writer.write_line(list);
-    });
+    }));
 }
 
 fn cmd_list(c: cargo) {
     sync(c);
 
     if vec::len(c.opts.free) >= 3u {
-        vec::iter_between(c.opts.free, 2u, vec::len(c.opts.free)) { |name|
+        do vec::iter_between(c.opts.free, 2u, vec::len(c.opts.free)) { |name|
             if !valid_pkg_name(name) {
                 error(#fmt("'%s' is an invalid source name", name));
             } else {
diff --git a/src/compiletest/header.rs b/src/compiletest/header.rs
index 3f2ce9a0507..2810ffd139a 100644
--- a/src/compiletest/header.rs
+++ b/src/compiletest/header.rs
@@ -43,11 +43,11 @@ fn load_props(testfile: str) -> test_props {
             pp_exact = parse_pp_exact(ln, testfile);
         }
 
-        option::iter(parse_aux_build(ln)) {|ab|
+        do option::iter(parse_aux_build(ln)) {|ab|
             vec::push(aux_builds, ab);
         }
 
-        option::iter(parse_exec_env(ln)) {|ee|
+        do option::iter(parse_exec_env(ln)) {|ee|
             vec::push(exec_env, ee);
         }
     };
@@ -104,7 +104,7 @@ fn parse_compile_flags(line: str) -> option<str> {
 }
 
 fn parse_exec_env(line: str) -> option<(str, str)> {
-    parse_name_value_directive(line, "exec-env").map {|nv|
+    do parse_name_value_directive(line, "exec-env").map {|nv|
         // nv is either FOO or FOO=BAR
         let strs = str::splitn_char(nv, '=', 1u);
         alt strs.len() {
diff --git a/src/compiletest/procsrv.rs b/src/compiletest/procsrv.rs
index 5875f240110..dfe66b57a88 100644
--- a/src/compiletest/procsrv.rs
+++ b/src/compiletest/procsrv.rs
@@ -13,7 +13,7 @@ fn target_env(lib_path: str, prog: str) -> ~[(str,str)] {
     assert prog.ends_with(".exe");
     let aux_path = prog.slice(0u, prog.len() - 4u) + ".libaux";
 
-    env = vec::map(env) {|pair|
+    env = do vec::map(env) {|pair|
         let (k,v) = pair;
         if k == "PATH" { ("PATH", v + ";" + lib_path + ";" + aux_path) }
         else { (k,v) }
@@ -60,14 +60,14 @@ fn run(lib_path: str,
     writeclose(pipe_in.out, input);
     let p = comm::port();
     let ch = comm::chan(p);
-    task::spawn_sched(task::single_threaded) {||
+    do task::spawn_sched(task::single_threaded) {||
         let errput = readclose(pipe_err.in);
         comm::send(ch, (2, errput));
-    };
-    task::spawn_sched(task::single_threaded) {||
+    }
+    do task::spawn_sched(task::single_threaded) {||
         let output = readclose(pipe_out.in);
         comm::send(ch, (1, output));
-    };
+    }
     let status = run::waitpid(pid);
     let mut errs = "";
     let mut outs = "";
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index d13a5bca1d2..c7fcf1ca3f6 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -321,7 +321,7 @@ fn compose_and_run_compiler(
 
     let extra_link_args = ~["-L", aux_output_dir_name(config, testfile)];
 
-    vec::iter(props.aux_builds) {|rel_ab|
+    do vec::iter(props.aux_builds) {|rel_ab|
         let abs_ab = path::connect(config.aux_base, rel_ab);
         let aux_args =
             make_compile_args(config, props, ~["--lib"] + extra_link_args,
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 0cad0ab5142..2cbcfafb4f2 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -259,9 +259,9 @@ fn check_variants_T<T: copy>(
     let L = vec::len(things);
 
     if L < 100u {
-        under(uint::min(L, 20u)) {|i|
+        do under(uint::min(L, 20u)) {|i|
             log(error, "Replacing... #" + uint::str(i));
-            under(uint::min(L, 30u)) {|j|
+            do under(uint::min(L, 30u)) {|j|
                 log(error, "With... " + stringifier(@things[j]));
                 let crate2 = @replacer(crate, i, things[j], cx.mode);
                 // It would be best to test the *crate* for stability, but
@@ -421,7 +421,7 @@ fn parse_and_print(code: @str) -> str {
     write_file(filename, *code);
     let crate = parse::parse_crate_from_source_str(
         filename, code, ~[], sess);
-    io::with_str_reader(*code) { |rdr|
+    io::with_str_reader(*code, { |rdr|
         as_str({|a|pprust::print_crate(sess.cm,
                                        sess.span_diagnostic,
                                        crate,
@@ -429,7 +429,7 @@ fn parse_and_print(code: @str) -> str {
                                        rdr, a,
                                        pprust::no_ann(),
                                        false)})
-    }
+    })
 }
 
 fn has_raw_pointers(c: ast::crate) -> bool {
@@ -565,7 +565,7 @@ fn check_variants(files: ~[str], cx: context) {
             parse::parse_crate_from_source_str(
                 file,
                 s, ~[], sess);
-        io::with_str_reader(*s) { |rdr|
+        io::with_str_reader(*s, { |rdr|
             #error("%s",
                    as_str({|a|pprust::print_crate(sess.cm,
                                                   sess.span_diagnostic,
@@ -573,8 +573,8 @@ fn check_variants(files: ~[str], cx: context) {
                                                   file,
                                                   rdr, a,
                                                   pprust::no_ann(),
-                                                  false)}));
-        }
+                                                  false)}))
+        });
         check_variants_of_ast(*crate, sess.cm, file, cx);
     }
 }
diff --git a/src/libcore/arc.rs b/src/libcore/arc.rs
index 5aa1a71bfd6..7a74410dc61 100644
--- a/src/libcore/arc.rs
+++ b/src/libcore/arc.rs
@@ -109,9 +109,9 @@ impl methods<T: send> for exclusive<T> {
             unsafe::reinterpret_cast(self.data);
         let r = {
             let rec: &ex_data<T> = &(*ptr).data;
-            rec.lock.lock_cond() {|c|
+            rec.lock.lock_cond({|c|
                 f(c, &rec.data)
-            }
+            })
         };
         unsafe::forget(ptr);
         r
@@ -135,7 +135,7 @@ fn shared_arc<T: send const>(-data: T) -> shared_arc<T> {
     let a = arc::arc(data);
     let p = port();
     let c = chan(p);
-    task::spawn() {|move a|
+    do task::spawn() {|move a|
         let mut live = true;
         let terminate = port();
         let get = port();
@@ -174,7 +174,7 @@ mod tests {
         let p = port();
         let c = chan(p);
 
-        task::spawn() {||
+        do task::spawn() {||
             let p = port();
             c.send(chan(p));
 
@@ -200,7 +200,7 @@ mod tests {
         let p = port();
         let c = chan(p);
 
-        task::spawn() {||
+        do task::spawn() {||
             let arc_v = get_arc(arc_c);
             let v = *get(&arc_v);
             assert v[2] == 3;
@@ -225,7 +225,7 @@ mod tests {
             let total = total.clone();
             futures += ~[future::spawn({||
                 for uint::range(0u, count) {|_i|
-                    total.with {|_cond, count|
+                    do total.with {|_cond, count|
                         **count += 1u;
                     }
                 }
@@ -234,7 +234,7 @@ mod tests {
 
         for futures.each {|f| f.get() };
 
-        total.with {|_cond, total|
+        do total.with {|_cond, total|
             assert **total == num_tasks * count
         };
     }
diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs
index 42df0e29a99..131b09b2d43 100644
--- a/src/libcore/bool.rs
+++ b/src/libcore/bool.rs
@@ -65,7 +65,7 @@ pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 #[test]
 fn test_bool_from_str() {
-    all_values { |v|
+    do all_values { |v|
         assert some(v) == from_str(bool::to_str(v))
     }
 }
@@ -78,7 +78,7 @@ fn test_bool_to_str() {
 
 #[test]
 fn test_bool_to_bit() {
-    all_values { |v|
+    do all_values { |v|
         assert to_bit(v) == if is_true(v) { 1u8 } else { 0u8 };
     }
 }
diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index a3b7a89b978..894256872bf 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -98,7 +98,7 @@ class port_ptr<T:send> {
   let po: *rust_port;
   new(po: *rust_port) { self.po = po; }
   drop unsafe {
-    task::unkillable {||
+    do task::unkillable {||
         // Once the port is detached it's guaranteed not to receive further
         // messages
         let yield = 0u;
@@ -223,7 +223,7 @@ fn select2<A: send, B: send>(p_a: port<A>, p_b: port<B>)
 
     let mut resport: *rust_port;
     resport = rusti::init::<*rust_port>();
-    vec::as_buf(ports) {|ports|
+    do vec::as_buf(ports) {|ports|
         rustrt::rust_port_select(ptr::addr_of(resport), ports, n_ports,
                                  yieldp);
     }
@@ -364,16 +364,16 @@ fn test_select2_rendezvous() {
     let ch_a = chan(po_a);
     let ch_b = chan(po_b);
 
-    iter::repeat(10u) {||
-        task::spawn {||
-            iter::repeat(10u) {|| task::yield() }
+    do iter::repeat(10u) {||
+        do task::spawn {||
+            iter::repeat(10u, {|| task::yield() });
             send(ch_a, "a");
         };
 
         assert select2(po_a, po_b) == either::left("a");
 
-        task::spawn {||
-            iter::repeat(10u) {|| task::yield() }
+        do task::spawn {||
+            iter::repeat(10u, {|| task::yield() });
             send(ch_b, "b");
         };
 
@@ -391,14 +391,14 @@ fn test_select2_stress() {
     let msgs = 100u;
     let times = 4u;
 
-    iter::repeat(times) {||
-        task::spawn {||
-            iter::repeat(msgs) {||
+    do iter::repeat(times) {||
+        do task::spawn {||
+            do iter::repeat(msgs) {||
                 send(ch_a, "a")
             }
         };
-        task::spawn {||
-            iter::repeat(msgs) {||
+        do task::spawn {||
+            do iter::repeat(msgs) {||
                 send(ch_b, "b")
             }
         };
@@ -406,7 +406,7 @@ fn test_select2_stress() {
 
     let mut as = 0;
     let mut bs = 0;
-    iter::repeat(msgs * times * 2u) {||
+    do iter::repeat(msgs * times * 2u) {||
         alt check select2(po_a, po_b) {
           either::left("a") { as += 1 }
           either::right("b") { bs += 1 }
@@ -440,9 +440,9 @@ fn test_recv_chan_wrong_task() {
     let po = port();
     let ch = chan(po);
     send(ch, "flower");
-    assert result::is_err(task::try {||
+    assert result::is_err(task::try({||
         recv_chan(ch)
-    })
+    }))
 }
 
 #[test]
@@ -462,8 +462,8 @@ fn test_chan_peek() {
 
 #[test]
 fn test_listen() {
-    listen {|parent|
-        task::spawn {||
+    do listen {|parent|
+        do task::spawn {||
             parent.send("oatmeal-salad");
         }
         assert parent.recv() == "oatmeal-salad";
@@ -473,18 +473,18 @@ fn test_listen() {
 #[test]
 #[ignore(cfg(windows))]
 fn test_port_detach_fail() {
-    iter::repeat(100u) {||
+    do iter::repeat(100u) {||
         let builder = task::builder();
         task::unsupervise(builder);
-        task::run(builder) {||
+        do task::run(builder) {||
             let po = port();
             let ch = po.chan();
 
-            task::spawn {||
+            do task::spawn {||
                 fail;
             }
 
-            task::spawn {||
+            do task::spawn {||
                 ch.send(());
             }
         }
diff --git a/src/libcore/dvec.rs b/src/libcore/dvec.rs
index bf42465a113..5f1bc5c6ce9 100644
--- a/src/libcore/dvec.rs
+++ b/src/libcore/dvec.rs
@@ -114,12 +114,12 @@ impl extensions<A> for dvec<A> {
     "]
     #[inline(always)]
     fn swap(f: fn(-~[mut A]) -> ~[mut A]) {
-        self.borrow { |v| self.return(f(v)) }
+        self.borrow({ |v| self.return(f(v)) })
     }
 
     #[doc = "Returns the number of elements currently in the dvec"]
     fn len() -> uint {
-        self.borrow { |v|
+        do self.borrow { |v|
             let l = v.len();
             self.return(v);
             l
@@ -134,7 +134,7 @@ impl extensions<A> for dvec<A> {
 
     #[doc = "Remove and return the last element"]
     fn pop() -> A {
-        self.borrow { |v|
+        do self.borrow { |v|
             let mut v <- v;
             let result = vec::pop(v);
             self.return(v);
@@ -164,7 +164,7 @@ impl extensions<A> for dvec<A> {
 
     #[doc = "Remove and return the first element"]
     fn shift() -> A {
-        self.borrow { |v|
+        do self.borrow { |v|
             let mut v = vec::from_mut(v);
             let result = vec::shift(v);
             self.return(vec::to_mut(v));
@@ -187,7 +187,7 @@ impl extensions<A:copy> for dvec<A> {
         Appends elements from `from_idx` to `to_idx` (exclusive)
     "]
     fn push_slice(ts: &[const A], from_idx: uint, to_idx: uint) {
-        self.swap { |v|
+        do self.swap { |v|
             let mut v <- v;
             let new_len = vec::len(v) + to_idx - from_idx;
             vec::reserve(v, new_len);
@@ -207,7 +207,7 @@ impl extensions<A:copy> for dvec<A> {
         attempts to access this vector.
     "]
     fn append_iter<A, I:iter::base_iter<A>>(ts: I) {
-       self.swap { |v|
+       do self.swap { |v|
            let mut v = alt ts.size_hint() {
              none { v }
              some(h) {
@@ -229,7 +229,7 @@ impl extensions<A:copy> for dvec<A> {
         See `unwrap()` if you do not wish to copy the contents.
     "]
     fn get() -> ~[A] {
-        self.borrow { |v|
+        do self.borrow { |v|
             let w = vec::from_mut(copy v);
             self.return(v);
             w
@@ -259,7 +259,7 @@ impl extensions<A:copy> for dvec<A> {
     growing the vector if necessary.  New elements will be initialized
     with `initval`"]
     fn grow_set_elt(idx: uint, initval: A, val: A) {
-        self.swap { |v|
+        do self.swap { |v|
             let mut v <- v;
             vec::grow_set(v, idx, initval, val);
             v
diff --git a/src/libcore/future.rs b/src/libcore/future.rs
index a164f69ae5c..6c707d56dd7 100644
--- a/src/libcore/future.rs
+++ b/src/libcore/future.rs
@@ -64,7 +64,7 @@ fn from_port<A:send>(-port: comm::port<A>) -> future<A> {
     waiting for the result to be received on the port.
     "];
 
-    from_fn {||
+    do from_fn {||
         comm::recv(port)
     }
 }
@@ -93,7 +93,7 @@ fn spawn<A:send>(+blk: fn~() -> A) -> future<A> {
 
     let mut po = comm::port();
     let ch = comm::chan(po);
-    task::spawn {||
+    do task::spawn {||
         comm::send(ch, blk())
     };
     from_port(po)
@@ -102,7 +102,7 @@ fn spawn<A:send>(+blk: fn~() -> A) -> future<A> {
 fn get<A:copy>(future: future<A>) -> A {
     #[doc = "Get the value of the future"];
 
-    with(future) {|v| v }
+    do with(future) {|v| v }
 }
 
 fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
@@ -150,18 +150,18 @@ fn test_iface_get() {
 #[test]
 fn test_with() {
     let f = from_value("nail");
-    assert with(f) {|v| v} == "nail";
+    assert with(f, {|v| v}) == "nail";
 }
 
 #[test]
 fn test_iface_with() {
     let f = from_value("kale");
-    assert f.with {|v| v} == "kale";
+    assert f.with({|v| v}) == "kale";
 }
 
 #[test]
 fn test_spawn() {
-    let f = spawn {|| "bale" };
+    let f = spawn({|| "bale" });
     assert get(f) == "bale";
 }
 
@@ -169,6 +169,6 @@ fn test_spawn() {
 #[should_fail]
 #[ignore(cfg(target_os = "win32"))]
 fn test_futurefail() {
-    let f = spawn {|| fail };
+    let f = spawn({|| fail });
     let _x: str = get(f);
 }
diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs
index d60da7b4794..91f44e7067b 100644
--- a/src/libcore/int-template.rs
+++ b/src/libcore/int-template.rs
@@ -93,8 +93,8 @@ fn from_str(s: str) -> option<T> { parse_buf(str::bytes(s), 10u) }
 
 #[doc = "Convert to a string in a given base"]
 fn to_str(n: T, radix: uint) -> str {
-    to_str_bytes(n, radix) {|slice|
-        vec::unpack_slice(slice) {|p, len|
+    do to_str_bytes(n, radix) {|slice|
+        do vec::unpack_slice(slice) {|p, len|
             unsafe { str::unsafe::from_buf_len(p, len) }
         }
     }
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 4dde9748b75..316c4d45761 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -195,7 +195,7 @@ impl of reader for *libc::FILE {
     fn read_bytes(len: uint) -> ~[u8] {
         let mut buf : ~[mut u8] = ~[mut];
         vec::reserve(buf, len);
-        vec::as_mut_buf(buf) {|b|
+        do vec::as_mut_buf(buf) {|b|
             let read = libc::fread(b as *mut c_void, 1u as size_t,
                                    len as size_t, self);
             unsafe { vec::unsafe::set_len(buf, read as uint) };
@@ -308,7 +308,7 @@ fn str_reader(s: str) -> reader {
 }
 
 fn with_str_reader<T>(s: str, f: fn(reader) -> T) -> T {
-    str::as_bytes(s) { |bytes|
+    do str::as_bytes(s) { |bytes|
         with_bytes_reader_between(bytes, 0u, str::len(s), f)
     }
 }
@@ -334,7 +334,7 @@ impl <T: writer, C> of writer for {base: T, cleanup: C} {
 
 impl of writer for *libc::FILE {
     fn write(v: &[const u8]) {
-        vec::unpack_const_slice(v) {|vbuf, len|
+        do vec::unpack_const_slice(v) {|vbuf, len|
             let nout = libc::fwrite(vbuf as *c_void, len as size_t,
                                     1u as size_t, self);
             if nout < 1 as size_t {
@@ -363,7 +363,7 @@ fn FILE_writer(f: *libc::FILE, cleanup: bool) -> writer {
 impl of writer for fd_t {
     fn write(v: &[const u8]) {
         let mut count = 0u;
-        vec::unpack_const_slice(v) {|vbuf, len|
+        do vec::unpack_const_slice(v) {|vbuf, len|
             while count < len {
                 let vb = ptr::const_offset(vbuf, count) as *c_void;
                 let nout = libc::write(self, vb, len as size_t);
@@ -420,7 +420,7 @@ fn mk_file_writer(path: str, flags: ~[fileflag])
           no_flag { }
         }
     }
-    let fd = os::as_c_charp(path) {|pathbuf|
+    let fd = do os::as_c_charp(path) {|pathbuf|
         libc::open(pathbuf, fflags,
                    (S_IRUSR | S_IWUSR) as c_int)
     };
@@ -514,64 +514,64 @@ impl writer_util for writer {
             self.write_str(str::from_char(ch));
         }
     }
-    fn write_str(s: str/&) { str::byte_slice(s) {|v| self.write(v); } }
+    fn write_str(s: str/&) { str::byte_slice(s, {|v| self.write(v); }) }
     fn write_line(s: str/&) {
         self.write_str(s);
         self.write_str("\n"/&);
     }
     fn write_int(n: int) {
-        int::to_str_bytes(n, 10u) {|buf| self.write(buf) }
+        int::to_str_bytes(n, 10u, {|buf| self.write(buf) })
     }
     fn write_uint(n: uint) {
-        uint::to_str_bytes(false, n, 10u) {|buf| self.write(buf) }
+        uint::to_str_bytes(false, n, 10u, {|buf| self.write(buf) })
     }
     fn write_le_uint(n: uint, size: uint) {
-        u64_to_le_bytes(n as u64, size) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, size, {|v| self.write(v) })
     }
     fn write_le_int(n: int, size: uint) {
-        u64_to_le_bytes(n as u64, size) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, size, {|v| self.write(v) })
     }
     fn write_be_uint(n: uint, size: uint) {
-        u64_to_be_bytes(n as u64, size) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, size, {|v| self.write(v) })
     }
     fn write_be_int(n: int, size: uint) {
-        u64_to_be_bytes(n as u64, size) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, size, {|v| self.write(v) })
     }
     fn write_be_u64(n: u64) {
-        u64_to_be_bytes(n, 8u) {|v| self.write(v); }
+        u64_to_be_bytes(n, 8u, {|v| self.write(v) })
     }
     fn write_be_u32(n: u32) {
-        u64_to_be_bytes(n as u64, 4u) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, 4u, {|v| self.write(v) })
     }
     fn write_be_u16(n: u16) {
-        u64_to_be_bytes(n as u64, 2u) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, 2u, {|v| self.write(v) })
     }
     fn write_be_i64(n: i64) {
-        u64_to_be_bytes(n as u64, 8u) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, 8u, {|v| self.write(v) })
     }
     fn write_be_i32(n: i32) {
-        u64_to_be_bytes(n as u64, 4u) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, 4u, {|v| self.write(v) })
     }
     fn write_be_i16(n: i16) {
-        u64_to_be_bytes(n as u64, 2u) {|v| self.write(v); }
+        u64_to_be_bytes(n as u64, 2u, {|v| self.write(v) })
     }
     fn write_le_u64(n: u64) {
-        u64_to_le_bytes(n, 8u) {|v| self.write(v); }
+        u64_to_le_bytes(n, 8u, {|v| self.write(v) })
     }
     fn write_le_u32(n: u32) {
-        u64_to_le_bytes(n as u64, 4u) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, 4u, {|v| self.write(v) })
     }
     fn write_le_u16(n: u16) {
-        u64_to_le_bytes(n as u64, 2u) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, 2u, {|v| self.write(v) })
     }
     fn write_le_i64(n: i64) {
-        u64_to_le_bytes(n as u64, 8u) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, 8u, {|v| self.write(v) })
     }
     fn write_le_i32(n: i32) {
-        u64_to_le_bytes(n as u64, 4u) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, 4u, {|v| self.write(v) })
     }
     fn write_le_i16(n: i16) {
-        u64_to_le_bytes(n as u64, 2u) {|v| self.write(v); }
+        u64_to_le_bytes(n as u64, 2u, {|v| self.write(v) })
     }
 
     fn write_u8(n: u8) { self.write(&[n]) }
@@ -584,8 +584,8 @@ fn file_writer(path: str, flags: ~[fileflag]) -> result<writer, str> {
 
 // FIXME: fileflags // #2004
 fn buffered_file_writer(path: str) -> result<writer, str> {
-    let f = os::as_c_charp(path) {|pathbuf|
-        os::as_c_charp("w") {|modebuf|
+    let f = do os::as_c_charp(path) {|pathbuf|
+        do os::as_c_charp("w") {|modebuf|
             libc::fopen(pathbuf, modebuf)
         }
     };
diff --git a/src/libcore/iter-trait/dvec.rs b/src/libcore/iter-trait/dvec.rs
index c68134153cd..5f7058ec975 100644
--- a/src/libcore/iter-trait/dvec.rs
+++ b/src/libcore/iter-trait/dvec.rs
@@ -7,7 +7,7 @@ Attempts to access this dvec during iteration will fail.
 "]
 fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) {
     import dvec::extensions;
-    self.swap { |v| vec::each(v, f); v }
+    self.swap({ |v| vec::each(v, f); v })
 }
 
 fn SIZE_HINT<A>(self: IMPL_T<A>) -> option<uint> {
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 1c89ec19568..7466bc11bc3 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -28,7 +28,7 @@ fn any<A,IA:base_iter<A>>(self: IA, blk: fn(A) -> bool) -> bool {
 fn filter_to_vec<A:copy,IA:base_iter<A>>(self: IA,
                                          prd: fn(A) -> bool) -> ~[A] {
     let mut result = ~[];
-    self.size_hint().iter {|hint| vec::reserve(result, hint); }
+    self.size_hint().iter({|hint| vec::reserve(result, hint); });
     for self.each {|a|
         if prd(a) { vec::push(result, a); }
     }
@@ -37,7 +37,7 @@ fn filter_to_vec<A:copy,IA:base_iter<A>>(self: IA,
 
 fn map_to_vec<A:copy,B,IA:base_iter<A>>(self: IA, op: fn(A) -> B) -> ~[B] {
     let mut result = ~[];
-    self.size_hint().iter {|hint| vec::reserve(result, hint); }
+    self.size_hint().iter({|hint| vec::reserve(result, hint); });
     for self.each {|a|
         vec::push(result, op(a));
     }
@@ -76,7 +76,7 @@ fn contains<A,IA:base_iter<A>>(self: IA, x: A) -> bool {
 }
 
 fn count<A,IA:base_iter<A>>(self: IA, x: A) -> uint {
-    foldl(self, 0u) {|count, value|
+    do foldl(self, 0u) {|count, value|
         if value == x {
             count + 1u
         } else {
@@ -108,7 +108,7 @@ fn repeat(times: uint, blk: fn()) {
 }
 
 fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
-    alt foldl::<A,option<A>,IA>(self, none) {|a, b|
+    alt do foldl::<A,option<A>,IA>(self, none) {|a, b|
         alt a {
           some(a_) if a_ < b {
             // FIXME (#2005): Not sure if this is successfully optimized to
@@ -124,7 +124,7 @@ fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
 }
 
 fn max<A:copy,IA:base_iter<A>>(self: IA) -> A {
-    alt foldl::<A,option<A>,IA>(self, none) {|a, b|
+    alt do foldl::<A,option<A>,IA>(self, none) {|a, b|
         alt a {
           some(a_) if a_ > b {
             // FIXME (#2005): Not sure if this is successfully optimized to
diff --git a/src/libcore/newcomm.rs b/src/libcore/newcomm.rs
index 24c4c1cbd9c..2c45034feb2 100644
--- a/src/libcore/newcomm.rs
+++ b/src/libcore/newcomm.rs
@@ -31,7 +31,7 @@ fn chan<T: send>(p: port<T>) -> chan<T> {
 
 fn send<T: send>(c: chan<T>, -x: T) {
     let mut x <- some(x);
-    (*c).with {|cond, data|
+    do (*c).with {|cond, data|
         let mut xx = none;
         xx <-> x;
         (*data).push(option::unwrap(xx));
@@ -40,7 +40,7 @@ fn send<T: send>(c: chan<T>, -x: T) {
 }
 
 fn recv<T: send>(p: port<T>) -> T {
-    (*p).with {|cond, data|
+    do (*p).with {|cond, data|
         if (*data).len() == 0u {
             cond.wait();
         }
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index fe07198b422..39437656c93 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -133,10 +133,10 @@ fn test_unwrap_ptr() {
 #[test]
 fn test_unwrap_str() {
     let x = "test";
-    let addr_x = str::as_buf(x) {|buf| ptr::addr_of(buf) };
+    let addr_x = str::as_buf(x, {|buf| ptr::addr_of(buf) });
     let opt = some(x);
     let y = unwrap(opt);
-    let addr_y = str::as_buf(y) {|buf| ptr::addr_of(buf) };
+    let addr_y = str::as_buf(y, {|buf| ptr::addr_of(buf) });
     assert addr_x == addr_y;
 }
 
diff --git a/src/libcore/os.rs b/src/libcore/os.rs
index 5c3715b671f..bd5354a8625 100644
--- a/src/libcore/os.rs
+++ b/src/libcore/os.rs
@@ -64,13 +64,13 @@ fn env() -> ~[(str,str)] {
 const tmpbuf_sz : uint = 1000u;
 
 fn as_c_charp<T>(s: str, f: fn(*c_char) -> T) -> T {
-    str::as_c_str(s) {|b| f(b as *c_char) }
+    str::as_c_str(s, {|b| f(b as *c_char) })
 }
 
 fn fill_charp_buf(f: fn(*mut c_char, size_t) -> bool)
     -> option<str> {
     let buf = vec::to_mut(vec::from_elem(tmpbuf_sz, 0u8 as c_char));
-    vec::as_mut_buf(buf) { |b|
+    do vec::as_mut_buf(buf) { |b|
         if f(b, tmpbuf_sz as size_t) unsafe {
             some(str::unsafe::from_buf(b as *u8))
         } else {
@@ -95,7 +95,7 @@ mod win32 {
         let mut done = false;
         while !done {
             let buf = vec::to_mut(vec::from_elem(n as uint, 0u16));
-            vec::as_mut_buf(buf) {|b|
+            do vec::as_mut_buf(buf) {|b|
                 let k : dword = f(b, tmpbuf_sz as dword);
                 if k == (0 as dword) {
                     done = true;
@@ -182,7 +182,7 @@ mod global_env {
 
     fn global_env_task(msg_po: comm::port<msg>) {
         unsafe {
-            priv::weaken_task {|weak_po|
+            do priv::weaken_task {|weak_po|
                 loop {
                     alt comm::select2(msg_po, weak_po) {
                       either::left(msg_getenv(n, resp_ch)) {
@@ -220,8 +220,8 @@ mod global_env {
             import libc::types::os::arch::extra::*;
             import libc::funcs::extra::kernel32::*;
             import win32::*;
-            as_utf16_p(n) {|u|
-                fill_utf16_buf_and_decode() {|buf, sz|
+            do as_utf16_p(n) {|u|
+                do fill_utf16_buf_and_decode() {|buf, sz|
                     GetEnvironmentVariableW(u, buf, sz)
                 }
             }
@@ -233,8 +233,8 @@ mod global_env {
 
             // FIXME: remove this when export globs work properly. #1238
             import libc::funcs::posix01::unistd::setenv;
-            str::as_c_str(n) {|nbuf|
-                str::as_c_str(v) {|vbuf|
+            do str::as_c_str(n) {|nbuf|
+                do str::as_c_str(v) {|vbuf|
                     setenv(nbuf, vbuf, 1i32);
                 }
             }
@@ -246,8 +246,8 @@ mod global_env {
             // FIXME: remove imports when export globs work properly. #1238
             import libc::funcs::extra::kernel32::*;
             import win32::*;
-            as_utf16_p(n) {|nbuf|
-                as_utf16_p(v) {|vbuf|
+            do as_utf16_p(n) {|nbuf|
+                do as_utf16_p(v) {|vbuf|
                     SetEnvironmentVariableW(nbuf, vbuf);
                 }
             }
@@ -257,7 +257,7 @@ mod global_env {
 }
 
 fn fdopen(fd: c_int) -> *FILE {
-    ret as_c_charp("r") {|modebuf|
+    ret do as_c_charp("r") {|modebuf|
         libc::fdopen(fd, modebuf)
     };
 }
@@ -370,7 +370,7 @@ fn self_exe_path() -> option<path> {
         unsafe {
             import libc::funcs::bsd44::*;
             import libc::consts::os::extra::*;
-            fill_charp_buf() {|buf, sz|
+            do fill_charp_buf() {|buf, sz|
                 let mib = ~[CTL_KERN as c_int,
                            KERN_PROC as c_int,
                            KERN_PROC_PATHNAME as c_int, -1 as c_int];
@@ -384,8 +384,8 @@ fn self_exe_path() -> option<path> {
     #[cfg(target_os = "linux")]
     fn load_self() -> option<path> {
         import libc::funcs::posix01::unistd::readlink;
-        fill_charp_buf() {|buf, sz|
-            as_c_charp("/proc/self/exe") { |proc_self_buf|
+        do fill_charp_buf() {|buf, sz|
+            do as_c_charp("/proc/self/exe") { |proc_self_buf|
                 readlink(proc_self_buf, buf, sz) != (-1 as ssize_t)
             }
         }
@@ -395,8 +395,7 @@ fn self_exe_path() -> option<path> {
     fn load_self() -> option<path> {
         // FIXME: remove imports when export globs work properly. #1238
         import libc::funcs::extra::*;
-
-        fill_charp_buf() {|buf, sz|
+        do fill_charp_buf() {|buf, sz|
             _NSGetExecutablePath(buf, ptr::mut_addr_of(sz as u32))
                 == (0 as c_int)
         }
@@ -408,12 +407,12 @@ fn self_exe_path() -> option<path> {
         import libc::types::os::arch::extra::*;
         import libc::funcs::extra::kernel32::*;
         import win32::*;
-        fill_utf16_buf_and_decode() {|buf, sz|
+        do fill_utf16_buf_and_decode() {|buf, sz|
             GetModuleFileNameW(0u as dword, buf, sz)
         }
     }
 
-    option::map(load_self()) {|pth|
+    do option::map(load_self()) {|pth|
         path::dirname(pth) + path::path_sep()
     }
 }
@@ -453,7 +452,7 @@ fn homedir() -> option<path> {
 
     #[cfg(windows)]
     fn secondary() -> option<path> {
-        option::chain(getenv("USERPROFILE")) {|p|
+        do option::chain(getenv("USERPROFILE")) {|p|
             if !str::is_empty(p) {
                 some(p)
             } else {
@@ -470,7 +469,7 @@ fn walk_dir(p: path, f: fn(path) -> bool) {
 
     fn walk_dir_(p: path, f: fn(path) -> bool) -> bool {
         let mut keepgoing = true;
-        list_dir(p).each {|q|
+        do list_dir(p).each {|q|
             let path = path::connect(p, q);
             if !f(path) {
                 keepgoing = false;
@@ -494,14 +493,14 @@ fn walk_dir(p: path, f: fn(path) -> bool) {
 
 #[doc = "Indicates whether a path represents a directory"]
 fn path_is_dir(p: path) -> bool {
-    str::as_c_str(p) {|buf|
+    do str::as_c_str(p) {|buf|
         rustrt::rust_path_is_dir(buf) != 0 as c_int
     }
 }
 
 #[doc = "Indicates whether a path exists"]
 fn path_exists(p: path) -> bool {
-    str::as_c_str(p) {|buf|
+    do str::as_c_str(p) {|buf|
         rustrt::rust_path_exists(buf) != 0 as c_int
     }
 }
@@ -538,7 +537,7 @@ fn make_dir(p: path, mode: c_int) -> bool {
         import libc::funcs::extra::kernel32::*;
         import win32::*;
         // FIXME: turn mode into something useful? #2623
-        as_utf16_p(p) {|buf|
+        do as_utf16_p(p) {|buf|
             CreateDirectoryW(buf, unsafe { unsafe::reinterpret_cast(0) })
                 != (0 as BOOL)
         }
@@ -546,7 +545,7 @@ fn make_dir(p: path, mode: c_int) -> bool {
 
     #[cfg(unix)]
     fn mkdir(p: path, mode: c_int) -> bool {
-        as_c_charp(p) {|c|
+        do as_c_charp(p) {|c|
             libc::mkdir(c, mode as mode_t) == (0 as c_int)
         }
     }
@@ -569,7 +568,7 @@ fn list_dir(p: path) -> ~[str] {
         }
     }
 
-    rustrt::rust_list_files(star(p)).filter {|filename|
+    do rustrt::rust_list_files(star(p)).filter {|filename|
         !str::eq(filename, ".") && !str::eq(filename, "..")
     }
 }
@@ -586,7 +585,7 @@ fn list_dir_path(p: path) -> ~[str] {
                     && p[pl - 1u] as char != path::consts::alt_path_sep) {
         p += path::path_sep();
     }
-    os::list_dir(p).map {|f| p + f}
+    os::list_dir(p).map({|f| p + f})
 }
 
 #[doc = "Removes a directory at the specified path"]
@@ -599,14 +598,14 @@ fn remove_dir(p: path) -> bool {
         import libc::funcs::extra::kernel32::*;
         import libc::types::os::arch::extra::*;
         import win32::*;
-        ret as_utf16_p(p) {|buf|
+        ret do as_utf16_p(p) {|buf|
             RemoveDirectoryW(buf) != (0 as BOOL)
         };
     }
 
     #[cfg(unix)]
     fn rmdir(p: path) -> bool {
-        ret as_c_charp(p) {|buf|
+        ret do as_c_charp(p) {|buf|
             libc::rmdir(buf) == (0 as c_int)
         };
     }
@@ -621,14 +620,14 @@ fn change_dir(p: path) -> bool {
         import libc::funcs::extra::kernel32::*;
         import libc::types::os::arch::extra::*;
         import win32::*;
-        ret as_utf16_p(p) {|buf|
+        ret do as_utf16_p(p) {|buf|
             SetCurrentDirectoryW(buf) != (0 as BOOL)
         };
     }
 
     #[cfg(unix)]
     fn chdir(p: path) -> bool {
-        ret as_c_charp(p) {|buf|
+        ret do as_c_charp(p) {|buf|
             libc::chdir(buf) == (0 as c_int)
         };
     }
@@ -644,8 +643,8 @@ fn copy_file(from: path, to: path) -> bool {
         import libc::funcs::extra::kernel32::*;
         import libc::types::os::arch::extra::*;
         import win32::*;
-        ret as_utf16_p(from) {|fromp|
-            as_utf16_p(to) {|top|
+        ret do as_utf16_p(from) {|fromp|
+            do as_utf16_p(to) {|top|
                 CopyFileW(fromp, top, (0 as BOOL)) != (0 as BOOL)
             }
         }
@@ -653,16 +652,16 @@ fn copy_file(from: path, to: path) -> bool {
 
     #[cfg(unix)]
     fn do_copy_file(from: path, to: path) -> bool {
-        let istream = as_c_charp(from) {|fromp|
-            as_c_charp("rb") {|modebuf|
+        let istream = do as_c_charp(from) {|fromp|
+            do as_c_charp("rb") {|modebuf|
                 libc::fopen(fromp, modebuf)
             }
         };
         if istream as uint == 0u {
             ret false;
         }
-        let ostream = as_c_charp(to) {|top|
-            as_c_charp("w+b") {|modebuf|
+        let ostream = do as_c_charp(to) {|top|
+            do as_c_charp("w+b") {|modebuf|
                 libc::fopen(top, modebuf)
             }
         };
@@ -676,7 +675,7 @@ fn copy_file(from: path, to: path) -> bool {
         let mut done = false;
         let mut ok = true;
         while !done {
-          vec::as_mut_buf(buf) {|b|
+          do vec::as_mut_buf(buf) {|b|
               let nread = libc::fread(b as *mut c_void, 1u as size_t,
                                       bufsize as size_t,
                                       istream);
@@ -708,14 +707,14 @@ fn remove_file(p: path) -> bool {
         import libc::funcs::extra::kernel32::*;
         import libc::types::os::arch::extra::*;
         import win32::*;
-        ret as_utf16_p(p) {|buf|
+        ret do as_utf16_p(p) {|buf|
             DeleteFileW(buf) != (0 as BOOL)
         };
     }
 
     #[cfg(unix)]
     fn unlink(p: path) -> bool {
-        ret as_c_charp(p) {|buf|
+        ret do as_c_charp(p) {|buf|
             libc::unlink(buf) == (0 as c_int)
         };
     }
@@ -971,15 +970,15 @@ mod tests {
       let out = tempdir + path::path_sep() + "out.txt";
 
       /* Write the temp input file */
-      let ostream = as_c_charp(in) {|fromp|
-            as_c_charp("w+b") {|modebuf|
+      let ostream = do as_c_charp(in) {|fromp|
+            do as_c_charp("w+b") {|modebuf|
                 libc::fopen(fromp, modebuf)
             }
       };
       assert (ostream as uint != 0u);
       let s = "hello";
       let mut buf = vec::to_mut(str::bytes(s) + ~[0 as u8]);
-      vec::as_mut_buf(buf) {|b|
+      do vec::as_mut_buf(buf) {|b|
           assert (libc::fwrite(b as *c_void, 1u as size_t,
                                (str::len(s) + 1u) as size_t, ostream)
                   == buf.len() as size_t)};
diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs
index 5b59496a488..f8ce85e360f 100644
--- a/src/libcore/priv.rs
+++ b/src/libcore/priv.rs
@@ -41,7 +41,7 @@ unsafe fn chan_from_global_ptr<T: send>(
 
         let setup_po = comm::port();
         let setup_ch = comm::chan(setup_po);
-        let setup_ch = task::run_listener(builder()) {|setup_po|
+        let setup_ch = do task::run_listener(builder()) {|setup_po|
             let po = comm::port::<T>();
             let ch = comm::chan(po);
             comm::send(setup_ch, ch);
@@ -92,7 +92,7 @@ fn test_from_global_chan1() {
 
     // Create the global channel, attached to a new task
     let ch = unsafe {
-        chan_from_global_ptr(globchanp, task::builder) {|po|
+        do chan_from_global_ptr(globchanp, task::builder) {|po|
             let ch = comm::recv(po);
             comm::send(ch, true);
             let ch = comm::recv(po);
@@ -106,7 +106,7 @@ fn test_from_global_chan1() {
 
     // This one just reuses the previous channel
     let ch = unsafe {
-        chan_from_global_ptr(globchanp, task::builder) {|po|
+        do chan_from_global_ptr(globchanp, task::builder) {|po|
             let ch = comm::recv(po);
             comm::send(ch, false);
         }
@@ -121,7 +121,7 @@ fn test_from_global_chan1() {
 #[test]
 fn test_from_global_chan2() {
 
-    iter::repeat(100u) {||
+    do iter::repeat(100u) {||
         // The global channel
         let globchan = 0u;
         let globchanp = ptr::addr_of(globchan);
@@ -132,9 +132,9 @@ fn test_from_global_chan2() {
         // Spawn a bunch of tasks that all want to compete to
         // create the global channel
         for uint::range(0u, 10u) {|i|
-            task::spawn() {||
+            do task::spawn {||
                 let ch = unsafe {
-                    chan_from_global_ptr(
+                    do chan_from_global_ptr(
                         globchanp, task::builder) {|po|
 
                         for uint::range(0u, 10u) {|_j|
@@ -200,9 +200,9 @@ unsafe fn weaken_task(f: fn(comm::port<()>)) {
 
 #[test]
 fn test_weaken_task_then_unweaken() {
-    task::try {||
+    do task::try {||
         unsafe {
-            weaken_task {|_po|
+            do weaken_task {|_po|
             }
         }
     };
@@ -212,9 +212,9 @@ fn test_weaken_task_then_unweaken() {
 fn test_weaken_task_wait() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {||
+    do task::run(builder) {||
         unsafe {
-            weaken_task {|po|
+            do weaken_task {|po|
                 comm::recv(po);
             }
         }
@@ -224,18 +224,18 @@ fn test_weaken_task_wait() {
 #[test]
 fn test_weaken_task_stress() {
     // Create a bunch of weak tasks
-    iter::repeat(100u) {||
-        task::spawn {||
+    do iter::repeat(100u) {||
+        do task::spawn {||
             unsafe {
-                weaken_task {|_po|
+                do weaken_task {|_po|
                 }
             }
         }
         let builder = task::builder();
         task::unsupervise(builder);
-        task::run(builder) {||
+        do task::run(builder) {||
             unsafe {
-                weaken_task {|po|
+                do weaken_task {|po|
                     // Wait for it to tell us to die
                     comm::recv(po);
                 }
@@ -247,9 +247,9 @@ fn test_weaken_task_stress() {
 #[test]
 #[ignore(cfg(windows))]
 fn test_weaken_task_fail() {
-    let res = task::try {||
+    let res = do task::try {||
         unsafe {
-            weaken_task {|_po|
+            do weaken_task {|_po|
                 fail;
             }
         }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 99841e3b464..add3c87ce34 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -70,7 +70,7 @@ fn mut_offset<T>(ptr: *mut T, count: uint) -> *mut T {
 #[doc = "Return the offset of the first null pointer in `buf`."]
 #[inline(always)]
 unsafe fn buf_len<T>(buf: **T) -> uint {
-    position(buf) {|i| i == null() }
+    do position(buf) {|i| i == null() }
 }
 
 #[doc = "Return the first offset `i` such that `f(buf[i]) == true`."]
@@ -171,9 +171,9 @@ fn test_position() {
 
     let s = "hello";
     unsafe {
-        assert 2u == as_c_str(s) {|p| position(p) {|c| c == 'l' as c_char} };
-        assert 4u == as_c_str(s) {|p| position(p) {|c| c == 'o' as c_char} };
-        assert 5u == as_c_str(s) {|p| position(p) {|c| c == 0 as c_char } };
+        assert 2u == as_c_str(s, {|p| position(p, {|c| c == 'l' as c_char})});
+        assert 4u == as_c_str(s, {|p| position(p, {|c| c == 'o' as c_char})});
+        assert 5u == as_c_str(s, {|p| position(p, {|c| c == 0 as c_char })});
     }
 }
 
@@ -182,11 +182,11 @@ fn test_buf_len() {
     let s0 = "hello";
     let s1 = "there";
     let s2 = "thing";
-    str::as_c_str(s0) {|p0|
-        str::as_c_str(s1) {|p1|
-            str::as_c_str(s2) {|p2|
+    do str::as_c_str(s0) {|p0|
+        do str::as_c_str(s1) {|p1|
+            do str::as_c_str(s2) {|p2|
                 let v = ~[p0, p1, p2, null()];
-                vec::as_buf(v) {|vp|
+                do vec::as_buf(v) {|vp|
                     assert unsafe { buf_len(vp) } == 3u;
                 }
             }
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index ed4be4e9d64..1eb0983b7e4 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -152,7 +152,7 @@ impl extensions for rng {
 
     #[doc = "Return a random byte string of the specified length"]
     fn gen_bytes(len: uint) -> ~[u8] {
-        vec::from_fn(len) {|_i|
+        do vec::from_fn(len) {|_i|
             self.gen_u8()
         }
     }
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index e17534b4d8c..899ad6040c1 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -362,33 +362,33 @@ mod tests {
     #[test]
     fn test_impl_iter() {
         let mut valid = false;
-        ok::<str, str>("a").iter { |_x| valid = true; };
+        ok::<str, str>("a").iter({ |_x| valid = true; });
         assert valid;
 
-        err::<str, str>("b").iter { |_x| valid = false; };
+        err::<str, str>("b").iter({ |_x| valid = false; });
         assert valid;
     }
 
     #[test]
     fn test_impl_iter_err() {
         let mut valid = true;
-        ok::<str, str>("a").iter_err { |_x| valid = false; };
+        ok::<str, str>("a").iter_err({ |_x| valid = false; });
         assert valid;
 
         valid = false;
-        err::<str, str>("b").iter_err { |_x| valid = true; };
+        err::<str, str>("b").iter_err({ |_x| valid = true; });
         assert valid;
     }
 
     #[test]
     fn test_impl_map() {
-        assert ok::<str, str>("a").map { |_x| "b" } == ok("b");
-        assert err::<str, str>("a").map { |_x| "b" } == err("a");
+        assert ok::<str, str>("a").map({ |_x| "b" }) == ok("b");
+        assert err::<str, str>("a").map({ |_x| "b" }) == err("a");
     }
 
     #[test]
     fn test_impl_map_err() {
-        assert ok::<str, str>("a").map_err { |_x| "b" } == ok("a");
-        assert err::<str, str>("a").map_err { |_x| "b" } == err("b");
+        assert ok::<str, str>("a").map_err({ |_x| "b" }) == ok("a");
+        assert err::<str, str>("a").map_err({ |_x| "b" }) == err("b");
     }
 }
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index c3e39ff0b94..83033bdf9d2 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -67,9 +67,9 @@ fn spawn_process(prog: str, args: ~[str],
                  dir: option<str>,
                  in_fd: c_int, out_fd: c_int, err_fd: c_int)
    -> pid_t {
-    with_argv(prog, args) {|argv|
-        with_envp(env) { |envp|
-            with_dirp(dir) { |dirp|
+    do with_argv(prog, args) {|argv|
+        do with_envp(env) { |envp|
+            do with_dirp(dir) { |dirp|
                 rustrt::rust_run_program(argv, envp, dirp,
                                          in_fd, out_fd, err_fd)
             }
@@ -79,12 +79,12 @@ fn spawn_process(prog: str, args: ~[str],
 
 fn with_argv<T>(prog: str, args: ~[str],
                 cb: fn(**libc::c_char) -> T) -> T {
-    let mut argptrs = str::as_c_str(prog) {|b| ~[b] };
+    let mut argptrs = str::as_c_str(prog, {|b| ~[b] });
     let mut tmps = ~[];
     for vec::each(args) {|arg|
         let t = @arg;
         vec::push(tmps, t);
-        vec::push_all(argptrs, str::as_c_str(*t) {|b| ~[b] });
+        vec::push_all(argptrs, str::as_c_str(*t, {|b| ~[b] }));
     }
     vec::push(argptrs, ptr::null());
     vec::as_buf(argptrs, cb)
@@ -104,12 +104,12 @@ fn with_envp<T>(env: option<~[(str,str)]>,
             let (k,v) = e;
             let t = @(#fmt("%s=%s", k, v));
             vec::push(tmps, t);
-            vec::push_all(ptrs, str::as_c_str(*t) {|b| ~[b]});
+            vec::push_all(ptrs, str::as_c_str(*t, {|b| ~[b]}));
         }
         vec::push(ptrs, ptr::null());
-        vec::as_buf(ptrs) { |p|
+        vec::as_buf(ptrs, { |p|
             unsafe { cb(::unsafe::reinterpret_cast(p)) }
-        }
+        })
       }
       _ {
         cb(ptr::null())
@@ -135,7 +135,7 @@ fn with_envp<T>(env: option<~[(str,str)]>,
                 ::unsafe::forget(v);
             }
             blk += ~[0_u8];
-            vec::as_buf(blk) {|p| cb(::unsafe::reinterpret_cast(p)) }
+            vec::as_buf(blk, {|p| cb(::unsafe::reinterpret_cast(p)) })
           }
           _ {
             cb(ptr::null())
@@ -298,11 +298,11 @@ fn program_output(prog: str, args: ~[str]) ->
     // clever way to do this.
     let p = comm::port();
     let ch = comm::chan(p);
-    task::spawn_sched(task::single_threaded) {||
+    do task::spawn_sched(task::single_threaded) {||
         let errput = readclose(pipe_err.in);
         comm::send(ch, (2, errput));
     };
-    task::spawn_sched(task::single_threaded) {||
+    do task::spawn_sched(task::single_threaded) {||
         let output = readclose(pipe_out.in);
         comm::send(ch, (1, output));
     };
diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs
index 0041dde319d..d6c78a4c575 100644
--- a/src/libcore/stackwalk.rs
+++ b/src/libcore/stackwalk.rs
@@ -18,7 +18,7 @@ fn walk_stack(visit: fn(frame) -> bool) {
 
     #debug("beginning stack walk");
 
-    frame_address { |frame_pointer|
+    do frame_address { |frame_pointer|
         let mut frame_address: *word = unsafe {
             reinterpret_cast(frame_pointer)
         };
diff --git a/src/libcore/str.rs b/src/libcore/str.rs
index 989c627d7ee..01b463fce24 100644
--- a/src/libcore/str.rs
+++ b/src/libcore/str.rs
@@ -154,7 +154,7 @@ fn push_char(&s: str, ch: char) {
         let new_len = len + nb;
         reserve_at_least(s, new_len);
         let off = len;
-        as_buf(s) {|buf|
+        do as_buf(s) {|buf|
             let buf: *mut u8 = ::unsafe::reinterpret_cast(buf);
             if nb == 1u {
                 *ptr::mut_offset(buf, off) =
@@ -208,7 +208,7 @@ fn push_char(&s: str, ch: char) {
             *ptr::mut_offset(buf, off + nb) = 0u8;
         }
 
-        as_bytes(s) {|bytes|
+        do as_bytes(s) {|bytes|
             let mut mut_bytes: ~[u8] = ::unsafe::reinterpret_cast(bytes);
             vec::unsafe::set_len(mut_bytes, new_len + 1u);
             ::unsafe::forget(mut_bytes);
@@ -336,7 +336,7 @@ Work with the string as a byte slice, not including trailing null.
 "]
 #[inline(always)]
 pure fn byte_slice<T>(s: str/&, f: fn(v: &[u8]) -> T) -> T {
-    unpack_slice(s) {|p,n|
+    do unpack_slice(s) {|p,n|
         unsafe { vec::unsafe::form_slice(p, n-1u, f) }
     }
 }
@@ -495,7 +495,7 @@ pure fn iter_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) {
 
 pure fn iter_between_matches(s: str/&a, sep: str/&b, f: fn(uint, uint)) {
     let mut last_end = 0u;
-    iter_matches(s, sep) {|from, to|
+    do iter_matches(s, sep) {|from, to|
         f(last_end, from);
         last_end = to;
     }
@@ -513,7 +513,7 @@ assert [\"\", \"XXX\", \"YYY\", \"\"] == split_str(\".XXX.YYY.\", \".\")
 "]
 pure fn split_str(s: str/&a, sep: str/&b) -> ~[str] {
     let mut result = ~[];
-    iter_between_matches(s, sep) {|from, to|
+    do iter_between_matches(s, sep) {|from, to|
         unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }
     }
     result
@@ -521,7 +521,7 @@ pure fn split_str(s: str/&a, sep: str/&b) -> ~[str] {
 
 pure fn split_str_nonempty(s: str/&a, sep: str/&b) -> ~[str] {
     let mut result = ~[];
-    iter_between_matches(s, sep) {|from, to|
+    do iter_between_matches(s, sep) {|from, to|
         if to > from {
             unsafe { vec::push(result, unsafe::slice_bytes(s, from, to)); }
         }
@@ -585,7 +585,7 @@ The original string with all occurances of `from` replaced with `to`
 "]
 pure fn replace(s: str, from: str, to: str) -> str {
     let mut result = "", first = true;
-    iter_between_matches(s, from) {|start, end|
+    do iter_between_matches(s, from) {|start, end|
         if first { first = false; } else { result += to; }
         unsafe { result += unsafe::slice_bytes(s, start, end); }
     }
@@ -651,7 +651,7 @@ pure fn map(ss: str/&, ff: fn(char) -> char) -> str {
     let mut result = "";
     unchecked {
         reserve(result, len(ss));
-        chars_iter(ss) {|cc|
+        do chars_iter(ss) {|cc|
             str::push_char(result, ff(cc));
         }
     }
@@ -1215,7 +1215,7 @@ fn is_alphanumeric(s: str/&) -> bool {
 Returns the string length/size in bytes not counting the null terminator
 "]
 pure fn len(s: str/&) -> uint {
-    unpack_slice(s) { |_p, n| n - 1u }
+    do unpack_slice(s) { |_p, n| n - 1u }
 }
 
 #[doc = "Returns the number of characters that a string holds"]
@@ -1267,7 +1267,7 @@ pure fn is_utf16(v: &[const u16]) -> bool {
 #[doc = "Converts to a vector of `u16` encoded as UTF-16"]
 pure fn to_utf16(s: str/&) -> ~[u16] {
     let mut u = ~[];
-    chars_iter(s) {|cch|
+    do chars_iter(s) {|cch|
         // Arithmetic with u32 literals is easier on the eyes than chars.
         let mut ch = cch as u32;
 
@@ -1316,7 +1316,7 @@ pure fn from_utf16(v: &[const u16]) -> str {
     let mut buf = "";
     unchecked {
         reserve(buf, vec::len(v));
-        utf16_chars(v) {|ch| push_char(buf, ch); }
+        do utf16_chars(v) {|ch| push_char(buf, ch); }
     }
     ret buf;
 }
@@ -1583,7 +1583,7 @@ Allows for unsafe manipulation of strings, which is useful for native
 interop.
 "]
 pure fn as_buf<T>(s: str, f: fn(*u8) -> T) -> T {
-    as_bytes(s) { |v| unsafe { vec::as_buf(v, f) } }
+    as_bytes(s, { |v| unsafe { vec::as_buf(v, f) } })
 }
 
 #[doc = "
@@ -1599,7 +1599,7 @@ let s = str::as_buf(\"PATH\", { |path_buf| libc::getenv(path_buf) });
 ~~~
 "]
 pure fn as_c_str<T>(s: str, f: fn(*libc::c_char) -> T) -> T {
-    as_buf(s) {|buf| f(buf as *libc::c_char) }
+    as_buf(s, {|buf| f(buf as *libc::c_char) })
 }
 
 
@@ -1671,7 +1671,7 @@ Returns the number of single-byte characters the string can hold without
 reallocating
 "]
 pure fn capacity(&&s: str) -> uint {
-    as_bytes(s) {|buf|
+    do as_bytes(s) {|buf|
         let vcap = vec::capacity(buf);
         assert vcap > 0u;
         vcap - 1u
@@ -1683,7 +1683,7 @@ pure fn escape_default(s: str/&) -> str {
     let mut out: str = "";
     unchecked {
         reserve_at_least(out, str::len(s));
-        chars_iter(s) {|c| out += char::escape_default(c); }
+        do chars_iter(s) {|c| out += char::escape_default(c); }
     }
     ret out;
 }
@@ -1693,7 +1693,7 @@ pure fn escape_unicode(s: str/&) -> str {
     let mut out: str = "";
     unchecked {
         reserve_at_least(out, str::len(s));
-        chars_iter(s) {|c| out += char::escape_unicode(c); }
+        do chars_iter(s) {|c| out += char::escape_unicode(c); }
     }
     ret out;
 }
@@ -1726,7 +1726,7 @@ mod unsafe {
     unsafe fn from_buf_len(buf: *u8, len: uint) -> str {
         let mut v: ~[u8] = ~[];
         vec::reserve(v, len + 1u);
-        vec::as_buf(v) {|b| ptr::memcpy(b, buf, len); }
+        do vec::as_buf(v) {|b| ptr::memcpy(b, buf, len); }
         vec::unsafe::set_len(v, len);
         vec::push(v, 0u8);
 
@@ -1777,14 +1777,14 @@ mod unsafe {
    If end is greater than the length of the string.
    "]
    unsafe fn slice_bytes(s: str/&, begin: uint, end: uint) -> str {
-       unpack_slice(s) { |sbuf, n|
+       do unpack_slice(s) { |sbuf, n|
            assert (begin <= end);
            assert (end <= n);
 
            let mut v = ~[];
            vec::reserve(v, end - begin + 1u);
            unsafe {
-               vec::as_buf(v) { |vbuf|
+               do vec::as_buf(v) { |vbuf|
                    let src = ptr::offset(sbuf, begin);
                    ptr::memcpy(vbuf, src, end - begin);
                }
@@ -2574,7 +2574,7 @@ mod tests {
     #[should_fail]
     fn test_as_bytes_fail() {
         // Don't double free
-        as_bytes("") {|_bytes| fail }
+        do as_bytes("") {|_bytes| fail }
     }
 
     #[test]
@@ -2647,7 +2647,7 @@ mod tests {
     #[test]
     fn test_chars_iter() {
         let mut i = 0;
-        chars_iter("x\u03c0y") {|ch|
+        do chars_iter("x\u03c0y") {|ch|
             alt check i {
               0 { assert ch == 'x'; }
               1 { assert ch == '\u03c0'; }
@@ -2656,14 +2656,14 @@ mod tests {
             i += 1;
         }
 
-        chars_iter("") {|_ch| fail; } // should not fail
+        do chars_iter("") {|_ch| fail; } // should not fail
     }
 
     #[test]
     fn test_bytes_iter() {
         let mut i = 0;
 
-        bytes_iter("xyz") {|bb|
+        do bytes_iter("xyz") {|bb|
             alt check i {
               0 { assert bb == 'x' as u8; }
               1 { assert bb == 'y' as u8; }
@@ -2672,7 +2672,7 @@ mod tests {
             i += 1;
         }
 
-        bytes_iter("") {|bb| assert bb == 0u8; }
+        do bytes_iter("") {|bb| assert bb == 0u8; }
     }
 
     #[test]
@@ -2681,7 +2681,7 @@ mod tests {
 
         let mut ii = 0;
 
-        split_char_iter(data, ' ') {|xx|
+        do split_char_iter(data, ' ') {|xx|
             alt ii {
               0 { assert "\nMary" == xx; }
               1 { assert "had"    == xx; }
@@ -2699,7 +2699,7 @@ mod tests {
 
         let mut ii = 0;
 
-        splitn_char_iter(data, ' ', 2u) {|xx|
+        do splitn_char_iter(data, ' ', 2u) {|xx|
             alt ii {
               0 { assert "\nMary" == xx; }
               1 { assert "had"    == xx; }
@@ -2716,7 +2716,7 @@ mod tests {
 
         let mut ii = 0;
 
-        words_iter(data) {|ww|
+        do words_iter(data) {|ww|
             alt ii {
               0 { assert "Mary"   == ww; }
               1 { assert "had"    == ww; }
@@ -2727,7 +2727,7 @@ mod tests {
             ii += 1;
         }
 
-        words_iter("") {|_x| fail; } // should not fail
+        do words_iter("") {|_x| fail; } // should not fail
     }
 
     #[test]
@@ -2736,7 +2736,7 @@ mod tests {
 
         let mut ii = 0;
 
-        lines_iter(lf) {|x|
+        do lines_iter(lf) {|x|
             alt ii {
                 0 { assert "" == x; }
                 1 { assert "Mary had a little lamb" == x; }
@@ -2844,7 +2844,7 @@ mod tests {
     #[test]
     fn test_unpack_slice() {
         let a = "hello";
-        unpack_slice(a) {|buf, len|
+        do unpack_slice(a) {|buf, len|
             unsafe {
                 assert a[0] == 'h' as u8;
                 assert *buf == 'h' as u8;
diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index c90b48a9342..25fa1fb525e 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -183,16 +183,16 @@ mod tests {
         let lock = arc::arc(create_lock());
         let lock2 = arc::clone(&lock);
 
-        task::spawn {|move lock2|
+        do task::spawn {|move lock2|
             let lock = arc::get(&lock2);
-            (*lock).lock_cond {|c|
+            do (*lock).lock_cond {|c|
                 c.wait();
             }
         }
 
         let mut signaled = false;
         while !signaled {
-            (*arc::get(&lock)).lock_cond {|c|
+            do (*arc::get(&lock)).lock_cond {|c|
                 signaled = c.signal()
             }
         }
diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index 9f379bbd94a..c3d215b2de7 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -295,7 +295,7 @@ fn future_result(builder: builder) -> future::future<task_result> {
         with get_opts(builder)
     });
 
-    future::from_fn {||
+    do future::from_fn {||
         alt comm::recv(po) {
           exit(_, result) { result }
         }
@@ -307,7 +307,7 @@ fn future_task(builder: builder) -> future::future<task> {
 
     let mut po = comm::port();
     let ch = comm::chan(po);
-    add_wrapper(builder) {|body|
+    do add_wrapper(builder) {|body|
         fn~() {
             comm::send(ch, get_task());
             body();
@@ -342,7 +342,7 @@ fn run_listener<A:send>(-builder: builder,
     let setup_po = comm::port();
     let setup_ch = comm::chan(setup_po);
 
-    run(builder) {||
+    do run(builder) {||
         let po = comm::port();
         let mut ch = comm::chan(po);
         comm::send(setup_ch, ch);
@@ -439,7 +439,7 @@ fn try<T:send>(+f: fn~() -> T) -> result<T,()> {
     let mut builder = builder();
     unsupervise(builder);
     let result = future_result(builder);
-    run(builder) {||
+    do run(builder) {||
         comm::send(ch, f());
     }
     alt future::get(result) {
@@ -540,7 +540,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
         };
         assert !new_task.is_null();
 
-        option::iter(opts.notify_chan) {|c|
+        do option::iter(opts.notify_chan) {|c|
             // FIXME (#1087): Would like to do notification in Rust
             rustrt::rust_task_config_notify(new_task, c);
         }
@@ -657,10 +657,10 @@ unsafe fn key_to_key_value<T>(key: local_data_key<T>) -> *libc::c_void {
 unsafe fn local_data_lookup<T>(map: task_local_map, key: local_data_key<T>)
         -> option<(uint, *libc::c_void, fn@(+*libc::c_void))> {
     let key_value = key_to_key_value(key);
-    let map_pos = (*map).position {|entry|
+    let map_pos = (*map).position({|entry|
         alt entry { some((k,_,_)) { k == key_value } none { false } }
-    };
-    map_pos.map {|index|
+    });
+    do map_pos.map {|index|
         // .get() is guaranteed because of "none { false }" above.
         let (_, data_ptr, finaliser) = (*map)[index].get();
         (index, data_ptr, finaliser)
@@ -671,7 +671,7 @@ unsafe fn local_get_helper<T>(task: *rust_task, key: local_data_key<T>,
                               do_pop: bool) -> option<@T> {
     let map = get_task_local_map(task);
     // Interpret our findings from the map
-    local_data_lookup(map, key).map {|result|
+    do local_data_lookup(map, key).map {|result|
         // A reference count magically appears on 'data' out of thin air.
         // 'data' has the reference we originally stored it with. We either
         // need to erase it from the map or artificially bump the count.
@@ -799,7 +799,7 @@ native mod rustrt {
 fn test_spawn_raw_simple() {
     let po = comm::port();
     let ch = comm::chan(po);
-    spawn_raw(default_task_opts()) {||
+    do spawn_raw(default_task_opts()) {||
         comm::send(ch, ());
     }
     comm::recv(po);
@@ -812,7 +812,7 @@ fn test_spawn_raw_unsupervise() {
         supervise: false
         with default_task_opts()
     };
-    spawn_raw(opts) {||
+    do spawn_raw(opts) {||
         fail;
     }
 }
@@ -829,7 +829,7 @@ fn test_spawn_raw_notify() {
         notify_chan: some(notify_ch)
         with default_task_opts()
     };
-    spawn_raw(opts) {||
+    do spawn_raw(opts) {||
         comm::send(task_ch, get_task());
     }
     let task_ = comm::recv(task_po);
@@ -840,7 +840,7 @@ fn test_spawn_raw_notify() {
         notify_chan: some(notify_ch)
         with default_task_opts()
     };
-    spawn_raw(opts) {||
+    do spawn_raw(opts) {||
         comm::send(task_ch, get_task());
         fail;
     }
@@ -853,7 +853,7 @@ fn test_run_basic() {
     let po = comm::port();
     let ch = comm::chan(po);
     let buildr = builder();
-    run(buildr) {||
+    do run(buildr) {||
         comm::send(ch, ());
     }
     comm::recv(po);
@@ -864,13 +864,13 @@ fn test_add_wrapper() {
     let po = comm::port();
     let ch = comm::chan(po);
     let buildr = builder();
-    add_wrapper(buildr) {|body|
+    do add_wrapper(buildr) {|body|
         fn~() {
             body();
             comm::send(ch, ());
         }
     }
-    run(buildr) {||}
+    do run(buildr) {||}
     comm::recv(po);
 }
 
@@ -879,13 +879,13 @@ fn test_add_wrapper() {
 fn test_future_result() {
     let buildr = builder();
     let result = future_result(buildr);
-    run(buildr) {||}
+    do run(buildr) {||}
     assert future::get(result) == success;
 
     let buildr = builder();
     let result = future_result(buildr);
     unsupervise(buildr);
-    run(buildr) {|| fail }
+    do run(buildr) {|| fail }
     assert future::get(result) == failure;
 }
 
@@ -895,7 +895,7 @@ fn test_future_task() {
     let ch = comm::chan(po);
     let buildr = builder();
     let task1 = future_task(buildr);
-    run(buildr) {|| comm::send(ch, get_task()) }
+    do run(buildr) {|| comm::send(ch, get_task()) }
     assert future::get(task1) == comm::recv(po);
 }
 
@@ -903,7 +903,7 @@ fn test_future_task() {
 fn test_spawn_listiner_bidi() {
     let po = comm::port();
     let ch = comm::chan(po);
-    let ch = spawn_listener {|po|
+    let ch = do spawn_listener {|po|
         // Now the child has a port called 'po' to read from and
         // an environment-captured channel called 'ch'.
         let res = comm::recv(po);
@@ -918,7 +918,7 @@ fn test_spawn_listiner_bidi() {
 
 #[test]
 fn test_try_success() {
-    alt try {||
+    alt do try {||
         "Success!"
     } {
         result::ok("Success!") { }
@@ -929,7 +929,7 @@ fn test_try_success() {
 #[test]
 #[ignore(cfg(windows))]
 fn test_try_fail() {
-    alt try {||
+    alt do try {||
         fail
     } {
         result::err(()) { }
@@ -941,7 +941,7 @@ fn test_try_fail() {
 #[should_fail]
 #[ignore(cfg(windows))]
 fn test_spawn_sched_no_threads() {
-    spawn_sched(manual_threads(0u)) {|| };
+    do spawn_sched(manual_threads(0u)) {|| };
 }
 
 #[test]
@@ -952,7 +952,7 @@ fn test_spawn_sched() {
     fn f(i: int, ch: comm::chan<()>) {
         let parent_sched_id = rustrt::rust_get_sched_id();
 
-        spawn_sched(single_threaded) {||
+        do spawn_sched(single_threaded) {||
             let child_sched_id = rustrt::rust_get_sched_id();
             assert parent_sched_id != child_sched_id;
 
@@ -973,9 +973,9 @@ fn test_spawn_sched_childs_on_same_sched() {
     let po = comm::port();
     let ch = comm::chan(po);
 
-    spawn_sched(single_threaded) {||
+    do spawn_sched(single_threaded) {||
         let parent_sched_id = rustrt::rust_get_sched_id();
-        spawn {||
+        do spawn {||
             let child_sched_id = rustrt::rust_get_sched_id();
             // This should be on the same scheduler
             assert parent_sched_id == child_sched_id;
@@ -1002,7 +1002,7 @@ fn test_spawn_sched_blocking() {
 
     // Testing that a task in one scheduler can block in foreign code
     // without affecting other schedulers
-    iter::repeat(20u) {||
+    do iter::repeat(20u) {||
 
         let start_po = comm::port();
         let start_ch = comm::chan(start_po);
@@ -1011,7 +1011,7 @@ fn test_spawn_sched_blocking() {
 
         let lock = testrt::rust_dbg_lock_create();
 
-        spawn_sched(single_threaded) {||
+        do spawn_sched(single_threaded) {||
             testrt::rust_dbg_lock_lock(lock);
 
             comm::send(start_ch, ());
@@ -1038,7 +1038,7 @@ fn test_spawn_sched_blocking() {
         let setup_ch = comm::chan(setup_po);
         let parent_po = comm::port();
         let parent_ch = comm::chan(parent_po);
-        spawn {||
+        do spawn {||
             let child_po = comm::port();
             comm::send(setup_ch, comm::chan(child_po));
             pingpong(child_po, parent_ch);
@@ -1063,7 +1063,7 @@ fn avoid_copying_the_body(spawnfn: fn(+fn~())) {
     let x = ~1;
     let x_in_parent = ptr::addr_of(*x) as uint;
 
-    spawnfn {||
+    do spawnfn {||
         let x_in_child = ptr::addr_of(*x) as uint;
         comm::send(ch, x_in_child);
     }
@@ -1079,7 +1079,7 @@ fn test_avoid_copying_the_body_spawn() {
 
 #[test]
 fn test_avoid_copying_the_body_spawn_listener() {
-    avoid_copying_the_body {|f|
+    do avoid_copying_the_body {|f|
         spawn_listener(fn~(move f, _po: comm::port<int>) {
             f();
         });
@@ -1088,9 +1088,9 @@ fn test_avoid_copying_the_body_spawn_listener() {
 
 #[test]
 fn test_avoid_copying_the_body_run() {
-    avoid_copying_the_body {|f|
+    do avoid_copying_the_body {|f|
         let buildr = builder();
-        run(buildr) {||
+        do run(buildr) {||
             f();
         }
     }
@@ -1098,7 +1098,7 @@ fn test_avoid_copying_the_body_run() {
 
 #[test]
 fn test_avoid_copying_the_body_run_listener() {
-    avoid_copying_the_body {|f|
+    do avoid_copying_the_body {|f|
         let buildr = builder();
         run_listener(buildr, fn~(move f, _po: comm::port<int>) {
             f();
@@ -1108,8 +1108,8 @@ fn test_avoid_copying_the_body_run_listener() {
 
 #[test]
 fn test_avoid_copying_the_body_try() {
-    avoid_copying_the_body {|f|
-        try {||
+    do avoid_copying_the_body {|f|
+        do try {||
             f()
         };
     }
@@ -1117,10 +1117,10 @@ fn test_avoid_copying_the_body_try() {
 
 #[test]
 fn test_avoid_copying_the_body_future_task() {
-    avoid_copying_the_body {|f|
+    do avoid_copying_the_body {|f|
         let buildr = builder();
         future_task(buildr);
-        run(buildr) {||
+        do run(buildr) {||
             f();
         }
     }
@@ -1128,10 +1128,10 @@ fn test_avoid_copying_the_body_future_task() {
 
 #[test]
 fn test_avoid_copying_the_body_unsupervise() {
-    avoid_copying_the_body {|f|
+    do avoid_copying_the_body {|f|
         let buildr = builder();
         unsupervise(buildr);
-        run(buildr) {||
+        do run(buildr) {||
             f();
         }
     }
@@ -1151,7 +1151,7 @@ fn test_osmain() {
 
     let po = comm::port();
     let ch = comm::chan(po);
-    run(buildr) {||
+    do run(buildr) {||
         comm::send(ch, ());
     }
     comm::recv(po);
@@ -1166,12 +1166,12 @@ fn test_unkillable() {
     let ch = po.chan();
 
     // We want to do this after failing
-    spawn {||
+    do spawn {||
         iter::repeat(10u, yield);
         ch.send(());
     }
 
-    spawn {||
+    do spawn {||
         yield();
         // We want to fail after the unkillable task
         // blocks on recv
@@ -1179,7 +1179,7 @@ fn test_unkillable() {
     }
 
     unsafe {
-        unkillable {||
+        do unkillable {||
             let p = ~0;
             let pp: *uint = unsafe::transmute(p);
 
@@ -1198,7 +1198,7 @@ fn test_unkillable() {
 fn test_tls_multitask() unsafe {
     fn my_key(+_x: @str) { }
     local_data_set(my_key, @"parent data");
-    task::spawn {||
+    do task::spawn {||
         assert local_data_get(my_key) == none; // TLS shouldn't carry over.
         local_data_set(my_key, @"child data");
         assert *(local_data_get(my_key).get()) == "child data";
@@ -1230,19 +1230,19 @@ fn test_tls_pop() unsafe {
 #[test]
 fn test_tls_modify() unsafe {
     fn my_key(+_x: @str) { }
-    local_data_modify(my_key) {|data|
+    local_data_modify(my_key, {|data|
         alt data {
             some(@val) { fail "unwelcome value: " + val }
             none       { some(@"first data") }
         }
-    }
-    local_data_modify(my_key) {|data|
+    });
+    local_data_modify(my_key, {|data|
         alt data {
             some(@"first data") { some(@"next data") }
             some(@val)          { fail "wrong value: " + val }
             none                { fail "missing value" }
         }
-    }
+    });
     assert *(local_data_pop(my_key).get()) == "next data";
 }
 
@@ -1254,7 +1254,7 @@ fn test_tls_crust_automorestack_memorial_bug() unsafe {
     // something within a rust stack segment. Then a subsequent upcall (esp.
     // for logging, think vsnprintf) would run on a stack smaller than 1 MB.
     fn my_key(+_x: @str) { }
-    task::spawn {||
+    do task::spawn {||
         unsafe { local_data_set(my_key, @"hax"); }
     }
 }
@@ -1264,7 +1264,7 @@ fn test_tls_multiple_types() unsafe {
     fn str_key(+_x: @str) { }
     fn box_key(+_x: @@()) { }
     fn int_key(+_x: @int) { }
-    task::spawn{||
+    do task::spawn{||
         local_data_set(str_key, @"string data");
         local_data_set(box_key, @@());
         local_data_set(int_key, @42);
@@ -1276,7 +1276,7 @@ fn test_tls_overwrite_multiple_types() unsafe {
     fn str_key(+_x: @str) { }
     fn box_key(+_x: @@()) { }
     fn int_key(+_x: @int) { }
-    task::spawn{||
+    do task::spawn{||
         local_data_set(str_key, @"string data");
         local_data_set(int_key, @42);
         // This could cause a segfault if overwriting-destruction is done with
@@ -1294,7 +1294,7 @@ fn test_tls_cleanup_on_failure() unsafe {
     fn int_key(+_x: @int) { }
     local_data_set(str_key, @"parent data");
     local_data_set(box_key, @@());
-    task::spawn{|| // spawn_linked
+    do task::spawn{|| // spawn_linked
         local_data_set(str_key, @"string data");
         local_data_set(box_key, @@());
         local_data_set(int_key, @42);
diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs
index 8e984f880f6..8e63bc61a7d 100644
--- a/src/libcore/uint-template.rs
+++ b/src/libcore/uint-template.rs
@@ -131,8 +131,8 @@ Convert to a string in a given base
 Fails if `radix` < 2 or `radix` > 16
 "]
 fn to_str(num: T, radix: uint) -> str {
-    to_str_bytes(false, num, radix) {|slice|
-        vec::unpack_slice(slice) {|p, len|
+    do to_str_bytes(false, num, radix) {|slice|
+        do vec::unpack_slice(slice) {|p, len|
             unsafe { str::unsafe::from_buf_len(p, len) }
         }
     }
@@ -177,7 +177,7 @@ fn to_str_bytes<U>(neg: bool, num: T, radix: uint,
     // in-bounds, no extra cost.
 
     unsafe {
-        vec::unpack_slice(buf) {|p, len|
+        do vec::unpack_slice(buf) {|p, len|
             let mp = p as *mut u8;
             let mut i = len;
             let mut n = num;
diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs
index 012527ce63a..cd895d5b436 100644
--- a/src/libcore/vec.rs
+++ b/src/libcore/vec.rs
@@ -103,12 +103,12 @@ type init_op<T> = fn(uint) -> T;
 
 #[doc = "Returns true if a vector contains no elements"]
 pure fn is_empty<T>(v: &[const T]) -> bool {
-    unpack_const_slice(v) {|_p, len| len == 0u}
+    unpack_const_slice(v, {|_p, len| len == 0u})
 }
 
 #[doc = "Returns true if a vector contains some elements"]
 pure fn is_not_empty<T>(v: &[const T]) -> bool {
-    unpack_const_slice(v) {|_p, len| len > 0u}
+    unpack_const_slice(v, {|_p, len| len > 0u})
 }
 
 #[doc = "Returns true if two vectors have the same length"]
@@ -169,7 +169,7 @@ pure fn capacity<T>(&&v: ~[const T]) -> uint {
 #[doc = "Returns the length of a vector"]
 #[inline(always)]
 pure fn len<T>(&&v: &[const T]) -> uint {
-    unpack_const_slice(v) {|_p, len| len}
+    unpack_const_slice(v, { |_p, len| len})
 }
 
 #[doc = "
@@ -266,7 +266,7 @@ pure fn slice<T: copy>(v: &[const T], start: uint, end: uint) -> ~[T] {
 pure fn view<T: copy>(v: &[const T], start: uint, end: uint) -> &a.[T] {
     assert (start <= end);
     assert (end <= len(v));
-    unpack_slice(v) {|p, _len|
+    do unpack_slice(v) {|p, _len|
         unsafe {
             ::unsafe::reinterpret_cast(
                 (ptr::offset(p, start), (end - start) * sys::size_of::<T>()))
@@ -455,9 +455,9 @@ fn push_slow<T>(&v: ~[const T], +initval: T) {
 // Unchecked vector indexing
 #[inline(always)]
 unsafe fn ref<T: copy>(v: &[const T], i: uint) -> T {
-    unpack_slice(v) {|p, _len|
+    unpack_slice(v, {|p, _len|
         *ptr::offset(p, i)
-    }
+    })
 }
 
 #[inline(always)]
@@ -473,7 +473,7 @@ fn push_all<T: copy>(&v: ~[const T], rhs: &[const T]) {
 fn push_all_move<T>(&v: ~[const T], -rhs: ~[const T]) {
     reserve(v, v.len() + rhs.len());
     unsafe {
-        unpack_slice(rhs) {|p, len|
+        do unpack_slice(rhs) {|p, len|
             for uint::range(0, len) {|i|
                 let x <- *ptr::offset(p, i);
                 push(v, x);
@@ -678,7 +678,7 @@ pure fn connect<T: copy>(v: &[[T]/~], sep: T) -> ~[T] {
 #[doc = "Reduce a vector from left to right"]
 pure fn foldl<T: copy, U>(z: T, v: &[U], p: fn(T, U) -> T) -> T {
     let mut accum = z;
-    iter(v) { |elt|
+    do iter(v) { |elt|
         accum = p(accum, elt);
     }
     ret accum;
@@ -687,7 +687,7 @@ pure fn foldl<T: copy, U>(z: T, v: &[U], p: fn(T, U) -> T) -> T {
 #[doc = "Reduce a vector from right to left"]
 pure fn foldr<T, U: copy>(v: &[T], z: U, p: fn(T, U) -> U) -> U {
     let mut accum = z;
-    riter(v) { |elt|
+    do riter(v) { |elt|
         accum = p(elt, accum);
     }
     ret accum;
@@ -787,7 +787,7 @@ is returned. If `f` matches no elements then none is returned.
 "]
 pure fn find_between<T: copy>(v: &[T], start: uint, end: uint,
                       f: fn(T) -> bool) -> option<T> {
-    option::map(position_between(v, start, end, f)) { |i| v[i] }
+    option::map(position_between(v, start, end, f), { |i| v[i] })
 }
 
 #[doc = "
@@ -810,12 +810,12 @@ the element is returned. If `f` matches no elements then none is returned.
 "]
 pure fn rfind_between<T: copy>(v: &[T], start: uint, end: uint,
                                f: fn(T) -> bool) -> option<T> {
-    option::map(rposition_between(v, start, end, f)) { |i| v[i] }
+    option::map(rposition_between(v, start, end, f), { |i| v[i] })
 }
 
 #[doc = "Find the first index containing a matching value"]
 pure fn position_elem<T>(v: &[T], x: T) -> option<uint> {
-    position(v) { |y| x == y }
+    position(v, { |y| x == y })
 }
 
 #[doc = "
@@ -847,7 +847,7 @@ pure fn position_between<T>(v: &[T], start: uint, end: uint,
 
 #[doc = "Find the last index containing a matching value"]
 pure fn rposition_elem<T>(v: &[T], x: T) -> option<uint> {
-    rposition(v) { |y| x == y }
+    rposition(v, { |y| x == y })
 }
 
 #[doc = "
@@ -974,7 +974,7 @@ element's value.
 */
 #[inline(always)]
 pure fn iter_between<T>(v: &[T], start: uint, end: uint, f: fn(T)) {
-    unpack_slice(v) { |base_ptr, len|
+    do unpack_slice(v) { |base_ptr, len|
         assert start <= end;
         assert end <= len;
         unsafe {
@@ -996,7 +996,7 @@ Return true to continue, false to break.
 "]
 #[inline(always)]
 pure fn each<T>(v: &[const T], f: fn(T) -> bool) {
-    vec::unpack_slice(v) {|p, n|
+    do vec::unpack_slice(v) {|p, n|
         let mut n = n;
         let mut p = p;
         while n > 0u {
@@ -1016,7 +1016,7 @@ Return true to continue, false to break.
 "]
 #[inline(always)]
 pure fn eachi<T>(v: &[const T], f: fn(uint, T) -> bool) {
-    vec::unpack_slice(v) {|p, n|
+    do vec::unpack_slice(v) {|p, n|
         let mut i = 0u;
         let mut p = p;
         while i < n {
@@ -1064,7 +1064,7 @@ Iterates over vector `v` and, for each element, calls function `f` with the
 element's value.
 "]
 pure fn riter<T>(v: &[T], f: fn(T)) {
-    riteri(v) { |_i, v| f(v) }
+    riteri(v, { |_i, v| f(v) })
 }
 
 #[doc ="
@@ -1102,9 +1102,9 @@ pure fn permute<T: copy>(v: &[T], put: fn(~[T])) {
             let mut rest = slice(v, 0u, i);
             unchecked {
                 push_all(rest, view(v, i+1u, ln));
-                permute(rest) {|permutation|
+                permute(rest, {|permutation|
                     put(append(~[elt], permutation))
-                }
+                })
             }
             i += 1u;
         }
@@ -1130,11 +1130,11 @@ Allows for unsafe manipulation of vector contents, which is useful for native
 interop.
 "]
 fn as_buf<E,T>(v: &[E], f: fn(*E) -> T) -> T {
-    unpack_slice(v) { |buf, _len| f(buf) }
+    unpack_slice(v, { |buf, _len| f(buf) })
 }
 
 fn as_mut_buf<E,T>(v: &[mut E], f: fn(*mut E) -> T) -> T {
-    unpack_mut_slice(v) { |buf, _len| f(buf) }
+    unpack_mut_slice(v, { |buf, _len| f(buf) })
 }
 
 #[doc = "
@@ -1896,19 +1896,19 @@ mod tests {
         let mut results: ~[~[int]];
 
         results = ~[];
-        permute(~[]) {|v| vec::push(results, v); }
+        permute(~[], {|v| vec::push(results, v); });
         assert results == ~[~[]];
 
         results = ~[];
-        permute(~[7]) {|v| results += ~[v]; }
+        permute(~[7], {|v| results += ~[v]; });
         assert results == ~[~[7]];
 
         results = ~[];
-        permute(~[1,1]) {|v| results += ~[v]; }
+        permute(~[1,1], {|v| results += ~[v]; });
         assert results == ~[~[1,1],~[1,1]];
 
         results = ~[];
-        permute(~[5,2,0]) {|v| results += ~[v]; }
+        permute(~[5,2,0], {|v| results += ~[v]; });
         assert results ==
             ~[~[5,2,0],~[5,0,2],~[2,5,0],~[2,0,5],~[0,5,2],~[0,2,5]];
     }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index c6fac371719..e3152839793 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -222,19 +222,19 @@ impl writer for writer {
     }
 
     fn wr_tagged_u64(tag_id: uint, v: u64) {
-        io::u64_to_be_bytes(v, 8u) {|v|
+        do io::u64_to_be_bytes(v, 8u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_u32(tag_id: uint, v: u32) {
-        io::u64_to_be_bytes(v as u64, 4u) {|v|
+        do io::u64_to_be_bytes(v as u64, 4u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_u16(tag_id: uint, v: u16) {
-        io::u64_to_be_bytes(v as u64, 2u) {|v|
+        do io::u64_to_be_bytes(v as u64, 2u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
@@ -244,19 +244,19 @@ impl writer for writer {
     }
 
     fn wr_tagged_i64(tag_id: uint, v: i64) {
-        io::u64_to_be_bytes(v as u64, 8u) {|v|
+        do io::u64_to_be_bytes(v as u64, 8u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_i32(tag_id: uint, v: i32) {
-        io::u64_to_be_bytes(v as u64, 4u) {|v|
+        do io::u64_to_be_bytes(v as u64, 4u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
 
     fn wr_tagged_i16(tag_id: uint, v: i16) {
-        io::u64_to_be_bytes(v as u64, 2u) {|v|
+        do io::u64_to_be_bytes(v as u64, 2u) {|v|
             self.wr_tagged_bytes(tag_id, v);
         }
     }
@@ -355,7 +355,7 @@ impl serializer of serialization::serializer for ebml::writer {
     fn emit_enum_variant_arg(_idx: uint, f: fn()) { f() }
 
     fn emit_vec(len: uint, f: fn()) {
-        self.wr_tag(es_vec as uint) {||
+        do self.wr_tag(es_vec as uint) {||
             self._emit_tagged_uint(es_vec_len, len);
             f()
         }
@@ -482,7 +482,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
         #debug["read_enum_variant()"];
         let idx = self._next_uint(es_enum_vid);
         #debug["  idx=%u", idx];
-        self.push_doc(self.next_doc(es_enum_body)) {||
+        do self.push_doc(self.next_doc(es_enum_body)) {||
             f(idx)
         }
     }
@@ -494,7 +494,7 @@ impl deserializer of serialization::deserializer for ebml_deserializer {
 
     fn read_vec<T:copy>(f: fn(uint) -> T) -> T {
         #debug["read_vec()"];
-        self.push_doc(self.next_doc(es_vec)) {||
+        do self.push_doc(self.next_doc(es_vec)) {||
             let len = self._next_uint(es_vec_len);
             #debug["  len=%u", len];
             f(len)
@@ -549,14 +549,14 @@ fn test_option_int() {
     }
 
     fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
-        s.emit_enum("core::option::t") {||
+        do s.emit_enum("core::option::t") {||
             alt v {
               none {
-                s.emit_enum_variant("core::option::none", 0u, 0u) {||}
+                s.emit_enum_variant("core::option::none", 0u, 0u, {||});
               }
               some(v0) {
-                s.emit_enum_variant("core::option::some", 1u, 1u) {||
-                    s.emit_enum_variant_arg(0u) {|| serialize_1(s, v0) }
+                do s.emit_enum_variant("core::option::some", 1u, 1u) {||
+                    s.emit_enum_variant_arg(0u, {|| serialize_1(s, v0) });
                 }
               }
             }
@@ -568,12 +568,12 @@ fn test_option_int() {
     }
 
     fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> {
-        s.read_enum("core::option::t") {||
-            s.read_enum_variant {|i|
+        do s.read_enum("core::option::t") {||
+            do s.read_enum_variant {|i|
                 alt check i {
                   0u { none }
                   1u {
-                    let v0 = s.read_enum_variant_arg(0u) {||
+                    let v0 = do s.read_enum_variant_arg(0u) {||
                         deserialize_1(s)
                     };
                     some(v0)
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index e68f41a7c38..51f59f59d13 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -90,7 +90,7 @@ fn to_writer(wr: io::writer, j: json) {
 
 fn escape_str(s: str) -> str {
     let mut escaped = "\"";
-    str::chars_iter(s) { |c|
+    do str::chars_iter(s) { |c|
         alt c {
           '"' { escaped += "\\\""; }
           '\\' { escaped += "\\\\"; }
@@ -110,7 +110,7 @@ fn escape_str(s: str) -> str {
 
 #[doc = "Serializes a json value into a string"]
 fn to_str(j: json) -> str {
-    io::with_str_writer { |wr| to_writer(wr, j) }
+    io::with_str_writer({ |wr| to_writer(wr, j) })
 }
 
 type parser = {
@@ -598,7 +598,7 @@ impl <A: to_json copy, B: to_json copy, C: to_json copy>
 }
 
 impl <A: to_json> of to_json for ~[A] {
-    fn to_json() -> json { list(@self.map { |elt| elt.to_json() }) }
+    fn to_json() -> json { list(@self.map({ |elt| elt.to_json() })) }
 }
 
 impl <A: to_json copy> of to_json for hashmap<str, A> {
@@ -635,7 +635,7 @@ mod tests {
     fn mk_dict(items: ~[(str, json)]) -> json {
         let d = map::str_hash();
 
-        vec::iter(items) { |item|
+        do vec::iter(items) { |item|
             let (key, value) = copy item;
             d.insert(key, value);
         };
diff --git a/src/libstd/list.rs b/src/libstd/list.rs
index 471abfe0856..5018f9860ce 100644
--- a/src/libstd/list.rs
+++ b/src/libstd/list.rs
@@ -29,7 +29,7 @@ accumulated result.
 "]
 fn foldl<T: copy, U>(z: T, ls: @list<U>, f: fn(T, U) -> T) -> T {
     let mut accum: T = z;
-    iter(ls) {|elt| accum = f(accum, elt);}
+    do iter(ls) {|elt| accum = f(accum, elt);}
     accum
 }
 
@@ -77,7 +77,7 @@ pure fn is_not_empty<T: copy>(ls: @list<T>) -> bool {
 #[doc = "Returns the length of a list"]
 fn len<T>(ls: @list<T>) -> uint {
     let mut count = 0u;
-    iter(ls) {|_e| count += 1u;}
+    iter(ls, {|_e| count += 1u;});
     count
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 3475a0e5e7c..331bc6dcced 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -261,9 +261,9 @@ mod chained {
             }
         }
 
-        fn each_key(blk: fn(K) -> bool) { self.each { |k, _v| blk(k)} }
+        fn each_key(blk: fn(K) -> bool) { self.each({ |k, _v| blk(k)}) }
 
-        fn each_value(blk: fn(V) -> bool) { self.each { |_k, v| blk(v)} }
+        fn each_value(blk: fn(V) -> bool) { self.each({ |_k, v| blk(v)}) }
     }
 
     fn chains<K,V>(nchains: uint) -> ~[mut chain<K,V>] {
@@ -332,7 +332,7 @@ Convert a set into a vector.
 "]
 fn vec_from_set<T: copy>(s: set<T>) -> ~[T] {
     let mut v = ~[];
-    s.each_key() {|k|
+    do s.each_key() {|k|
         vec::push(v, k);
         true
     };
@@ -343,7 +343,7 @@ fn vec_from_set<T: copy>(s: set<T>) -> ~[T] {
 fn hash_from_vec<K: const copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>,
                                          items: ~[(K, V)]) -> hashmap<K, V> {
     let map = hashmap(hasher, eqer);
-    vec::iter(items) { |item|
+    do vec::iter(items) { |item|
         let (key, value) = item;
         map.insert(key, value);
     }
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 8f852ab7a13..f923b6fedea 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -88,7 +88,7 @@ fn md4_str(msg: ~[u8]) -> str {
         f(a); f(b); f(c); f(d);
     }
     let mut result = "";
-    app(a, b, c, d) {|u|
+    do app(a, b, c, d) {|u|
         let mut i = 0u32;
         while i < 4u32 {
             let byte = (u >> (i * 8u32)) as u8;
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index 20598777f11..f1e28ed0290 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -48,7 +48,7 @@ class tcp_socket {
        };
        let close_data_ptr = ptr::addr_of(close_data);
        let stream_handle_ptr = (*(self.socket_data)).stream_handle_ptr;
-       iotask::interact((*(self.socket_data)).iotask) {|loop_ptr|
+       do iotask::interact((*(self.socket_data)).iotask) {|loop_ptr|
           log(debug, #fmt("interact dtor for tcp_socket stream %? loop %?",
             stream_handle_ptr, loop_ptr));
            uv::ll::set_data_for_uv_handle(stream_handle_ptr,
@@ -72,7 +72,7 @@ class tcp_conn_port {
     let server_stream_ptr = ptr::addr_of((*conn_data_ptr).server_stream);
     let stream_closed_po = (*(self.conn_data)).stream_closed_po;
     let iotask = (*conn_data_ptr).iotask;
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         log(debug, #fmt("dtor for tcp_conn_port loop: %?",
                        loop_ptr));
         uv::ll::close(server_stream_ptr, tcp_nl_close_cb);
@@ -131,7 +131,7 @@ fn connect(input_ip: ip::ip_addr, port: uint,
     // we can send into the interact cb to be handled in libuv..
     log(debug, #fmt("stream_handle_ptr outside interact %?",
         stream_handle_ptr));
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         log(debug, "in interact cb for tcp client connect..");
         log(debug, #fmt("stream_handle_ptr in interact %?",
             stream_handle_ptr));
@@ -251,7 +251,7 @@ value as the `err` variant
 fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
     -> future<result::result<(), tcp_err_data>> unsafe {
     let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
-    future_spawn {||
+    do future_spawn {||
         write_common_impl(socket_data_ptr, raw_write_data)
     }
 }
@@ -340,7 +340,7 @@ read attempt. Pass `0u` to wait indefinitely
 fn read_future(sock: tcp_socket, timeout_msecs: uint)
     -> future<result::result<~[u8],tcp_err_data>> {
     let socket_data = ptr::addr_of(*(sock.socket_data));
-    future_spawn {||
+    do future_spawn {||
         read_common_impl(socket_data, timeout_msecs)
     }
 }
@@ -387,7 +387,7 @@ fn new_listener(host_ip: ip::ip_addr, port: uint, backlog: uint,
 
     let setup_po = comm::port::<option<tcp_err_data>>();
     let setup_ch = comm::chan(setup_po);
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         let tcp_addr = ipv4_ip_addr_to_sockaddr_in(host_ip,
                                                    port);
         alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
@@ -488,7 +488,7 @@ fn conn_recv_spawn(server_port: tcp_conn_port,
     let new_conn_po = (*(server_port.conn_data)).new_conn_po;
     let iotask = (*(server_port.conn_data)).iotask;
     let new_conn_result = comm::recv(new_conn_po);
-    task::spawn {||
+    do task::spawn {||
         let sock_create_result = alt new_conn_result {
           ok(client_stream_ptr) {
             conn_port_new_tcp_socket(client_stream_ptr, iotask)
@@ -709,7 +709,7 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
 
     let setup_po = comm::port::<option<tcp_err_data>>();
     let setup_ch = comm::chan(setup_po);
-    iotask::interact(iotask) {|loop_ptr|
+    do iotask::interact(iotask) {|loop_ptr|
         let tcp_addr = ipv4_ip_addr_to_sockaddr_in(host_ip,
                                                    port);
         alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
@@ -755,7 +755,7 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
       none {
         on_establish_cb(kill_ch);
         let kill_result = comm::recv(kill_po);
-        iotask::interact(iotask) {|loop_ptr|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, #fmt("tcp::listen post-kill recv hl interact %?",
                             loop_ptr));
             (*server_data_ptr).active = false;
@@ -861,7 +861,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     let stop_po = comm::port::<option<tcp_err_data>>();
     let stop_ch = comm::chan(stop_po);
-    iotask::interact((*socket_data).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data).iotask) {|loop_ptr|
         log(debug, "in interact cb for tcp::read_stop");
         alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
           0i32 {
@@ -893,7 +893,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
     let start_po = comm::port::<option<uv::ll::uv_err_data>>();
     let start_ch = comm::chan(start_po);
     log(debug, "in tcp::read_start before interact loop");
-    iotask::interact((*socket_data).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data).iotask) {|loop_ptr|
         log(debug, #fmt("in tcp::read_start interact cb %?", loop_ptr));
         alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
                                on_alloc_cb,
@@ -935,7 +935,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
         result_ch: comm::chan(result_po)
     };
     let write_data_ptr = ptr::addr_of(write_data);
-    iotask::interact((*socket_data_ptr).iotask) {|loop_ptr|
+    do iotask::interact((*socket_data_ptr).iotask) {|loop_ptr|
         log(debug, #fmt("in interact cb for tcp::write %?", loop_ptr));
         alt uv::ll::write(write_req_ptr,
                           stream_handle_ptr,
@@ -979,8 +979,8 @@ fn conn_port_new_tcp_socket(
         iotask : iotask
     };
     let client_socket_data_ptr = ptr::addr_of(*client_socket_data);
-    comm::listen {|cont_ch|
-        iotask::interact(iotask) {|loop_ptr|
+    do comm::listen {|cont_ch|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, #fmt("in interact cb 4 conn_port_new_tcp.. loop %?",
                 loop_ptr));
             uv::ll::set_data_for_uv_handle(stream_handle_ptr,
@@ -1332,8 +1332,8 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = comm::listen {|server_ch|
+        do task::spawn_sched(task::manual_threads(1u)) {||
+            let actual_req = do comm::listen {|server_ch|
                 run_tcp_test_server(
                     server_ip,
                     server_port,
@@ -1347,7 +1347,7 @@ mod test {
         comm::recv(cont_po);
         // client
         log(debug, "server started, firing up client..");
-        let actual_resp = comm::listen {|client_ch|
+        let actual_resp = do comm::listen {|client_ch|
             run_tcp_test_client(
                 server_ip,
                 server_port,
@@ -1376,8 +1376,8 @@ mod test {
         let cont_po = comm::port::<()>();
         let cont_ch = comm::chan(cont_po);
         // server
-        task::spawn_sched(task::manual_threads(1u)) {||
-            let actual_req = comm::listen {|server_ch|
+        do task::spawn_sched(task::manual_threads(1u)) {||
+            let actual_req = do comm::listen {|server_ch|
                 run_tcp_test_server_listener(
                     server_ip,
                     server_port,
@@ -1391,7 +1391,7 @@ mod test {
         comm::recv(cont_po);
         // client
         log(debug, "server started, firing up client..");
-        let actual_resp = comm::listen {|client_ch|
+        let actual_resp = do comm::listen {|client_ch|
             run_tcp_test_client(
                 server_ip,
                 server_port,
@@ -1413,7 +1413,7 @@ mod test {
                           cont_ch: comm::chan<()>,
                           iotask: iotask) -> str {
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let listen_result =
                 listen_for_conn(server_ip_addr, server_port, 128u,
@@ -1428,8 +1428,8 @@ mod test {
                 // will want the POWER
                 {|new_conn, kill_ch|
                 log(debug, "SERVER: new connection!");
-                comm::listen {|cont_ch|
-                    task::spawn_sched(task::manual_threads(1u)) {||
+                do comm::listen {|cont_ch|
+                    do task::spawn_sched(task::manual_threads(1u)) {||
                         log(debug, "SERVER: starting worker for new req");
 
                         let accept_result = accept(new_conn);
@@ -1492,7 +1492,7 @@ mod test {
                                     cont_ch: comm::chan<()>,
                                     iotask: iotask) -> str {
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let new_listener_result =
                 new_listener(server_ip_addr, server_port, 128u, iotask);
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 91460b3a1d7..eab0fa6980f 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -41,9 +41,9 @@ fn map_slices<A: copy send, B: copy send>(
         while base < len {
             let end = uint::min(len, base + items_per_task);
             // FIXME: why is the ::<A, ()> annotation required here? (#2617)
-            vec::unpack_slice::<A, ()>(xs) {|p, _len|
+            do vec::unpack_slice::<A, ()>(xs) {|p, _len|
                 let f = f();
-                let f = future_spawn() {|copy base|
+                let f = do future_spawn() {|copy base|
                     unsafe {
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
@@ -66,7 +66,7 @@ fn map_slices<A: copy send, B: copy send>(
         log(info, #fmt("num_tasks: %?", (num_tasks, futures.len())));
         assert(num_tasks == futures.len());
 
-        let r = futures.map() {|ys|
+        let r = do futures.map() {|ys|
             ys.get()
         };
         assert(r.len() == futures.len());
@@ -76,23 +76,23 @@ fn map_slices<A: copy send, B: copy send>(
 
 #[doc="A parallel version of map."]
 fn map<A: copy send, B: copy send>(xs: ~[A], f: fn~(A) -> B) -> ~[B] {
-    vec::concat(map_slices(xs) {||
+    vec::concat(map_slices(xs, {||
         fn~(_base: uint, slice : &[A], copy f) -> ~[B] {
             vec::map(slice, f)
         }
-    })
+    }))
 }
 
 #[doc="A parallel version of mapi."]
 fn mapi<A: copy send, B: copy send>(xs: ~[A],
                                     f: fn~(uint, A) -> B) -> ~[B] {
-    let slices = map_slices(xs) {||
+    let slices = map_slices(xs, {||
         fn~(base: uint, slice : &[A], copy f) -> ~[B] {
-            vec::mapi(slice) {|i, x|
+            vec::mapi(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    };
+    });
     let r = vec::concat(slices);
     log(info, (r.len(), xs.len()));
     assert(r.len() == xs.len());
@@ -105,14 +105,14 @@ In this case, f is a function that creates functions to run over the
 inner elements. This is to skirt the need for copy constructors."]
 fn mapi_factory<A: copy send, B: copy send>(
     xs: ~[A], f: fn() -> fn~(uint, A) -> B) -> ~[B] {
-    let slices = map_slices(xs) {||
+    let slices = map_slices(xs, {||
         let f = f();
         fn~(base: uint, slice : &[A], move f) -> ~[B] {
-            vec::mapi(slice) {|i, x|
+            vec::mapi(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    };
+    });
     let r = vec::concat(slices);
     log(info, (r.len(), xs.len()));
     assert(r.len() == xs.len());
@@ -121,20 +121,20 @@ fn mapi_factory<A: copy send, B: copy send>(
 
 #[doc="Returns true if the function holds for all elements in the vector."]
 fn alli<A: copy send>(xs: ~[A], f: fn~(uint, A) -> bool) -> bool {
-    vec::all(map_slices(xs) {||
+    do vec::all(map_slices(xs, {||
         fn~(base: uint, slice : &[A], copy f) -> bool {
-            vec::alli(slice) {|i, x|
+            vec::alli(slice, {|i, x|
                 f(i + base, x)
-            }
+            })
         }
-    }) {|x| x }
+    })) {|x| x }
 }
 
 #[doc="Returns true if the function holds for any elements in the vector."]
 fn any<A: copy send>(xs: ~[A], f: fn~(A) -> bool) -> bool {
-    vec::any(map_slices(xs) {||
+    do vec::any(map_slices(xs, {||
         fn~(_base : uint, slice: &[A], copy f) -> bool {
             vec::any(slice, f)
         }
-    }) {|x| x }
+    })) {|x| x }
 }
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 28b6ac7acb2..374add74404 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -397,7 +397,7 @@ Loop through a rope, char by char, until the end.
 * it - A block to execute with each consecutive character of the rope.
 "]
 fn iter_chars(rope: rope, it: fn(char)) {
-    loop_chars(rope) {|x|
+    do loop_chars(rope) {|x|
         it(x);
         true
     };
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index c6d75f538c8..6819711aad6 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -84,9 +84,9 @@ iface deserializer {
 // In some cases, these should eventually be coded as traits.
 
 fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
-    s.emit_vec(vec::len(v)) {||
-        vec::iteri(v) {|i,e|
-            s.emit_vec_elt(i) {||
+    do s.emit_vec(vec::len(v)) {||
+        do vec::iteri(v) {|i,e|
+            do s.emit_vec_elt(i) {||
                 f(e)
             }
         }
@@ -94,9 +94,9 @@ fn emit_from_vec<S: serializer, T>(s: S, v: ~[T], f: fn(T)) {
 }
 
 fn read_to_vec<D: deserializer, T: copy>(d: D, f: fn() -> T) -> ~[T] {
-    d.read_vec {|len|
-        vec::from_fn(len) {|i|
-            d.read_vec_elt(i) {|| f() }
+    do d.read_vec {|len|
+        do vec::from_fn(len) {|i|
+            do d.read_vec_elt(i) {|| f() }
         }
     }
 }
@@ -234,16 +234,16 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
 }
 
 fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
-    s.emit_enum("option") {||
+    do s.emit_enum("option") {||
         alt v {
           none {
-            s.emit_enum_variant("none", 0u, 0u) {||
+            do s.emit_enum_variant("none", 0u, 0u) {||
             }
           }
 
           some(v) {
-            s.emit_enum_variant("some", 1u, 1u) {||
-                s.emit_enum_variant_arg(0u) {||
+            do s.emit_enum_variant("some", 1u, 1u) {||
+                do s.emit_enum_variant_arg(0u) {||
                     st(v)
                 }
             }
@@ -254,16 +254,16 @@ fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
 
 fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
     -> option<T> {
-    d.read_enum("option") {||
-        d.read_enum_variant {|i|
+    do d.read_enum("option") {||
+        do d.read_enum_variant {|i|
             alt check i {
               0u { // none
                 none
               }
               1u { // some(v)
-                some(d.read_enum_variant_arg(0u) {||
+                some(d.read_enum_variant_arg(0u, {||
                     st()
-                })
+                }))
               }
             }
         }
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 3369e95f1a3..a7df6df281a 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -102,7 +102,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
         }
     }
     fn each_value(it: fn(V) -> bool) {
-        self.each {|_i, v| it(v)}
+        self.each({|_i, v| it(v)});
     }
 }
 
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 8358123bf1f..6c18afb6474 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -216,7 +216,7 @@ fn run_tests_console(opts: test_opts,
 fn print_failures(st: console_test_state) {
     st.out.write_line("\nfailures:");
     let failures = copy st.failures;
-    let failures = vec::map(failures) {|test| test.name};
+    let failures = vec::map(failures, {|test| test.name});
     let failures = sort::merge_sort(str::le, failures);
     for vec::each(failures) {|name|
         st.out.write_line(#fmt["    %s", name]);
@@ -390,7 +390,7 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
         ret;
     }
 
-    task::spawn {||
+    do task::spawn {||
         let testfn = copy test.fn;
         let mut builder = task::builder();
         let result_future = task::future_result(builder);
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 5cfcbc7fd8c..e38f72ab189 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -283,21 +283,21 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'c' {
             parse_type(s, pos, 'a', tm)
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'b', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'e', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'T', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'Y', tm) }
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'b', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'e', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'T', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'Y', tm) })
           }
           'D' | 'x' {
             parse_type(s, pos, 'm', tm)
-                .chain { |pos| parse_char(s, pos, '/') }
-                .chain { |pos| parse_type(s, pos, 'd', tm) }
-                .chain { |pos| parse_char(s, pos, '/') }
-                .chain { |pos| parse_type(s, pos, 'y', tm) }
+                .chain({ |pos| parse_char(s, pos, '/') })
+                .chain({ |pos| parse_type(s, pos, 'd', tm) })
+                .chain({ |pos| parse_char(s, pos, '/') })
+                .chain({ |pos| parse_type(s, pos, 'y', tm) })
           }
           'd' {
             alt match_digits(s, pos, 2u, false) {
@@ -313,10 +313,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'F' {
             parse_type(s, pos, 'Y', tm)
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'm', tm) }
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'd', tm) }
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'm', tm) })
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'd', tm) })
           }
           'H' {
             // FIXME (#2350): range check.
@@ -398,17 +398,17 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'R' {
             parse_type(s, pos, 'H', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
           }
           'r' {
             parse_type(s, pos, 'I', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'S', tm) }
-                .chain { |pos| parse_char(s, pos, ' ') }
-                .chain { |pos| parse_type(s, pos, 'p', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'S', tm) })
+                .chain({ |pos| parse_char(s, pos, ' ') })
+                .chain({ |pos| parse_type(s, pos, 'p', tm) })
           }
           'S' {
             // FIXME (#2350): range check.
@@ -424,10 +424,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           //'s' {}
           'T' | 'X' {
             parse_type(s, pos, 'H', tm)
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'M', tm) }
-                .chain { |pos| parse_char(s, pos, ':') }
-                .chain { |pos| parse_type(s, pos, 'S', tm) }
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'M', tm) })
+                .chain({ |pos| parse_char(s, pos, ':') })
+                .chain({ |pos| parse_type(s, pos, 'S', tm) })
           }
           't' { parse_char(s, pos, '\t') }
           'u' {
@@ -443,10 +443,10 @@ fn strptime(s: str, format: str) -> result<tm, str> {
           }
           'v' {
             parse_type(s, pos, 'e', tm)
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'b', tm) }
-                .chain { |pos| parse_char(s, pos, '-') }
-                .chain { |pos| parse_type(s, pos, 'Y', tm) }
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'b', tm) })
+                .chain({ |pos| parse_char(s, pos, '-') })
+                .chain({ |pos| parse_type(s, pos, 'Y', tm) })
           }
           //'W' {}
           'w' {
@@ -526,7 +526,7 @@ fn strptime(s: str, format: str) -> result<tm, str> {
         }
     }
 
-    io::with_str_reader(format) { |rdr|
+    do io::with_str_reader(format) { |rdr|
         let tm = {
             mut tm_sec: 0_i32,
             mut tm_min: 0_i32,
@@ -738,7 +738,7 @@ fn strftime(format: str, tm: tm) -> str {
 
     let mut buf = "";
 
-    io::with_str_reader(format) { |rdr|
+    do io::with_str_reader(format) { |rdr|
         while !rdr.eof() {
             alt rdr.read_char() {
                 '%' { buf += parse_type(rdr.read_char(), tm); }
@@ -1002,7 +1002,7 @@ mod tests {
             }
         }
 
-        [
+        do [
             "Sunday",
             "Monday",
             "Tuesday",
@@ -1012,7 +1012,7 @@ mod tests {
             "Saturday"
         ]/_.iter { |day| assert test(day, "%A"); }
 
-        [
+        do [
             "Sun",
             "Mon",
             "Tue",
@@ -1022,7 +1022,7 @@ mod tests {
             "Sat"
         ]/_.iter { |day| assert test(day, "%a"); }
 
-        [
+        do [
             "January",
             "February",
             "March",
@@ -1037,7 +1037,7 @@ mod tests {
             "December"
         ]/_.iter { |day| assert test(day, "%B"); }
 
-        [
+        do [
             "Jan",
             "Feb",
             "Mar",
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 7d7e01bb892..b907944e51a 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -31,7 +31,7 @@ fn delayed_send<T: copy send>(iotask: iotask,
             let timer_done_ch_ptr = ptr::addr_of(timer_done_ch);
             let timer = uv::ll::timer_t();
             let timer_ptr = ptr::addr_of(timer);
-            iotask::interact(iotask) {|loop_ptr|
+            do iotask::interact(iotask) {|loop_ptr|
                 let init_result = uv::ll::timer_init(loop_ptr, timer_ptr);
                 if (init_result == 0i32) {
                     let start_result = uv::ll::timer_start(
@@ -151,7 +151,7 @@ mod test {
     #[test]
     fn test_gl_timer_sleep_stress1() {
         let hl_loop = uv::global_loop::get();
-        iter::repeat(200u) {||
+        do iter::repeat(200u) {||
             sleep(hl_loop, 1u);
         }
     }
@@ -171,14 +171,14 @@ mod test {
 
         };
 
-        iter::repeat(repeat) {||
+        do iter::repeat(repeat) {||
 
             for spec.each {|spec|
                 let (times, maxms) = spec;
-                task::spawn {||
+                do task::spawn {||
                     import rand::*;
                     let rng = rng();
-                    iter::repeat(times) {||
+                    do iter::repeat(times) {||
                         sleep(hl_loop, rng.next() as uint % maxms);
                     }
                     comm::send(ch, ());
@@ -186,7 +186,7 @@ mod test {
             }
         }
 
-        iter::repeat(repeat * spec.len()) {||
+        do iter::repeat(repeat * spec.len()) {||
             comm::recv(po)
         }
     }
@@ -204,14 +204,14 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        iter::repeat(times as uint) {||
+        do iter::repeat(times as uint) {||
             task::yield();
 
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            task::spawn() {||
+            do task::spawn() {||
                 delayed_send(hl_loop, 1u, test_ch, expected);
             };
 
@@ -231,12 +231,12 @@ mod test {
         let mut failures = 0;
         let hl_loop = uv::global_loop::get();
 
-        iter::repeat(times as uint) {||
+        do iter::repeat(times as uint) {||
             let expected = rand::rng().gen_str(16u);
             let test_po = comm::port::<str>();
             let test_ch = comm::chan(test_po);
 
-            task::spawn() {||
+            do task::spawn() {||
                 delayed_send(hl_loop, 1000u, test_ch, expected);
             };
 
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index ec2ce9b684c..6ea7b48ad97 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -56,12 +56,12 @@ fn get_monitor_task_gl() -> iotask unsafe {
     #debug("before priv::chan_from_global_ptr");
     type monchan = chan<iotask>;
 
-    let monitor_ch = chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
+    let monitor_ch = do chan_from_global_ptr::<monchan>(monitor_loop_chan_ptr,
                                                      builder_fn) {|msg_po|
         #debug("global monitor task starting");
 
         // As a weak task the runtime will notify us when to exit
-        weaken_task() {|weak_exit_po|
+        do weaken_task() {|weak_exit_po|
             #debug("global monitor task is now weak");
             let hl_loop = spawn_loop();
             loop {
@@ -87,7 +87,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
     // once we have a chan to the monitor loop, we ask it for
     // the libuv loop's async handle
-    listen { |fetch_ch|
+    do listen { |fetch_ch|
         monitor_ch.send(fetch_ch);
         fetch_ch.recv()
     }
@@ -95,11 +95,11 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
 fn spawn_loop() -> iotask unsafe {
     let builder = task::builder();
-    task::add_wrapper(builder) {|task_body|
+    do task::add_wrapper(builder) {|task_body|
         fn~(move task_body) {
             // The I/O loop task also needs to be weak so it doesn't keep
             // the runtime alive
-            weaken_task {|weak_exit_po|
+            do weaken_task {|weak_exit_po|
                 #debug("global libuv task is now weak %?", weak_exit_po);
                 task_body();
 
@@ -129,7 +129,7 @@ mod test {
         log(debug, "in simple timer cb");
         ll::timer_stop(timer_ptr);
         let hl_loop = get_gl();
-        iotask::interact(hl_loop) {|_loop_ptr|
+        do iotask::interact(hl_loop) {|_loop_ptr|
             log(debug, "closing timer");
             ll::close(timer_ptr, simple_timer_close_cb);
             log(debug, "about to deref exit_ch_ptr");
@@ -146,7 +146,7 @@ mod test {
                        exit_ch_ptr));
         let timer_handle = ll::timer_t();
         let timer_ptr = ptr::addr_of(timer_handle);
-        iotask::interact(iotask) {|loop_ptr|
+        do iotask::interact(iotask) {|loop_ptr|
             log(debug, "user code inside interact loop!!!");
             let init_status = ll::timer_init(loop_ptr, timer_ptr);
             if(init_status == 0i32) {
@@ -191,13 +191,13 @@ mod test {
         let exit_po = comm::port::<()>();
         let exit_ch = comm::chan(exit_po);
         let cycles = 5000u;
-        iter::repeat(cycles) {||
+        do iter::repeat(cycles) {||
             task::spawn_sched(task::manual_threads(1u), {||
                 impl_uv_hl_simple_timer(hl_loop);
                 comm::send(exit_ch, ());
             });
         };
-        iter::repeat(cycles) {||
+        do iter::repeat(cycles) {||
             comm::recv(exit_po);
         };
         log(debug, "test_stress_gl_uv_global_loop_high_level_global_timer"+
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index 3833cafe15e..625a261b6f5 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -39,9 +39,9 @@ fn spawn_iotask(-builder: task::builder) -> iotask {
         with get_opts(builder)
     });
 
-    listen {|iotask_ch|
+    do listen {|iotask_ch|
 
-        run(copy(builder)) {||
+        do run(copy(builder)) {||
             #debug("entering libuv task");
             run_loop(iotask_ch);
             #debug("libuv task exiting");
@@ -211,7 +211,7 @@ mod test {
             exit_ch: exit_ch
         };
         let ah_data_ptr = ptr::addr_of(ah_data);
-        interact(iotask) {|loop_ptr|
+        do interact(iotask) {|loop_ptr|
             ll::async_init(loop_ptr, ah_ptr, async_handle_cb);
             ll::set_data_for_uv_handle(ah_ptr, ah_data_ptr as *libc::c_void);
             ll::async_send(ah_ptr);
@@ -224,7 +224,7 @@ mod test {
     unsafe fn spawn_test_loop(exit_ch: comm::chan<()>) -> iotask {
         let iotask_port = comm::port::<iotask>();
         let iotask_ch = comm::chan(iotask_port);
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             run_loop(iotask_ch);
             exit_ch.send(());
         };
@@ -255,13 +255,13 @@ mod test {
         // called, at least.
         let work_exit_po = comm::port::<()>();
         let work_exit_ch = comm::chan(work_exit_po);
-        iter::repeat(7u) {||
-            task::spawn_sched(task::manual_threads(1u), {||
+        do iter::repeat(7u) {||
+            do task::spawn_sched(task::manual_threads(1u)) {||
                 impl_uv_iotask_async(iotask);
                 comm::send(work_exit_ch, ());
-            });
+            };
         };
-        iter::repeat(7u) {||
+        do iter::repeat(7u) {||
             comm::recv(work_exit_po);
         };
         log(debug, "sending teardown_loop msg..");
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 043c4e2204a..bb8eac6d528 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -1262,7 +1262,7 @@ mod test {
         let continue_chan = comm::chan::<bool>(continue_port);
         let continue_chan_ptr = ptr::addr_of(continue_chan);
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             impl_uv_tcp_server(bind_ip, port,
                                kill_server_msg,
                                server_resp_msg,
@@ -1275,7 +1275,7 @@ mod test {
         comm::recv(continue_port);
         log(debug, "received on continue port, set up tcp client");
 
-        task::spawn_sched(task::manual_threads(1u)) {||
+        do task::spawn_sched(task::manual_threads(1u)) {||
             impl_uv_tcp_request(request_ip, port,
                                kill_server_msg,
                                ptr::addr_of(client_chan));
diff --git a/src/libsyntax/ast_map.rs b/src/libsyntax/ast_map.rs
index 0733dc903ba..f393f37dfb9 100644
--- a/src/libsyntax/ast_map.rs
+++ b/src/libsyntax/ast_map.rs
@@ -11,7 +11,7 @@ type path = ~[path_elt];
 
 /* FIXMEs that say "bad" are as per #2543 */
 fn path_to_str_with_sep(p: path, sep: str) -> str {
-    let strs = vec::map(p) {|e|
+    let strs = do vec::map(p) {|e|
         alt e {
           path_mod(s) { /* FIXME (#2543) */ copy *s }
           path_name(s) { /* FIXME (#2543) */ copy *s }
@@ -156,7 +156,7 @@ fn map_block(b: blk, cx: ctx, v: vt) {
 }
 
 fn number_pat(cx: ctx, pat: @pat) {
-    ast_util::walk_pat(pat) {|p|
+    do ast_util::walk_pat(pat) {|p|
         alt p.node {
           pat_ident(_, _) {
             cx.map.insert(p.id, node_local(cx.local_id));
@@ -218,12 +218,12 @@ fn map_item(i: @item, cx: ctx, v: vt) {
           let (_, ms) = ast_util::split_class_items(items);
           // Map iface refs to their parent classes. This is
           // so we can find the self_ty
-          vec::iter(ifces) {|p| cx.map.insert(p.id,
+          do vec::iter(ifces) {|p| cx.map.insert(p.id,
                                   node_item(i, item_path)); };
           let d_id = ast_util::local_def(i.id);
           let p = extend(cx, i.ident);
            // only need to handle methods
-          vec::iter(ms) {|m| map_method(d_id, p, m, cx); }
+          do vec::iter(ms) {|m| map_method(d_id, p, m, cx); }
       }
       _ { }
     }
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 8d0cca2770a..fdb6d4dc7d9 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -408,7 +408,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
             alt vi.node {
               view_item_use(_, _, id) { vfn(id) }
               view_item_import(vps) | view_item_export(vps) {
-                vec::iter(vps) {|vp|
+                do vec::iter(vps) {|vp|
                     alt vp.node {
                       view_path_simple(_, _, id) { vfn(id) }
                       view_path_glob(_, id) { vfn(id) }
@@ -473,7 +473,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
         },
 
         visit_ty_params: fn@(ps: ~[ty_param]) {
-            vec::iter(ps) {|p| vfn(p.id) }
+            vec::iter(ps, {|p| vfn(p.id) })
         },
 
         visit_constr: fn@(_p: @path, _sp: span, id: node_id) {
@@ -486,23 +486,23 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
 
             alt fk {
               visit::fk_ctor(nm, tps, self_id, parent_id) {
-                vec::iter(tps) {|tp| vfn(tp.id)}
+                vec::iter(tps, {|tp| vfn(tp.id)});
                 vfn(id);
                 vfn(self_id);
                 vfn(parent_id.node);
               }
               visit::fk_dtor(tps, self_id, parent_id) {
-                vec::iter(tps) {|tp| vfn(tp.id)}
+                vec::iter(tps, {|tp| vfn(tp.id)});
                 vfn(id);
                 vfn(self_id);
                 vfn(parent_id.node);
               }
               visit::fk_item_fn(_, tps) {
-                vec::iter(tps) {|tp| vfn(tp.id)}
+                vec::iter(tps, {|tp| vfn(tp.id)});
               }
               visit::fk_method(_, tps, m) {
                 vfn(m.self_id);
-                vec::iter(tps) {|tp| vfn(tp.id)}
+                vec::iter(tps, {|tp| vfn(tp.id)});
               }
               visit::fk_anon(_, capture_clause)
               | visit::fk_fn_block(capture_clause) {
@@ -512,7 +512,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
               }
             }
 
-            vec::iter(d.inputs) {|arg|
+            do vec::iter(d.inputs) {|arg|
                 vfn(arg.id)
             }
         },
@@ -536,7 +536,7 @@ fn visit_ids_for_inlined_item(item: inlined_item, vfn: fn@(node_id)) {
 fn compute_id_range(visit_ids_fn: fn(fn@(node_id))) -> id_range {
     let min = @mut int::max_value;
     let max = @mut int::min_value;
-    visit_ids_fn { |id|
+    do visit_ids_fn { |id|
         *min = int::min(*min, id);
         *max = int::max(*max, id + 1);
     }
@@ -544,7 +544,7 @@ fn compute_id_range(visit_ids_fn: fn(fn@(node_id))) -> id_range {
 }
 
 fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range {
-    compute_id_range { |f| visit_ids_for_inlined_item(item, f) }
+    compute_id_range({ |f| visit_ids_for_inlined_item(item, f) })
 }
 
 pure fn is_item_impl(item: @ast::item) -> bool {
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index e137dc6127c..08e2fd6c9b8 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -315,7 +315,7 @@ From a list of crate attributes get only the meta_items that impact crate
 linkage
 "]
 fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
-    find_linkage_attrs(attrs).flat_map {|attr|
+    do find_linkage_attrs(attrs).flat_map {|attr|
         alt check attr.node.value.node {
           ast::meta_list(_, items) { /* FIXME (#2543) */ copy items }
         }
@@ -351,7 +351,7 @@ enum inline_attr {
 #[doc = "True if something like #[inline] is found in the list of attrs."]
 fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr {
     // TODO---validate the usage of #[inline] and #[inline(always)]
-    vec::foldl(ia_none, attrs) {|ia,attr|
+    do vec::foldl(ia_none, attrs) {|ia,attr|
         alt attr.node.value.node {
           ast::meta_word(@"inline") { ia_hint }
           ast::meta_list(@"inline", items) {
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index b8ebb27f51b..56017cd1f27 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -249,7 +249,7 @@ fn highlight_lines(cm: codemap::codemap, sp: span,
 }
 
 fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
-    option::iter (sp.expn_info) {|ei|
+    do option::iter (sp.expn_info) {|ei|
         let ss = option::map_default(ei.callie.span, @"", {
             |span|
             @codemap::span_to_str(span, cm)
diff --git a/src/libsyntax/ext/auto_serialize.rs b/src/libsyntax/ext/auto_serialize.rs
index 0e4592b1970..487a435df46 100644
--- a/src/libsyntax/ext/auto_serialize.rs
+++ b/src/libsyntax/ext/auto_serialize.rs
@@ -100,7 +100,7 @@ fn expand(cx: ext_ctxt,
           with *item}
     }
 
-    vec::flat_map(in_items) {|in_item|
+    do vec::flat_map(in_items) {|in_item|
         alt in_item.node {
           ast::item_ty(ty, tps, _) {
             vec::append(~[filter_attrs(in_item)],
@@ -151,7 +151,7 @@ impl helpers for ext_ctxt {
     fn ty_fn(span: span,
              -input_tys: ~[@ast::ty],
              -output: @ast::ty) -> @ast::ty {
-        let args = vec::map(input_tys) {|ty|
+        let args = do vec::map(input_tys) {|ty|
             {mode: ast::expl(ast::by_ref),
              ty: ty,
              ident: @"",
@@ -294,7 +294,7 @@ fn ser_path(cx: ext_ctxt, tps: ser_tps_map, path: @ast::path,
             ast::expr_path(
                 cx.helper_path(path, "serialize")));
 
-    let ty_args = vec::map(path.types) {|ty|
+    let ty_args = do vec::map(path.types) {|ty|
         let sv_stmts = ser_ty(cx, tps, ty, cx.clone(s), #ast{ __v });
         let sv = cx.expr(path.span,
                          ast::expr_block(cx.blk(path.span, sv_stmts)));
@@ -316,12 +316,14 @@ fn ser_variant(cx: ext_ctxt,
                bodyfn: fn(-@ast::expr, ast::blk) -> @ast::expr,
                argfn: fn(-@ast::expr, uint, ast::blk) -> @ast::expr)
     -> ast::arm {
-    let vnames = vec::from_fn(vec::len(tys)) {|i| @#fmt["__v%u", i]};
-    let pats = vec::from_fn(vec::len(tys)) {|i|
+    let vnames = do vec::from_fn(vec::len(tys)) {|i|
+        @#fmt["__v%u", i]
+    };
+    let pats = do vec::from_fn(vec::len(tys)) {|i|
         cx.binder_pat(tys[i].span, vnames[i])
     };
     let pat: @ast::pat = @{id: cx.next_id(), node: pfn(pats), span: span};
-    let stmts = vec::from_fn(vec::len(tys)) {|i|
+    let stmts = do vec::from_fn(vec::len(tys)) {|i|
         let v = cx.var_ref(span, vnames[i]);
         let arg_blk =
             cx.blk(
@@ -374,7 +376,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
       }
 
       ast::ty_rec(flds) {
-        let fld_stmts = vec::from_fn(vec::len(flds)) {|fidx|
+        let fld_stmts = do vec::from_fn(vec::len(flds)) {|fidx|
             let fld = flds[fidx];
             let vf = cx.expr(fld.span,
                              ast::expr_field(cx.clone(v),
@@ -516,7 +518,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
                     tp_inputs);
 
     let tps_map = map::str_hash();
-    vec::iter2(tps, tp_inputs) {|tp, arg|
+    do vec::iter2(tps, tp_inputs) {|tp, arg|
         let arg_ident = arg.ident;
         tps_map.insert(
             *tp.ident,
@@ -537,7 +539,7 @@ fn mk_ser_fn(cx: ext_ctxt, span: span, name: ast::ident,
         vec::append(~[{ident: @"__S",
                       id: cx.next_id(),
                       bounds: ser_bnds}],
-                    vec::map(tps) {|tp| cx.clone_ty_param(tp) });
+                    vec::map(tps, {|tp| cx.clone_ty_param(tp) }));
 
     let ser_output: @ast::ty = @{id: cx.next_id(),
                                  node: ast::ty_nil,
@@ -573,7 +575,7 @@ fn deser_path(cx: ext_ctxt, tps: deser_tps_map, path: @ast::path,
             ast::expr_path(
                 cx.helper_path(path, "deserialize")));
 
-    let ty_args = vec::map(path.types) {|ty|
+    let ty_args = do vec::map(path.types) {|ty|
         let dv_expr = deser_ty(cx, tps, ty, cx.clone(d));
         cx.lambda(cx.expr_blk(dv_expr))
     };
@@ -616,7 +618,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
       }
 
       ast::ty_rec(flds) {
-        let fields = vec::from_fn(vec::len(flds)) {|fidx|
+        let fields = do vec::from_fn(vec::len(flds)) {|fidx|
             let fld = flds[fidx];
             let d = cx.clone(d);
             let f = cx.lit_str(fld.span, fld.node.ident);
@@ -645,7 +647,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
         //    d.read_tup_elt(2u, {||...}))
         // }
 
-        let arg_exprs = vec::from_fn(vec::len(tys)) {|i|
+        let arg_exprs = do vec::from_fn(vec::len(tys)) {|i|
             let idx = cx.lit_uint(ty.span, i);
             let body = deser_lambda(cx, tps, tys[i], cx.clone(d));
             #ast{ $(d).read_tup_elt($(idx), $(body)) }
@@ -723,7 +725,7 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
                     tp_inputs);
 
     let tps_map = map::str_hash();
-    vec::iter2(tps, tp_inputs) {|tp, arg|
+    do vec::iter2(tps, tp_inputs) {|tp, arg|
         let arg_ident = arg.ident;
         tps_map.insert(
             *tp.ident,
@@ -743,12 +745,12 @@ fn mk_deser_fn(cx: ext_ctxt, span: span,
         vec::append(~[{ident: @"__D",
                       id: cx.next_id(),
                       bounds: deser_bnds}],
-                    vec::map(tps) {|tp|
+                    vec::map(tps, {|tp|
                         let cloned = cx.clone_ty_param(tp);
                         {bounds: @(vec::append(*cloned.bounds,
                                                ~[ast::bound_copy]))
                          with cloned}
-                    });
+                    }));
 
     let deser_blk = cx.expr_blk(f(cx, tps_map, #ast(expr){__d}));
 
@@ -781,11 +783,11 @@ fn ser_enum(cx: ext_ctxt, tps: ser_tps_map, e_name: ast::ident,
             e_span: span, variants: ~[ast::variant],
             -s: @ast::expr, -v: @ast::expr) -> ~[@ast::stmt] {
     let ext_cx = cx;
-    let arms = vec::from_fn(vec::len(variants)) {|vidx|
+    let arms = do vec::from_fn(vec::len(variants)) {|vidx|
         let variant = variants[vidx];
         let v_span = variant.span;
         let v_name = variant.node.name;
-        let variant_tys = vec::map(variant.node.args) {|a| a.ty };
+        let variant_tys = vec::map(variant.node.args, {|a| a.ty });
 
         ser_variant(
             cx, tps, variant_tys, v_span, cx.clone(s),
@@ -830,13 +832,13 @@ fn deser_enum(cx: ext_ctxt, tps: deser_tps_map, e_name: ast::ident,
               e_span: span, variants: ~[ast::variant],
               -d: @ast::expr) -> @ast::expr {
     let ext_cx = cx;
-    let arms: ~[ast::arm] = vec::from_fn(vec::len(variants)) {|vidx|
+    let arms: ~[ast::arm] = do vec::from_fn(vec::len(variants)) {|vidx|
         let variant = variants[vidx];
         let v_span = variant.span;
         let v_name = variant.node.name;
-        let tys = vec::map(variant.node.args) {|a| a.ty };
+        let tys = vec::map(variant.node.args, {|a| a.ty });
 
-        let arg_exprs = vec::from_fn(vec::len(tys)) {|i|
+        let arg_exprs = do vec::from_fn(vec::len(tys)) {|i|
             let idx = cx.lit_uint(v_span, i);
             let body = deser_lambda(cx, tps, tys[i], cx.clone(d));
             #ast{ $(d).read_enum_variant_arg($(idx), $(body)) }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 77bf868de37..1b7abc21394 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -100,8 +100,8 @@ fn expand_mod_items(exts: hashmap<str, syntax_extension>, cx: ext_ctxt,
     // For each item, look through the attributes.  If any of them are
     // decorated with "item decorators", then use that function to transform
     // the item into a new set of items.
-    let new_items = vec::flat_map(module.items) {|item|
-        vec::foldr(item.attrs, ~[item]) {|attr, items|
+    let new_items = do vec::flat_map(module.items) {|item|
+        do vec::foldr(item.attrs, ~[item]) {|attr, items|
             let mname = alt attr.node.value.node {
               ast::meta_word(n) { n }
               ast::meta_name_value(n, _) { n }
diff --git a/src/libsyntax/ext/qquote.rs b/src/libsyntax/ext/qquote.rs
index 17468e6b9ef..367a0dcea50 100644
--- a/src/libsyntax/ext/qquote.rs
+++ b/src/libsyntax/ext/qquote.rs
@@ -106,7 +106,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt
     node.visit(cx, mk_vt(v));
     // FIXME (#2250): Maybe this is an overkill (merge_sort), it might
     // be better to just keep the gather array in sorted order.
-    cx.gather.swap { |v|
+    do cx.gather.swap { |v|
         vec::to_mut(std::sort::merge_sort({|a,b| a.lo < b.lo}, v))
     };
     ret cx;
@@ -132,7 +132,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
     -> @ast::expr
 {
     let mut what = "expr";
-    option::iter(arg) {|arg|
+    do option::iter(arg) {|arg|
         let args: ~[@ast::expr] =
             alt arg.node {
               ast::expr_vec(elts, _) { elts }
@@ -205,7 +205,7 @@ fn finish<T: qq_helper>
     let mut state = active;
     let mut i = 0u, j = 0u;
     let g_len = cx.gather.len();
-    str::chars_iter(*str) {|ch|
+    do str::chars_iter(*str) {|ch|
         if (j < g_len && i == cx.gather[j].lo) {
             assert ch == '$';
             let repl = #fmt("$%u ", j);
@@ -259,11 +259,11 @@ fn finish<T: qq_helper>
         rcall = mk_call(cx,sp,
                         ~[@"syntax", @"ext", @"qquote", @"replace"],
                         ~[pcall,
-                         mk_uniq_vec_e(cx,sp, qcx.gather.map_to_vec {|g|
+                         mk_uniq_vec_e(cx,sp, qcx.gather.map_to_vec({|g|
                              mk_call(cx,sp,
                                      ~[@"syntax", @"ext",
                                       @"qquote", @g.constr],
-                                     ~[g.e])}),
+                                     ~[g.e])})),
                          mk_path(cx,sp,
                                  ~[@"syntax", @"ext", @"qquote",
                                   @node.get_fold_fn()])]);
diff --git a/src/libsyntax/ext/simplext.rs b/src/libsyntax/ext/simplext.rs
index bfd78b40b6f..cc3a4d04d06 100644
--- a/src/libsyntax/ext/simplext.rs
+++ b/src/libsyntax/ext/simplext.rs
@@ -276,7 +276,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
             let mut repeat: option<{rep_count: uint, name: ident}> = none;
             /* we need to walk over all the free vars in lockstep, except for
             the leaves, which are just duplicated */
-            free_vars(b, repeat_me) {|fv|
+            do free_vars(b, repeat_me) {|fv|
                 let cur_pos = follow(b.get(fv), idx_path);
                 alt cur_pos {
                   leaf(_) { }
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index d8afdb7534a..51feb53b2b3 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -88,9 +88,9 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
 
     alt io::read_whole_file(res_rel_file(cx, sp, file)) {
       result::ok(src) {
-        let u8_exprs = vec::map(src) { |char: u8|
+        let u8_exprs = vec::map(src, { |char: u8|
             mk_lit(cx, sp, ast::lit_uint(char as u64, ast::ty_u8))
-        };
+        });
         ret mk_uniq_vec_e(cx, sp, u8_exprs);
       }
       result::err(e) {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 942441c5513..dbe09a31dd2 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -255,7 +255,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
               let ctor_body = fld.fold_block(ctor.node.body);
               let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
               let ctor_id   = fld.new_id(ctor.node.id);
-              let dtor = option::map(m_dtor) {|dtor|
+              let dtor = do option::map(m_dtor) {|dtor|
                 let dtor_body = fld.fold_block(dtor.node.body);
                 let dtor_id   = fld.new_id(dtor.node.id);
                 {node: {body: dtor_body,
@@ -273,7 +273,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           item_impl(tps, rp, ifce, ty, methods) {
               item_impl(fold_ty_params(tps, fld),
                         rp,
-                        ifce.map { |p| fold_iface_ref(p, fld) },
+                        ifce.map({ |p| fold_iface_ref(p, fld) }),
                         fld.fold_ty(ty),
                         vec::map(methods, fld.fold_method))
           }
@@ -332,8 +332,8 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
           }
           pat_lit(e) { pat_lit(fld.fold_expr(e)) }
           pat_enum(pth, pats) {
-              pat_enum(fld.fold_path(pth), option::map(pats)
-                       {|pats| vec::map(pats, fld.fold_pat)})
+              pat_enum(fld.fold_path(pth), option::map(pats,
+                       {|pats| vec::map(pats, fld.fold_pat)}))
           }
           pat_rec(fields, etc) {
             let mut fs = ~[];
@@ -490,9 +490,9 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
       ty_vec(mt) {ty_vec(fold_mt(mt, fld))}
       ty_ptr(mt) {ty_ptr(fold_mt(mt, fld))}
       ty_rptr(region, mt) {ty_rptr(region, fold_mt(mt, fld))}
-      ty_rec(fields) {ty_rec(vec::map(fields) {|f| fold_field(f, fld)})}
+      ty_rec(fields) {ty_rec(vec::map(fields, {|f| fold_field(f, fld)}))}
       ty_fn(proto, decl) {ty_fn(proto, fold_fn_decl(decl, fld))}
-      ty_tup(tys) {ty_tup(vec::map(tys) {|ty| fld.fold_ty(ty)})}
+      ty_tup(tys) {ty_tup(vec::map(tys, {|ty| fld.fold_ty(ty)}))}
       ty_path(path, id) {ty_path(fld.fold_path(path), fld.new_id(id))}
       ty_constr(ty, constrs) {ty_constr(fld.fold_ty(ty),
                                 vec::map(constrs, fld.fold_ty_constr))}
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index c9406731030..da09b5daf27 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -159,7 +159,7 @@ class parser {
     }
 
     fn parse_ty_fn_decl(purity: ast::purity) -> fn_decl {
-        let inputs = self.parse_unspanned_seq(
+        let inputs = do self.parse_unspanned_seq(
             token::LPAREN, token::RPAREN,
             seq_sep_trailing_disallowed(token::COMMA)) { |p|
             let mode = p.parse_arg_mode();
@@ -186,7 +186,7 @@ class parser {
     }
 
     fn parse_ty_methods() -> ~[ty_method] {
-        self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
+        do self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
                                  seq_sep_none()) { |p|
             let attrs = p.parse_outer_attributes();
             let flo = p.span.lo;
@@ -494,11 +494,11 @@ class parser {
     }
 
     fn parse_arg_or_capture_item() -> arg_or_capture_item {
-        self.parse_capture_item_or() {|p| p.parse_arg() }
+        self.parse_capture_item_or({|p| p.parse_arg() })
     }
 
     fn parse_fn_block_arg() -> arg_or_capture_item {
-        self.parse_capture_item_or() {|p|
+        do self.parse_capture_item_or {|p|
             let m = p.parse_arg_mode();
             let i = p.parse_value_ident();
             let t = if p.eat(token::COLON) {
@@ -2065,7 +2065,7 @@ class parser {
               members(mms) { ms = vec::append(ms, mms); }
             }
         }
-        let actual_dtor = option::map(the_dtor) {|dtor|
+        let actual_dtor = do option::map(the_dtor) {|dtor|
             let (d_body, d_s) = dtor;
             {node: {id: self.get_id(),
                     self_id: self.get_id(),
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 53d32f2f32f..9a994afb149 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -511,7 +511,7 @@ fn print_item(s: ps, &&item: @ast::item) {
           print_fn_args_and_ret(s, ctor.node.dec, ~[]);
           space(s.s);
           print_block(s, ctor.node.body);
-          option::iter(m_dtor) {|dtor|
+          do option::iter(m_dtor) {|dtor|
             hardbreak_if_not_bol(s);
             maybe_print_comment(s, dtor.span.lo);
             head(s, "drop");
@@ -1136,8 +1136,8 @@ fn print_decl(s: ps, decl: @ast::decl) {
         word_nbsp(s, "let");
 
         // if any are mut, all are mut
-        if vec::any(locs) {|l| l.node.is_mutbl } {
-            assert vec::all(locs) {|l| l.node.is_mutbl };
+        if vec::any(locs, {|l| l.node.is_mutbl }) {
+            assert vec::all(locs, {|l| l.node.is_mutbl });
             word_nbsp(s, "mut");
         }
 
@@ -1405,7 +1405,7 @@ fn print_view_path(s: ps, &&vp: @ast::view_path) {
       ast::view_path_list(path, idents, _) {
         print_path(s, path, false);
         word(s.s, "::{");
-        commasep(s, inconsistent, idents) {|s, w|
+        do commasep(s, inconsistent, idents) {|s, w|
             word(s.s, *w.node.name)
         }
         word(s.s, "}");
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 1e96899fa5c..4e8f1028bcd 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -151,7 +151,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
           for ifaces.each {|p| visit_path(p.path, e, v); }
           visit_class_ctor_helper(ctor, i.ident, tps,
                                   ast_util::local_def(i.id), e, v);
-          option::iter(m_dtor) {|dtor|
+          do option::iter(m_dtor) {|dtor|
                   visit_class_dtor_helper(dtor, tps,
                      ast_util::local_def(i.id), e, v)};
       }
@@ -227,7 +227,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
     alt p.node {
       pat_enum(path, children) {
         visit_path(path, e, v);
-        option::iter(children) {|children|
+        do option::iter(children) {|children|
                 for children.each {|child| v.visit_pat(child, e, v); }}
       }
       pat_rec(fields, _) {
@@ -239,7 +239,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
       }
       pat_ident(path, inner) {
           visit_path(path, e, v);
-          option::iter(inner) {|subpat| v.visit_pat(subpat, e, v)};
+          do option::iter(inner) {|subpat| v.visit_pat(subpat, e, v)};
       }
       pat_lit(ex) { v.visit_expr(ex, e, v); }
       pat_range(e1, e2) { v.visit_expr(e1, e, v); v.visit_expr(e2, e, v); }
@@ -344,7 +344,7 @@ fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
 fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
     alt m.node {
       ast::mac_invoc(pth, arg, body) {
-        option::map(arg) {|arg| v.visit_expr(arg, e, v)}; }
+        option::map(arg, {|arg| v.visit_expr(arg, e, v)}); }
       ast::mac_invoc_tt(pth, tt) { /* no user-serviceable parts inside */ }
       ast::mac_embed_type(ty) { v.visit_ty(ty, e, v); }
       ast::mac_embed_block(blk) { v.visit_block(blk, e, v); }
diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs
index 525f254d4f2..4bdf5ae311b 100644
--- a/src/rustc/back/link.rs
+++ b/src/rustc/back/link.rs
@@ -443,7 +443,7 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> str {
 // gas doesn't!
 fn sanitize(s: str) -> str {
     let mut result = "";
-    str::chars_iter(s) {|c|
+    do str::chars_iter(s) {|c|
         alt c {
           '@' { result += "_sbox_"; }
           '~' { result += "_ubox_"; }
diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs
index 4909cd84771..806f6cded59 100644
--- a/src/rustc/driver/driver.rs
+++ b/src/rustc/driver/driver.rs
@@ -322,7 +322,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
     };
     let is_expanded = upto != cu_parse;
     let src = codemap::get_filemap(sess.codemap, source_name(input)).src;
-    io::with_str_reader(*src) { |rdr|
+    do io::with_str_reader(*src) { |rdr|
         pprust::print_crate(sess.codemap, sess.span_diagnostic, crate,
                             source_name(input),
                             rdr, io::stdout(), ann, is_expanded);
@@ -417,7 +417,7 @@ fn build_session_options(match: getopts::match,
     let lint_flags = vec::append(getopts::opt_strs(match, "W"),
                                  getopts::opt_strs(match, "warn"));
     let lint_dict = lint::get_lint_dict();
-    let lint_opts = vec::map(lint_flags) {|flag|
+    let lint_opts = do vec::map(lint_flags) {|flag|
         alt lint::lookup_lint(lint_dict, flag) {
           (flag, none) {
             early_error(demitter, #fmt("unknown warning: %s", flag))
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 1c4d8d0fcd1..68cfb22fab1 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -211,7 +211,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
     let p = comm::port();
     let ch = comm::chan(p);
 
-    alt task::try  {||
+    alt do task::try  {||
 
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
@@ -259,7 +259,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
 }
 
 fn main(args: ~[str]) {
-    monitor {|demitter|
+    do monitor {|demitter|
         run_compiler(args, demitter);
     }
 }
diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs
index d5725607278..58976b6be36 100644
--- a/src/rustc/front/config.rs
+++ b/src/rustc/front/config.rs
@@ -13,7 +13,7 @@ type ctxt = @{
 // Support conditional compilation by transforming the AST, stripping out
 // any items that do not belong in the current configuration
 fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
-    strip_items(crate) {|attrs|
+    do strip_items(crate) {|attrs|
         in_cfg(crate.node.config, attrs)
     }
 }
diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs
index 52c09f561e8..1f71352b0f3 100644
--- a/src/rustc/front/test.rs
+++ b/src/rustc/front/test.rs
@@ -57,7 +57,7 @@ fn generate_test_harness(sess: session::session,
 fn strip_test_functions(crate: @ast::crate) -> @ast::crate {
     // When not compiling with --test we should not compile the
     // #[test] functions
-    config::strip_items(crate) {|attrs|
+    do config::strip_items(crate) {|attrs|
         !attr::contains_name(attr::attr_metas(attrs), "test")
     }
 }
diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs
index 68d0f48a142..aec77c13633 100644
--- a/src/rustc/metadata/creader.rs
+++ b/src/rustc/metadata/creader.rs
@@ -68,14 +68,14 @@ fn warn_if_multiple_versions(diag: span_handler,
     if crate_cache.len() != 0u {
         let name = loader::crate_name_from_metas(*crate_cache.last().metas);
         let {lefts: matches, rights: non_matches} =
-            partition(crate_cache.map_to_vec {|entry|
+            partition(crate_cache.map_to_vec({|entry|
                 let othername = loader::crate_name_from_metas(*entry.metas);
                 if name == othername {
                     left(entry)
                 } else {
                     right(entry)
                 }
-            });
+            }));
 
         assert matches.is_not_empty();
 
diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs
index 5834cdcb1ce..14877cf7971 100644
--- a/src/rustc/metadata/csearch.rs
+++ b/src/rustc/metadata/csearch.rs
@@ -120,7 +120,7 @@ fn get_impls_for_mod(cstore: cstore::cstore, def: ast::def_id,
                      name: option<ast::ident>)
     -> @~[@decoder::_impl] {
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_impls_for_mod(cdata, def.node, name) {|cnum|
+    do decoder::get_impls_for_mod(cdata, def.node, name) {|cnum|
         cstore::get_crate_data(cstore, cnum)
     }
 }
diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs
index e1de034f40a..cfdc1f555a4 100644
--- a/src/rustc/metadata/cstore.rs
+++ b/src/rustc/metadata/cstore.rs
@@ -96,7 +96,7 @@ fn get_crate_vers(cstore: cstore, cnum: ast::crate_num) -> @str {
 fn set_crate_data(cstore: cstore, cnum: ast::crate_num,
                   data: crate_metadata) {
     p(cstore).metas.insert(cnum, data);
-    vec::iter(decoder::get_crate_module_paths(data.data)) {|dp|
+    do vec::iter(decoder::get_crate_module_paths(data.data)) {|dp|
         let (did, path) = dp;
         let d = {crate: cnum, node: did.node};
         p(cstore).mod_path_map.insert(d, @path);
diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs
index db5bd5665a0..b738bd2ed8c 100644
--- a/src/rustc/metadata/decoder.rs
+++ b/src/rustc/metadata/decoder.rs
@@ -64,7 +64,7 @@ fn lookup_hash(d: ebml::doc, eq_fn: fn@(~[u8]) -> bool, hash: uint) ->
 
     let mut result: ~[ebml::doc] = ~[];
     let belt = tag_index_buckets_bucket_elt;
-    ebml::tagged_docs(bucket, belt) {|elt|
+    do ebml::tagged_docs(bucket, belt) {|elt|
         let pos = io::u64_from_be_bytes(*elt.data, elt.start, 4u) as uint;
         if eq_fn(vec::slice::<u8>(*elt.data, elt.start + 4u, elt.end)) {
             vec::push(result, ebml::doc_at(d.data, pos).doc);
@@ -110,7 +110,7 @@ fn item_symbol(item: ebml::doc) -> str {
 
 fn item_parent_item(d: ebml::doc) -> option<ast::def_id> {
     let mut found = none;
-    ebml::tagged_docs(d, tag_items_data_parent_item) {|did|
+    do ebml::tagged_docs(d, tag_items_data_parent_item) {|did|
         found = some(parse_def_id(ebml::doc_data(did)));
     }
     found
@@ -134,7 +134,7 @@ fn field_mutability(d: ebml::doc) -> ast::class_mutability {
 }
 
 fn variant_disr_val(d: ebml::doc) -> option<int> {
-    option::chain(ebml::maybe_get_doc(d, tag_disr_val)) {|val_doc|
+    do option::chain(ebml::maybe_get_doc(d, tag_disr_val)) {|val_doc|
         int::parse_buf(ebml::doc_data(val_doc), 10u)
     }
 }
@@ -157,7 +157,7 @@ fn item_type(item_id: ast::def_id, item: ebml::doc,
 fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
     -> option<ty::t> {
     let mut result = none;
-    ebml::tagged_docs(item, tag_impl_iface) {|ity|
+    do ebml::tagged_docs(item, tag_impl_iface) {|ity|
         result = some(doc_type(ity, tcx, cdata));
     };
     result
@@ -166,7 +166,7 @@ fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
 fn item_ty_param_bounds(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
     -> @~[ty::param_bounds] {
     let mut bounds = ~[];
-    ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
+    do ebml::tagged_docs(item, tag_items_data_item_ty_param_bounds) {|p|
         let bd = parse_bounds_data(p.data, p.start, cdata.cnum, tcx, {|did|
             translate_def_id(cdata, did)
         });
@@ -197,7 +197,7 @@ fn item_ty_param_count(item: ebml::doc) -> uint {
 fn enum_variant_ids(item: ebml::doc, cdata: cmd) -> ~[ast::def_id] {
     let mut ids: ~[ast::def_id] = ~[];
     let v = tag_items_data_item_variant;
-    ebml::tagged_docs(item, v) {|p|
+    do ebml::tagged_docs(item, v) {|p|
         let ext = parse_def_id(ebml::doc_data(p));
         vec::push(ids, {crate: cdata.cnum, node: ext.node});
     };
@@ -232,7 +232,7 @@ fn item_path(item_doc: ebml::doc) -> ast_map::path {
     let mut result = ~[];
     vec::reserve(result, len);
 
-    ebml::docs(path_doc) {|tag, elt_doc|
+    do ebml::docs(path_doc) {|tag, elt_doc|
         if tag == tag_path_elt_mod {
             let str = ebml::doc_as_str(elt_doc);
             vec::push(result, ast_map::path_mod(@str));
@@ -306,7 +306,7 @@ fn get_impl_method(cdata: cmd, id: ast::node_id,
                    name: ast::ident) -> ast::def_id {
     let items = ebml::get_doc(ebml::doc(cdata.data), tag_items);
     let mut found = none;
-    ebml::tagged_docs(find_item(id, items), tag_item_impl_method) {|mid|
+    do ebml::tagged_docs(find_item(id, items), tag_item_impl_method) {|mid|
         let m_did = parse_def_id(ebml::doc_data(mid));
         if item_name(find_item(m_did.node, items)) == name {
             found = some(translate_def_id(cdata, m_did));
@@ -323,7 +323,7 @@ fn get_class_method(cdata: cmd, id: ast::node_id,
             some(it) { it }
             none { fail (#fmt("get_class_method: class id not found \
              when looking up method %s", *name)) }};
-    ebml::tagged_docs(cls_items, tag_item_iface_method) {|mid|
+    do ebml::tagged_docs(cls_items, tag_item_iface_method) {|mid|
         let m_did = class_member_id(mid, cdata);
         if item_name(mid) == name {
             found = some(m_did);
@@ -343,7 +343,7 @@ fn class_dtor(cdata: cmd, id: ast::node_id) -> option<ast::def_id> {
             none     { fail (#fmt("class_dtor: class id not found \
               when looking up dtor for %d", id)); }
     };
-    ebml::tagged_docs(cls_items, tag_item_dtor) {|doc|
+    do ebml::tagged_docs(cls_items, tag_item_dtor) {|doc|
          let doc1 = ebml::get_doc(doc, tag_def_id);
          let did = parse_def_id(ebml::doc_data(doc1));
          found = some(translate_def_id(cdata, did));
@@ -429,7 +429,7 @@ type _impl = {did: ast::def_id, ident: ast::ident, methods: ~[@method_info]};
 fn item_impl_methods(cdata: cmd, item: ebml::doc, base_tps: uint)
     -> ~[@method_info] {
     let mut rslt = ~[];
-    ebml::tagged_docs(item, tag_item_impl_method) {|doc|
+    do ebml::tagged_docs(item, tag_item_impl_method) {|doc|
         let m_did = parse_def_id(ebml::doc_data(doc));
         let mth_item = lookup_item(m_did.node, cdata.data);
         vec::push(rslt, @{did: translate_def_id(cdata, m_did),
@@ -447,7 +447,7 @@ fn get_impls_for_mod(cdata: cmd, m_id: ast::node_id,
     let data = cdata.data;
     let mod_item = lookup_item(m_id, data);
     let mut result = ~[];
-    ebml::tagged_docs(mod_item, tag_mod_impl) {|doc|
+    do ebml::tagged_docs(mod_item, tag_mod_impl) {|doc|
         let did = parse_def_id(ebml::doc_data(doc));
         let local_did = translate_def_id(cdata, did);
           // The impl may be defined in a different crate. Ask the caller
@@ -473,7 +473,7 @@ fn get_iface_methods(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
-    ebml::tagged_docs(item, tag_item_iface_method) {|mth|
+    do ebml::tagged_docs(item, tag_item_iface_method) {|mth|
         let bounds = item_ty_param_bounds(mth, tcx, cdata);
         let name = item_name(mth);
         let ty = doc_type(mth, tcx, cdata);
@@ -498,7 +498,7 @@ fn get_class_members(cdata: cmd, id: ast::node_id,
     let data = cdata.data;
     let item = lookup_item(id, data);
     let mut result = ~[];
-    ebml::tagged_docs(item, tag_item_field) {|an_item|
+    do ebml::tagged_docs(item, tag_item_field) {|an_item|
        let f = item_family(an_item);
        if p(f) {
           let name = item_name(an_item);
@@ -578,12 +578,12 @@ fn item_family_to_str(fam: char) -> str {
 
 fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] {
     let mut items: ~[@ast::meta_item] = ~[];
-    ebml::tagged_docs(md, tag_meta_item_word) {|meta_item_doc|
+    do ebml::tagged_docs(md, tag_meta_item_word) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::from_bytes(ebml::doc_data(nd));
         vec::push(items, attr::mk_word_item(@n));
     };
-    ebml::tagged_docs(md, tag_meta_item_name_value) {|meta_item_doc|
+    do ebml::tagged_docs(md, tag_meta_item_name_value) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let vd = ebml::get_doc(meta_item_doc, tag_meta_item_value);
         let n = str::from_bytes(ebml::doc_data(nd));
@@ -592,7 +592,7 @@ fn get_meta_items(md: ebml::doc) -> ~[@ast::meta_item] {
         // but currently the encoder just drops them
         vec::push(items, attr::mk_name_value_item_str(@n, v));
     };
-    ebml::tagged_docs(md, tag_meta_item_list) {|meta_item_doc|
+    do ebml::tagged_docs(md, tag_meta_item_list) {|meta_item_doc|
         let nd = ebml::get_doc(meta_item_doc, tag_meta_item_name);
         let n = str::from_bytes(ebml::doc_data(nd));
         let subitems = get_meta_items(meta_item_doc);
@@ -605,7 +605,7 @@ fn get_attributes(md: ebml::doc) -> ~[ast::attribute] {
     let mut attrs: ~[ast::attribute] = ~[];
     alt ebml::maybe_get_doc(md, tag_attributes) {
       option::some(attrs_d) {
-        ebml::tagged_docs(attrs_d, tag_attribute) {|attr_doc|
+        do ebml::tagged_docs(attrs_d, tag_attribute) {|attr_doc|
             let meta_items = get_meta_items(attr_doc);
             // Currently it's only possible to have a single meta item on
             // an attribute
@@ -652,7 +652,7 @@ fn get_crate_deps(data: @~[u8]) -> ~[crate_dep] {
     fn docstr(doc: ebml::doc, tag_: uint) -> str {
         str::from_bytes(ebml::doc_data(ebml::get_doc(doc, tag_)))
     }
-    ebml::tagged_docs(depsdoc, tag_crate_dep) {|depdoc|
+    do ebml::tagged_docs(depsdoc, tag_crate_dep) {|depdoc|
         vec::push(deps, {cnum: crate_num,
                   name: @docstr(depdoc, tag_crate_dep_name),
                   vers: @docstr(depdoc, tag_crate_dep_vers),
@@ -691,7 +691,7 @@ fn get_crate_vers(data: @~[u8]) -> @str {
 fn list_crate_items(bytes: @~[u8], md: ebml::doc, out: io::writer) {
     out.write_str("=Items=\n");
     let items = ebml::get_doc(md, tag_items);
-    iter_crate_items(bytes) {|path, did|
+    do iter_crate_items(bytes) {|path, did|
         out.write_str(#fmt["%s (%s)\n", path, describe_def(items, did)]);
     }
     out.write_str("\n");
@@ -702,9 +702,9 @@ fn iter_crate_items(bytes: @~[u8], proc: fn(str, ast::def_id)) {
     let paths = ebml::get_doc(md, tag_paths);
     let index = ebml::get_doc(paths, tag_index);
     let bs = ebml::get_doc(index, tag_index_buckets);
-    ebml::tagged_docs(bs, tag_index_buckets_bucket) {|bucket|
+    do ebml::tagged_docs(bs, tag_index_buckets_bucket) {|bucket|
         let et = tag_index_buckets_bucket_elt;
-        ebml::tagged_docs(bucket, et) {|elt|
+        do ebml::tagged_docs(bucket, et) {|elt|
             let data = read_path(elt);
             let {tag:_, doc:def} = ebml::doc_at(bytes, data.pos);
             let did_doc = ebml::get_doc(def, tag_def_id);
@@ -723,7 +723,7 @@ fn get_crate_module_paths(bytes: @~[u8]) -> ~[(ast::def_id, str)] {
     // fowarded path due to renamed import or reexport
     let mut res = ~[];
     let mods = map::str_hash();
-    iter_crate_items(bytes) {|path, did|
+    do iter_crate_items(bytes) {|path, did|
         let m = mod_of_path(path);
         if str::is_not_empty(m) {
             // if m has a sub-item, it must be a module
@@ -734,7 +734,7 @@ fn get_crate_module_paths(bytes: @~[u8]) -> ~[(ast::def_id, str)] {
         // unified later by using the mods map
         vec::push(res, (did, path));
     }
-    ret vec::filter(res) {|x|
+    ret do vec::filter(res) {|x|
         let (_, xp) = x;
         mods.contains_key(xp)
     }
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
index 583be6c03f2..b62854ab8cc 100644
--- a/src/rustc/metadata/encoder.rs
+++ b/src/rustc/metadata/encoder.rs
@@ -87,20 +87,20 @@ fn encode_name_and_def_id(ebml_w: ebml::writer, nm: ident,
 }
 
 fn encode_region_param(ebml_w: ebml::writer, rp: region_param) {
-    ebml_w.wr_tag(tag_region_param) {||
+    do ebml_w.wr_tag(tag_region_param) {||
         serialize_region_param(ebml_w, rp)
     }
 }
 
 fn encode_named_def_id(ebml_w: ebml::writer, name: ident, id: def_id) {
-    ebml_w.wr_tag(tag_paths_data_item) {||
+    do ebml_w.wr_tag(tag_paths_data_item) {||
         encode_name(ebml_w, name);
         encode_def_id(ebml_w, id);
     }
 }
 
 fn encode_mutability(ebml_w: ebml::writer, mt: class_mutability) {
-    ebml_w.wr_tag(tag_class_mut) {||
+    do ebml_w.wr_tag(tag_class_mut) {||
         ebml_w.writer.write(&[alt mt { class_immutable { 'i' }
                 class_mutable { 'm' } } as u8]);
         }
@@ -112,7 +112,7 @@ fn encode_enum_variant_paths(ebml_w: ebml::writer, variants: ~[variant],
                             path: ~[ident], &index: ~[entry<str>]) {
     for variants.each {|variant|
         add_to_index(ebml_w, path, index, variant.node.name);
-        ebml_w.wr_tag(tag_paths_data_item) {||
+        do ebml_w.wr_tag(tag_paths_data_item) {||
             encode_name(ebml_w, variant.node.name);
             encode_def_id(ebml_w, local_def(variant.node.id));
         }
@@ -170,7 +170,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             encode_named_def_id(ebml_w, it.ident, local_def(it.id));
           }
           item_mod(_mod) {
-            ebml_w.wr_tag(tag_paths_data_mod) {||
+            do ebml_w.wr_tag(tag_paths_data_mod) {||
                encode_name_and_def_id(ebml_w, it.ident, it.id);
                encode_module_item_paths(ebml_w, ecx, _mod,
                                         vec::append_one(path, it.ident),
@@ -178,7 +178,7 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             }
           }
           item_foreign_mod(nmod) {
-            ebml_w.wr_tag(tag_paths_data_mod) {||
+            do ebml_w.wr_tag(tag_paths_data_mod) {||
               encode_name_and_def_id(ebml_w, it.ident, it.id);
               encode_foreign_module_item_paths(
                   ebml_w, nmod,
@@ -186,15 +186,15 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             }
           }
           item_ty(_, tps, _) {
-            ebml_w.wr_tag(tag_paths_data_item) {||
+            do ebml_w.wr_tag(tag_paths_data_item) {||
               encode_name_and_def_id(ebml_w, it.ident, it.id);
             }
           }
           item_class(_, _, items, ctor, m_dtor, _) {
-            ebml_w.wr_tag(tag_paths_data_item) {||
+            do ebml_w.wr_tag(tag_paths_data_item) {||
                 encode_name_and_def_id(ebml_w, it.ident, it.id);
             }
-            ebml_w.wr_tag(tag_paths) {||
+            do ebml_w.wr_tag(tag_paths) {||
                 // We add the same ident twice: for the
                 // class and for its ctor
                 add_to_index(ebml_w, path, index, it.ident);
@@ -206,13 +206,13 @@ fn encode_module_item_paths(ebml_w: ebml::writer, ecx: @encode_ctxt,
             }
           }
           item_enum(variants, _, _) {
-              ebml_w.wr_tag(tag_paths_data_item) {||
+              do ebml_w.wr_tag(tag_paths_data_item) {||
                   encode_name_and_def_id(ebml_w, it.ident, it.id);
               }
               encode_enum_variant_paths(ebml_w, variants, path, index);
           }
           item_iface(*) {
-              ebml_w.wr_tag(tag_paths_data_item) {||
+              do ebml_w.wr_tag(tag_paths_data_item) {||
                   encode_name_and_def_id(ebml_w, it.ident, it.id);
               }
           }
@@ -372,9 +372,9 @@ fn encode_path(ebml_w: ebml::writer,
         ebml_w.wr_tagged_str(tag, *name);
     }
 
-    ebml_w.wr_tag(tag_path) {||
+    do ebml_w.wr_tag(tag_path) {||
         ebml_w.wr_tagged_u32(tag_path_len, (vec::len(path) + 1u) as u32);
-        vec::iter(path) {|pe| encode_path_elt(ebml_w, pe); }
+        do vec::iter(path) {|pe| encode_path_elt(ebml_w, pe); }
         encode_path_elt(ebml_w, name);
     }
 }
@@ -602,7 +602,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
       }
       item_enum(variants, tps, rp) {
         add_to_index();
-        ebml_w.wr_tag(tag_items_data_item) {||
+        do ebml_w.wr_tag(tag_items_data_item) {||
             encode_def_id(ebml_w, local_def(item.id));
             encode_family(ebml_w, 't');
             encode_type_param_bounds(ebml_w, ecx, tps);
@@ -626,7 +626,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         let idx = encode_info_for_class(ecx, ebml_w, item.id, path, tps,
                                           items, index);
         /* Encode the dtor */
-        option::iter(m_dtor) {|dtor|
+        do option::iter(m_dtor) {|dtor|
             vec::push(*index, {val: dtor.node.id, pos: ebml_w.writer.tell()});
           encode_info_for_fn(ecx, ebml_w, dtor.node.id, @(*item.ident
                              + "_dtor"), path, if tps.len() > 0u {
@@ -651,8 +651,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         }
         /* Encode the dtor */
         /* Encode id for dtor */
-        option::iter(m_dtor) {|dtor|
-            ebml_w.wr_tag(tag_item_dtor) {||
+        do option::iter(m_dtor) {|dtor|
+            do ebml_w.wr_tag(tag_item_dtor) {||
                 encode_def_id(ebml_w, local_def(dtor.node.id));
             }
         };
@@ -708,7 +708,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             ebml_w.writer.write(str::bytes(def_to_str(local_def(m.id))));
             ebml_w.end_tag();
         }
-        option::iter(ifce) {|t|
+        do option::iter(ifce) {|t|
            encode_iface_ref(ebml_w, ecx, t)
         };
         encode_path(ebml_w, path, ast_map::path_name(item.ident));
@@ -977,7 +977,7 @@ fn encode_crate_deps(ebml_w: ebml::writer, cstore: cstore::cstore) {
 
         // Pull the cnums and name,vers,hash out of cstore
         let mut deps: ~[mut numdep] = ~[mut];
-        cstore::iter_crate_data(cstore) {|key, val|
+        do cstore::iter_crate_data(cstore) {|key, val|
             let dep = {cnum: key, name: @val.name,
                        vers: decoder::get_crate_vers(val.data),
                        hash: decoder::get_crate_hash(val.data)};
diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs
index 06f5bbcd4a9..8ceb5d5b68c 100644
--- a/src/rustc/metadata/filesearch.rs
+++ b/src/rustc/metadata/filesearch.rs
@@ -134,7 +134,7 @@ fn get_cargo_root() -> result<path, str> {
 }
 
 fn get_cargo_root_nearest() -> result<path, str> {
-    result::chain(get_cargo_root()) { |p|
+    do result::chain(get_cargo_root()) { |p|
         let cwd = os::getcwd();
         let mut dirname = path::dirname(cwd);
         let mut dirpath = path::split(dirname);
@@ -158,13 +158,13 @@ fn get_cargo_root_nearest() -> result<path, str> {
 }
 
 fn get_cargo_lib_path() -> result<path, str> {
-    result::chain(get_cargo_root()) { |p|
+    do result::chain(get_cargo_root()) { |p|
         result::ok(path::connect(p, libdir()))
     }
 }
 
 fn get_cargo_lib_path_nearest() -> result<path, str> {
-    result::chain(get_cargo_root_nearest()) { |p|
+    do result::chain(get_cargo_root_nearest()) { |p|
         result::ok(path::connect(p, libdir()))
     }
 }
diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs
index f3622f33f38..3fc88ffa794 100644
--- a/src/rustc/metadata/tydecode.rs
+++ b/src/rustc/metadata/tydecode.rs
@@ -192,9 +192,9 @@ fn parse_vstore(st: @pstate) -> ty::vstore {
 }
 
 fn parse_substs(st: @pstate, conv: conv_did) -> ty::substs {
-    let self_r = parse_opt(st) {|| parse_region(st) };
+    let self_r = parse_opt(st, {|| parse_region(st) });
 
-    let self_ty = parse_opt(st) {|| parse_ty(st, conv) };
+    let self_ty = parse_opt(st, {|| parse_ty(st, conv) });
 
     assert next(st) == '[';
     let mut params: [ty::t]/~ = []/~;
diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs
index 6e6f683d0e3..f90834ea1fc 100644
--- a/src/rustc/metadata/tyencode.rs
+++ b/src/rustc/metadata/tyencode.rs
@@ -115,8 +115,8 @@ fn enc_opt<T>(w: io::writer, t: option<T>, enc_f: fn(T)) {
 }
 
 fn enc_substs(w: io::writer, cx: @ctxt, substs: ty::substs) {
-    enc_opt(w, substs.self_r) { |r| enc_region(w, cx, r) }
-    enc_opt(w, substs.self_ty) { |t| enc_ty(w, cx, t) }
+    do enc_opt(w, substs.self_r) { |r| enc_region(w, cx, r) }
+    do enc_opt(w, substs.self_ty) { |t| enc_ty(w, cx, t) }
     w.write_char('[');
     for substs.tps.each { |t| enc_ty(w, cx, t); }
     w.write_char(']');
diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs
index 1082133f2b8..165a9e28264 100644
--- a/src/rustc/middle/astencode.rs
+++ b/src/rustc/middle/astencode.rs
@@ -87,7 +87,7 @@ fn encode_inlined_item(ecx: @e::encode_ctxt,
            ebml_w.writer.tell()];
 
     let id_range = ast_util::compute_id_range_for_inlined_item(ii);
-    ebml_w.wr_tag(c::tag_ast as uint) {||
+    do ebml_w.wr_tag(c::tag_ast as uint) {||
         ast_util::serialize_id_range(ebml_w, id_range);
         encode_ast(ebml_w, simplify_ast(ii));
         encode_side_tables_for_ii(ecx, maps, ebml_w, ii);
@@ -210,7 +210,7 @@ impl deserializer_helpers<D: deserializer> for D {
 // but eventually we should add entries to the local codemap as required.
 
 fn encode_ast(ebml_w: ebml::writer, item: ast::inlined_item) {
-    ebml_w.wr_tag(c::tag_tree as uint) {||
+    do ebml_w.wr_tag(c::tag_tree as uint) {||
         ast::serialize_inlined_item(ebml_w, item)
     }
 }
@@ -227,7 +227,7 @@ fn encode_ast(ebml_w: ebml::writer, item: ast::inlined_item) {
 // inlined items.
 fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
     fn drop_nested_items(blk: ast::blk_, fld: fold::ast_fold) -> ast::blk_ {
-        let stmts_sans_items = vec::filter(blk.stmts) {|stmt|
+        let stmts_sans_items = do vec::filter(blk.stmts) {|stmt|
             alt stmt.node {
               ast::stmt_expr(_, _) | ast::stmt_semi(_, _) |
               ast::stmt_decl(@{node: ast::decl_local(_), span: _}, _) { true }
@@ -425,7 +425,7 @@ fn encode_vtable_res(ecx: @e::encode_ctxt,
     // ty::t doesn't work, and there is no way (atm) to have
     // hand-written serialization routines combine with auto-generated
     // ones.  perhaps we should fix this.
-    ebml_w.emit_from_vec(*dr) {|vtable_origin|
+    do ebml_w.emit_from_vec(*dr) {|vtable_origin|
         encode_vtable_origin(ecx, ebml_w, vtable_origin)
     }
 }
@@ -433,37 +433,37 @@ fn encode_vtable_res(ecx: @e::encode_ctxt,
 fn encode_vtable_origin(ecx: @e::encode_ctxt,
                       ebml_w: ebml::writer,
                       vtable_origin: typeck::vtable_origin) {
-    ebml_w.emit_enum("vtable_origin") {||
+    do ebml_w.emit_enum("vtable_origin") {||
         alt vtable_origin {
           typeck::vtable_static(def_id, tys, vtable_res) {
-            ebml_w.emit_enum_variant("vtable_static", 0u, 3u) {||
-                ebml_w.emit_enum_variant_arg(0u) {||
+            do ebml_w.emit_enum_variant("vtable_static", 0u, 3u) {||
+                do ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_def_id(def_id)
                 }
-                ebml_w.emit_enum_variant_arg(1u) {||
+                do ebml_w.emit_enum_variant_arg(1u) {||
                     ebml_w.emit_tys(ecx, tys);
                 }
-                ebml_w.emit_enum_variant_arg(2u) {||
+                do ebml_w.emit_enum_variant_arg(2u) {||
                     encode_vtable_res(ecx, ebml_w, vtable_res);
                 }
             }
           }
           typeck::vtable_param(pn, bn) {
-            ebml_w.emit_enum_variant("vtable_param", 1u, 2u) {||
-                ebml_w.emit_enum_variant_arg(0u) {||
+            do ebml_w.emit_enum_variant("vtable_param", 1u, 2u) {||
+                do ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_uint(pn);
                 }
-                ebml_w.emit_enum_variant_arg(1u) {||
+                do ebml_w.emit_enum_variant_arg(1u) {||
                     ebml_w.emit_uint(bn);
                 }
             }
           }
           typeck::vtable_iface(def_id, tys) {
-            ebml_w.emit_enum_variant("vtable_iface", 1u, 3u) {||
-                ebml_w.emit_enum_variant_arg(0u) {||
+            do ebml_w.emit_enum_variant("vtable_iface", 1u, 3u) {||
+                do ebml_w.emit_enum_variant_arg(0u) {||
                     ebml_w.emit_def_id(def_id)
                 }
-                ebml_w.emit_enum_variant_arg(1u) {||
+                do ebml_w.emit_enum_variant_arg(1u) {||
                     ebml_w.emit_tys(ecx, tys);
                 }
             }
@@ -475,43 +475,43 @@ fn encode_vtable_origin(ecx: @e::encode_ctxt,
 
 impl helpers for ebml::ebml_deserializer {
     fn read_vtable_res(xcx: extended_decode_ctxt) -> typeck::vtable_res {
-        @self.read_to_vec {|| self.read_vtable_origin(xcx) }
+        @self.read_to_vec({|| self.read_vtable_origin(xcx) })
     }
 
     fn read_vtable_origin(xcx: extended_decode_ctxt)
         -> typeck::vtable_origin {
-        self.read_enum("vtable_origin") {||
-            self.read_enum_variant {|i|
+        do self.read_enum("vtable_origin") {||
+            do self.read_enum_variant {|i|
                 alt check i {
                   0u {
                     typeck::vtable_static(
-                        self.read_enum_variant_arg(0u) {||
+                        do self.read_enum_variant_arg(0u) {||
                             self.read_def_id(xcx)
                         },
-                        self.read_enum_variant_arg(1u) {||
+                        do self.read_enum_variant_arg(1u) {||
                             self.read_tys(xcx)
                         },
-                        self.read_enum_variant_arg(2u) {||
+                        do self.read_enum_variant_arg(2u) {||
                             self.read_vtable_res(xcx)
                         }
                     )
                   }
                   1u {
                     typeck::vtable_param(
-                        self.read_enum_variant_arg(0u) {||
+                        do self.read_enum_variant_arg(0u) {||
                             self.read_uint()
                         },
-                        self.read_enum_variant_arg(1u) {||
+                        do self.read_enum_variant_arg(1u) {||
                             self.read_uint()
                         }
                     )
                   }
                   2u {
                     typeck::vtable_iface(
-                        self.read_enum_variant_arg(0u) {||
+                        do self.read_enum_variant_arg(0u) {||
                             self.read_def_id(xcx)
                         },
-                        self.read_enum_variant_arg(1u) {||
+                        do self.read_enum_variant_arg(1u) {||
                             self.read_tys(xcx)
                         }
                     )
@@ -541,7 +541,7 @@ impl helpers for ebml::writer {
     }
 
     fn emit_tys(ecx: @e::encode_ctxt, tys: ~[ty::t]) {
-        self.emit_from_vec(tys) {|ty|
+        do self.emit_from_vec(tys) {|ty|
             e::write_type(ecx, self, ty)
         }
     }
@@ -551,16 +551,16 @@ impl helpers for ebml::writer {
     }
 
     fn emit_tpbt(ecx: @e::encode_ctxt, tpbt: ty::ty_param_bounds_and_ty) {
-        self.emit_rec {||
-            self.emit_rec_field("bounds", 0u) {||
-                self.emit_from_vec(*tpbt.bounds) {|bs|
+        do self.emit_rec {||
+            do self.emit_rec_field("bounds", 0u) {||
+                do self.emit_from_vec(*tpbt.bounds) {|bs|
                     self.emit_bounds(ecx, bs)
                 }
             }
-            self.emit_rec_field("rp", 1u) {||
+            do self.emit_rec_field("rp", 1u) {||
                 ast::serialize_region_param(self, tpbt.rp)
             }
-            self.emit_rec_field("ty", 2u) {||
+            do self.emit_rec_field("ty", 2u) {||
                 self.emit_ty(ecx, tpbt.ty);
             }
         }
@@ -569,7 +569,7 @@ impl helpers for ebml::writer {
 
 impl writer for ebml::writer {
     fn tag(tag_id: c::astencode_tag, f: fn()) {
-        self.wr_tag(tag_id as uint) {|| f() }
+        do self.wr_tag(tag_id as uint) {|| f() }
     }
 
     fn id(id: ast::node_id) {
@@ -581,7 +581,7 @@ fn encode_side_tables_for_ii(ecx: @e::encode_ctxt,
                              maps: maps,
                              ebml_w: ebml::writer,
                              ii: ast::inlined_item) {
-    ebml_w.wr_tag(c::tag_table as uint) {||
+    do ebml_w.wr_tag(c::tag_table as uint) {||
         ast_util::visit_ids_for_inlined_item(
             ii,
             fn@(id: ast::node_id, copy ebml_w) {
@@ -601,37 +601,37 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
 
     #debug["Encoding side tables for id %d", id];
 
-    option::iter(tcx.def_map.find(id)) {|def|
-        ebml_w.tag(c::tag_table_def) {||
+    do option::iter(tcx.def_map.find(id)) {|def|
+        do ebml_w.tag(c::tag_table_def) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 ast::serialize_def(ebml_w, def)
             }
         }
     }
-    option::iter((*tcx.node_types).find(id as uint)) {|ty|
-        ebml_w.tag(c::tag_table_node_type) {||
+    do option::iter((*tcx.node_types).find(id as uint)) {|ty|
+        do ebml_w.tag(c::tag_table_node_type) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 e::write_type(ecx, ebml_w, ty)
             }
         }
     }
 
-    option::iter(tcx.node_type_substs.find(id)) {|tys|
-        ebml_w.tag(c::tag_table_node_type_subst) {||
+    do option::iter(tcx.node_type_substs.find(id)) {|tys|
+        do ebml_w.tag(c::tag_table_node_type_subst) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 ebml_w.emit_tys(ecx, tys)
             }
         }
     }
 
-    option::iter(tcx.freevars.find(id)) {|fv|
-        ebml_w.tag(c::tag_table_freevars) {||
+    do option::iter(tcx.freevars.find(id)) {|fv|
+        do ebml_w.tag(c::tag_table_freevars) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
-                ebml_w.emit_from_vec(*fv) {|fv_entry|
+            do ebml_w.tag(c::tag_table_val) {||
+                do ebml_w.emit_from_vec(*fv) {|fv_entry|
                     encode_freevar_entry(ebml_w, *fv_entry)
                 }
             }
@@ -639,19 +639,19 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
     }
 
     let lid = {crate: ast::local_crate, node: id};
-    option::iter(tcx.tcache.find(lid)) {|tpbt|
-        ebml_w.tag(c::tag_table_tcache) {||
+    do option::iter(tcx.tcache.find(lid)) {|tpbt|
+        do ebml_w.tag(c::tag_table_tcache) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 ebml_w.emit_tpbt(ecx, tpbt);
             }
         }
     }
 
-    option::iter(tcx.ty_param_bounds.find(id)) {|pbs|
-        ebml_w.tag(c::tag_table_param_bounds) {||
+    do option::iter(tcx.ty_param_bounds.find(id)) {|pbs|
+        do ebml_w.tag(c::tag_table_param_bounds) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 ebml_w.emit_bounds(ecx, pbs)
             }
         }
@@ -671,17 +671,17 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
     //    }
     //}
 
-    option::iter(maps.mutbl_map.find(id)) {|_m|
-        ebml_w.tag(c::tag_table_mutbl) {||
+    do option::iter(maps.mutbl_map.find(id)) {|_m|
+        do ebml_w.tag(c::tag_table_mutbl) {||
             ebml_w.id(id);
         }
     }
 
-    option::iter(maps.last_use_map.find(id)) {|m|
-        ebml_w.tag(c::tag_table_last_use) {||
+    do option::iter(maps.last_use_map.find(id)) {|m|
+        do ebml_w.tag(c::tag_table_last_use) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
-                ebml_w.emit_from_vec((*m).get()) {|id|
+            do ebml_w.tag(c::tag_table_val) {||
+                do ebml_w.emit_from_vec((*m).get()) {|id|
                     ebml_w.emit_int(id);
                 }
             }
@@ -691,28 +691,28 @@ fn encode_side_tables_for_id(ecx: @e::encode_ctxt,
     // impl_map is not used except when emitting metadata,
     // don't need to keep it.
 
-    option::iter(maps.method_map.find(id)) {|mme|
-        ebml_w.tag(c::tag_table_method_map) {||
+    do option::iter(maps.method_map.find(id)) {|mme|
+        do ebml_w.tag(c::tag_table_method_map) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 serialize_method_map_entry(ebml_w, mme)
             }
         }
     }
 
-    option::iter(maps.vtable_map.find(id)) {|dr|
-        ebml_w.tag(c::tag_table_vtable_map) {||
+    do option::iter(maps.vtable_map.find(id)) {|dr|
+        do ebml_w.tag(c::tag_table_vtable_map) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 encode_vtable_res(ecx, ebml_w, dr);
             }
         }
     }
 
-    option::iter(tcx.borrowings.find(id)) {|borrow|
-        ebml_w.tag(c::tag_table_borrowings) {||
+    do option::iter(tcx.borrowings.find(id)) {|borrow|
+        do ebml_w.tag(c::tag_table_borrowings) {||
             ebml_w.id(id);
-            ebml_w.tag(c::tag_table_val) {||
+            do ebml_w.tag(c::tag_table_val) {||
                 ty::serialize_borrow(ebml_w, borrow)
             }
         }
@@ -742,7 +742,7 @@ impl decoder for ebml::ebml_deserializer {
     }
 
     fn read_tys(xcx: extended_decode_ctxt) -> ~[ty::t] {
-        self.read_to_vec {|| self.read_ty(xcx) }
+        self.read_to_vec({|| self.read_ty(xcx) })
     }
 
     fn read_bounds(xcx: extended_decode_ctxt) -> @~[ty::param_bound] {
@@ -753,17 +753,17 @@ impl decoder for ebml::ebml_deserializer {
 
     fn read_ty_param_bounds_and_ty(xcx: extended_decode_ctxt)
         -> ty::ty_param_bounds_and_ty {
-        self.read_rec {||
+        do self.read_rec {||
             {
-                bounds: self.read_rec_field("bounds", 0u) {||
-                    @self.read_to_vec {|| self.read_bounds(xcx) }
-                },
-                rp: self.read_rec_field("rp", 1u) {||
+                bounds: self.read_rec_field("bounds", 0u, {||
+                    @self.read_to_vec({|| self.read_bounds(xcx) })
+                }),
+                rp: self.read_rec_field("rp", 1u, {||
                     ast::deserialize_region_param(self)
-                },
-                ty: self.read_rec_field("ty", 2u) {||
+                }),
+                ty: self.read_rec_field("ty", 2u, {||
                     self.read_ty(xcx)
-                }
+                })
             }
         }
     }
@@ -773,7 +773,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                       ast_doc: ebml::doc) {
     let dcx = xcx.dcx;
     let tbl_doc = ast_doc[c::tag_table];
-    ebml::docs(tbl_doc) {|tag, entry_doc|
+    do ebml::docs(tbl_doc) {|tag, entry_doc|
         let id0 = entry_doc[c::tag_table_id].as_int();
         let id = xcx.tr_id(id0);
 
@@ -796,9 +796,9 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                 let tys = val_dsr.read_tys(xcx);
                 dcx.tcx.node_type_substs.insert(id, tys);
             } else if tag == (c::tag_table_freevars as uint) {
-                let fv_info = @val_dsr.read_to_vec {||
+                let fv_info = @val_dsr.read_to_vec({||
                     @val_dsr.read_freevar_entry(xcx)
-                };
+                });
                 dcx.tcx.freevars.insert(id, fv_info);
             } else if tag == (c::tag_table_tcache as uint) {
                 let tpbt = val_dsr.read_ty_param_bounds_and_ty(xcx);
@@ -808,9 +808,9 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
                 let bounds = val_dsr.read_bounds(xcx);
                 dcx.tcx.ty_param_bounds.insert(id, bounds);
             } else if tag == (c::tag_table_last_use as uint) {
-                let ids = val_dsr.read_to_vec {||
+                let ids = val_dsr.read_to_vec({||
                     xcx.tr_id(val_dsr.read_int())
-                };
+                });
                 let dvec = @dvec::from_vec(vec::to_mut(ids));
                 dcx.maps.last_use_map.insert(id, dvec);
             } else if tag == (c::tag_table_method_map as uint) {
@@ -838,7 +838,7 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
 
 #[cfg(test)]
 fn encode_item_ast(ebml_w: ebml::writer, item: @ast::item) {
-    ebml_w.wr_tag(c::tag_tree as uint) {||
+    do ebml_w.wr_tag(c::tag_tree as uint) {||
         ast::serialize_item(ebml_w, *item);
     }
 }
@@ -881,9 +881,9 @@ fn roundtrip(in_item: @ast::item) {
     #debug["out_item = %s", pprust::item_to_str(out_item)];
 
     let exp_str =
-        io::with_str_writer {|w| ast::serialize_item(w, *in_item) };
+        io::with_str_writer({|w| ast::serialize_item(w, *in_item) });
     let out_str =
-        io::with_str_writer {|w| ast::serialize_item(w, *out_item) };
+        io::with_str_writer({|w| ast::serialize_item(w, *out_item) });
 
     #debug["expected string: %s", exp_str];
     #debug["actual string  : %s", out_str];
diff --git a/src/rustc/middle/borrowck/categorization.rs b/src/rustc/middle/borrowck/categorization.rs
index f594f335de2..adf68fa52da 100644
--- a/src/rustc/middle/borrowck/categorization.rs
+++ b/src/rustc/middle/borrowck/categorization.rs
@@ -280,7 +280,7 @@ impl public_methods for borrowck_ctxt {
                                 cmt: cmt) -> cmt {
         @{id: arg.id(), span: arg.span(),
           cat: cat_comp(cmt, comp_variant(enum_did)),
-          lp: cmt.lp.map { |l| @lp_comp(l, comp_variant(enum_did)) },
+          lp: cmt.lp.map({ |l| @lp_comp(l, comp_variant(enum_did)) }),
           mutbl: cmt.mutbl, // imm iff in an immutable context
           ty: self.tcx.ty(arg)}
     }
@@ -311,9 +311,9 @@ impl public_methods for borrowck_ctxt {
           m_mutbl | m_const { f_mutbl }
         };
         let f_comp = comp_field(f_name, f_mutbl);
-        let lp = base_cmt.lp.map { |lp|
+        let lp = base_cmt.lp.map({ |lp|
             @lp_comp(lp, f_comp)
-        };
+        });
         @{id: node.id(), span: node.span(),
           cat: cat_comp(base_cmt, f_comp), lp:lp,
           mutbl: m, ty: self.tcx.ty(node)}
@@ -321,10 +321,10 @@ impl public_methods for borrowck_ctxt {
 
     fn cat_deref<N:ast_node>(node: N, base_cmt: cmt, derefs: uint,
                              expl: bool) -> option<cmt> {
-        ty::deref(self.tcx, base_cmt.ty, expl).map { |mt|
+        do ty::deref(self.tcx, base_cmt.ty, expl).map { |mt|
             alt deref_kind(self.tcx, base_cmt.ty) {
               deref_ptr(ptr) {
-                let lp = base_cmt.lp.chain { |l|
+                let lp = do base_cmt.lp.chain { |l|
                     // Given that the ptr itself is loanable, we can
                     // loan out deref'd uniq ptrs as the data they are
                     // the only way to reach the data they point at.
@@ -341,7 +341,7 @@ impl public_methods for borrowck_ctxt {
               }
 
               deref_comp(comp) {
-                let lp = base_cmt.lp.map { |l| @lp_comp(l, comp) };
+                let lp = base_cmt.lp.map({ |l| @lp_comp(l, comp) });
                 @{id:node.id(), span:node.span(),
                   cat:cat_comp(base_cmt, comp), lp:lp,
                   mutbl:mt.mutbl, ty:mt.ty}
@@ -367,7 +367,7 @@ impl public_methods for borrowck_ctxt {
           deref_ptr(ptr) {
             // make deref of vectors explicit, as explained in the comment at
             // the head of this section
-            let deref_lp = base_cmt.lp.map { |lp| @lp_deref(lp, ptr) };
+            let deref_lp = base_cmt.lp.map({ |lp| @lp_deref(lp, ptr) });
             let deref_cmt = @{id:expr.id, span:expr.span,
                               cat:cat_deref(base_cmt, 0u, ptr), lp:deref_lp,
                               mutbl:m_imm, ty:mt.ty};
@@ -383,7 +383,7 @@ impl public_methods for borrowck_ctxt {
         fn comp(expr: @ast::expr, of_cmt: cmt,
                 vect: ty::t, mt: ty::mt) -> cmt {
             let comp = comp_index(vect, mt.mutbl);
-            let index_lp = of_cmt.lp.map { |lp| @lp_comp(lp, comp) };
+            let index_lp = of_cmt.lp.map({ |lp| @lp_comp(lp, comp) });
             @{id:expr.id, span:expr.span,
               cat:cat_comp(of_cmt, comp), lp:index_lp,
               mutbl:mt.mutbl, ty:mt.ty}
@@ -393,7 +393,7 @@ impl public_methods for borrowck_ctxt {
     fn cat_tuple_elt<N: ast_node>(elt: N, cmt: cmt) -> cmt {
         @{id: elt.id(), span: elt.span(),
           cat: cat_comp(cmt, comp_tuple),
-          lp: cmt.lp.map { |l| @lp_comp(l, comp_tuple) },
+          lp: cmt.lp.map({ |l| @lp_comp(l, comp_tuple) }),
           mutbl: cmt.mutbl, // imm iff in an immutable context
           ty: self.tcx.ty(elt)}
     }
diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs
index 53e2b002826..41abc8af1ce 100644
--- a/src/rustc/middle/borrowck/check_loans.rs
+++ b/src/rustc/middle/borrowck/check_loans.rs
@@ -488,7 +488,7 @@ impl methods for check_loan_ctxt {
         let arg_tys =
             ty::ty_fn_args(
                 ty::node_id_to_type(self.tcx(), callee_id));
-        vec::iter2(args, arg_tys) { |arg, arg_ty|
+        do vec::iter2(args, arg_tys) { |arg, arg_ty|
             alt ty::resolved_mode(self.tcx(), arg_ty.mode) {
               ast::by_move {
                 self.check_move_out(arg);
@@ -508,9 +508,9 @@ fn check_loans_in_fn(fk: visit::fn_kind, decl: ast::fn_decl, body: ast::blk,
                      visitor: visit::vt<check_loan_ctxt>) {
 
     #debug["purity on entry=%?", copy self.declared_purity];
-    save_and_restore(self.in_ctor) {||
-        save_and_restore(self.declared_purity) {||
-            save_and_restore(self.fn_args) {||
+    do save_and_restore(self.in_ctor) {||
+        do save_and_restore(self.declared_purity) {||
+            do save_and_restore(self.fn_args) {||
                 let is_stack_closure = self.is_stack_closure(id);
 
                 // In principle, we could consider fk_anon(*) or
@@ -637,7 +637,7 @@ fn check_loans_in_expr(expr: @ast::expr,
 fn check_loans_in_block(blk: ast::blk,
                         &&self: check_loan_ctxt,
                         vt: visit::vt<check_loan_ctxt>) {
-    save_and_restore(self.declared_purity) {||
+    do save_and_restore(self.declared_purity) {||
         self.check_for_conflicting_loans(blk.node.id);
 
         alt blk.node.rules {
diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs
index f17299009ae..9c406219183 100644
--- a/src/rustc/middle/borrowck/gather_loans.rs
+++ b/src/rustc/middle/borrowck/gather_loans.rs
@@ -56,7 +56,7 @@ fn req_loans_in_expr(ex: @ast::expr,
       ast::expr_call(f, args, _) {
         let arg_tys = ty::ty_fn_args(ty::expr_ty(self.tcx(), f));
         let scope_r = ty::re_scope(ex.id);
-        vec::iter2(args, arg_tys) { |arg, arg_ty|
+        do vec::iter2(args, arg_tys) { |arg, arg_ty|
             alt ty::resolved_mode(self.tcx(), arg_ty.mode) {
               ast::by_mutbl_ref {
                 let arg_cmt = self.bccx.cat_expr(arg);
@@ -215,7 +215,7 @@ impl methods for gather_loan_ctxt {
             };
 
             let result = {
-                self.check_mutbl(req_mutbl, cmt).chain { |_ok|
+                do self.check_mutbl(req_mutbl, cmt).chain { |_ok|
                     self.bccx.preserve(cmt, opt_scope_id)
                 }
             };
diff --git a/src/rustc/middle/capture.rs b/src/rustc/middle/capture.rs
index 388cd42291e..0340a373ddd 100644
--- a/src/rustc/middle/capture.rs
+++ b/src/rustc/middle/capture.rs
@@ -106,7 +106,7 @@ fn compute_capture_vars(tcx: ty::ctxt,
       ast::proto_bare | ast::proto_box | ast::proto_uniq { cap_copy }
     };
 
-    vec::iter(*freevars) { |fvar|
+    do vec::iter(*freevars) { |fvar|
         let fvar_def_id = ast_util::def_id_of_def(fvar.def).node;
         alt cap_map.find(fvar_def_id) {
           option::some(_) { /* was explicitly named, do nothing */ }
diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs
index 646ef95630b..8db30048ff9 100644
--- a/src/rustc/middle/check_alt.rs
+++ b/src/rustc/middle/check_alt.rs
@@ -219,7 +219,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> option<ctor> {
       ty::ty_enum(eid, _) {
         let mut found = ~[];
         for m.each {|r|
-            option::iter(pat_ctor_id(tcx, r[0])) {|id|
+            do option::iter(pat_ctor_id(tcx, r[0])) {|id|
                 if !vec::contains(found, id) { vec::push(found, id); }
             }
         }
diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs
index 9abeda8dded..a84be38488c 100644
--- a/src/rustc/middle/check_const.rs
+++ b/src/rustc/middle/check_const.rs
@@ -27,7 +27,7 @@ fn check_item(sess: session, ast_map: ast_map::map, def_map: resolve::def_map,
       }
       item_enum(vs, _, _) {
         for vs.each {|var|
-            option::iter(var.node.disr_expr) {|ex|
+            do option::iter(var.node.disr_expr) {|ex|
                 v.visit_expr(ex, true, v);
             }
         }
diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs
index ecab6ace90f..d29bd4f9b7c 100644
--- a/src/rustc/middle/kind.rs
+++ b/src/rustc/middle/kind.rs
@@ -150,7 +150,7 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
 
     // Find the check function that enforces the appropriate bounds for this
     // kind of function:
-    with_appropriate_checker(cx, fn_id) { |chk|
+    do with_appropriate_checker(cx, fn_id) { |chk|
 
         // Begin by checking the variables in the capture clause, if any.
         // Here we slightly abuse the map function to both check and report
@@ -162,7 +162,7 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
           visit::fk_item_fn(*) | visit::fk_method(*) |
           visit::fk_ctor(*) | visit::fk_dtor(*) { @~[] }
         };
-        let captured_vars = (*cap_clause).map { |cap_item|
+        let captured_vars = do (*cap_clause).map { |cap_item|
             let cap_def = cx.tcx.def_map.get(cap_item.id);
             let cap_def_id = ast_util::def_id_of_def(cap_def).node;
             let ty = ty::node_id_to_type(cx.tcx, cap_def_id);
@@ -251,7 +251,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
         }
       }
       expr_path(_) | expr_field(_, _, _) {
-        option::iter(cx.tcx.node_type_substs.find(e.id)) {|ts|
+        do option::iter(cx.tcx.node_type_substs.find(e.id)) {|ts|
             let bounds = alt check e.node {
               expr_path(_) {
                 let did = ast_util::def_id_of_def(cx.tcx.def_map.get(e.id));
@@ -286,7 +286,7 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                   %s (%u tys), declared = %? (%u tys)",
                   tys_to_str(cx.tcx, ts), ts.len(), *bounds, (*bounds).len());
             }
-            vec::iter2(ts, *bounds) {|ty, bound|
+            do vec::iter2(ts, *bounds) {|ty, bound|
                 check_bounds(cx, e.id, e.span, ty, bound)
             }
         }
@@ -314,10 +314,10 @@ fn check_stmt(stmt: @stmt, cx: ctx, v: visit::vt<ctx>) {
 fn check_ty(aty: @ty, cx: ctx, v: visit::vt<ctx>) {
     alt aty.node {
       ty_path(_, id) {
-        option::iter(cx.tcx.node_type_substs.find(id)) {|ts|
+        do option::iter(cx.tcx.node_type_substs.find(id)) {|ts|
             let did = ast_util::def_id_of_def(cx.tcx.def_map.get(id));
             let bounds = ty::lookup_item_type(cx.tcx, did).bounds;
-            vec::iter2(ts, *bounds) {|ty, bound|
+            do vec::iter2(ts, *bounds) {|ty, bound|
                 check_bounds(cx, aty.id, aty.span, ty, bound)
             }
         }
diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs
index f4c3bb81e8b..9755e0deeaa 100644
--- a/src/rustc/middle/lint.rs
+++ b/src/rustc/middle/lint.rs
@@ -273,7 +273,7 @@ fn lookup_lint(dict: lint_dict, s: str)
 }
 
 fn build_settings_item(i: @ast::item, &&cx: ctxt, v: visit::vt<ctxt>) {
-    cx.with_warn_attrs(i.attrs) {|cx|
+    do cx.with_warn_attrs(i.attrs) {|cx|
         if !cx.is_default {
             cx.sess.warning_settings.settings_map.insert(i.id, cx.curr);
         }
@@ -297,7 +297,7 @@ fn build_settings_crate(sess: session::session, crate: @ast::crate) {
         cx.set_level(lint, level);
     }
 
-    cx.with_warn_attrs(crate.node.attrs) {|cx|
+    do cx.with_warn_attrs(crate.node.attrs) {|cx|
         // Copy out the default settings
         for cx.curr.each {|k, v|
             sess.warning_settings.default_settings.insert(k, v);
@@ -357,7 +357,7 @@ fn check_item_ctypes(cx: ty::ctxt, it: @ast::item) {
 
     fn check_foreign_fn(cx: ty::ctxt, fn_id: ast::node_id,
                        decl: ast::fn_decl) {
-        let tys = vec::map(decl.inputs) {|a| a.ty };
+        let tys = vec::map(decl.inputs, {|a| a.ty });
         for vec::each(vec::append_one(tys, decl.output)) {|ty|
             alt ty.node {
               ast::ty_path(_, id) {
diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs
index 04b0f1bd6f6..8aaf53adece 100644
--- a/src/rustc/middle/liveness.rs
+++ b/src/rustc/middle/liveness.rs
@@ -406,7 +406,7 @@ fn add_class_fields(self: @ir_maps, did: def_id) {
 
 fn visit_local(local: @local, &&self: @ir_maps, vt: vt<@ir_maps>) {
     let def_map = self.tcx.def_map;
-    pat_util::pat_bindings(def_map, local.node.pat) { |p_id, sp, path|
+    do pat_util::pat_bindings(def_map, local.node.pat) { |p_id, sp, path|
         #debug["adding local variable %d", p_id];
         let name = ast_util::path_to_ident(path);
         (*self).add_live_node_for_node(p_id, lnk_vdef(sp));
@@ -560,9 +560,9 @@ class liveness {
         alt expr.node {
           expr_path(_) {
             let def = self.tcx.def_map.get(expr.id);
-            relevant_def(def).map { |rdef|
+            relevant_def(def).map({ |rdef|
                 self.variable_from_rdef(rdef, expr.span)
-            }
+            })
           }
           _ {none}
         }
@@ -576,9 +576,9 @@ class liveness {
                              span: span) -> option<variable> {
         alt self.tcx.def_map.find(node_id) {
           some(def) {
-            relevant_def(def).map { |rdef|
+            relevant_def(def).map({ |rdef|
               self.variable_from_rdef(rdef, span)
-            }
+            })
           }
           none {
             self.tcx.sess.span_bug(
@@ -589,7 +589,7 @@ class liveness {
 
     fn pat_bindings(pat: @pat, f: fn(live_node, variable, span)) {
         let def_map = self.tcx.def_map;
-        pat_util::pat_bindings(def_map, pat) {|p_id, sp, _n|
+        do pat_util::pat_bindings(def_map, pat) {|p_id, sp, _n|
             let ln = self.live_node(p_id, sp);
             let var = self.variable(p_id, sp);
             f(ln, var, sp);
@@ -663,7 +663,7 @@ class liveness {
     }
 
     fn ln_str(ln: live_node) -> str {
-        io::with_str_writer { |wr|
+        do io::with_str_writer { |wr|
             wr.write_str("[ln(");
             wr.write_uint(*ln);
             wr.write_str(") of kind ");
@@ -695,9 +695,9 @@ class liveness {
     fn init_from_succ(ln: live_node, succ_ln: live_node) {
         // more efficient version of init_empty() / merge_from_succ()
         self.successors[*ln] = succ_ln;
-        self.indices2(ln, succ_ln) { |idx, succ_idx|
+        self.indices2(ln, succ_ln, { |idx, succ_idx|
             self.users[idx] = self.users[succ_idx];
-        }
+        });
         #debug["init_from_succ(ln=%s, succ=%s)",
                self.ln_str(ln), self.ln_str(succ_ln)];
     }
@@ -707,7 +707,7 @@ class liveness {
         if ln == succ_ln { ret false; }
 
         let mut changed = false;
-        self.indices2(ln, succ_ln) { |idx, succ_idx|
+        do self.indices2(ln, succ_ln) { |idx, succ_idx|
             changed |= copy_if_invalid(copy self.users[succ_idx].reader,
                                        self.users[idx].reader);
             changed |= copy_if_invalid(copy self.users[succ_idx].writer,
@@ -776,9 +776,9 @@ class liveness {
         // effectively a return---this only occurs in `for` loops,
         // where the body is really a closure.
         let entry_ln: live_node =
-            self.with_loop_nodes(self.s.exit_ln, self.s.exit_ln) {||
+            self.with_loop_nodes(self.s.exit_ln, self.s.exit_ln, {||
                 self.propagate_through_fn_block(decl, body)
-            };
+            });
 
         // hack to skip the loop unless #debug is enabled:
         #debug["^^ liveness computation results for body %d (entry=%s)",
@@ -832,7 +832,7 @@ class liveness {
 
     fn propagate_through_block(blk: blk, succ: live_node) -> live_node {
         let succ = self.propagate_through_opt_expr(blk.node.expr, succ);
-        blk.node.stmts.foldr(succ) { |stmt, succ|
+        do blk.node.stmts.foldr(succ) { |stmt, succ|
             self.propagate_through_stmt(stmt, succ)
         }
     }
@@ -852,7 +852,7 @@ class liveness {
     fn propagate_through_decl(decl: @decl, succ: live_node) -> live_node {
         alt decl.node {
           decl_local(locals) {
-            locals.foldr(succ) { |local, succ|
+            do locals.foldr(succ) { |local, succ|
                 self.propagate_through_local(local, succ)
             }
           }
@@ -877,9 +877,9 @@ class liveness {
         // initialization, which is mildly more complex than checking
         // once at the func header but otherwise equivalent.
 
-        let opt_init = local.node.init.map { |i| i.expr };
+        let opt_init = local.node.init.map({ |i| i.expr });
         let mut succ = self.propagate_through_opt_expr(opt_init, succ);
-        self.pat_bindings(local.node.pat) { |ln, var, _sp|
+        do self.pat_bindings(local.node.pat) { |ln, var, _sp|
             self.init_from_succ(ln, succ);
             self.define(ln, var);
             succ = ln;
@@ -889,14 +889,14 @@ class liveness {
 
     fn propagate_through_exprs(exprs: ~[@expr],
                                succ: live_node) -> live_node {
-        exprs.foldr(succ) { |expr, succ|
+        do exprs.foldr(succ) { |expr, succ|
             self.propagate_through_expr(expr, succ)
         }
     }
 
     fn propagate_through_opt_expr(opt_expr: option<@expr>,
                                   succ: live_node) -> live_node {
-        opt_expr.foldl(succ) { |succ, expr|
+        do opt_expr.foldl(succ) { |succ, expr|
             self.propagate_through_expr(expr, succ)
         }
     }
@@ -930,7 +930,7 @@ class liveness {
             // the construction of a closure itself is not important,
             // but we have to consider the closed over variables.
             let caps = (*self.ir).captures(expr);
-            (*caps).foldr(succ) { |cap, succ|
+            do (*caps).foldr(succ) { |cap, succ|
                 self.init_from_succ(cap.ln, succ);
                 let var = self.variable_from_rdef(cap.rv, expr.span);
                 self.acc(cap.ln, var, ACC_READ | ACC_USE);
@@ -1063,7 +1063,7 @@ class liveness {
 
           expr_rec(fields, with_expr) {
             let succ = self.propagate_through_opt_expr(with_expr, succ);
-            fields.foldr(succ) { |field, succ|
+            do fields.foldr(succ) { |field, succ|
                 self.propagate_through_expr(field.node.expr, succ)
             }
           }
@@ -1273,10 +1273,10 @@ class liveness {
             alt def {
               def_self(_) {
                 // Note: the field_map is empty unless we are in a ctor
-                ret self.ir.field_map.find(fld).map { |var|
+                ret self.ir.field_map.find(fld).map({ |var|
                     let ln = self.live_node(expr.id, expr.span);
                     (ln, var)
-                };
+                });
               }
               _ { ret none; }
             }
@@ -1320,17 +1320,17 @@ class liveness {
             first_merge = false;
         }
         let cond_ln = self.propagate_through_opt_expr(cond, ln);
-        let body_ln = self.with_loop_nodes(succ, ln) {||
+        let body_ln = self.with_loop_nodes(succ, ln, {||
             self.propagate_through_block(body, cond_ln)
-        };
+        });
 
         // repeat until fixed point is reached:
         while self.merge_from_succ(ln, body_ln, first_merge) {
             first_merge = false;
             assert cond_ln == self.propagate_through_opt_expr(cond, ln);
-            assert body_ln == self.with_loop_nodes(succ, ln) {||
+            assert body_ln == self.with_loop_nodes(succ, ln, {||
                 self.propagate_through_block(body, cond_ln)
-            };
+            });
         }
 
         cond_ln
@@ -1373,7 +1373,7 @@ fn check_local(local: @local, &&self: @liveness, vt: vt<@liveness>) {
         // should not be live at this point.
 
         #debug["check_local() with no initializer"];
-        (*self).pat_bindings(local.node.pat) { |ln, var, sp|
+        do (*self).pat_bindings(local.node.pat) { |ln, var, sp|
             if !self.warn_about_unused(sp, ln, var) {
                 alt (*self).live_on_exit(ln, var) {
                   none { /* not live: good */ }
@@ -1438,7 +1438,7 @@ fn check_expr(expr: @expr, &&self: @liveness, vt: vt<@liveness>) {
       expr_call(f, args, _) {
         let targs = ty::ty_fn_args(ty::expr_ty(self.tcx, f));
         vt.visit_expr(f, self, vt);
-        vec::iter2(args, targs) { |arg_expr, arg_ty|
+        do vec::iter2(args, targs) { |arg_expr, arg_ty|
             alt ty::resolved_mode(self.tcx, arg_ty.mode) {
               by_val | by_copy | by_ref | by_mutbl_ref{
                 vt.visit_expr(arg_expr, self, vt);
@@ -1621,7 +1621,7 @@ impl check_methods for @liveness {
     }
 
     fn check_for_reassignments_in_pat(pat: @pat) {
-        (*self).pat_bindings(pat) { |ln, var, sp|
+        do (*self).pat_bindings(pat) { |ln, var, sp|
             self.check_for_reassignment(ln, var, sp);
         }
     }
@@ -1752,7 +1752,7 @@ impl check_methods for @liveness {
     }
 
     fn warn_about_unused_or_dead_vars_in_pat(pat: @pat) {
-        (*self).pat_bindings(pat) { |ln, var, sp|
+        do (*self).pat_bindings(pat) { |ln, var, sp|
             if !self.warn_about_unused(sp, ln, var) {
                 self.warn_about_dead_assign(sp, ln, var);
             }
diff --git a/src/rustc/middle/pat_util.rs b/src/rustc/middle/pat_util.rs
index f304317f359..c139915c0a5 100644
--- a/src/rustc/middle/pat_util.rs
+++ b/src/rustc/middle/pat_util.rs
@@ -15,7 +15,7 @@ type pat_id_map = std::map::hashmap<ident, node_id>;
 // use the node_id of their namesake in the first pattern.
 fn pat_id_map(dm: resolve::def_map, pat: @pat) -> pat_id_map {
     let map = std::map::box_str_hash();
-    pat_bindings(dm, pat) {|p_id, _s, n|
+    do pat_bindings(dm, pat) {|p_id, _s, n|
       map.insert(path_to_ident(n), p_id);
     };
     ret map;
@@ -39,7 +39,7 @@ fn pat_is_variant(dm: resolve::def_map, pat: @pat) -> bool {
 // Could return a constrained type in order to express that (future work)
 fn pat_bindings(dm: resolve::def_map, pat: @pat,
                 it: fn(node_id, span, @path)) {
-    walk_pat(pat) {|p|
+    do walk_pat(pat) {|p|
         alt p.node {
           pat_ident(pth, _) if !pat_is_variant(dm, p) {
             it(p.id, p.span, pth);
@@ -51,6 +51,6 @@ fn pat_bindings(dm: resolve::def_map, pat: @pat,
 
 fn pat_binding_ids(dm: resolve::def_map, pat: @pat) -> ~[node_id] {
     let mut found = ~[];
-    pat_bindings(dm, pat) {|b_id, _sp, _pt| vec::push(found, b_id); };
+    pat_bindings(dm, pat, {|b_id, _sp, _pt| vec::push(found, b_id); });
     ret found;
 }
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
index 3c0a784dd5e..a3a81092ed5 100644
--- a/src/rustc/middle/resolve.rs
+++ b/src/rustc/middle/resolve.rs
@@ -212,7 +212,7 @@ fn iter_import_paths(vi: ast::view_item, f: fn(vp: @ast::view_path)) {
 fn iter_effective_import_paths(vi: ast::view_item,
                                f: fn(vp: @ast::view_path)) {
     iter_import_paths(vi, f);
-    iter_export_paths(vi) {|vp|
+    do iter_export_paths(vi) {|vp|
         alt vp.node {
           ast::view_path_simple(_, _, _) { }
           // FIXME (but also see #1893): support uniform ident-list exports
@@ -231,7 +231,7 @@ fn iter_effective_import_paths(vi: ast::view_item,
 fn map_crate(e: @env, c: @ast::crate) {
 
     fn index_vi(e: @env, i: @ast::view_item, &&sc: scopes, _v: vt<scopes>) {
-        iter_effective_import_paths(*i) { |vp|
+        do iter_effective_import_paths(*i) { |vp|
             alt vp.node {
               ast::view_path_simple(name, path, id) {
                 e.imports.insert(id, todo(name, @path.idents, vp.span,
@@ -255,7 +255,7 @@ fn map_crate(e: @env, c: @ast::crate) {
 
     fn path_from_scope(sc: scopes, n: str) -> str {
         let mut path = n + "::";
-        list::iter(sc) {|s|
+        do list::iter(sc) {|s|
             alt s {
               scope_item(i) { path = *i.ident + "::" + path; }
               _ {}
@@ -294,7 +294,7 @@ fn map_crate(e: @env, c: @ast::crate) {
     // So we wind up reusing the glob-import machinery when looking at
     // glob exports. They just do re-exporting in a later step.
     fn link_glob(e: @env, vi: @ast::view_item, &&sc: scopes, _v: vt<scopes>) {
-        iter_effective_import_paths(*vi) { |vp|
+        do iter_effective_import_paths(*vi) { |vp|
             alt vp.node {
               ast::view_path_glob(path, _) {
                 alt follow_import(*e, sc, path.idents, vp.span) {
@@ -440,7 +440,7 @@ fn resolve_names(e: @env, c: @ast::crate) {
              refer to, so it's possible to resolve them.
            */
           ast::item_impl(_, _, ifce, _, _) {
-            ifce.iter {|p| resolve_iface_ref(p, sc, e);}
+            ifce.iter({|p| resolve_iface_ref(p, sc, e);})
           }
           ast::item_class(_, ifaces, _, _, _, _) {
             for ifaces.each {|p|
@@ -554,7 +554,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
     alt i.node {
       ast::item_impl(tps, _, ifce, sty, methods) {
         v.visit_ty_params(tps, sc, v);
-        option::iter(ifce) {|p| visit::visit_path(p.path, sc, v)};
+        option::iter(ifce, {|p| visit::visit_path(p.path, sc, v)});
         v.visit_ty(sty, sc, v);
         for methods.each {|m|
             v.visit_ty_params(m.tps, sc, v);
@@ -588,7 +588,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item,
                                              local_def(i.id)), ctor.node.dec,
                             ctor.node.body, ctor.span, ctor.node.id,
                             ctor_scope, v);
-        option::iter(m_dtor) {|dtor|
+        do option::iter(m_dtor) {|dtor|
           let dtor_scope = @cons(scope_method(dtor.node.self_id, tps),
                                  class_scope);
 
@@ -694,7 +694,7 @@ fn visit_local_with_scope(e: @env, loc: @local, &&sc: scopes, v:vt<scopes>) {
     // scope. We disallow this, in order to make alt patterns consisting of a
     // single identifier unambiguous (does the pattern "foo" refer to enum
     // foo, or is it binding a new name foo?)
-    ast_util::walk_pat(loc.node.pat) { |p|
+    do ast_util::walk_pat(loc.node.pat) { |p|
         alt p.node {
           pat_ident(path, _) {
             alt lookup_in_scope(*e, sc, loc.span, path_to_ident(path),
@@ -780,7 +780,7 @@ fn resolve_import(e: env, n_id: node_id, name: ast::ident,
         fn lst(my_id: node_id, vis: ~[@view_item]) -> ~[node_id] {
             let mut imports = ~[], found = false;
             for vis.each {|vi|
-                iter_effective_import_paths(*vi) {|vp|
+                do iter_effective_import_paths(*vi) {|vp|
                     alt vp.node {
                       view_path_simple(_, _, id)
                       | view_path_glob(_, id) {
@@ -1180,7 +1180,7 @@ fn lookup_in_ty_params(e: env, name: ident, ty_params: ~[ast::ty_param])
 fn lookup_in_pat(e: env, name: ident, pat: @ast::pat) -> option<node_id> {
     let mut found = none;
 
-    pat_util::pat_bindings(e.def_map, pat) {|p_id, _sp, n|
+    do pat_util::pat_bindings(e.def_map, pat) {|p_id, _sp, n|
         if str::eq(*path_to_ident(n), *name)
                     { found = some(p_id); }
     };
@@ -1612,7 +1612,7 @@ fn index_view_items(view_items: ~[@ast::view_item],
           _ {}
         }
 
-        iter_effective_import_paths(*vi) {|vp|
+        do iter_effective_import_paths(*vi) {|vp|
             alt vp.node {
               ast::view_path_simple(ident, _, id) {
                 add_to_index(index, ident, mie_import_ident(id, vp.span));
@@ -1793,7 +1793,7 @@ fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
 }
 
 fn check_pat(e: @env, ch: checker, p: @ast::pat) {
-    pat_util::pat_bindings(e.def_map, p) {|_i, p_sp, n|
+    do pat_util::pat_bindings(e.def_map, p) {|_i, p_sp, n|
        add_name(ch, p_sp, path_to_ident(n));
     };
 }
@@ -1840,7 +1840,7 @@ fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
               ast::decl_local(locs) {
                 let local_values = checker(*e, "value");
                 for locs.each {|loc|
-                     pat_util::pat_bindings(e.def_map, loc.node.pat)
+                     do pat_util::pat_bindings(e.def_map, loc.node.pat)
                          {|_i, p_sp, n|
                          let ident = path_to_ident(n);
                          add_name(local_values, p_sp, ident);
@@ -1943,7 +1943,7 @@ fn check_exports(e: @env) {
             let ixm = e.mod_map.get(mid.node);
 
             for ixm.index.each {|ident, mies|
-                list::iter(mies) {|mie|
+                do list::iter(mies) {|mie|
                     alt mie {
                       mie_item(item) {
                         let defs =
@@ -1984,7 +1984,7 @@ fn check_exports(e: @env) {
 
 
     fn maybe_add_reexport(e: @env, export_id: node_id, def: option<def>) {
-        option::iter(def) {|def|
+        do option::iter(def) {|def|
             add_export(e, export_id, def_id_of_def(def), true);
         }
     }
@@ -2004,7 +2004,7 @@ fn check_exports(e: @env) {
         if _mod.index.contains_key(ident) {
             found_something = true;
             let xs = _mod.index.get(ident);
-            list::iter(xs) {|x|
+            do list::iter(xs) {|x|
                 alt x {
                   mie_import_ident(id, _) {
                     alt check e.imports.get(id) {
@@ -2045,7 +2045,7 @@ fn check_exports(e: @env) {
             e.sess.span_fatal(sp, #fmt("undefined id %s in an export", *id));
           }
           some(ms) {
-            let maybe_id = list_search(ms) {|m|
+            let maybe_id = do list_search(ms) {|m|
                 alt m {
                   mie_item(@{node: item_enum(_, _, _), id, _}) { some(id) }
                   _ { none }
@@ -2069,7 +2069,7 @@ fn check_exports(e: @env) {
             let mut found = false;
             alt _mod.index.find(variant_id.node.name) {
               some(ms) {
-                list::iter(ms) {|m|
+                do list::iter(ms) {|m|
                     alt m {
                       mie_enum_variant(_, _, actual_parent_id, _) {
                         found = true;
@@ -2099,7 +2099,7 @@ fn check_exports(e: @env) {
             let glob_is_re_exported = int_hash();
 
             for m.view_items.each {|vi|
-                iter_export_paths(*vi) { |vp|
+                do iter_export_paths(*vi) { |vp|
                     alt vp.node {
                       ast::view_path_simple(ident, _, id) {
                         check_export(e, ident, _mod, id, vi);
@@ -2126,7 +2126,7 @@ fn check_exports(e: @env) {
                   ast::view_path_glob(_, node_id) { node_id }
                 };
                 if ! glob_is_re_exported.contains_key(id) { cont; }
-                iter_mod(*e, glob.def,
+                do iter_mod(*e, glob.def,
                          glob.path.span, outside) {|ident, def|
                     vec::push(_mod.globbed_exports, ident);
                     maybe_add_reexport(e, id, some(def));
@@ -2177,13 +2177,13 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
         }
     }
 
-    iter_effective_import_paths(*vi) { |vp|
+    do iter_effective_import_paths(*vi) { |vp|
         alt vp.node {
           ast::view_path_simple(name, pt, id) {
             let mut found = ~[];
             if vec::len(pt.idents) == 1u {
-                option::iter(sc) {|sc|
-                    list::iter(sc) {|level|
+                do option::iter(sc) {|sc|
+                    do list::iter(sc) {|level|
                         if vec::len(found) == 0u {
                             for vec::each(*level) {|imp|
                                 if imp.ident == pt.idents[0] {
@@ -2198,7 +2198,7 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
                     }
                 }
             } else {
-                lookup_imported_impls(e, id) {|is|
+                do lookup_imported_impls(e, id) {|is|
                     for vec::each(*is) {|i|
                         vec::push(impls, @{ident: name with *i});
                     }
@@ -2208,9 +2208,9 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
 
           ast::view_path_list(base, names, _) {
             for names.each {|nm|
-                lookup_imported_impls(e, nm.node.id) {|is|
+                lookup_imported_impls(e, nm.node.id, {|is|
                     vec::push_all(impls, *is);
-                }
+                })
             }
           }
 
@@ -2256,7 +2256,7 @@ fn find_impls_in_item(e: env, i: @ast::item, &impls: ~[@_impl],
       ast::item_class(tps, ifces, items, _, _, _) {
           let (_, mthds) = ast_util::split_class_items(items);
           let n_tps = tps.len();
-          vec::iter(ifces) {|p|
+          do vec::iter(ifces) {|p|
               // The def_id, in this case, identifies the combination of
               // class and iface
               vec::push(impls, @{did: local_def(p.id),
@@ -2289,7 +2289,7 @@ fn find_impls_in_mod_by_id(e: env, defid: def_id, &impls: ~[@_impl],
             for md.items.each {|i|
                 find_impls_in_item(e, i, tmp, none, none);
             }
-            @vec::filter(tmp) {|i| is_exported(e, i.ident, mi)}
+            @vec::filter(tmp, {|i| is_exported(e, i.ident, mi)})
         } else {
             csearch::get_impls_for_mod(e.sess.cstore, defid, none)
         };
diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs
index b55d4a2bfb3..82b47654377 100644
--- a/src/rustc/middle/trans/alt.rs
+++ b/src/rustc/middle/trans/alt.rs
@@ -153,7 +153,7 @@ fn enter_match(dm: def_map, m: match, col: uint, val: ValueRef,
 }
 
 fn enter_default(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
-    enter_match(dm, m, col, val) {|p|
+    do enter_match(dm, m, col, val) {|p|
         alt p.node {
           ast::pat_wild | ast::pat_rec(_, _) | ast::pat_tup(_) { some(~[]) }
           ast::pat_ident(_, none) if !pat_is_variant(dm, p) {
@@ -167,7 +167,7 @@ fn enter_default(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
 fn enter_opt(tcx: ty::ctxt, m: match, opt: opt, col: uint,
              variant_size: uint, val: ValueRef) -> match {
     let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
-    enter_match(tcx.def_map, m, col, val) {|p|
+    do enter_match(tcx.def_map, m, col, val) {|p|
         alt p.node {
           ast::pat_enum(_, subpats) {
             if opt_eq(tcx, variant_opt(tcx, p.id), opt) {
@@ -193,7 +193,7 @@ fn enter_opt(tcx: ty::ctxt, m: match, opt: opt, col: uint,
 fn enter_rec(dm: def_map, m: match, col: uint, fields: ~[ast::ident],
              val: ValueRef) -> match {
     let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
-    enter_match(dm, m, col, val) {|p|
+    do enter_match(dm, m, col, val) {|p|
         alt p.node {
           ast::pat_rec(fpats, _) {
             let mut pats = ~[];
@@ -214,7 +214,7 @@ fn enter_rec(dm: def_map, m: match, col: uint, fields: ~[ast::ident],
 fn enter_tup(dm: def_map, m: match, col: uint, val: ValueRef,
              n_elts: uint) -> match {
     let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
-    enter_match(dm, m, col, val) {|p|
+    do enter_match(dm, m, col, val) {|p|
         alt p.node {
           ast::pat_tup(elts) { some(elts) }
           _ { some(vec::from_elem(n_elts, dummy)) }
@@ -224,7 +224,7 @@ fn enter_tup(dm: def_map, m: match, col: uint, val: ValueRef,
 
 fn enter_box(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
     let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
-    enter_match(dm, m, col, val) {|p|
+    do enter_match(dm, m, col, val) {|p|
         alt p.node {
           ast::pat_box(sub) { some(~[sub]) }
           _ { some(~[dummy]) }
@@ -234,7 +234,7 @@ fn enter_box(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
 
 fn enter_uniq(dm: def_map, m: match, col: uint, val: ValueRef) -> match {
     let dummy = @{id: 0, node: ast::pat_wild, span: dummy_sp()};
-    enter_match(dm, m, col, val) {|p|
+    do enter_match(dm, m, col, val) {|p|
         alt p.node {
           ast::pat_uniq(sub) { some(~[sub]) }
           _ { some(~[dummy]) }
@@ -285,7 +285,7 @@ fn extract_variant_args(bcx: block, pat_id: ast::node_id,
     }
     let vdefs_tg = vdefs.enm;
     let vdefs_var = vdefs.var;
-    let args = vec::from_fn(size) { |i|
+    let args = do vec::from_fn(size) { |i|
         GEP_enum(bcx, blobptr, vdefs_tg, vdefs_var,
                  enum_ty_substs, i)
     };
@@ -398,11 +398,11 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef],
                 bcx.fcx.lllocals.insert(val, loc);
             };
             let {bcx: guard_cx, val} = {
-                with_scope_result(bcx, e.info(), "guard") {|bcx|
+                do with_scope_result(bcx, e.info(), "guard") {|bcx|
                     trans_temp_expr(bcx, e)
                 }
             };
-            bcx = with_cond(guard_cx, Not(guard_cx, val)) {|bcx|
+            bcx = do with_cond(guard_cx, Not(guard_cx, val)) {|bcx|
                 compile_submatch(bcx, vec::tail(m), vals, chk, exits);
                 bcx
             };
@@ -553,7 +553,7 @@ fn compile_submatch(bcx: block, m: match, vals: ~[ValueRef],
               compare {
                 let t = node_id_type(bcx, pat_id);
                 let {bcx: after_cx, val: matches} = {
-                    with_scope_result(bcx, none, "compare_scope") {|bcx|
+                    do with_scope_result(bcx, none, "compare_scope") {|bcx|
                         alt trans_opt(bcx, opt) {
                           single_result({bcx, val}) {
                             trans_compare(bcx, ast::eq, test_val, t, val, t)
@@ -636,7 +636,7 @@ fn trans_alt(bcx: block,
              mode: ast::alt_mode,
              dest: dest) -> block {
     let _icx = bcx.insn_ctxt("alt::trans_alt");
-    with_scope(bcx, alt_expr.info(), "alt") {|bcx|
+    do with_scope(bcx, alt_expr.info(), "alt") {|bcx|
         trans_alt_inner(bcx, expr, arms, mode, dest)
     }
 }
@@ -728,7 +728,7 @@ fn bind_irrefutable_pat(bcx: block, pat: @ast::pat, val: ValueRef,
         let vdefs = ast_util::variant_def_ids(ccx.tcx.def_map.get(pat.id));
         let args = extract_variant_args(bcx, pat.id, vdefs, val);
         let mut i = 0;
-        option::iter(sub) {|sub| for vec::each(args.vals) {|argval|
+        do option::iter(sub) {|sub| for vec::each(args.vals) {|argval|
             bcx = bind_irrefutable_pat(bcx, sub[i], argval, make_copy);
             i += 1;
         }}
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
index 15df0ab5ca9..a743d6254b8 100644
--- a/src/rustc/middle/trans/base.rs
+++ b/src/rustc/middle/trans/base.rs
@@ -733,7 +733,7 @@ fn make_free_glue(bcx: block, v: ValueRef, t: ty::t) {
       }
       ty::ty_class(did,substs) {
         // Call the dtor if there is one
-        option::map_default(ty::ty_dtor(bcx.tcx(), did), bcx) {|dt_id|
+        do option::map_default(ty::ty_dtor(bcx.tcx(), did), bcx) {|dt_id|
           trans_class_drop(bcx, v, dt_id, did, substs)
         }
       }
@@ -746,7 +746,7 @@ fn trans_class_drop(bcx: block, v0: ValueRef, dtor_did: ast::def_id,
                     class_did: ast::def_id,
                     substs: ty::substs) -> block {
   let drop_flag = GEPi(bcx, v0, ~[0u, 0u]);
-  with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) {|cx|
+  do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) {|cx|
     let mut bcx = cx;
       // We have to cast v0
      let classptr = GEPi(bcx, v0, ~[0u, 1u]);
@@ -864,12 +864,12 @@ fn decr_refcnt_maybe_free(bcx: block, box_ptr: ValueRef, t: ty::t) -> block {
 
     let llbox_ty = T_opaque_box_ptr(ccx);
     let box_ptr = PointerCast(bcx, box_ptr, llbox_ty);
-    with_cond(bcx, IsNotNull(bcx, box_ptr)) {|bcx|
+    do with_cond(bcx, IsNotNull(bcx, box_ptr)) {|bcx|
         let rc_ptr = GEPi(bcx, box_ptr, ~[0u, abi::box_field_refcnt]);
         let rc = Sub(bcx, Load(bcx, rc_ptr), C_int(ccx, 1));
         Store(bcx, rc, rc_ptr);
         let zero_test = ICmp(bcx, lib::llvm::IntEQ, C_int(ccx, 0), rc);
-        with_cond(bcx, zero_test) {|bcx| free_ty(bcx, box_ptr, t)}
+        with_cond(bcx, zero_test, {|bcx| free_ty(bcx, box_ptr, t)})
     }
 }
 
@@ -1354,7 +1354,7 @@ fn copy_val(cx: block, action: copy_action, dst: ValueRef,
         let dstcmp = load_if_immediate(cx, dst, t);
         let cast = PointerCast(cx, dstcmp, val_ty(src));
         // Self-copy check
-        with_cond(cx, ICmp(cx, lib::llvm::IntNE, cast, src)) {|bcx|
+        do with_cond(cx, ICmp(cx, lib::llvm::IntNE, cast, src)) {|bcx|
             copy_val_no_check(bcx, action, dst, src, t)
         }
     } else {
@@ -1637,7 +1637,7 @@ fn fail_if_zero(cx: block, span: span, divmod: ast::binop,
                           ty_to_str(cx.ccx().tcx, rhs_t));
       }
     };
-    with_cond(cx, is_zero) {|bcx|
+    do with_cond(cx, is_zero) {|bcx|
         trans_fail(bcx, some(span), text)
     }
 }
@@ -1870,7 +1870,7 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr,
                     b: @ast::expr, dest: dest) -> block {
     let _icx = bcx.insn_ctxt("trans_lazy_binop");
     let {bcx: past_lhs, val: lhs} = {
-        with_scope_result(bcx, a.info(), "lhs") { |bcx|
+        do with_scope_result(bcx, a.info(), "lhs") { |bcx|
             trans_temp_expr(bcx, a)
         }
     };
@@ -1882,7 +1882,7 @@ fn trans_lazy_binop(bcx: block, op: lazy_binop_ty, a: @ast::expr,
       lazy_or { CondBr(past_lhs, lhs, join.llbb, before_rhs.llbb); }
     }
     let {bcx: past_rhs, val: rhs} = {
-        with_scope_result(before_rhs, b.info(), "rhs") { |bcx|
+        do with_scope_result(before_rhs, b.info(), "rhs") { |bcx|
             trans_temp_expr(bcx, b)
         }
     };
@@ -2331,7 +2331,7 @@ fn maybe_instantiate_inline(ccx: @crate_ctxt, fn_id: ast::def_id)
               ast::item_enum(_, _, _) {
                 let vs_here = ty::enum_variants(ccx.tcx, local_def(item.id));
                 let vs_there = ty::enum_variants(ccx.tcx, parent_id);
-                vec::iter2(*vs_here, *vs_there) {|here, there|
+                do vec::iter2(*vs_here, *vs_there) {|here, there|
                     if there.id == fn_id { my_id = here.id.node; }
                     ccx.external.insert(there.id, some(here.id.node));
                 }
@@ -2622,7 +2622,7 @@ fn trans_index(cx: block, ex: @ast::expr, base: @ast::expr,
     #debug("trans_index: len %s", val_str(bcx.ccx().tn, len));
 
     let bounds_check = ICmp(bcx, lib::llvm::IntUGE, scaled_ix, len);
-    let bcx = with_cond(bcx, bounds_check) {|bcx|
+    let bcx = do with_cond(bcx, bounds_check) {|bcx|
         // fail: bad bounds check.
         trans_fail(bcx, some(ex.span), "bounds check")
     };
@@ -3109,7 +3109,7 @@ fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t,
       arg_exprs(es) {
         let llarg_tys = type_of_explicit_args(ccx, arg_tys);
         let last = es.len() - 1u;
-        vec::iteri(es) {|i, e|
+        do vec::iteri(es) {|i, e|
             let r = trans_arg_expr(bcx, arg_tys[i], llarg_tys[i],
                                    e, temp_cleanups, if i == last { ret_flag }
                                    else { none }, 0u);
@@ -3125,7 +3125,7 @@ fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t,
     // now that all arguments have been successfully built, we can revoke any
     // temporary cleanups, as they are only needed if argument construction
     // should fail (for example, cleanup of copy mode args).
-    vec::iter(temp_cleanups) {|c|
+    do vec::iter(temp_cleanups) {|c|
         revoke_clean(bcx, c)
     }
 
@@ -3169,7 +3169,7 @@ fn trans_call_inner(
     args: call_args,
     dest: dest) -> block {
 
-    with_scope(in_cx, call_info, "call") {|cx|
+    do with_scope(in_cx, call_info, "call") {|cx|
         let ret_in_loop = alt args {
           arg_exprs(args) { args.len() > 0u && alt vec::last(args).node {
             ast::expr_loop_body(@{node: ast::expr_fn_block(_, body, _), _}) {
@@ -3237,8 +3237,8 @@ fn trans_call_inner(
         if ty::type_is_bot(ret_ty) {
             Unreachable(bcx);
         } else if ret_in_loop {
-            bcx = with_cond(bcx, Load(bcx, option::get(ret_flag))) {|bcx|
-                option::iter(copy bcx.fcx.loop_ret) {|lret|
+            bcx = do with_cond(bcx, Load(bcx, option::get(ret_flag))) {|bcx|
+                do option::iter(copy bcx.fcx.loop_ret) {|lret|
                     Store(bcx, C_bool(true), lret.flagptr);
                     Store(bcx, C_bool(false), bcx.fcx.llretptr);
                 }
@@ -3297,7 +3297,7 @@ fn need_invoke(bcx: block) -> bool {
 
 fn have_cached_lpad(bcx: block) -> bool {
     let mut res = false;
-    in_lpad_scope_cx(bcx) {|inf|
+    do in_lpad_scope_cx(bcx) {|inf|
         alt inf.landing_pad {
           some(_) { res = true; }
           none { res = false; }
@@ -3325,7 +3325,7 @@ fn get_landing_pad(bcx: block) -> BasicBlockRef {
     let _icx = bcx.insn_ctxt("get_landing_pad");
 
     let mut cached = none, pad_bcx = bcx; // Guaranteed to be set below
-    in_lpad_scope_cx(bcx) {|inf|
+    do in_lpad_scope_cx(bcx) {|inf|
         // If there is a valid landing pad still around, use it
         alt copy inf.landing_pad {
           some(target) { cached = some(target); }
@@ -3585,7 +3585,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
             ret alt::trans_alt(bcx, e, expr, arms, mode, dest);
           }
           ast::expr_block(blk) {
-            ret with_scope(bcx, blk.info(), "block-expr body") {|bcx|
+            ret do with_scope(bcx, blk.info(), "block-expr body") {|bcx|
                 trans_block(bcx, blk, dest)
             };
           }
@@ -3697,7 +3697,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
             otherwise. */
             let c = get_extern_const(bcx.ccx().externs, bcx.ccx().llmod,
                                      "check_claims", T_bool());
-            ret with_cond(bcx, Load(bcx, c)) {|bcx|
+            ret do with_cond(bcx, Load(bcx, c)) {|bcx|
                 trans_check_expr(bcx, e, a, "Claim")
             };
           }
@@ -3895,13 +3895,14 @@ fn trans_log(log_ex: @ast::expr, lvl: @ast::expr,
     };
     let current_level = Load(bcx, global);
     let {bcx, val: level} = {
-        with_scope_result(bcx, lvl.info(), "level") {|bcx|
+        do with_scope_result(bcx, lvl.info(), "level") {|bcx|
             trans_temp_expr(bcx, lvl)
         }
     };
 
-    with_cond(bcx, ICmp(bcx, lib::llvm::IntUGE, current_level, level)) {|bcx|
-        with_scope(bcx, log_ex.info(), "log") {|bcx|
+    do with_cond(bcx, ICmp(bcx, lib::llvm::IntUGE, current_level, level)) {
+        |bcx|
+        do with_scope(bcx, log_ex.info(), "log") {|bcx|
             let {bcx, val, _} = trans_temp_expr(bcx, e);
             let e_ty = expr_ty(bcx, e);
             let tydesc = get_tydesc_simple(ccx, e_ty);
@@ -3919,11 +3920,11 @@ fn trans_check_expr(bcx: block, chk_expr: @ast::expr,
     let _icx = bcx.insn_ctxt("trans_check_expr");
     let expr_str = s + " " + expr_to_str(pred_expr) + " failed";
     let {bcx, val} = {
-        with_scope_result(bcx, chk_expr.info(), "check") {|bcx|
+        do with_scope_result(bcx, chk_expr.info(), "check") {|bcx|
             trans_temp_expr(bcx, pred_expr)
         }
     };
-    with_cond(bcx, Not(bcx, val)) {|bcx|
+    do with_cond(bcx, Not(bcx, val)) {|bcx|
         trans_fail(bcx, some(pred_expr.span), expr_str)
     }
 }
@@ -4159,7 +4160,7 @@ fn new_block(cx: fn_ctxt, parent: option<block>, +kind: block_kind,
         llvm::LLVMAppendBasicBlock(cx.llfn, buf)
     });
     let bcx = mk_block(llbb, parent, kind, opt_node_info, cx);
-    option::iter(parent) {|cx|
+    do option::iter(parent) {|cx|
         if cx.unreachable { Unreachable(bcx); }
     };
     ret bcx;
@@ -4223,7 +4224,7 @@ fn trans_block_cleanups_(bcx: block, cleanup_cx: block, is_lpad: bool) ->
     alt check cleanup_cx.kind {
       block_scope({cleanups, _}) {
         let cleanups = copy cleanups;
-        vec::riter(cleanups) {|cu|
+        do vec::riter(cleanups) {|cu|
             alt cu {
               clean(cfn, cleanup_type) | clean_temp(_, cfn, cleanup_type) {
                 // Some types don't need to be cleaned up during
@@ -4361,7 +4362,7 @@ fn alloc_local(cx: block, local: @ast::local) -> block {
     };
     let val = alloc_ty(cx, t);
     if cx.sess().opts.debuginfo {
-        option::iter(simple_name) {|name|
+        do option::iter(simple_name) {|name|
             str::as_c_str(*name, {|buf|
                 llvm::LLVMSetValueName(val, buf)
             });
@@ -4375,7 +4376,7 @@ fn trans_block(bcx: block, b: ast::blk, dest: dest)
     -> block {
     let _icx = bcx.insn_ctxt("trans_block");
     let mut bcx = bcx;
-    block_locals(b) {|local| bcx = alloc_local(bcx, local); };
+    do block_locals(b) {|local| bcx = alloc_local(bcx, local); };
     for vec::each(b.node.stmts) {|s|
         debuginfo::update_source_pos(bcx, b.span);
         bcx = trans_stmt(bcx, *s);
@@ -4871,7 +4872,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
   /* Look up the parent class's def_id */
   let mut class_ty = ty::lookup_item_type(tcx, parent_id).ty;
   /* Substitute in the class type if necessary */
-  option::iter(psubsts) {|ss|
+  do option::iter(psubsts) {|ss|
     class_ty = ty::subst_tps(tcx, ss.tys, class_ty);
   }
 
@@ -4889,7 +4890,7 @@ fn trans_class_dtor(ccx: @crate_ctxt, path: path,
 
   /* If we're monomorphizing, register the monomorphized decl
      for the dtor */
-  option::iter(hash_id) {|h_id|
+  do option::iter(hash_id) {|h_id|
     ccx.monomorphized.insert(h_id, lldecl);
   }
   /* Translate the dtor body */
@@ -4966,7 +4967,7 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
           trans_class_ctor(ccx, *path, ctor.node.dec, ctor.node.body,
                            get_item_val(ccx, ctor.node.id), psubsts,
                            ctor.node.id, local_def(item.id), ctor.span);
-          option::iter(m_dtor) {|dtor|
+          do option::iter(m_dtor) {|dtor|
              trans_class_dtor(ccx, *path, dtor.node.body,
                dtor.node.id, none, none, local_def(item.id));
           };
diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs
index bff06c8a679..f2e0a9eaef2 100644
--- a/src/rustc/middle/trans/build.rs
+++ b/src/rustc/middle/trans/build.rs
@@ -672,7 +672,7 @@ fn Call(cx: block, Fn: ValueRef, Args: ~[ValueRef]) -> ValueRef {
 
         #debug["Call(Fn=%s, Args=%?)",
                val_str(cx.ccx().tn, Fn),
-               Args.map { |arg| val_str(cx.ccx().tn, arg) }];
+               Args.map({ |arg| val_str(cx.ccx().tn, arg) })];
 
         ret llvm::LLVMBuildCall(B(cx), Fn, vec::unsafe::to_ptr(Args),
                                 Args.len() as c_uint, noname());
diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs
index d3f5e186014..c98fe609661 100644
--- a/src/rustc/middle/trans/closure.rs
+++ b/src/rustc/middle/trans/closure.rs
@@ -233,7 +233,7 @@ fn store_environment(bcx: block,
 
     // Copy expr values into boxed bindings.
     let mut bcx = bcx;
-    vec::iteri(bound_values) { |i, bv|
+    do vec::iteri(bound_values) { |i, bv|
         #debug["Copy %s into closure", ev_to_str(ccx, bv)];
 
         if !ccx.sess.no_asm_comments() {
@@ -294,7 +294,7 @@ fn build_closure(bcx0: block,
     let ccx = bcx.ccx(), tcx = ccx.tcx;
 
     // Package up the captured upvars
-    vec::iter(cap_vars) { |cap_var|
+    do vec::iter(cap_vars) { |cap_var|
         #debug["Building closure: captured variable %?", cap_var];
         let lv = trans_local_var(bcx, cap_var.def);
         let nid = ast_util::def_id_of_def(cap_var.def).node;
@@ -323,7 +323,7 @@ fn build_closure(bcx0: block,
           }
         }
     }
-    option::iter(include_ret_handle) {|flagptr|
+    do option::iter(include_ret_handle) {|flagptr|
         let our_ret = alt bcx.fcx.loop_ret {
           some({retptr, _}) { retptr }
           none { bcx.fcx.llretptr }
@@ -354,7 +354,7 @@ fn load_environment(fcx: fn_ctxt,
 
     // Populate the upvars from the environment.
     let mut i = 0u;
-    vec::iter(cap_vars) { |cap_var|
+    do vec::iter(cap_vars) { |cap_var|
         alt cap_var.mode {
           capture::cap_drop { /* ignore */ }
           _ {
@@ -504,7 +504,7 @@ fn make_fn_glue(
     let fn_env = fn@(ck: ty::closure_kind) -> block {
         let box_cell_v = GEPi(cx, v, ~[0u, abi::fn_field_box]);
         let box_ptr_v = Load(cx, box_cell_v);
-        with_cond(cx, IsNotNull(cx, box_ptr_v)) {|bcx|
+        do with_cond(cx, IsNotNull(cx, box_ptr_v)) {|bcx|
             let closure_ty = ty::mk_opaque_closure_ptr(tcx, ck);
             glue_fn(bcx, box_cell_v, closure_ty)
         }
@@ -537,7 +537,7 @@ fn make_opaque_cbox_take_glue(
     let ccx = bcx.ccx(), tcx = ccx.tcx;
     let llopaquecboxty = T_opaque_box_ptr(ccx);
     let cbox_in = Load(bcx, cboxptr);
-    with_cond(bcx, IsNotNull(bcx, cbox_in)) {|bcx|
+    do with_cond(bcx, IsNotNull(bcx, cbox_in)) {|bcx|
         // Load the size from the type descr found in the cbox
         let cbox_in = PointerCast(bcx, cbox_in, llopaquecboxty);
         let tydescptr = GEPi(bcx, cbox_in, ~[0u, abi::box_field_tydesc]);
@@ -599,7 +599,7 @@ fn make_opaque_cbox_free_glue(
     }
 
     let ccx = bcx.ccx();
-    with_cond(bcx, IsNotNull(bcx, cbox)) {|bcx|
+    do with_cond(bcx, IsNotNull(bcx, cbox)) {|bcx|
         // Load the type descr found in the cbox
         let lltydescty = T_ptr(ccx.tydesc_type);
         let cbox = PointerCast(bcx, cbox, T_opaque_cbox_ptr(ccx));
diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs
index b82f426776a..cf23bf7e6bc 100644
--- a/src/rustc/middle/trans/common.rs
+++ b/src/rustc/middle/trans/common.rs
@@ -251,7 +251,7 @@ fn add_clean(cx: block, val: ValueRef, ty: ty::t) {
            cx.to_str(), val_str(cx.ccx().tn, val),
            ty_to_str(cx.ccx().tcx, ty)];
     let cleanup_type = cleanup_type(cx.tcx(), ty);
-    in_scope_cx(cx) {|info|
+    do in_scope_cx(cx) {|info|
         vec::push(info.cleanups, clean({|a|base::drop_ty(a, val, ty)},
                                 cleanup_type));
         scope_clean_changed(info);
@@ -271,7 +271,7 @@ fn add_clean_temp(cx: block, val: ValueRef, ty: ty::t) {
             ret base::drop_ty(bcx, val, ty);
         }
     }
-    in_scope_cx(cx) {|info|
+    do in_scope_cx(cx) {|info|
         vec::push(info.cleanups, clean_temp(val, {|a|do_drop(a, val, ty)},
                                      cleanup_type));
         scope_clean_changed(info);
@@ -283,7 +283,7 @@ fn add_clean_temp_mem(cx: block, val: ValueRef, ty: ty::t) {
            cx.to_str(), val_str(cx.ccx().tn, val),
            ty_to_str(cx.ccx().tcx, ty)];
     let cleanup_type = cleanup_type(cx.tcx(), ty);
-    in_scope_cx(cx) {|info|
+    do in_scope_cx(cx) {|info|
         vec::push(info.cleanups,
                   clean_temp(val, {|a|base::drop_ty(a, val, ty)},
                              cleanup_type));
@@ -295,7 +295,7 @@ fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) {
       heap_shared { {|a|base::trans_free(a, ptr)} }
       heap_exchange { {|a|base::trans_unique_free(a, ptr)} }
     };
-    in_scope_cx(cx) {|info|
+    do in_scope_cx(cx) {|info|
         vec::push(info.cleanups, clean_temp(ptr, free_fn,
                                      normal_exit_and_unwind));
         scope_clean_changed(info);
@@ -307,8 +307,8 @@ fn add_clean_free(cx: block, ptr: ValueRef, heap: heap) {
 // this will be more involved. For now, we simply zero out the local, and the
 // drop glue checks whether it is zero.
 fn revoke_clean(cx: block, val: ValueRef) {
-    in_scope_cx(cx) {|info|
-        option::iter(vec::position(info.cleanups, {|cu|
+    do in_scope_cx(cx) {|info|
+        do option::iter(vec::position(info.cleanups, {|cu|
             alt cu { clean_temp(v, _, _) if v == val { true } _ { false } }
         })) {|i|
             info.cleanups =
@@ -361,7 +361,7 @@ impl node_info for ast::blk {
 
 impl node_info for option<@ast::expr> {
     fn info() -> option<node_info> {
-        self.chain { |s| s.info() }
+        self.chain({ |s| s.info() })
     }
 }
 
@@ -840,7 +840,7 @@ fn C_cstr(cx: @crate_ctxt, s: str) -> ValueRef {
       none { }
     }
 
-    let sc = str::as_c_str(s) {|buf|
+    let sc = do str::as_c_str(s) {|buf|
         llvm::LLVMConstString(buf, str::len(s) as c_uint, False)
     };
     let g =
@@ -862,7 +862,7 @@ fn C_estr_slice(cx: @crate_ctxt, s: str) -> ValueRef {
 
 // Returns a Plain Old LLVM String:
 fn C_postr(s: str) -> ValueRef {
-    ret str::as_c_str(s) {|buf|
+    ret do str::as_c_str(s) {|buf|
         llvm::LLVMConstString(buf, str::len(s) as c_uint, False)
     };
 }
@@ -924,7 +924,7 @@ fn hash_mono_id(&&mi: mono_id) -> uint {
         h = h * alt param {
           mono_precise(ty, vts) {
             let mut h = ty::type_id(ty);
-            option::iter(vts) {|vts|
+            do option::iter(vts) {|vts|
                 for vec::each(vts) {|vt| h += hash_mono_id(vt); }
             }
             h
@@ -980,7 +980,7 @@ fn node_id_type_params(bcx: block, id: ast::node_id) -> ~[ty::t] {
     let params = ty::node_id_to_type_params(tcx, id);
     alt bcx.fcx.param_substs {
       some(substs) {
-        vec::map(params) {|t| ty::subst_tps(tcx, substs.tys, t) }
+        vec::map(params, {|t| ty::subst_tps(tcx, substs.tys, t) })
       }
       _ { params }
     }
diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs
index 836b0e0a28e..23a90e7b39f 100644
--- a/src/rustc/middle/trans/foreign.rs
+++ b/src/rustc/middle/trans/foreign.rs
@@ -67,7 +67,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
     fn struct_tys(ty: TypeRef) -> ~[TypeRef] {
         let n = llvm::LLVMCountStructElementTypes(ty);
         let elts = vec::from_elem(n as uint, ptr::null());
-        vec::as_buf(elts) {|buf|
+        do vec::as_buf(elts) {|buf|
             llvm::LLVMGetStructElementTypes(ty, buf);
         }
         ret elts;
@@ -82,7 +82,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
             2 /* float */ { 4u }
             3 /* double */ { 8u }
             10 /* struct */ {
-                vec::foldl(0u, struct_tys(ty)) {|a, t|
+                do vec::foldl(0u, struct_tys(ty)) {|a, t|
                     uint::max(a, ty_align(t))
                 }
             }
@@ -105,7 +105,7 @@ fn classify_ty(ty: TypeRef) -> ~[x86_64_reg_class] {
             2 /* float */ { 4u }
             3 /* double */ { 8u }
             10 /* struct */ {
-                vec::foldl(0u, struct_tys(ty)) {|s, t|
+                do vec::foldl(0u, struct_tys(ty)) {|s, t|
                     s + ty_size(t)
                 }
             }
@@ -404,12 +404,12 @@ fn x86_64_tys(atys: ~[TypeRef],
 
 fn decl_x86_64_fn(tys: x86_64_tys,
                   decl: fn(fnty: TypeRef) -> ValueRef) -> ValueRef {
-    let atys = vec::map(tys.arg_tys) {|t| t.ty };
+    let atys = vec::map(tys.arg_tys, {|t| t.ty });
     let rty = tys.ret_ty.ty;
     let fnty = T_fn(atys, rty);
     let llfn = decl(fnty);
 
-    vec::iteri(tys.attrs) {|i, a|
+    do vec::iteri(tys.attrs) {|i, a|
         alt a {
             option::some(attr) {
                 let llarg = get_param(llfn, i);
@@ -640,7 +640,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
             let _icx = bcx.insn_ctxt("foreign::shim::build_ret");
             alt tys.x86_64_tys {
                 some(x86_64) {
-                    vec::iteri(x86_64.attrs) {|i, a|
+                    do vec::iteri(x86_64.attrs) {|i, a|
                         alt a {
                             some(attr) {
                                 llvm::LLVMAddInstrAttribute(
@@ -691,7 +691,7 @@ fn trans_foreign_mod(ccx: @crate_ctxt,
         // Declare the "prototype" for the base function F:
         alt tys.x86_64_tys {
           some(x86_64) {
-            decl_x86_64_fn(x86_64) {|fnty|
+            do decl_x86_64_fn(x86_64) {|fnty|
                 decl_fn(ccx.llmod, lname, cc, fnty)
             }
           }
@@ -1153,7 +1153,7 @@ fn register_extern_fn(ccx: @crate_ctxt, sp: span,
     ret if ccx.sess.targ_cfg.arch == arch_x86_64 {
         let ret_def = !ty::type_is_bot(ret_ty) && !ty::type_is_nil(ret_ty);
         let x86_64 = x86_64_tys(llargtys, llretty, ret_def);
-        decl_x86_64_fn(x86_64) {|fnty|
+        do decl_x86_64_fn(x86_64) {|fnty|
             register_fn_fuller(ccx, sp, path, node_id,
                                t, lib::llvm::CCallConv, fnty)
         }
diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs
index 384e4af0f33..b62434eb211 100644
--- a/src/rustc/middle/trans/impl.rs
+++ b/src/rustc/middle/trans/impl.rs
@@ -260,7 +260,7 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: ~[ty::t],
                                                              impl_id))),
                          {|| "make_impl_vtable: non-iface-type implemented"});
     let has_tps = (*ty::lookup_item_type(ccx.tcx, impl_id).bounds).len() > 0u;
-    make_vtable(ccx, vec::map(*ty::iface_methods(tcx, ifce_id)) {|im|
+    make_vtable(ccx, vec::map(*ty::iface_methods(tcx, ifce_id), {|im|
         let fty = ty::subst_tps(tcx, substs, ty::mk_fn(tcx, im.fty));
         if (*im.tps).len() > 0u || ty::type_has_self(fty) {
             C_null(T_ptr(T_nil()))
@@ -279,7 +279,7 @@ fn make_impl_vtable(ccx: @crate_ctxt, impl_id: ast::def_id, substs: ~[ty::t],
                 trans_external_path(ccx, m_id, fty)
             }
         }
-    })
+    }))
 }
 
 fn trans_cast(bcx: block, val: @ast::expr, id: ast::node_id, dest: dest)
diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs
index 0fdaf1b268d..05253f29adc 100644
--- a/src/rustc/middle/trans/reachable.rs
+++ b/src/rustc/middle/trans/reachable.rs
@@ -53,7 +53,7 @@ fn traverse_exports(cx: ctx, vis: ~[@view_item]) -> bool {
 }
 
 fn traverse_export(cx: ctx, exp_id: node_id) {
-    option::iter(cx.exp_map.find(exp_id)) {|defs|
+    do option::iter(cx.exp_map.find(exp_id)) {|defs|
         for vec::each(defs) {|def| traverse_def_id(cx, def.id); }
     }
 }
@@ -111,7 +111,7 @@ fn traverse_public_item(cx: ctx, item: @item) {
       }
       item_class(tps, _ifaces, items, ctor, m_dtor, _) {
         cx.rmap.insert(ctor.node.id, ());
-        option::iter(m_dtor) {|dtor|
+        do option::iter(m_dtor) {|dtor|
             cx.rmap.insert(dtor.node.id, ());
             // dtors don't have attrs
             if tps.len() > 0u {
diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs
index 0d9dfbe7020..00af035e1fa 100644
--- a/src/rustc/middle/trans/reflect.rs
+++ b/src/rustc/middle/trans/reflect.rs
@@ -129,12 +129,12 @@ impl methods for reflector {
 
           ty::ty_vec(mt) { self.bracketed_mt("vec", mt, ~[]) }
           ty::ty_estr(vst) {
-            self.vstore_name_and_extra(t, vst) {|name, extra|
+            do self.vstore_name_and_extra(t, vst) {|name, extra|
                 self.visit("estr_" + name, extra)
             }
           }
           ty::ty_evec(mt, vst) {
-            self.vstore_name_and_extra(t, vst) {|name, extra|
+            do self.vstore_name_and_extra(t, vst) {|name, extra|
                 self.bracketed_mt("evec_" + name, mt, extra)
             }
           }
diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs
index 45a9224c8ad..404682ada7b 100644
--- a/src/rustc/middle/trans/shape.rs
+++ b/src/rustc/middle/trans/shape.rs
@@ -28,7 +28,7 @@ type nominal_id = @{did: ast::def_id, parent_id: option<ast::def_id>,
 fn mk_nominal_id(tcx: ty::ctxt, did: ast::def_id,
                  parent_id: option<ast::def_id>,
                  tps: ~[ty::t]) -> nominal_id {
-    let tps_norm = tps.map { |t| ty::normalize_ty(tcx, t) };
+    let tps_norm = tps.map({ |t| ty::normalize_ty(tcx, t) });
     @{did: did, parent_id: parent_id, tps: tps_norm}
 }
 
@@ -49,7 +49,7 @@ fn eq_nominal_id(&&mi: nominal_id, &&ni: nominal_id) -> bool {
     if mi.did != ni.did {
         false
     } else {
-        vec::all2(mi.tps, ni.tps) { |m_tp, n_tp|
+        do vec::all2(mi.tps, ni.tps) { |m_tp, n_tp|
             ty::type_id(m_tp) == ty::type_id(n_tp)
         }
     }
@@ -137,7 +137,7 @@ enum enum_kind {
 
 fn enum_kind(ccx: @crate_ctxt, did: ast::def_id) -> enum_kind {
     let variants = ty::enum_variants(ccx.tcx, did);
-    if vec::any(*variants) {|v| vec::len(v.args) > 0u} {
+    if vec::any(*variants, {|v| vec::len(v.args) > 0u}) {
         if vec::len(*variants) == 1u { tk_newtype }
         else { tk_complex }
     } else {
@@ -338,7 +338,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t) -> ~[u8] {
             ~[shape_res]
           }
         else { ~[shape_struct] }, sub = ~[];
-        option::iter(m_dtor_did) {|dtor_did|
+        do option::iter(m_dtor_did) {|dtor_did|
           let ri = @{did: dtor_did, parent_id: some(did), tps: tps};
           let id = interner::intern(ccx.shape_cx.resources, ri);
           add_u16(s, id as u16);
@@ -391,7 +391,7 @@ fn gen_enum_shapes(ccx: @crate_ctxt) -> ValueRef {
     while i < ccx.shape_cx.tag_order.len() {
         let {did, substs} = ccx.shape_cx.tag_order[i];
         let variants = @ty::substd_enum_variants(ccx.tcx, did, substs);
-        vec::iter(*variants) {|v|
+        do vec::iter(*variants) {|v|
             offsets += ~[vec::len(data) as u16];
 
             let variant_shape = shape_of_variant(ccx, v);
@@ -583,7 +583,7 @@ fn gen_resource_shapes(ccx: @crate_ctxt) -> ValueRef {
     for uint::range(0u, len) {|i|
         let ri = interner::get(ccx.shape_cx.resources, i);
         for ri.tps.each() {|s| assert !ty::type_has_params(s); }
-        option::iter(ri.parent_id) {|id|
+        do option::iter(ri.parent_id) {|id|
             dtors += ~[trans::base::get_res_dtor(ccx, ri.did, id, ri.tps)];
         }
     }
@@ -742,7 +742,7 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
                                         ty::mk_u8(tcx),
                                         mutbl: ast::m_mutbl}}] }
                 else { ~[] }) +
-              ty::lookup_class_fields(tcx, did).map {|f|
+              do ty::lookup_class_fields(tcx, did).map {|f|
                  let t = ty::lookup_field_type(tcx, did, f.id, substs);
                  {ident: f.ident,
                   mt: {ty: simplify_type(tcx, t), mutbl: ast::m_const}}
@@ -752,5 +752,5 @@ fn simplify_type(tcx: ty::ctxt, typ: ty::t) -> ty::t {
           _ { typ }
         }
     }
-    ty::fold_ty(tcx, typ) {|t| simplifier(tcx, t) }
+    ty::fold_ty(tcx, typ, {|t| simplifier(tcx, t) })
 }
diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs
index 40cf9f1bd7d..cda8f2f1e52 100644
--- a/src/rustc/middle/trans/tvec.rs
+++ b/src/rustc/middle/trans/tvec.rs
@@ -360,7 +360,7 @@ fn trans_append_literal(bcx: block, vptrptr: ValueRef, vec_ty: ty::t,
         let new_fill = Add(bcx, old_fill, elt_sz);
         let do_grow = ICmp(bcx, lib::llvm::IntUGT, new_fill,
                            get_alloc(bcx, vptr));
-        bcx = base::with_cond(bcx, do_grow) {|bcx|
+        bcx = do base::with_cond(bcx, do_grow) {|bcx|
             let pt = PointerCast(bcx, vptrptr,
                                  T_ptr(T_ptr(T_i8())));
             Call(bcx, ccx.upcalls.vec_grow, ~[pt, new_fill]);
diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs
index 926547355db..1ae34c5ce60 100644
--- a/src/rustc/middle/trans/type_of.rs
+++ b/src/rustc/middle/trans/type_of.rs
@@ -16,7 +16,7 @@ export type_of_non_gc_box;
 
 fn type_of_explicit_args(cx: @crate_ctxt,
                          inputs: ~[ty::arg]) -> ~[TypeRef] {
-    vec::map(inputs) {|arg|
+    do vec::map(inputs) {|arg|
         let arg_ty = arg.ty;
         let llty = type_of(cx, arg_ty);
         alt ty::resolved_mode(cx.tcx, arg.mode) {
@@ -175,7 +175,7 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
           ty::ty_class(did, ts) {
             // Only instance vars are record fields at runtime.
             let fields = lookup_class_fields(cx.tcx, did);
-            let mut tys = vec::map(fields) {|f|
+            let mut tys = do vec::map(fields) {|f|
                 let t = ty::lookup_field_type(cx.tcx, did, f.id, ts);
                 type_of(cx, t)
             };
diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs
index b09171fd84e..f71ff22db88 100644
--- a/src/rustc/middle/trans/type_use.rs
+++ b/src/rustc/middle/trans/type_use.rs
@@ -114,7 +114,7 @@ fn type_needs(cx: ctx, use: uint, ty: ty::t) {
 
 fn type_needs_inner(cx: ctx, use: uint, ty: ty::t,
                     enums_seen: @list<def_id>) {
-    ty::maybe_walk_ty(ty) {|ty|
+    do ty::maybe_walk_ty(ty) {|ty|
         if ty::type_has_params(ty) {
             alt ty::get(ty).struct {
                 /*
@@ -181,11 +181,11 @@ fn mark_for_expr(cx: ctx, e: @expr) {
         }
       }
       expr_path(_) {
-        cx.ccx.tcx.node_type_substs.find(e.id).iter {|ts|
+        do cx.ccx.tcx.node_type_substs.find(e.id).iter {|ts|
             let id = ast_util::def_id_of_def(cx.ccx.tcx.def_map.get(e.id));
-            vec::iter2(type_uses_for(cx.ccx, id, ts.len()), ts) {|uses, subst|
+            vec::iter2(type_uses_for(cx.ccx, id, ts.len()), ts, {|uses, subst|
                 type_needs(cx, uses, subst)
-            }
+            })
         }
       }
       expr_fn(*) | expr_fn_block(*) {
@@ -209,11 +209,11 @@ fn mark_for_expr(cx: ctx, e: @expr) {
         let base_ty = ty::node_id_to_type(cx.ccx.tcx, base.id);
         type_needs(cx, use_repr, ty::type_autoderef(cx.ccx.tcx, base_ty));
 
-        option::iter(cx.ccx.maps.method_map.find(e.id)) {|mth|
+        do option::iter(cx.ccx.maps.method_map.find(e.id)) {|mth|
             alt mth.origin {
               typeck::method_static(did) {
-                option::iter(cx.ccx.tcx.node_type_substs.find(e.id)) {|ts|
-                    vec::iter2(type_uses_for(cx.ccx, did, ts.len()), ts)
+                do option::iter(cx.ccx.tcx.node_type_substs.find(e.id)) {|ts|
+                    do vec::iter2(type_uses_for(cx.ccx, did, ts.len()), ts)
                         {|uses, subst| type_needs(cx, uses, subst)}
                 }
               }
@@ -231,14 +231,14 @@ fn mark_for_expr(cx: ctx, e: @expr) {
         node_type_needs(cx, use_repr, v.id);
       }
       expr_call(f, _, _) {
-        vec::iter(ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, f.id))) {|a|
+        vec::iter(ty::ty_fn_args(ty::node_id_to_type(cx.ccx.tcx, f.id)), {|a|
             alt a.mode {
               expl(by_move) | expl(by_copy) | expl(by_val) {
                 type_needs(cx, use_repr, a.ty);
               }
               _ {}
             }
-        }
+        })
       }
       expr_alt(_, _, _) | expr_block(_) | expr_if(_, _, _) |
       expr_while(_, _) | expr_fail(_) | expr_break | expr_cont |
@@ -265,7 +265,7 @@ fn handle_body(cx: ctx, body: blk) {
         },
         visit_block: {|b, cx, v|
             visit::visit_block(b, cx, v);
-            option::iter(b.node.expr) {|e|
+            do option::iter(b.node.expr) {|e|
                 node_type_needs(cx, use_repr, e.id);
             }
         },
diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs
index c76395ee0ee..544128acf2e 100644
--- a/src/rustc/middle/trans/uniq.rs
+++ b/src/rustc/middle/trans/uniq.rs
@@ -10,7 +10,7 @@ export make_free_glue, autoderef, duplicate;
 fn make_free_glue(bcx: block, vptr: ValueRef, t: ty::t)
     -> block {
     let _icx = bcx.insn_ctxt("uniq::make_free_glue");
-    with_cond(bcx, IsNotNull(bcx, vptr)) {|bcx|
+    do with_cond(bcx, IsNotNull(bcx, vptr)) {|bcx|
         let content_ty = content_ty(t);
         let body_ptr = opaque_box_body(bcx, content_ty, vptr);
         let bcx = drop_ty(bcx, body_ptr, content_ty);
diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs
index 30659522153..2cb4efa40b6 100644
--- a/src/rustc/middle/tstate/auxiliary.rs
+++ b/src/rustc/middle/tstate/auxiliary.rs
@@ -661,7 +661,7 @@ fn find_instances(_fcx: fn_ctxt, subst: subst,
 
     if vec::len(subst) == 0u { ret ~[]; }
     let mut res = ~[];
-    (*c.descs).swap { |v|
+    do (*c.descs).swap { |v|
         let v <- vec::from_mut(v);
         for v.each { |d|
             if args_mention(d.node.args, find_in_subst_bool, subst) {
@@ -821,8 +821,8 @@ fn forget_in_postcond(fcx: fn_ctxt, parent_exp: node_id, dead_v: node_id) {
     // In the postcondition given by parent_exp, clear the bits
     // for any constraints mentioning dead_v
     let d = local_node_id_to_local_def_id(fcx, dead_v);
-    option::iter(d) {|d_id|
-        for_constraints_mentioning(fcx, d_id) {|c|
+    do option::iter(d) {|d_id|
+        do for_constraints_mentioning(fcx, d_id) {|c|
                 #debug("clearing constraint %u %s",
                        c.bit_num,
                        constraint_to_str(fcx.ccx.tcx, c.c));
@@ -838,8 +838,8 @@ fn forget_in_poststate(fcx: fn_ctxt, p: poststate, dead_v: node_id) -> bool {
     // for any constraints mentioning dead_v
     let d = local_node_id_to_local_def_id(fcx, dead_v);
     let mut changed = false;
-    option::iter(d) {|d_id|
-        for_constraints_mentioning(fcx, d_id) {|c|
+    do option::iter(d) {|d_id|
+        do for_constraints_mentioning(fcx, d_id) {|c|
                 changed |= clear_in_poststate_(c.bit_num, p);
         }
     }
@@ -926,7 +926,7 @@ type binding = {lhs: ~[dest], rhs: option<initializer>};
 
 fn local_to_bindings(tcx: ty::ctxt, loc: @local) -> binding {
     let mut lhs = ~[];
-    pat_bindings(tcx.def_map, loc.node.pat) {|p_id, _s, name|
+    do pat_bindings(tcx.def_map, loc.node.pat) {|p_id, _s, name|
       vec::push(lhs, local_dest({ident: path_to_ident(name), node: p_id}));
     };
     {lhs: lhs, rhs: loc.node.init}
@@ -956,7 +956,7 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> ~[mode] {
 }
 
 fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> ~[init_op] {
-    vec::map(callee_modes(fcx, callee)) {|m|
+    do vec::map(callee_modes(fcx, callee)) {|m|
         alt ty::resolved_mode(fcx.ccx.tcx, m) {
           by_move { init_move }
           by_copy | by_ref | by_val | by_mutbl_ref { init_assign }
diff --git a/src/rustc/middle/tstate/bitvectors.rs b/src/rustc/middle/tstate/bitvectors.rs
index dfeeaa5e99f..d1be0f990b1 100644
--- a/src/rustc/middle/tstate/bitvectors.rs
+++ b/src/rustc/middle/tstate/bitvectors.rs
@@ -49,7 +49,7 @@ fn seq_postconds(fcx: fn_ctxt, ps: ~[postcond]) -> postcond {
     let sz = vec::len(ps);
     if sz >= 1u {
         let prev = tritv_clone(ps[0]);
-        vec::iter_between(ps, 1u, sz) {|p| seq_tritv(prev, p); }
+        vec::iter_between(ps, 1u, sz, {|p| seq_tritv(prev, p); });
         ret prev;
     } else { ret ann::empty_poststate(num_constraints(fcx.enclosing)); }
 }
diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs
index e2c9b9e8deb..5c31cc2c17c 100644
--- a/src/rustc/middle/tstate/pre_post_conditions.rs
+++ b/src/rustc/middle/tstate/pre_post_conditions.rs
@@ -230,7 +230,7 @@ fn handle_update(fcx: fn_ctxt, parent: @expr, lhs: @expr, rhs: @expr,
 
 fn forget_args_moved_in(fcx: fn_ctxt, parent: @expr, modes: ~[mode],
                         operands: ~[@expr]) {
-    vec::iteri(modes) {|i,mode|
+    do vec::iteri(modes) {|i,mode|
         alt ty::resolved_mode(fcx.ccx.tcx, mode) {
           by_move { forget_in_postcond(fcx, parent.id, operands[i].id); }
           by_ref | by_val | by_mutbl_ref | by_copy { }
@@ -463,7 +463,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                     /* LHS always becomes initialized,
                      whether or not this is a move */
                     find_pre_post_expr(fcx, an_init.expr);
-                    pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
+                    do pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
                         {|p_id, _s, _n|
                         copy_pre_post(fcx.ccx, p_id, an_init.expr);
                     };
@@ -477,7 +477,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                       _ { }
                     }
 
-                    pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
+                    do pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
                         {|p_id, _s, n|
                         let ident = path_to_ident(n);
                         alt p {
@@ -505,7 +505,7 @@ fn find_pre_post_stmt(fcx: fn_ctxt, s: stmt) {
                                    prev_pp.postcondition);
                   }
                   none {
-                    pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
+                    do pat_bindings(fcx.ccx.tcx.def_map, alocal.node.pat)
                         {|p_id, _s, _n|
                         clear_pp(node_id_to_ts_ann(fcx.ccx, p_id).conditions);
                     };
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
index 75b45b804cd..840dc83477c 100644
--- a/src/rustc/middle/ty.rs
+++ b/src/rustc/middle/ty.rs
@@ -558,7 +558,7 @@ fn mk_t_with_id(cx: ctxt, st: sty, o_def_id: option<ast::def_id>) -> t {
     fn sflags(substs: substs) -> uint {
         let mut f = 0u;
         for substs.tps.each {|tt| f |= get(tt).flags; }
-        substs.self_r.iter { |r| f |= rflags(r) }
+        substs.self_r.iter({ |r| f |= rflags(r) });
         ret f;
     }
     alt st {
@@ -795,8 +795,8 @@ fn fold_sty_to_ty(tcx: ty::ctxt, sty: sty, foldop: fn(t) -> t) -> t {
 fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
     fn fold_substs(substs: substs, fldop: fn(t) -> t) -> substs {
         {self_r: substs.self_r,
-         self_ty: substs.self_ty.map { |t| fldop(t) },
-         tps: substs.tps.map { |t| fldop(t) }}
+         self_ty: substs.self_ty.map({ |t| fldop(t) }),
+         tps: substs.tps.map({ |t| fldop(t) })}
     }
 
     alt sty {
@@ -825,7 +825,7 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
         ty_iface(did, fold_substs(substs, fldop))
       }
       ty_rec(fields) {
-        let new_fields = vec::map(fields) {|fl|
+        let new_fields = do vec::map(fields) {|fl|
             let new_ty = fldop(fl.mt.ty);
             let new_mt = {ty: new_ty, mutbl: fl.mt.mutbl};
             {ident: fl.ident, mt: new_mt}
@@ -833,14 +833,14 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
         ty_rec(new_fields)
       }
       ty_tup(ts) {
-        let new_ts = vec::map(ts) {|tt| fldop(tt) };
+        let new_ts = vec::map(ts, {|tt| fldop(tt) });
         ty_tup(new_ts)
       }
       ty_fn(f) {
-        let new_args = vec::map(f.inputs) {|a|
+        let new_args = vec::map(f.inputs, {|a|
             let new_ty = fldop(a.ty);
             {mode: a.mode, ty: new_ty}
-        };
+        });
         let new_output = fldop(f.output);
         ty_fn({inputs: new_args, output: new_output with f})
       }
@@ -863,7 +863,7 @@ fn fold_sty(sty: sty, fldop: fn(t) -> t) -> sty {
 
 // Folds types from the bottom up.
 fn fold_ty(cx: ctxt, t0: t, fldop: fn(t) -> t) -> t {
-    let sty = fold_sty(get(t0).struct) {|t| fold_ty(cx, fldop(t), fldop) };
+    let sty = fold_sty(get(t0).struct, {|t| fold_ty(cx, fldop(t), fldop) });
     fldop(mk_t(cx, sty))
 }
 
@@ -894,9 +894,9 @@ fn fold_regions_and_ty(
         fldr: fn(r: region) -> region,
         fldt: fn(t: t) -> t) -> substs {
 
-        {self_r: substs.self_r.map { |r| fldr(r) },
-         self_ty: substs.self_ty.map { |t| fldt(t) },
-         tps: substs.tps.map { |t| fldt(t) }}
+        {self_r: substs.self_r.map({ |r| fldr(r) }),
+         self_ty: substs.self_ty.map({ |t| fldt(t) }),
+         tps: substs.tps.map({ |t| fldt(t) })}
     }
 
     let tb = ty::get(ty);
@@ -925,14 +925,10 @@ fn fold_regions_and_ty(
         ty::mk_iface(cx, def_id, fold_substs(substs, fldr, fldt))
       }
       sty @ ty_fn(_) {
-        fold_sty_to_ty(cx, sty) {|t|
-            fldfnt(t)
-        }
+        fold_sty_to_ty(cx, sty, {|t| fldfnt(t) })
       }
       sty {
-        fold_sty_to_ty(cx, sty) {|t|
-            fldt(t)
-        }
+        fold_sty_to_ty(cx, sty, {|t| fldt(t) })
       }
     }
 }
@@ -981,7 +977,7 @@ fn fold_region(cx: ctxt, t0: t, fldop: fn(region, bool) -> region) -> t {
             t0
           }
           sty {
-            fold_sty_to_ty(cx, sty) {|t|
+            do fold_sty_to_ty(cx, sty) {|t|
                 do_fold(cx, t, under_r, fldop)
             }
           }
@@ -998,7 +994,7 @@ fn subst_tps(cx: ctxt, tps: ~[t], typ: t) -> t {
     if !tbox_has_flag(tb, has_params) { ret typ; }
     alt tb.struct {
       ty_param(idx, _) { tps[idx] }
-      sty { fold_sty_to_ty(cx, sty) {|t| subst_tps(cx, tps, t) } }
+      sty { fold_sty_to_ty(cx, sty, {|t| subst_tps(cx, tps, t) }) }
     }
 }
 
@@ -1012,7 +1008,7 @@ fn substs_to_str(cx: ctxt, substs: substs) -> str {
     #fmt["substs(self_r=%s, self_ty=%s, tps=%?)",
          substs.self_r.map_default("none", { |r| region_to_str(cx, r) }),
          substs.self_ty.map_default("none", { |t| ty_to_str(cx, t) }),
-         substs.tps.map { |t| ty_to_str(cx, t) }]
+         substs.tps.map({ |t| ty_to_str(cx, t) })]
 }
 
 fn subst(cx: ctxt,
@@ -1276,7 +1272,7 @@ fn type_needs_unwind_cleanup_(cx: ctxt, ty: t,
 
     let mut encountered_box = encountered_box;
     let mut needs_unwind_cleanup = false;
-    maybe_walk_ty(ty) {|ty|
+    do maybe_walk_ty(ty) {|ty|
         let old_encountered_box = encountered_box;
         let result = alt get(ty).struct {
           ty_box(_) | ty_opaque_box {
@@ -1665,7 +1661,7 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
           }
 
           ty_rec(fields) {
-            vec::any(fields) {|field|
+            do vec::any(fields) {|field|
                 type_requires(cx, seen, r_ty, field.mt.ty)
             }
           }
@@ -1680,16 +1676,16 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
 
           ty_class(did, substs) {
             vec::push(*seen, did);
-            let r = vec::any(class_items_as_fields(cx, did, substs)) {|f|
-                      type_requires(cx, seen, r_ty, f.mt.ty)};
+            let r = vec::any(class_items_as_fields(cx, did, substs),{|f|
+                      type_requires(cx, seen, r_ty, f.mt.ty)});
             vec::pop(*seen);
             r
           }
 
           ty_tup(ts) {
-            vec::any(ts) {|t|
+            vec::any(ts, {|t|
                 type_requires(cx, seen, r_ty, t)
-            }
+            })
           }
 
           ty_enum(did, _) if vec::contains(*seen, did) {
@@ -1699,12 +1695,12 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
           ty_enum(did, substs) {
             vec::push(*seen, did);
             let vs = enum_variants(cx, did);
-            let r = vec::len(*vs) > 0u && vec::all(*vs) {|variant|
-                vec::any(variant.args) {|aty|
+            let r = vec::len(*vs) > 0u && vec::all(*vs, {|variant|
+                vec::any(variant.args, {|aty|
                     let sty = subst(cx, substs, aty);
                     type_requires(cx, seen, r_ty, sty)
-                }
-            };
+                })
+            });
             vec::pop(*seen);
             r
           }
@@ -1865,11 +1861,11 @@ fn type_is_pod(cx: ctxt, ty: t) -> bool {
       ty_param(_, _) { result = false; }
       ty_opaque_closure_ptr(_) { result = true; }
       ty_class(did, substs) {
-        result = vec::any(lookup_class_fields(cx, did)) { |f|
+        result = vec::any(lookup_class_fields(cx, did), { |f|
             let fty = ty::lookup_item_type(cx, f.id);
             let sty = subst(cx, substs, fty.ty);
             type_is_pod(cx, sty)
-        };
+        });
       }
 
       ty_estr(vstore_slice(*)) | ty_evec(_, vstore_slice(*)) {
@@ -2294,7 +2290,7 @@ fn occurs_check(tcx: ctxt, sp: span, vid: tv_vid, rt: t) {
     // contain duplicates.  (Integral type vars aren't counted.)
     fn vars_in_type(ty: t) -> ~[tv_vid] {
         let mut rslt = ~[];
-        walk_ty(ty) {|ty|
+        do walk_ty(ty) {|ty|
             alt get(ty).struct { ty_var(v) { vec::push(rslt, v); } _ { } }
         }
         rslt
@@ -2574,10 +2570,10 @@ type variant_info = @{args: ~[t], ctor_ty: t, name: ast::ident,
 fn substd_enum_variants(cx: ctxt,
                         id: ast::def_id,
                         substs: substs) -> ~[variant_info] {
-    vec::map(*enum_variants(cx, id)) { |variant_info|
-        let substd_args = vec::map(variant_info.args) {|aty|
+    do vec::map(*enum_variants(cx, id)) { |variant_info|
+        let substd_args = vec::map(variant_info.args, {|aty|
             subst(cx, substs, aty)
-        };
+        });
 
         let substd_ctor_ty = subst(cx, substs, variant_info.ctor_ty);
 
@@ -2682,7 +2678,7 @@ fn enum_variants(cx: ctxt, id: ast::def_id) -> @~[variant_info] {
                 let ctor_ty = node_id_to_type(cx, variant.node.id);
                 let arg_tys = {
                     if vec::len(variant.node.args) > 0u {
-                        ty_fn_args(ctor_ty).map { |a| a.ty }
+                        ty_fn_args(ctor_ty).map({ |a| a.ty })
                     } else { ~[] }
                 };
                 alt variant.node.disr_expr {
@@ -2791,8 +2787,8 @@ fn lookup_class_fields(cx: ctxt, did: ast::def_id) -> ~[field_ty] {
 
 fn lookup_class_field(cx: ctxt, parent: ast::def_id, field_id: ast::def_id)
     -> field_ty {
-    alt vec::find(lookup_class_fields(cx, parent))
-                 {|f| f.id.node == field_id.node} {
+    alt vec::find(lookup_class_fields(cx, parent),
+                 {|f| f.id.node == field_id.node}) {
         some(t) { t }
         none { cx.sess.bug("class ID not found in parent's fields"); }
     }
@@ -3029,7 +3025,7 @@ fn normalize_ty(cx: ctxt, t: t) -> t {
     // types, which isn't necessary after #2187
     let t = mk_t(cx, mach_sty(cx.sess.targ_cfg, t));
 
-    let sty = fold_sty(get(t).struct) {|t| normalize_ty(cx, t) };
+    let sty = fold_sty(get(t).struct, {|t| normalize_ty(cx, t) });
     let t_norm = mk_t(cx, sty);
     cx.normalized_cache.insert(t, t_norm);
     ret t_norm;
diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs
index 01647000b0b..be0018aeeba 100644
--- a/src/rustc/middle/typeck/astconv.rs
+++ b/src/rustc/middle/typeck/astconv.rs
@@ -121,7 +121,7 @@ fn ast_path_to_substs_and_ty<AC: ast_conv, RS: region_scope copy>(
             #fmt["wrong number of type arguments, expected %u but found %u",
                  (*decl_bounds).len(), path.types.len()]);
     }
-    let tps = path.types.map { |a_t| ast_ty_to_ty(self, rscope, a_t) };
+    let tps = path.types.map({ |a_t| ast_ty_to_ty(self, rscope, a_t) });
 
     let substs = {self_r:self_r, self_ty:none, tps:tps};
     {substs: substs, ty: ty::subst(tcx, substs, decl_ty)}
@@ -244,11 +244,11 @@ fn ast_ty_to_ty<AC: ast_conv, RS: region_scope copy>(
         ty::mk_rptr(tcx, r, mt)
       }
       ast::ty_tup(fields) {
-        let flds = vec::map(fields) { |t| ast_ty_to_ty(self, rscope, t) };
+        let flds = vec::map(fields, { |t| ast_ty_to_ty(self, rscope, t) });
         ty::mk_tup(tcx, flds)
       }
       ast::ty_rec(fields) {
-        let flds = fields.map {|f|
+        let flds = do fields.map {|f|
             let tm = ast_mt_to_mt(self, rscope, f.node.mt);
             {ident: f.node.ident, mt: tm}
         };
@@ -412,13 +412,13 @@ fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy>(
     expected_tys: expected_tys) -> ty::fn_ty {
 
     #debug["ty_of_fn_decl"];
-    indent {||
+    do indent {||
         // new region names that appear inside of the fn decl are bound to
         // that function type
         let rb = in_binding_rscope(rscope);
 
-        let input_tys = decl.inputs.mapi { |i, a|
-            let expected_arg_ty = expected_tys.chain { |e|
+        let input_tys = do decl.inputs.mapi { |i, a|
+            let expected_arg_ty = do expected_tys.chain { |e|
                 // no guarantee that the correct number of expected args
                 // were supplied
                 if i < e.inputs.len() {some(e.inputs[i])} else {none}
@@ -426,16 +426,16 @@ fn ty_of_fn_decl<AC: ast_conv, RS: region_scope copy>(
             ty_of_arg(self, rb, a, expected_arg_ty)
         };
 
-        let expected_ret_ty = expected_tys.map { |e| e.output };
+        let expected_ret_ty = expected_tys.map({ |e| e.output });
         let output_ty = alt decl.output.node {
           ast::ty_infer if expected_ret_ty.is_some() {expected_ret_ty.get()}
           ast::ty_infer {self.ty_infer(decl.output.span)}
           _ {ast_ty_to_ty(self, rb, decl.output)}
         };
 
-        let out_constrs = vec::map(decl.constraints) {|constr|
+        let out_constrs = vec::map(decl.constraints, {|constr|
             ty::ast_constr_to_constr(self.tcx(), constr)
-        };
+        });
 
         {purity: decl.purity, proto: proto, inputs: input_tys,
          output: output_ty, ret_style: decl.cf, constraints: out_constrs}
diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs
index 06ad3f96c5e..c46e2e63c77 100644
--- a/src/rustc/middle/typeck/check.rs
+++ b/src/rustc/middle/typeck/check.rs
@@ -172,13 +172,13 @@ fn check_fn(ccx: @crate_ctxt,
                                        { |br| ty::re_free(body.node.id, br) })
     };
 
-    let arg_tys = fn_ty.inputs.map { |a| a.ty };
+    let arg_tys = fn_ty.inputs.map({ |a| a.ty });
     let ret_ty = fn_ty.output;
 
     #debug["check_fn(arg_tys=%?, ret_ty=%?, self_ty=%?)",
-           arg_tys.map {|a| ty_to_str(tcx, a) },
+           arg_tys.map({|a| ty_to_str(tcx, a) }),
            ty_to_str(tcx, ret_ty),
-           option::map(self_ty) {|st| ty_to_str(tcx, st) }];
+           option::map(self_ty, {|st| ty_to_str(tcx, st) })];
 
     // ______________________________________________________________________
     // Create the function context.  This is either derived from scratch or,
@@ -239,7 +239,7 @@ fn check_fn(ccx: @crate_ctxt,
     }
 
     let mut i = 0u;
-    vec::iter(arg_tys) {|arg|
+    do vec::iter(arg_tys) {|arg|
         fcx.write_ty(decl.inputs[i].id, arg);
         i += 1u;
     }
@@ -272,7 +272,7 @@ fn check_fn(ccx: @crate_ctxt,
         };
 
         // Add formal parameters.
-        vec::iter2(arg_tys, decl.inputs) {|arg_ty, input|
+        do vec::iter2(arg_tys, decl.inputs) {|arg_ty, input|
             assign(input.id, some(arg_ty));
             #debug["Argument %s is assigned to %s",
                    *input.ident, fcx.locals.get(input.id).to_str()];
@@ -368,7 +368,7 @@ fn check_item(ccx: @crate_ctxt, it: @ast::item) {
           // Write the ctor's self's type
           write_ty_to_tcx(tcx, ctor.node.self_id, class_t);
 
-          option::iter(m_dtor) {|dtor|
+          do option::iter(m_dtor) {|dtor|
             // typecheck the dtor
            check_bare_fn(ccx, ast_util::dtor_dec(),
                            dtor.node.body, dtor.node.id,
@@ -430,7 +430,7 @@ impl of region_scope for @fn_ctxt {
         result::ok(self.infcx.next_region_var())
     }
     fn named_region(id: ast::ident) -> result<ty::region, str> {
-        empty_rscope.named_region(id).chain_err { |_e|
+        do empty_rscope.named_region(id).chain_err { |_e|
             alt self.in_scope_regions.find(ty::br_named(id)) {
               some(r) { result::ok(r) }
               none if *id == "blk" { self.block_region() }
@@ -632,7 +632,7 @@ fn check_expr_with(fcx: @fn_ctxt, expr: @ast::expr, expected: ty::t) -> bool {
 
 fn check_expr(fcx: @fn_ctxt, expr: @ast::expr,
               expected: option<ty::t>) -> bool {
-    ret check_expr_with_unifier(fcx, expr, expected) {||
+    ret do check_expr_with_unifier(fcx, expr, expected) {||
         for expected.each {|t|
             demand::suptype(fcx, expr.span, t, fcx.expr_ty(expr));
         }
@@ -697,7 +697,7 @@ fn lookup_field_ty(tcx: ty::ctxt, class_id: ast::def_id,
                    substs: ty::substs) -> option<ty::t> {
 
     let o_field = vec::find(items, {|f| f.ident == fieldname});
-    option::map(o_field) {|f|
+    do option::map(o_field) {|f|
         ty::lookup_field_type(tcx, class_id, f.id, substs)
     }
 }
@@ -756,7 +756,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         // if the wrong number of arguments were supplied
         let expected_arg_count = vec::len(fn_ty.inputs);
         let arg_tys = if expected_arg_count == supplied_arg_count {
-            fn_ty.inputs.map { |a| a.ty }
+            fn_ty.inputs.map({ |a| a.ty })
         } else {
             fcx.ccx.tcx.sess.span_err(
                 sp, #fmt["this function takes %u parameter%s but %u \
@@ -792,10 +792,10 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                     if is_block == check_blocks {
                         let arg_ty = arg_tys[i];
                         bot |= check_expr_with_unifier(
-                            fcx, a, some(arg_ty)) {||
+                            fcx, a, some(arg_ty), {||
                             demand::assign(fcx, a.span, call_expr_id,
                                            arg_ty, a);
-                        };
+                        });
                     }
                   }
                   none { }
@@ -824,7 +824,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
 
         // Call the generic checker.
         let fty = {
-            let args_opt = args.map { |arg| some(arg) };
+            let args_opt = args.map({ |arg| some(arg) });
             let r = check_call_or_bind(fcx, sp, call_expr_id,
                                        fn_ty, args_opt);
             bot |= r.bot;
@@ -1021,7 +1021,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
                      expected: option<ty::t>) {
         let tcx = fcx.ccx.tcx;
 
-        let expected_tys = unpack_expected(fcx, expected) { |sty|
+        let expected_tys = do unpack_expected(fcx, expected) { |sty|
             alt sty {
               ty::ty_fn(fn_ty) {some({inputs:fn_ty.inputs,
                                       output:fn_ty.output})}
@@ -1106,7 +1106,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         fcx.write_nil(expr.id);
       }
       ast::expr_unary(unop, oprnd) {
-        let exp_inner = unpack_expected(fcx, expected) {|sty|
+        let exp_inner = do unpack_expected(fcx, expected) {|sty|
             alt unop {
               ast::box(_) | ast::uniq(_) {
                 alt sty {
@@ -1182,9 +1182,9 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         fcx.write_ty(id, oprnd_t);
       }
       ast::expr_addr_of(mutbl, oprnd) {
-        bot = check_expr(fcx, oprnd, unpack_expected(fcx, expected) {|ty|
+        bot = check_expr(fcx, oprnd, unpack_expected(fcx, expected, {|ty|
             alt ty { ty::ty_rptr(_, mt) { some(mt.ty) } _ { none } }
-        });
+        }));
         let region = region_of(fcx, oprnd);
         let tm = { ty: fcx.expr_ty(oprnd), mutbl: mutbl };
         let oprnd_t = ty::mk_rptr(tcx, region, tm);
@@ -1418,11 +1418,11 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
       ast::expr_tup(elts) {
         let mut elt_ts = ~[];
         vec::reserve(elt_ts, vec::len(elts));
-        let flds = unpack_expected(fcx, expected) {|sty|
+        let flds = unpack_expected(fcx, expected, {|sty|
             alt sty { ty::ty_tup(flds) { some(flds) } _ { none } }
-        };
+        });
         for elts.eachi {|i, e|
-            check_expr(fcx, e, flds.map {|fs| fs[i]});
+            check_expr(fcx, e, flds.map({|fs| fs[i]}));
             let ety = fcx.expr_ty(e);
             vec::push(elt_ts, ety);
         }
@@ -1430,17 +1430,17 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
         fcx.write_ty(id, typ);
       }
       ast::expr_rec(fields, base) {
-        option::iter(base) {|b| check_expr(fcx, b, expected); }
+        option::iter(base, {|b| check_expr(fcx, b, expected); });
         let expected = if expected == none && base != none {
             some(fcx.expr_ty(base.get()))
         } else { expected };
-        let flds = unpack_expected(fcx, expected) {|sty|
+        let flds = unpack_expected(fcx, expected, {|sty|
             alt sty { ty::ty_rec(flds) { some(flds) } _ { none } }
-        };
+        });
         let fields_t = vec::map(fields, {|f|
-            bot |= check_expr(fcx, f.node.expr, flds.chain {|flds|
-                vec::find(flds) {|tf| tf.ident == f.node.ident}
-            }.map {|tf| tf.mt.ty});
+            bot |= check_expr(fcx, f.node.expr, flds.chain({|flds|
+                vec::find(flds, {|tf| tf.ident == f.node.ident})
+            }).map({|tf| tf.mt.ty}));
             let expr_t = fcx.expr_ty(f.node.expr);
             let expr_mt = {ty: expr_t, mutbl: f.node.mutbl};
             // for the most precise error message,
@@ -1533,7 +1533,7 @@ fn check_expr_with_unifier(fcx: @fn_ctxt,
           _ {}
         }
         if !handled {
-            let tps = vec::map(tys) { |ty| fcx.to_ty(ty) };
+            let tps = vec::map(tys, { |ty| fcx.to_ty(ty) });
             let is_self_ref = self_ref(fcx, base.id);
 
             // this will be the call or block that immediately
@@ -1829,7 +1829,7 @@ fn check_enum_variants(ccx: @crate_ctxt,
         vec::push(disr_vals, disr_val);
         let ctor_ty = ty::node_id_to_type(ccx.tcx, v.node.id);
         let arg_tys = if v.node.args.len() > 0u {
-            ty::ty_fn_args(ctor_ty).map {|a| a.ty }
+            ty::ty_fn_args(ctor_ty).map({|a| a.ty })
           } else { ~[] };
         vec::push(variants, @{args: arg_tys, ctor_ty: ctor_ty,
               name: v.node.name, id: local_def(v.node.id),
@@ -2098,7 +2098,7 @@ fn instantiate_path(fcx: @fn_ctxt,
             (sp, "not enough type parameters provided for this item");
         fcx.infcx.next_ty_vars(ty_param_count)
     } else {
-        pth.types.map { |aty| fcx.to_ty(aty) }
+        pth.types.map({ |aty| fcx.to_ty(aty) })
     };
 
     let substs = {self_r: self_r, self_ty: none, tps: tps};
diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs
index 266817763a5..6831e7da077 100644
--- a/src/rustc/middle/typeck/check/alt.rs
+++ b/src/rustc/middle/typeck/check/alt.rs
@@ -79,7 +79,7 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
             let vinfo =
                 ty::enum_variant_with_id(
                     tcx, v_def_ids.enm, v_def_ids.var);
-            vinfo.args.map { |t| ty::subst(tcx, expected_substs, t) }
+            vinfo.args.map({ |t| ty::subst(tcx, expected_substs, t) })
         };
         let arg_len = arg_types.len(), subpats_len = alt subpats {
             none { arg_len }
@@ -96,8 +96,8 @@ fn check_pat_variant(pcx: pat_ctxt, pat: @ast::pat, path: @ast::path,
                 tcx.sess.span_fatal(pat.span, s);
             }
 
-            option::iter(subpats) {|pats|
-                vec::iter2(pats, arg_types) {|subpat, arg_ty|
+            do option::iter(subpats) {|pats|
+                do vec::iter2(pats, arg_types) {|subpat, arg_ty|
                   check_pat(pcx, subpat, arg_ty);
                 }
             };
diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs
index 5d27a7e4a39..fc208bcb56f 100644
--- a/src/rustc/middle/typeck/check/regionmanip.rs
+++ b/src/rustc/middle/typeck/check/regionmanip.rs
@@ -15,22 +15,22 @@ fn replace_bound_regions_in_fn_ty(
     for self_ty.each { |t| vec::push(all_tys, t) }
 
     #debug["replace_bound_regions_in_fn_ty(self_ty=%?, fn_ty=%s, all_tys=%?)",
-           self_ty.map { |t| ty_to_str(tcx, t) },
+           self_ty.map({ |t| ty_to_str(tcx, t) }),
            ty_to_str(tcx, ty::mk_fn(tcx, fn_ty)),
-           all_tys.map { |t| ty_to_str(tcx, t) }];
+           all_tys.map({ |t| ty_to_str(tcx, t) })];
     let _i = indenter();
 
-    let isr = create_bound_region_mapping(tcx, isr, all_tys) { |br|
+    let isr = do create_bound_region_mapping(tcx, isr, all_tys) { |br|
         #debug["br=%?", br];
         mapf(br)
     };
-    let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(fn_ty)) { |t|
+    let t_fn = ty::fold_sty_to_ty(tcx, ty::ty_fn(fn_ty), { |t|
         replace_bound_regions(tcx, isr, t)
-    };
-    let t_self = self_ty.map { |t| replace_bound_regions(tcx, isr, t) };
+    });
+    let t_self = self_ty.map({ |t| replace_bound_regions(tcx, isr, t) });
 
     #debug["result of replace_bound_regions_in_fn_ty: self_ty=%?, fn_ty=%s",
-           t_self.map { |t| ty_to_str(tcx, t) },
+           t_self.map({ |t| ty_to_str(tcx, t) }),
            ty_to_str(tcx, t_fn)];
 
     ret {isr: isr,
@@ -78,7 +78,7 @@ fn replace_bound_regions_in_fn_ty(
         }
 
         // For each type `ty` in `tys`...
-        tys.foldl(isr) { |isr, ty|
+        do tys.foldl(isr) { |isr, ty|
             let mut isr = isr;
 
             // Using fold_regions is inefficient, because it
@@ -86,7 +86,7 @@ fn replace_bound_regions_in_fn_ty(
             // terms of locating all the regions within the various
             // kinds of types.  This had already caused me several
             // bugs so I decided to switch over.
-            ty::fold_regions(tcx, ty) { |r, in_fn|
+            do ty::fold_regions(tcx, ty) { |r, in_fn|
                 if !in_fn { isr = append_isr(isr, to_r, r); }
                 r
             };
@@ -104,7 +104,7 @@ fn replace_bound_regions_in_fn_ty(
         isr: isr_alist,
         ty: ty::t) -> ty::t {
 
-        ty::fold_regions(tcx, ty) { |r, in_fn|
+        do ty::fold_regions(tcx, ty) { |r, in_fn|
             alt r {
               // As long as we are not within a fn() type, `&T` is
               // mapped to the free region anon_r.  But within a fn
diff --git a/src/rustc/middle/typeck/check/writeback.rs b/src/rustc/middle/typeck/check/writeback.rs
index 1c017dc501e..6c001bfda8f 100644
--- a/src/rustc/middle/typeck/check/writeback.rs
+++ b/src/rustc/middle/typeck/check/writeback.rs
@@ -83,7 +83,7 @@ fn visit_expr(e: @ast::expr, wbcx: wb_ctxt, v: wb_vt) {
     alt e.node {
       ast::expr_fn(_, decl, _, _) |
       ast::expr_fn_block(decl, _, _) {
-        vec::iter(decl.inputs) {|input|
+        do vec::iter(decl.inputs) {|input|
             let r_ty = resolve_type_vars_for_node(wbcx, e.span, input.id);
 
             // Just in case we never constrained the mode to anything,
diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs
index 52daa1331f3..2bc178d1641 100644
--- a/src/rustc/middle/typeck/collect.rs
+++ b/src/rustc/middle/typeck/collect.rs
@@ -109,10 +109,10 @@ fn get_enum_variant_types(ccx: @crate_ctxt,
             enum_ty
         } else {
             let rs = type_rscope(rp);
-            let args = variant.node.args.map { |va|
+            let args = variant.node.args.map({ |va|
                 let arg_ty = ccx.to_ty(rs, va.ty);
                 {mode: ast::expl(ast::by_copy), ty: arg_ty}
-            };
+            });
             ty::mk_fn(tcx, {purity: ast::pure_fn,
                             proto: ast::proto_box,
                             inputs: args,
@@ -137,17 +137,17 @@ fn ensure_iface_methods(ccx: @crate_ctxt, id: ast::node_id) {
     let tcx = ccx.tcx;
     alt check tcx.items.get(id) {
       ast_map::node_item(@{node: ast::item_iface(_, rp, ms), _}, _) {
-        store_methods::<ast::ty_method>(ccx, id, ms) {|m|
+        store_methods::<ast::ty_method>(ccx, id, ms, {|m|
             ty_of_ty_method(ccx, m, rp)
-        };
+        });
       }
       ast_map::node_item(@{node: ast::item_class(_,_,its,_,_,rp), _}, _) {
         let (_,ms) = split_class_items(its);
         // All methods need to be stored, since lookup_method
         // relies on the same method cache for self-calls
-        store_methods::<@ast::method>(ccx, id, ms) {|m|
+        store_methods::<@ast::method>(ccx, id, ms, {|m|
             ty_of_method(ccx, m, rp)
-        };
+        });
       }
     }
 }
@@ -196,7 +196,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
         replace_bound_self(tcx, impl_fty, dummy_self_r)
     };
     let if_fty = {
-        let dummy_tps = vec::from_fn((*if_m.tps).len()) { |i|
+        let dummy_tps = do vec::from_fn((*if_m.tps).len()) { |i|
             // hack: we don't know the def id of the impl tp, but it
             // is not important for unification
             ty::mk_param(tcx, i + impl_tps, {crate: 0, node: 0})
@@ -217,7 +217,7 @@ fn compare_impl_method(tcx: ty::ctxt, sp: span,
     // Replaces bound references to the self region with `with_r`.
     fn replace_bound_self(tcx: ty::ctxt, ty: ty::t,
                           with_r: ty::region) -> ty::t {
-        ty::fold_regions(tcx, ty) { |r, _in_fn|
+        do ty::fold_regions(tcx, ty) { |r, _in_fn|
             if r == ty::re_bound(ty::br_self) {with_r} else {r}
         }
     }
@@ -276,7 +276,7 @@ fn convert_methods(ccx: @crate_ctxt,
                    self_ty: ty::t) -> ~[converted_method] {
 
     let tcx = ccx.tcx;
-    vec::map(ms) { |m|
+    do vec::map(ms) { |m|
         write_ty_to_tcx(tcx, m.self_id, self_ty);
         let bounds = ty_param_bounds(ccx, m.tps);
         let mty = ty_of_method(ccx, m, rp);
@@ -330,8 +330,8 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
         write_ty_to_tcx(tcx, it.id, tpt.ty);
         tcx.tcache.insert(local_def(it.id), tpt);
         // Write the ctor type
-        let t_args = ctor.node.dec.inputs.map {|a|
-                           ty_of_arg(ccx, type_rscope(rp), a, none)};
+        let t_args = ctor.node.dec.inputs.map({|a|
+                           ty_of_arg(ccx, type_rscope(rp), a, none)});
         let t_res = ty::mk_class(tcx, local_def(it.id),
                                  {self_r: alt rp {
                        ast::rp_none { none }
@@ -350,7 +350,7 @@ fn convert(ccx: @crate_ctxt, it: @ast::item) {
                           {bounds: tpt.bounds,
                            rp: rp,
                            ty: t_ctor});
-        option::iter(m_dtor) {|dtor|
+        do option::iter(m_dtor) {|dtor|
             // Write the dtor type
             let t_dtor = ty::mk_fn(
                 tcx,
@@ -553,7 +553,7 @@ fn ty_param_bounds(ccx: @crate_ctxt,
 
     fn compute_bounds(ccx: @crate_ctxt,
                       param: ast::ty_param) -> ty::param_bounds {
-        @vec::flat_map(*param.bounds) { |b|
+        @do vec::flat_map(*param.bounds) { |b|
             alt b {
               ast::bound_send { ~[ty::bound_send] }
               ast::bound_copy { ~[ty::bound_copy] }
@@ -576,7 +576,7 @@ fn ty_param_bounds(ccx: @crate_ctxt,
         }
     }
 
-    @params.map { |param|
+    @do params.map { |param|
         alt ccx.tcx.ty_param_bounds.find(param.id) {
           some(bs) { bs }
           none {
@@ -595,7 +595,7 @@ fn ty_of_foreign_fn_decl(ccx: @crate_ctxt,
 
     let bounds = ty_param_bounds(ccx, ty_params);
     let rb = in_binding_rscope(empty_rscope);
-    let input_tys = decl.inputs.map { |a| ty_of_arg(ccx, rb, a, none) };
+    let input_tys = decl.inputs.map({ |a| ty_of_arg(ccx, rb, a, none) });
     let output_ty = ast_ty_to_ty(ccx, rb, decl.output);
 
     let t_fn = ty::mk_fn(ccx.tcx, {purity: decl.purity,
diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs
index 80d4e57750e..f34cfd5cc3f 100644
--- a/src/rustc/middle/typeck/infer.rs
+++ b/src/rustc/middle/typeck/infer.rs
@@ -355,31 +355,31 @@ fn new_infer_ctxt(tcx: ty::ctxt) -> infer_ctxt {
 
 fn mk_subty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures {
     #debug["mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)];
-    indent {|| cx.commit {|| sub(cx).tys(a, b) } }.to_ures()
+    indent({|| cx.commit({|| sub(cx).tys(a, b) }) }).to_ures()
 }
 
 fn can_mk_subty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures {
     #debug["can_mk_subty(%s <: %s)", a.to_str(cx), b.to_str(cx)];
-    indent {|| cx.probe {|| sub(cx).tys(a, b) } }.to_ures()
+    indent({|| cx.probe({|| sub(cx).tys(a, b) }) }).to_ures()
 }
 
 fn mk_subr(cx: infer_ctxt, a: ty::region, b: ty::region) -> ures {
     #debug["mk_subr(%s <: %s)", a.to_str(cx), b.to_str(cx)];
-    indent {|| cx.commit {|| sub(cx).regions(a, b) } }.to_ures()
+    indent({|| cx.commit({|| sub(cx).regions(a, b) }) }).to_ures()
 }
 
 fn mk_eqty(cx: infer_ctxt, a: ty::t, b: ty::t) -> ures {
     #debug["mk_eqty(%s <: %s)", a.to_str(cx), b.to_str(cx)];
-    indent {|| cx.commit {|| cx.eq_tys(a, b) } }.to_ures()
+    indent({|| cx.commit({|| cx.eq_tys(a, b) }) }).to_ures()
 }
 
 fn mk_assignty(cx: infer_ctxt, anmnt: assignment,
                a: ty::t, b: ty::t) -> ures {
     #debug["mk_assignty(%? / %s <: %s)",
            anmnt, a.to_str(cx), b.to_str(cx)];
-    indent {|| cx.commit {||
+    indent({|| cx.commit({||
         cx.assign_tys(anmnt, a, b)
-    } }.to_ures()
+    }) }).to_ures()
 }
 
 fn can_mk_assignty(cx: infer_ctxt, anmnt: assignment,
@@ -392,9 +392,9 @@ fn can_mk_assignty(cx: infer_ctxt, anmnt: assignment,
     // used in method lookup, and there must be exactly one match or an
     // error is reported. Still, it should be fixed.
 
-    indent {|| cx.probe {||
+    indent({|| cx.probe({||
         cx.assign_tys(anmnt, a, b)
-    } }.to_ures()
+    }) }).to_ures()
 }
 
 // See comment on the type `resolve_state` below
@@ -418,7 +418,7 @@ fn resolve_deep(cx: infer_ctxt, a: ty::t, force_vars: force_level)
 impl methods for ures {
     fn then<T:copy>(f: fn() -> result<T,ty::type_err>)
         -> result<T,ty::type_err> {
-        self.chain() {|_i| f() }
+        self.chain({|_i| f() })
     }
 }
 
@@ -431,7 +431,7 @@ impl methods<T:copy> for cres<T> {
     }
 
     fn compare(t: T, f: fn() -> ty::type_err) -> cres<T> {
-        self.chain {|s|
+        do self.chain {|s|
             if s == t {
                 self
             } else {
@@ -520,7 +520,7 @@ impl of st for ty::t {
 
 impl of st for ty::region {
     fn sub(infcx: infer_ctxt, &&b: ty::region) -> ures {
-        sub(infcx).regions(self, b).chain {|_r| ok(()) }
+        sub(infcx).regions(self, b).chain({|_r| ok(()) })
     }
 
     fn lub(infcx: infer_ctxt, &&b: ty::region) -> cres<ty::region> {
@@ -605,7 +605,7 @@ impl methods for infer_ctxt {
     }
 
     fn next_ty_vars(n: uint) -> ~[ty::t] {
-        vec::from_fn(n) {|_i| self.next_ty_var() }
+        vec::from_fn(n, {|_i| self.next_ty_var() })
     }
 
     fn next_ty_var_integral_id() -> tvi_vid {
@@ -706,7 +706,7 @@ impl unify_methods for infer_ctxt {
             ok(b)
           }
           (some(v_a), some(v_b)) {
-            merge_op(v_a, v_b).chain {|v|
+            do merge_op(v_a, v_b).chain {|v|
                 ok(some(v))
             }
           }
@@ -719,11 +719,11 @@ impl unify_methods for infer_ctxt {
         glb: fn(V,V) -> cres<V>) -> cres<bounds<V>> {
 
         let _r = indenter();
-        self.merge_bnd(a.ub, b.ub, glb).chain {|ub|
+        do self.merge_bnd(a.ub, b.ub, glb).chain {|ub|
             #debug["glb of ubs %s and %s is %s",
                    a.ub.to_str(self), b.ub.to_str(self),
                    ub.to_str(self)];
-            self.merge_bnd(a.lb, b.lb, lub).chain {|lb|
+            do self.merge_bnd(a.lb, b.lb, lub).chain {|lb|
                 #debug["lub of lbs %s and %s is %s",
                        a.lb.to_str(self), b.lb.to_str(self),
                        lb.to_str(self)];
@@ -771,11 +771,11 @@ impl unify_methods for infer_ctxt {
         // them explicitly gives the type inferencer more
         // information and helps to produce tighter bounds
         // when necessary.
-        indent {||
-        self.bnds(a.lb, b.ub).then {||
-        self.bnds(b.lb, a.ub).then {||
-        self.merge_bnd(a.ub, b.ub, {|x, y| x.glb(self, y)}).chain {|ub|
-        self.merge_bnd(a.lb, b.lb, {|x, y| x.lub(self, y)}).chain {|lb|
+        do indent {||
+        do self.bnds(a.lb, b.ub).then {||
+        do self.bnds(b.lb, a.ub).then {||
+        do self.merge_bnd(a.ub, b.ub, {|x, y| x.glb(self, y)}).chain {|ub|
+        do self.merge_bnd(a.lb, b.lb, {|x, y| x.lub(self, y)}).chain {|lb|
             let bnds = {lb: lb, ub: ub};
             #debug["merge(%s): bnds=%s",
                    v_id.to_str(),
@@ -783,7 +783,7 @@ impl unify_methods for infer_ctxt {
 
             // the new bounds must themselves
             // be relatable:
-            self.bnds(bnds.lb, bnds.ub).then {||
+            do self.bnds(bnds.lb, bnds.ub).then {||
                 self.set(vb, v_id, root(bnds, rank));
                 uok()
         }
@@ -812,7 +812,7 @@ impl unify_methods for infer_ctxt {
         // see if we can make those types subtypes.
         alt (a_bounds.ub, b_bounds.lb) {
           (some(a_ub), some(b_lb)) {
-            let r = self.try {|| a_ub.sub(self, b_lb) };
+            let r = self.try({|| a_ub.sub(self, b_lb) });
             alt r {
               ok(()) { ret result::ok(()); }
               err(_) { /*fallthrough */ }
@@ -835,17 +835,17 @@ impl unify_methods for infer_ctxt {
             // i.e., b should redirect to a.
             self.set(vb, b_id, redirect(a_id));
             self.set_var_to_merged_bounds(
-                vb, a_id, a_bounds, b_bounds, nde_a.rank).then {||
+                vb, a_id, a_bounds, b_bounds, nde_a.rank).then({||
                 uok()
-            }
+            })
         } else if nde_a.rank < nde_b.rank {
             #debug["vars(): b has smaller rank"];
             // b has greater rank, so a should redirect to b.
             self.set(vb, a_id, redirect(b_id));
             self.set_var_to_merged_bounds(
-                vb, b_id, a_bounds, b_bounds, nde_b.rank).then {||
+                vb, b_id, a_bounds, b_bounds, nde_b.rank).then({||
                 uok()
-            }
+            })
         } else {
             #debug["vars(): a and b have equal rank"];
             assert nde_a.rank == nde_b.rank;
@@ -854,9 +854,9 @@ impl unify_methods for infer_ctxt {
             // to a and increment a's rank.
             self.set(vb, b_id, redirect(a_id));
             self.set_var_to_merged_bounds(
-                vb, a_id, a_bounds, b_bounds, nde_a.rank + 1u).then {||
+                vb, a_id, a_bounds, b_bounds, nde_a.rank + 1u).then({||
                 uok()
-            }
+            })
         }
     }
 
@@ -1026,7 +1026,7 @@ impl unify_methods for infer_ctxt {
         a: bound<T>, b: bound<T>) -> ures {
 
         #debug("bnds(%s <: %s)", a.to_str(self), b.to_str(self));
-        indent {||
+        do indent {||
             alt (a, b) {
               (none, none) |
               (some(_), none) |
@@ -1044,7 +1044,7 @@ impl unify_methods for infer_ctxt {
         as: ~[@ty::type_constr], bs: ~[@ty::type_constr]) -> ures {
 
         if check vec::same_length(as, bs) {
-            iter_vec2(as, bs) {|a,b|
+            do iter_vec2(as, bs) {|a,b|
                 self.constrs(a, b)
             }
         } else {
@@ -1053,24 +1053,24 @@ impl unify_methods for infer_ctxt {
     }
 
     fn sub_tys(a: ty::t, b: ty::t) -> ures {
-        sub(self).tys(a, b).chain {|_t| ok(()) }
+        sub(self).tys(a, b).chain({|_t| ok(()) })
     }
 
     fn sub_regions(a: ty::region, b: ty::region) -> ures {
-        sub(self).regions(a, b).chain {|_t| ok(()) }
+        sub(self).regions(a, b).chain({|_t| ok(()) })
     }
 
     fn eq_tys(a: ty::t, b: ty::t) -> ures {
-        self.sub_tys(a, b).then {||
+        self.sub_tys(a, b).then({||
             self.sub_tys(b, a)
-        }
+        })
     }
 
     fn eq_regions(a: ty::region, b: ty::region) -> ures {
         #debug["eq_regions(%s, %s)",
                a.to_str(self), b.to_str(self)];
-        indent {||
-            self.sub_regions(a, b).then {||
+        do indent {||
+            do self.sub_regions(a, b).then {||
                 self.sub_regions(b, a)
             }
         }
@@ -1134,7 +1134,7 @@ impl methods for resolve_state {
         // allow us to pass back errors in any useful way.
 
         assert vec::is_empty(self.v_seen) && vec::is_empty(self.r_seen);
-        let rty = indent {|| self.resolve1(typ) };
+        let rty = indent({|| self.resolve1(typ) });
         assert vec::is_empty(self.v_seen) && vec::is_empty(self.r_seen);
         alt self.err {
           none {
@@ -1462,11 +1462,11 @@ impl assignment for infer_ctxt {
                anmnt, a.to_str(self), nr_b.to_str(self),
                r_b.to_str(self)];
 
-        indent {||
-            self.sub_tys(a, nr_b).then {||
+        do indent {||
+            do self.sub_tys(a, nr_b).then {||
                 let r_a = ty::re_scope(anmnt.borrow_scope);
                 #debug["anmnt=%?", anmnt];
-                sub(self).contraregions(r_a, r_b).chain {|_r|
+                do sub(self).contraregions(r_a, r_b).chain {|_r|
                     // if successful, add an entry indicating that
                     // borrowing occurred
                     #debug["borrowing expression #%?", anmnt];
@@ -1564,7 +1564,7 @@ fn super_substs<C:combine>(
             ok(none)
           }
           (some(a), some(b)) {
-            infcx.eq_regions(a, b).then {||
+            do infcx.eq_regions(a, b).then {||
                 ok(some(a))
             }
           }
@@ -1582,9 +1582,10 @@ fn super_substs<C:combine>(
         }
     }
 
-    self.tps(a.tps, b.tps).chain { |tps|
-        self.self_tys(a.self_ty, b.self_ty).chain { |self_ty|
-            eq_opt_regions(self.infcx(), a.self_r, b.self_r).chain { |self_r|
+    do self.tps(a.tps, b.tps).chain { |tps|
+        do self.self_tys(a.self_ty, b.self_ty).chain { |self_ty|
+            do eq_opt_regions(self.infcx(), a.self_r, b.self_r).chain {
+                |self_r|
                 ok({self_r: self_r, self_ty: self_ty, tps: tps})
             }
         }
@@ -1600,11 +1601,11 @@ fn super_tps<C:combine>(
     // variance.
 
     if check vec::same_length(as, bs) {
-        iter_vec2(as, bs) {|a, b|
+        iter_vec2(as, bs, {|a, b|
             self.infcx().eq_tys(a, b)
-        }.then {||
+        }).then({||
             ok(as)
-        }
+        })
     } else {
         err(ty::terr_ty_param_size(bs.len(), as.len()))
     }
@@ -1621,9 +1622,9 @@ fn super_self_tys<C:combine>(
         ok(none)
       }
       (some(a), some(b)) {
-        self.infcx().eq_tys(a, b).then {||
+        self.infcx().eq_tys(a, b).then({||
             ok(some(a))
-        }
+        })
       }
       (none, some(_)) |
       (some(_), none) {
@@ -1639,11 +1640,11 @@ fn super_flds<C:combine>(
     self: C, a: ty::field, b: ty::field) -> cres<ty::field> {
 
     if a.ident == b.ident {
-        self.mts(a.mt, b.mt).chain {|mt|
+        self.mts(a.mt, b.mt).chain({|mt|
             ok({ident: a.ident, mt: mt})
-        }.chain_err {|e|
+        }).chain_err({|e|
             err(ty::terr_in_field(@e, a.ident))
-        }
+        })
     } else {
         err(ty::terr_record_fields(b.ident, a.ident))
     }
@@ -1661,8 +1662,8 @@ fn super_args<C:combine>(
     self: C, a: ty::arg, b: ty::arg)
     -> cres<ty::arg> {
 
-    self.modes(a.mode, b.mode).chain {|m|
-        self.contratys(a.ty, b.ty).chain {|t|
+    do self.modes(a.mode, b.mode).chain {|m|
+        do self.contratys(a.ty, b.ty).chain {|t|
             ok({mode: m, ty: t})
         }
     }
@@ -1674,7 +1675,7 @@ fn super_vstores<C:combine>(
 
     alt (a, b) {
       (ty::vstore_slice(a_r), ty::vstore_slice(b_r)) {
-        self.contraregions(a_r, b_r).chain {|r|
+        do self.contraregions(a_r, b_r).chain {|r|
             ok(ty::vstore_slice(r))
         }
       }
@@ -1696,17 +1697,17 @@ fn super_fns<C:combine>(
                           b_args: ~[ty::arg]) -> cres<~[ty::arg]> {
 
         if check vec::same_length(a_args, b_args) {
-            map_vec2(a_args, b_args) {|a, b| self.args(a, b) }
+            map_vec2(a_args, b_args, {|a, b| self.args(a, b) })
         } else {
             err(ty::terr_arg_count)
         }
     }
 
-    self.protos(a_f.proto, b_f.proto).chain {|p|
-        self.ret_styles(a_f.ret_style, b_f.ret_style).chain {|rs|
-            argvecs(self, a_f.inputs, b_f.inputs).chain {|inputs|
-                self.tys(a_f.output, b_f.output).chain {|output|
-                    self.purities(a_f.purity, b_f.purity).chain {|purity|
+    do self.protos(a_f.proto, b_f.proto).chain {|p|
+        do self.ret_styles(a_f.ret_style, b_f.ret_style).chain {|rs|
+            do argvecs(self, a_f.inputs, b_f.inputs).chain {|inputs|
+                do self.tys(a_f.output, b_f.output).chain {|output|
+                    do self.purities(a_f.purity, b_f.purity).chain {|purity|
                     // FIXME: uncomment if #2588 doesn't get accepted:
                     // self.infcx().constrvecs(a_f.constraints,
                     //                         b_f.constraints).then {||
@@ -1743,18 +1744,18 @@ fn super_tys<C:combine>(
 
       // Have to handle these first
       (ty::ty_var_integral(a_id), ty::ty_var_integral(b_id)) {
-        self.infcx().vars_integral(self.infcx().tvib, a_id, b_id).then {||
-            ok(a) }
+        self.infcx().vars_integral(self.infcx().tvib, a_id, b_id).then({||
+            ok(a) })
       }
       (ty::ty_var_integral(a_id), ty::ty_int(_)) |
       (ty::ty_var_integral(a_id), ty::ty_uint(_)) {
-        self.infcx().vart_integral(self.infcx().tvib, a_id, b).then {||
-            ok(a) }
+        self.infcx().vart_integral(self.infcx().tvib, a_id, b).then({||
+            ok(a) })
       }
       (ty::ty_int(_), ty::ty_var_integral(b_id)) |
       (ty::ty_uint(_), ty::ty_var_integral(b_id)) {
-        self.infcx().tvar_integral(self.infcx().tvib, a, b_id).then {||
-            ok(a) }
+        self.infcx().tvar_integral(self.infcx().tvib, a, b_id).then({||
+            ok(a) })
       }
 
       (ty::ty_int(_), _) |
@@ -1786,78 +1787,78 @@ fn super_tys<C:combine>(
 
       (ty::ty_enum(a_id, a_substs), ty::ty_enum(b_id, b_substs))
       if a_id == b_id {
-        self.substs(a_substs, b_substs).chain {|tps|
+        do self.substs(a_substs, b_substs).chain {|tps|
             ok(ty::mk_enum(tcx, a_id, tps))
         }
       }
 
       (ty::ty_iface(a_id, a_substs), ty::ty_iface(b_id, b_substs))
       if a_id == b_id {
-        self.substs(a_substs, b_substs).chain {|substs|
+        do self.substs(a_substs, b_substs).chain {|substs|
             ok(ty::mk_iface(tcx, a_id, substs))
         }
       }
 
       (ty::ty_class(a_id, a_substs), ty::ty_class(b_id, b_substs))
       if a_id == b_id {
-        self.substs(a_substs, b_substs).chain {|substs|
+        do self.substs(a_substs, b_substs).chain {|substs|
             ok(ty::mk_class(tcx, a_id, substs))
         }
       }
 
       (ty::ty_box(a_mt), ty::ty_box(b_mt)) {
-        self.mts(a_mt, b_mt).chain {|mt|
+        do self.mts(a_mt, b_mt).chain {|mt|
             ok(ty::mk_box(tcx, mt))
         }
       }
 
       (ty::ty_uniq(a_mt), ty::ty_uniq(b_mt)) {
-        self.mts(a_mt, b_mt).chain {|mt|
+        do self.mts(a_mt, b_mt).chain {|mt|
             ok(ty::mk_uniq(tcx, mt))
         }
       }
 
       (ty::ty_vec(a_mt), ty::ty_vec(b_mt)) {
-        self.mts(a_mt, b_mt).chain {|mt|
+        do self.mts(a_mt, b_mt).chain {|mt|
             ok(ty::mk_vec(tcx, mt))
         }
       }
 
       (ty::ty_ptr(a_mt), ty::ty_ptr(b_mt)) {
-        self.mts(a_mt, b_mt).chain {|mt|
+        do self.mts(a_mt, b_mt).chain {|mt|
             ok(ty::mk_ptr(tcx, mt))
         }
       }
 
       (ty::ty_rptr(a_r, a_mt), ty::ty_rptr(b_r, b_mt)) {
-        self.contraregions(a_r, b_r).chain {|r|
-            self.mts(a_mt, b_mt).chain {|mt|
+        do self.contraregions(a_r, b_r).chain {|r|
+            do self.mts(a_mt, b_mt).chain {|mt|
                 ok(ty::mk_rptr(tcx, r, mt))
             }
         }
       }
 
       (ty::ty_evec(a_mt, vs_a), ty::ty_evec(b_mt, vs_b)) {
-        self.mts(a_mt, b_mt).chain {|mt|
-            self.vstores(ty::terr_vec, vs_a, vs_b).chain {|vs|
+        do self.mts(a_mt, b_mt).chain {|mt|
+            do self.vstores(ty::terr_vec, vs_a, vs_b).chain {|vs|
                 ok(ty::mk_evec(tcx, mt, vs))
             }
         }
       }
 
       (ty::ty_estr(vs_a), ty::ty_estr(vs_b)) {
-        self.vstores(ty::terr_str, vs_a, vs_b).chain {|vs|
+        do self.vstores(ty::terr_str, vs_a, vs_b).chain {|vs|
             ok(ty::mk_estr(tcx,vs))
         }
       }
 
       (ty::ty_rec(as), ty::ty_rec(bs)) {
         if check vec::same_length(as, bs) {
-            map_vec2(as, bs) {|a,b|
+            map_vec2(as, bs, {|a,b|
                 self.flds(a, b)
-            }.chain {|flds|
+            }).chain({|flds|
                 ok(ty::mk_rec(tcx, flds))
-            }
+            })
         } else {
             err(ty::terr_record_size(bs.len(), as.len()))
         }
@@ -1865,23 +1866,23 @@ fn super_tys<C:combine>(
 
       (ty::ty_tup(as), ty::ty_tup(bs)) {
         if check vec::same_length(as, bs) {
-            map_vec2(as, bs) {|a, b| self.tys(a, b) }.chain {|ts|
+            map_vec2(as, bs, {|a, b| self.tys(a, b) }).chain({|ts|
                 ok(ty::mk_tup(tcx, ts))
-            }
+            })
         } else {
             err(ty::terr_tuple_size(bs.len(), as.len()))
         }
       }
 
       (ty::ty_fn(a_fty), ty::ty_fn(b_fty)) {
-        self.fns(a_fty, b_fty).chain {|fty|
+        do self.fns(a_fty, b_fty).chain {|fty|
             ok(ty::mk_fn(tcx, fty))
         }
       }
 
       (ty::ty_constr(a_t, a_constrs), ty::ty_constr(b_t, b_constrs)) {
-        self.tys(a_t, b_t).chain {|t|
-            self.infcx().constrvecs(a_constrs, b_constrs).then {||
+        do self.tys(a_t, b_t).chain {|t|
+            do self.infcx().constrvecs(a_constrs, b_constrs).then {||
                 ok(ty::mk_constr(tcx, t, a_constrs))
             }
         }
@@ -1910,25 +1911,25 @@ impl of combine for sub {
                self.tag(),
                a.to_str(self.infcx()),
                b.to_str(self.infcx())];
-        indent {||
+        do indent {||
             alt (a, b) {
               (ty::re_var(a_id), ty::re_var(b_id)) {
-                self.infcx().vars(self.rb, a_id, b_id).then {||
+                do self.infcx().vars(self.rb, a_id, b_id).then {||
                     ok(a)
                 }
               }
               (ty::re_var(a_id), _) {
-                  self.infcx().vart(self.rb, a_id, b).then {||
+                  do self.infcx().vart(self.rb, a_id, b).then {||
                       ok(a)
                   }
               }
               (_, ty::re_var(b_id)) {
-                  self.infcx().tvar(self.rb, a, b_id).then {||
+                  do self.infcx().tvar(self.rb, a, b_id).then {||
                       ok(a)
                   }
               }
               _ {
-                self.lub().regions(a, b).compare(b) {||
+                do self.lub().regions(a, b).compare(b) {||
                     ty::terr_regions_differ(b, a)
                 }
               }
@@ -1947,50 +1948,50 @@ impl of combine for sub {
           m_mutbl {
             // If supertype is mut, subtype must match exactly
             // (i.e., invariant if mut):
-            self.infcx().eq_tys(a.ty, b.ty).then {|| ok(a) }
+            self.infcx().eq_tys(a.ty, b.ty).then({|| ok(a) })
           }
           m_imm | m_const {
             // Otherwise we can be covariant:
-            self.tys(a.ty, b.ty).chain {|_t| ok(a) }
+            self.tys(a.ty, b.ty).chain({|_t| ok(a) })
           }
         }
     }
 
     fn protos(a: ast::proto, b: ast::proto) -> cres<ast::proto> {
-        self.lub().protos(a, b).compare(b) {||
+        self.lub().protos(a, b).compare(b, {||
             ty::terr_proto_mismatch(b, a)
-        }
+        })
     }
 
     fn purities(f1: purity, f2: purity) -> cres<purity> {
-        self.lub().purities(f1, f2).compare(f2) {||
+        self.lub().purities(f1, f2).compare(f2, {||
             ty::terr_purity_mismatch(f2, f1)
-        }
+        })
     }
 
     fn ret_styles(a: ret_style, b: ret_style) -> cres<ret_style> {
-        self.lub().ret_styles(a, b).compare(b) {||
+        self.lub().ret_styles(a, b).compare(b, {||
             ty::terr_ret_style_mismatch(b, a)
-        }
+        })
     }
 
     fn tys(a: ty::t, b: ty::t) -> cres<ty::t> {
         #debug("%s.tys(%s, %s)", self.tag(),
                a.to_str(*self), b.to_str(*self));
         if a == b { ret ok(a); }
-        indent {||
+        do indent {||
             alt (ty::get(a).struct, ty::get(b).struct) {
               (ty::ty_bot, _) {
                 ok(a)
               }
               (ty::ty_var(a_id), ty::ty_var(b_id)) {
-                self.infcx().vars(self.tvb, a_id, b_id).then {|| ok(a) }
+                self.infcx().vars(self.tvb, a_id, b_id).then({|| ok(a) })
               }
               (ty::ty_var(a_id), _) {
-                self.infcx().vart(self.tvb, a_id, b).then {|| ok(a) }
+                self.infcx().vart(self.tvb, a_id, b).then({|| ok(a) })
               }
               (_, ty::ty_var(b_id)) {
-                self.infcx().tvar(self.tvb, a, b_id).then {|| ok(a) }
+                self.infcx().tvar(self.tvb, a, b_id).then({|| ok(a) })
               }
               (_, ty::ty_bot) {
                 err(ty::terr_sorts(b, a))
@@ -2011,7 +2012,7 @@ impl of combine for sub {
         // First, we instantiate each bound region in the subtype with a fresh
         // region variable.
         let {fn_ty: a_fn_ty, _} = {
-            replace_bound_regions_in_fn_ty(self.tcx, @nil, none, a) { |br|
+            do replace_bound_regions_in_fn_ty(self.tcx, @nil, none, a) { |br|
                 // N.B.: The name of the bound region doesn't have
                 // anything to do with the region variable that's created
                 // for it.  The only thing we're doing with `br` here is
@@ -2027,7 +2028,7 @@ impl of combine for sub {
         // Second, we instantiate each bound region in the supertype with a
         // fresh concrete region.
         let {fn_ty: b_fn_ty, _} = {
-            replace_bound_regions_in_fn_ty(self.tcx, @nil, none, b) { |br|
+            do replace_bound_regions_in_fn_ty(self.tcx, @nil, none, b) { |br|
                 // FIXME: eventually re_skolemized (issue #2263)
                 ty::re_bound(br)
             }
@@ -2093,21 +2094,21 @@ impl of combine for lub {
 
         alt m {
           m_imm | m_const {
-            self.tys(a.ty, b.ty).chain {|t|
+            self.tys(a.ty, b.ty).chain({|t|
                 ok({ty: t, mutbl: m})
-            }
+            })
           }
 
           m_mutbl {
-            self.infcx().try {||
-                self.infcx().eq_tys(a.ty, b.ty).then {||
+            self.infcx().try({||
+                self.infcx().eq_tys(a.ty, b.ty).then({||
                     ok({ty: a.ty, mutbl: m})
-                }
-            }.chain_err {|_e|
-                self.tys(a.ty, b.ty).chain {|t|
+                })
+            }).chain_err({|_e|
+                self.tys(a.ty, b.ty).chain({|t|
                     ok({ty: t, mutbl: m_const})
-                }
-            }
+                })
+            })
           }
         }
     }
@@ -2159,7 +2160,7 @@ impl of combine for lub {
                a.to_str(self.infcx()),
                b.to_str(self.infcx())];
 
-        indent {||
+        do indent {||
             alt (a, b) {
               (ty::re_static, _) | (_, ty::re_static) {
                 ok(ty::re_static) // nothing lives longer than static
@@ -2272,19 +2273,19 @@ impl of combine for glb {
           // If one side or both is mut, then the GLB must use
           // the precise type from the mut side.
           (m_mutbl, m_const) {
-            sub(*self).tys(a.ty, b.ty).chain {|_t|
+            sub(*self).tys(a.ty, b.ty).chain({|_t|
                 ok({ty: a.ty, mutbl: m_mutbl})
-            }
+            })
           }
           (m_const, m_mutbl) {
-            sub(*self).tys(b.ty, a.ty).chain {|_t|
+            sub(*self).tys(b.ty, a.ty).chain({|_t|
                 ok({ty: b.ty, mutbl: m_mutbl})
-            }
+            })
           }
           (m_mutbl, m_mutbl) {
-            self.infcx().eq_tys(a.ty, b.ty).then {||
+            self.infcx().eq_tys(a.ty, b.ty).then({||
                 ok({ty: a.ty, mutbl: m_mutbl})
-            }
+            })
           }
 
           // If one side or both is immutable, we can use the GLB of
@@ -2292,17 +2293,17 @@ impl of combine for glb {
           (m_imm, m_const) |
           (m_const, m_imm) |
           (m_imm, m_imm) {
-            self.tys(a.ty, b.ty).chain {|t|
+            self.tys(a.ty, b.ty).chain({|t|
                 ok({ty: t, mutbl: m_imm})
-            }
+            })
           }
 
           // If both sides are const, then we can use GLB of both
           // sides and mutbl of only `m_const`.
           (m_const, m_const) {
-            self.tys(a.ty, b.ty).chain {|t|
+            self.tys(a.ty, b.ty).chain({|t|
                 ok({ty: t, mutbl: m_const})
-            }
+            })
           }
 
           // There is no mutual subtype of these combinations.
@@ -2356,7 +2357,7 @@ impl of combine for glb {
                a.to_str(self.infcx()),
                b.to_str(self.infcx())];
 
-        indent {||
+        do indent {||
             alt (a, b) {
               (ty::re_static, r) | (r, ty::re_static) {
                 // static lives longer than everything else
@@ -2494,7 +2495,7 @@ fn lattice_tys<L:lattice_ops combine>(
            a.to_str(self.infcx()),
            b.to_str(self.infcx()));
     if a == b { ret ok(a); }
-    indent {||
+    do indent {||
         alt (ty::get(a).struct, ty::get(b).struct) {
           (ty::ty_bot, _) { self.ty_bot(b) }
           (_, ty::ty_bot) { self.ty_bot(a) }
@@ -2580,7 +2581,7 @@ fn lattice_vars<V:copy vid, T:copy to_str st, L:lattice_ops combine>(
     let a_bnd = self.bnd(a_bounds), b_bnd = self.bnd(b_bounds);
     alt (a_bnd, b_bnd) {
       (some(a_ty), some(b_ty)) {
-        alt self.infcx().try {|| c_ts(a_ty, b_ty) } {
+        alt self.infcx().try({|| c_ts(a_ty, b_ty) }) {
             ok(t) { ret ok(t); }
             err(_) { /*fallthrough */ }
         }
@@ -2590,9 +2591,9 @@ fn lattice_vars<V:copy vid, T:copy to_str st, L:lattice_ops combine>(
 
     // Otherwise, we need to merge A and B into one variable.  We can
     // then use either variable as an upper bound:
-    self.infcx().vars(vb, a_vid, b_vid).then {||
+    self.infcx().vars(vb, a_vid, b_vid).then({||
         ok(a_t)
-    }
+    })
 }
 
 fn lattice_var_t<V:copy vid, T:copy to_str st, L:lattice_ops combine>(
@@ -2623,7 +2624,7 @@ fn lattice_var_t<V:copy vid, T:copy to_str st, L:lattice_ops combine>(
         // and then return b.
         #debug["bnd=none"];
         let a_bounds = self.with_bnd(a_bounds, b);
-        self.infcx().bnds(a_bounds.lb, a_bounds.ub).then {||
+        do self.infcx().bnds(a_bounds.lb, a_bounds.ub).then {||
             self.infcx().set(vb, a_id, root(a_bounds,
                                             nde_a.rank));
             ok(b)
diff --git a/src/rustc/middle/typeck/rscope.rs b/src/rustc/middle/typeck/rscope.rs
index 2420250aa1a..3210f07803a 100644
--- a/src/rustc/middle/typeck/rscope.rs
+++ b/src/rustc/middle/typeck/rscope.rs
@@ -28,7 +28,7 @@ impl of region_scope for type_rscope {
         }
     }
     fn named_region(id: ast::ident) -> result<ty::region, str> {
-        empty_rscope.named_region(id).chain_err { |_e|
+        do empty_rscope.named_region(id).chain_err { |_e|
             if *id == "self" { self.anon_region() }
             else {
                 result::err("named regions other than `self` are not \
@@ -62,7 +62,7 @@ impl of region_scope for @binding_rscope {
         result::ok(ty::re_bound(ty::br_anon))
     }
     fn named_region(id: ast::ident) -> result<ty::region, str> {
-        self.base.named_region(id).chain_err {|_e|
+        do self.base.named_region(id).chain_err {|_e|
             result::ok(ty::re_bound(ty::br_named(id)))
         }
     }
diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs
index 52b3018e9ae..8de7718fef2 100644
--- a/src/rustc/util/common.rs
+++ b/src/rustc/util/common.rs
@@ -56,13 +56,13 @@ fn loop_query(b: ast::blk, p: fn@(ast::expr_) -> bool) -> bool {
 }
 
 fn has_nonlocal_exits(b: ast::blk) -> bool {
-    loop_query(b) {|e| alt e {
+    do loop_query(b) {|e| alt e {
       ast::expr_break | ast::expr_cont { true }
       _ { false }}}
 }
 
 fn may_break(b: ast::blk) -> bool {
-    loop_query(b) {|e| alt e {
+    do loop_query(b) {|e| alt e {
       ast::expr_break { true }
       _ { false }}}
 }
diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs
index f1a702c9df8..7f82e690e33 100644
--- a/src/rustdoc/astsrv.rs
+++ b/src/rustdoc/astsrv.rs
@@ -60,7 +60,7 @@ fn from_file<T>(file: str, owner: srv_owner<T>) -> T {
 fn run<T>(owner: srv_owner<T>, source: str, +parse: parser) -> T {
 
     let srv_ = srv({
-        ch: task::spawn_listener {|po|
+        ch: do task::spawn_listener {|po|
             act(po, source, parse);
         }
     });
@@ -199,8 +199,8 @@ fn build_error_handlers(
 #[test]
 fn should_prune_unconfigured_items() {
     let source = "#[cfg(shut_up_and_leave_me_alone)]fn a() { }";
-    from_str(source) {|srv|
-        exec(srv) {|ctxt|
+    do from_str(source) {|srv|
+        do exec(srv) {|ctxt|
             assert vec::is_empty(ctxt.ast.node.module.items);
         }
     }
@@ -209,8 +209,8 @@ fn should_prune_unconfigured_items() {
 #[test]
 fn srv_should_build_ast_map() {
     let source = "fn a() { }";
-    from_str(source) {|srv|
-        exec(srv) {|ctxt|
+    do from_str(source) {|srv|
+        do exec(srv) {|ctxt|
             assert ctxt.ast_map.size() != 0u
         };
     }
@@ -219,8 +219,8 @@ fn srv_should_build_ast_map() {
 #[test]
 fn srv_should_build_reexport_map() {
     let source = "import a::b; export b; mod a { mod b { } }";
-    from_str(source) {|srv|
-        exec(srv) {|ctxt|
+    do from_str(source) {|srv|
+        do exec(srv) {|ctxt|
             assert ctxt.exp_map.size() != 0u
         };
     }
@@ -232,14 +232,14 @@ fn srv_should_resolve_external_crates() {
                   fn f() -> std::sha1::sha1 {\
                   std::sha1::mk_sha1() }";
     // Just testing that resolve doesn't crash
-    from_str(source) {|_srv| }
+    from_str(source, {|_srv| })
 }
 
 #[test]
 fn srv_should_resolve_core_crate() {
     let source = "fn a() -> option { fail }";
     // Just testing that resolve doesn't crash
-    from_str(source) {|_srv| }
+    from_str(source, {|_srv| })
 }
 
 #[test]
@@ -247,26 +247,26 @@ fn srv_should_resolve_non_existant_imports() {
     // We want to ignore things we can't resolve. Shouldn't
     // need to be able to find external crates to create docs.
     let source = "import wooboo; fn a() { }";
-    from_str(source) {|_srv| }
+    from_str(source, {|_srv| })
 }
 
 #[test]
 fn srv_should_resolve_non_existant_uses() {
     let source = "use forble; fn a() { }";
-    from_str(source) {|_srv| }
+    from_str(source, {|_srv| })
 }
 
 #[test]
 fn should_ignore_external_import_paths_that_dont_exist() {
     let source = "use forble; import forble::bippy;";
-    from_str(source) {|_srv| }
+    from_str(source, {|_srv| })
 }
 
 #[test]
 fn srv_should_return_request_result() {
     let source = "fn a() { }";
-    from_str(source) {|srv|
-        let result = exec(srv) {|_ctxt| 1000};
+    do from_str(source) {|srv|
+        let result = exec(srv, {|_ctxt| 1000});
         assert result == 1000;
     }
 }
diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs
index 22ed0874636..21e8d002d0d 100644
--- a/src/rustdoc/attr_pass.rs
+++ b/src/rustdoc/attr_pass.rs
@@ -42,7 +42,7 @@ fn fold_crate(
     let srv = fold.ctxt;
     let doc = fold::default_seq_fold_crate(fold, doc);
 
-    let attrs = astsrv::exec(srv) {|ctxt|
+    let attrs = do astsrv::exec(srv) {|ctxt|
         let attrs = ctxt.ast.node.attrs;
         attr_parser::parse_crate(attrs)
     };
@@ -74,7 +74,7 @@ fn fold_item(
 
     let desc = if doc.id == ast::crate_node_id {
         // This is the top-level mod, use the crate attributes
-        astsrv::exec(srv) {|ctxt|
+        do astsrv::exec(srv) {|ctxt|
             attr_parser::parse_desc(ctxt.ast.node.attrs)
         }
     } else {
@@ -91,7 +91,7 @@ fn parse_item_attrs<T:send>(
     srv: astsrv::srv,
     id: doc::ast_id,
     +parse_attrs: fn~(~[ast::attribute]) -> T) -> T {
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         let attrs = alt ctxt.ast_map.get(id) {
           ast_map::node_item(item, _) { item.attrs }
           ast_map::node_foreign_item(item, _, _) { item.attrs }
@@ -143,16 +143,16 @@ fn fold_enum(
     let doc = fold::default_seq_fold_enum(fold, doc);
 
     {
-        variants: par::anymap(doc.variants) {|variant|
-            let desc = astsrv::exec(srv) {|ctxt|
+        variants: do par::anymap(doc.variants) {|variant|
+            let desc = do astsrv::exec(srv) {|ctxt|
                 alt check ctxt.ast_map.get(doc_id) {
                   ast_map::node_item(@{
                     node: ast::item_enum(ast_variants, _, _), _
                   }, _) {
                     let ast_variant = option::get(
-                        vec::find(ast_variants) {|v|
+                        vec::find(ast_variants, {|v|
                             *v.node.name == variant.name
-                        });
+                        }));
 
                     attr_parser::parse_desc(ast_variant.node.attrs)
                   }
@@ -201,27 +201,27 @@ fn merge_method_attrs(
 ) -> ~[doc::methoddoc] {
 
     // Create an assoc list from method name to attributes
-    let attrs: ~[(str, option<str>)] = astsrv::exec(srv) {|ctxt|
+    let attrs: ~[(str, option<str>)] = do astsrv::exec(srv) {|ctxt|
         alt ctxt.ast_map.get(item_id) {
           ast_map::node_item(@{
             node: ast::item_iface(_, _, methods), _
           }, _) {
-            par::seqmap(methods) {|method|
+            par::seqmap(methods, {|method|
                 (*method.ident, attr_parser::parse_desc(method.attrs))
-            }
+            })
           }
           ast_map::node_item(@{
             node: ast::item_impl(_, _, _, _, methods), _
           }, _) {
-            par::seqmap(methods) {|method|
+            par::seqmap(methods, {|method|
                 (*method.ident, attr_parser::parse_desc(method.attrs))
-            }
+            })
           }
           _ { fail "unexpected item" }
         }
     };
 
-    vec::map2(docs, attrs) {|doc, attrs|
+    do vec::map2(docs, attrs) {|doc, attrs|
         assert doc.name == tuple::first(attrs);
         let desc = tuple::second(attrs);
 
@@ -282,7 +282,7 @@ fn should_extract_impl_method_docs() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/config.rs b/src/rustdoc/config.rs
index e130e95d70b..e3332cfe54b 100644
--- a/src/rustdoc/config.rs
+++ b/src/rustdoc/config.rs
@@ -122,19 +122,21 @@ fn config_from_opts(
 
     let config = default_config(input_crate);
     let result = result::ok(config);
-    let result = result::chain(result) {|config|
+    let result = do result::chain(result) {|config|
         let output_dir = getopts::opt_maybe_str(match, opt_output_dir());
         result::ok({
             output_dir: option::get_default(output_dir, config.output_dir)
             with config
         })
     };
-    let result = result::chain(result) {|config|
+    let result = do result::chain(result) {|config|
         let output_format = getopts::opt_maybe_str(
             match, opt_output_format());
-        option::map_default(output_format, result::ok(config))
+        do option::map_default(output_format, result::ok(config))
            {|output_format|
-            result::chain(parse_output_format(output_format)) {|output_format|
+            do result::chain(parse_output_format(output_format))
+                {|output_format|
+
                 result::ok({
                     output_format: output_format
                     with config
@@ -142,11 +144,11 @@ fn config_from_opts(
             }
         }
     };
-    let result = result::chain(result) {|config|
+    let result = do result::chain(result) {|config|
         let output_style = getopts::opt_maybe_str(match, opt_output_style());
-        option::map_default(output_style, result::ok(config))
+        do option::map_default(output_style, result::ok(config))
           {|output_style|
-            result::chain(parse_output_style(output_style)) {|output_style|
+            do result::chain(parse_output_style(output_style)) {|output_style|
                 result::ok({
                     output_style: output_style
                     with config
@@ -154,11 +156,11 @@ fn config_from_opts(
             }
         }
     };
-    let result = result::chain(result) {|config|
+    let result = do result::chain(result) {|config|
         let pandoc_cmd = getopts::opt_maybe_str(match, opt_pandoc_cmd());
         let pandoc_cmd = maybe_find_pandoc(
             config, pandoc_cmd, program_output);
-        result::chain(pandoc_cmd) {|pandoc_cmd|
+        do result::chain(pandoc_cmd) {|pandoc_cmd|
             result::ok({
                 pandoc_cmd: pandoc_cmd
                 with config
@@ -205,7 +207,7 @@ fn maybe_find_pandoc(
       }
     };
 
-    let pandoc = vec::find(possible_pandocs) {|pandoc|
+    let pandoc = do vec::find(possible_pandocs) {|pandoc|
         let output = program_output(pandoc, ~["--version"]);
         #debug("testing pandoc cmd %s: %?", pandoc, output);
         output.status == 0
diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs
index 4c476840c08..3738b443ffe 100644
--- a/src/rustdoc/desc_to_brief_pass.rs
+++ b/src/rustdoc/desc_to_brief_pass.rs
@@ -42,12 +42,12 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
     let doc =fold::default_seq_fold_iface(fold, doc);
 
     {
-        methods: par::anymap(doc.methods) {|doc|
+        methods: par::anymap(doc.methods, {|doc|
             {
                 brief: extract(doc.desc)
                 with doc
             }
-        }
+        })
         with doc
     }
 }
@@ -56,12 +56,12 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
     let doc =fold::default_seq_fold_impl(fold, doc);
 
     {
-        methods: par::anymap(doc.methods) {|doc|
+        methods: par::anymap(doc.methods, {|doc|
             {
                 brief: extract(doc.desc)
                 with doc
             }
-        }
+        })
         with doc
     }
 }
@@ -88,7 +88,7 @@ fn should_promote_impl_method_desc() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -134,7 +134,7 @@ fn first_sentence_(s: str) -> str {
     let mut dotcount = 0;
     // The index of the character following a single dot. This allows
     // Things like [0..1) to appear in the brief description
-    let idx = str::find(s) {|ch|
+    let idx = do str::find(s) {|ch|
         if ch == '.' {
             dotcount += 1;
             false
@@ -165,7 +165,7 @@ fn paragraphs(s: str) -> ~[str] {
     let lines = str::lines_any(s);
     let mut whitespace_lines = 0;
     let mut accum = "";
-    let paras = vec::foldl(~[], lines) {|paras, line|
+    let paras = do vec::foldl(~[], lines) {|paras, line|
         let mut res = paras;
 
         if str::is_whitespace(line) {
diff --git a/src/rustdoc/doc.rs b/src/rustdoc/doc.rs
index 7b65e1de117..b0369620daf 100644
--- a/src/rustdoc/doc.rs
+++ b/src/rustdoc/doc.rs
@@ -128,12 +128,12 @@ type index_entry = {
 
 impl util for doc {
     fn cratedoc() -> cratedoc {
-        option::get(vec::foldl(none, self.pages) {|_m, page|
+        option::get(vec::foldl(none, self.pages, {|_m, page|
             alt page {
               doc::cratepage(doc) { some(doc) }
               _ { none }
             }
-        })
+        }))
     }
 
     fn cratemod() -> moddoc {
@@ -145,7 +145,7 @@ impl util for doc {
 impl util for moddoc {
 
     fn mods() -> ~[moddoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               modtag(moddoc) { some(moddoc) }
               _ { none }
@@ -154,7 +154,7 @@ impl util for moddoc {
     }
 
     fn nmods() -> ~[nmoddoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               nmodtag(nmoddoc) { some(nmoddoc) }
               _ { none }
@@ -163,7 +163,7 @@ impl util for moddoc {
     }
 
     fn fns() -> ~[fndoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               fntag(fndoc) { some(fndoc) }
               _ { none }
@@ -172,7 +172,7 @@ impl util for moddoc {
     }
 
     fn consts() -> ~[constdoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               consttag(constdoc) { some(constdoc) }
               _ { none }
@@ -181,7 +181,7 @@ impl util for moddoc {
     }
 
     fn enums() -> ~[enumdoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               enumtag(enumdoc) { some(enumdoc) }
               _ { none }
@@ -190,7 +190,7 @@ impl util for moddoc {
     }
 
     fn ifaces() -> ~[ifacedoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               ifacetag(ifacedoc) { some(ifacedoc) }
               _ { none }
@@ -199,7 +199,7 @@ impl util for moddoc {
     }
 
     fn impls() -> ~[impldoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               impltag(impldoc) { some(impldoc) }
               _ { none }
@@ -208,7 +208,7 @@ impl util for moddoc {
     }
 
     fn types() -> ~[tydoc] {
-        vec::filter_map(self.items) {|itemtag|
+        do vec::filter_map(self.items) {|itemtag|
             alt itemtag {
               tytag(tydoc) { some(tydoc) }
               _ { none }
@@ -220,7 +220,7 @@ impl util for moddoc {
 impl util for ~[page] {
 
     fn mods() -> ~[moddoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(modtag(moddoc)) { some(moddoc) }
               _ { none }
@@ -229,7 +229,7 @@ impl util for ~[page] {
     }
 
     fn nmods() -> ~[nmoddoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(nmodtag(nmoddoc)) { some(nmoddoc) }
               _ { none }
@@ -238,7 +238,7 @@ impl util for ~[page] {
     }
 
     fn fns() -> ~[fndoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(fntag(fndoc)) { some(fndoc) }
               _ { none }
@@ -247,7 +247,7 @@ impl util for ~[page] {
     }
 
     fn consts() -> ~[constdoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(consttag(constdoc)) { some(constdoc) }
               _ { none }
@@ -256,7 +256,7 @@ impl util for ~[page] {
     }
 
     fn enums() -> ~[enumdoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(enumtag(enumdoc)) { some(enumdoc) }
               _ { none }
@@ -265,7 +265,7 @@ impl util for ~[page] {
     }
 
     fn ifaces() -> ~[ifacedoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(ifacetag(ifacedoc)) { some(ifacedoc) }
               _ { none }
@@ -274,7 +274,7 @@ impl util for ~[page] {
     }
 
     fn impls() -> ~[impldoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(impltag(impldoc)) { some(impldoc) }
               _ { none }
@@ -283,7 +283,7 @@ impl util for ~[page] {
     }
 
     fn types() -> ~[tydoc] {
-        vec::filter_map(self) {|page|
+        do vec::filter_map(self) {|page|
             alt page {
               itempage(tytag(tydoc)) { some(tydoc) }
               _ { none }
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
index bbfa8cd9497..17ce84f266d 100644
--- a/src/rustdoc/extract.rs
+++ b/src/rustdoc/extract.rs
@@ -11,7 +11,7 @@ fn from_srv(
 
     #[doc = "Use the AST service to create a document tree"];
 
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         extract(ctxt.ast, default_name)
     }
 }
@@ -55,7 +55,7 @@ fn moddoc_from_mod(
 ) -> doc::moddoc {
     {
         item: itemdoc,
-        items: vec::filter_map(module.items) {|item|
+        items: do vec::filter_map(module.items) {|item|
             let itemdoc = mk_itemdoc(item.id, item.ident);
             alt item.node {
               ast::item_mod(m) {
@@ -113,7 +113,7 @@ fn nmoddoc_from_mod(
 ) -> doc::nmoddoc {
     {
         item: itemdoc,
-        fns: par::seqmap(module.items) {|item|
+        fns: do par::seqmap(module.items) {|item|
             let itemdoc = mk_itemdoc(item.id, item.ident);
             alt item.node {
               ast::foreign_item_fn(_, _) {
@@ -189,7 +189,7 @@ fn ifacedoc_from_iface(
 ) -> doc::ifacedoc {
     {
         item: itemdoc,
-        methods: par::seqmap(methods) {|method|
+        methods: do par::seqmap(methods) {|method|
             {
                 name: *method.ident,
                 brief: none,
@@ -221,7 +221,7 @@ fn impldoc_from_impl(
         item: itemdoc,
         iface_ty: none,
         self_ty: none,
-        methods: par::seqmap(methods) {|method|
+        methods: do par::seqmap(methods) {|method|
             {
                 name: *method.ident,
                 brief: none,
@@ -339,7 +339,7 @@ mod test {
     #[test]
     fn extract_from_seq_srv() {
         let source = "";
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = from_srv(srv, "name");
             assert doc.cratemod().name() == "name";
         }
diff --git a/src/rustdoc/fold.rs b/src/rustdoc/fold.rs
index e502bb7ce41..7e5cafcb91e 100644
--- a/src/rustdoc/fold.rs
+++ b/src/rustdoc/fold.rs
@@ -133,7 +133,7 @@ fn default_par_fold<T:send copy>(ctxt: T) -> fold<T> {
 
 fn default_seq_fold_doc<T>(fold: fold<T>, doc: doc::doc) -> doc::doc {
     {
-        pages: par::seqmap(doc.pages) {|page|
+        pages: do par::seqmap(doc.pages) {|page|
             alt page {
               doc::cratepage(doc) {
                 doc::cratepage(fold.fold_crate(fold, doc))
@@ -169,9 +169,9 @@ fn default_any_fold_mod<T:send copy>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::anymap(doc.items) {|itemtag, copy fold|
+        items: par::anymap(doc.items, {|itemtag, copy fold|
             fold_itemtag(fold, itemtag)
-        }
+        })
         with doc
     }
 }
@@ -182,9 +182,9 @@ fn default_seq_fold_mod<T>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::seqmap(doc.items) {|itemtag|
+        items: par::seqmap(doc.items, {|itemtag|
             fold_itemtag(fold, itemtag)
-        }
+        })
         with doc
     }
 }
@@ -195,9 +195,9 @@ fn default_par_fold_mod<T:send copy>(
 ) -> doc::moddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        items: par::parmap(doc.items) {|itemtag, copy fold|
+        items: par::parmap(doc.items, {|itemtag, copy fold|
             fold_itemtag(fold, itemtag)
-        }
+        })
         with doc
     }
 }
@@ -208,9 +208,9 @@ fn default_any_fold_nmod<T:send copy>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::anymap(doc.fns) {|fndoc, copy fold|
+        fns: par::anymap(doc.fns, {|fndoc, copy fold|
             fold.fold_fn(fold, fndoc)
-        }
+        })
         with doc
     }
 }
@@ -221,9 +221,9 @@ fn default_seq_fold_nmod<T>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::seqmap(doc.fns) {|fndoc|
+        fns: par::seqmap(doc.fns, {|fndoc|
             fold.fold_fn(fold, fndoc)
-        }
+        })
         with doc
     }
 }
@@ -234,9 +234,9 @@ fn default_par_fold_nmod<T:send copy>(
 ) -> doc::nmoddoc {
     {
         item: fold.fold_item(fold, doc.item),
-        fns: par::parmap(doc.fns) {|fndoc, copy fold|
+        fns: par::parmap(doc.fns, {|fndoc, copy fold|
             fold.fold_fn(fold, fndoc)
-        }
+        })
         with doc
     }
 }
diff --git a/src/rustdoc/markdown_index_pass.rs b/src/rustdoc/markdown_index_pass.rs
index 78ab0ab8424..83d2180e1e7 100644
--- a/src/rustdoc/markdown_index_pass.rs
+++ b/src/rustdoc/markdown_index_pass.rs
@@ -55,9 +55,9 @@ fn build_mod_index(
     config: config::config
 ) -> doc::index {
     {
-        entries: par::anymap(doc.items) {|doc|
+        entries: par::anymap(doc.items, {|doc|
             item_to_entry(doc, config)
-        }
+        })
     }
 }
 
@@ -66,9 +66,9 @@ fn build_nmod_index(
     config: config::config
 ) -> doc::index {
     {
-        entries: par::anymap(doc.fns) {|doc|
+        entries: par::anymap(doc.fns, {|doc|
             item_to_entry(doc::fntag(doc), config)
-        }
+        })
     }
 }
 
@@ -215,7 +215,7 @@ fn should_index_foreign_mod_contents() {
 #[cfg(test)]
 mod test {
     fn mk_doc(output_style: config::output_style, source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let config = {
                 output_style: output_style
                 with config::default_config("whatever")
diff --git a/src/rustdoc/markdown_pass.rs b/src/rustdoc/markdown_pass.rs
index a73fd2d478d..9fe29dafd05 100644
--- a/src/rustdoc/markdown_pass.rs
+++ b/src/rustdoc/markdown_pass.rs
@@ -82,7 +82,7 @@ fn write_markdown(
     doc: doc::doc,
     +writer_factory: writer_factory
 ) {
-    par::anymap(doc.pages) {|page|
+    do par::anymap(doc.pages) {|page|
         let ctxt = {
             w: writer_factory(page)
         };
@@ -115,7 +115,7 @@ fn should_request_new_writer_for_each_page() {
     let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc);
     write_markdown(doc, writer_factory);
     // We expect two pages to have been written
-    iter::repeat(2u) {||
+    do iter::repeat(2u) {||
         comm::recv(po);
     }
 }
@@ -146,7 +146,7 @@ fn should_write_title_for_each_page() {
         "#[link(name = \"core\")]; mod a { }");
     let doc = page_pass::mk_pass(config::doc_per_mod).f(srv, doc);
     write_markdown(doc, writer_factory);
-    iter::repeat(2u) {||
+    do iter::repeat(2u) {||
         let (page, markdown) = comm::recv(po);
         alt page {
           doc::cratepage(_) {
@@ -295,7 +295,7 @@ fn write_desc(
 }
 
 fn write_sections(ctxt: ctxt, sections: ~[doc::section]) {
-    vec::iter(sections) {|section|
+    do vec::iter(sections) {|section|
         write_section(ctxt, section);
     }
 }
@@ -645,7 +645,7 @@ fn write_iface(ctxt: ctxt, doc: doc::ifacedoc) {
 }
 
 fn write_methods(ctxt: ctxt, docs: ~[doc::methoddoc]) {
-    vec::iter(docs) {|doc| write_method(ctxt, doc) }
+    do vec::iter(docs) {|doc| write_method(ctxt, doc) }
 }
 
 fn write_method(ctxt: ctxt, doc: doc::methoddoc) {
@@ -760,7 +760,7 @@ mod test {
     }
 
     fn create_doc_srv(source: str) -> (astsrv::srv, doc::doc) {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
 
             let config = {
                 output_style: config::doc_per_crate
diff --git a/src/rustdoc/markdown_writer.rs b/src/rustdoc/markdown_writer.rs
index 46462c272f9..6d8a4d9632c 100644
--- a/src/rustdoc/markdown_writer.rs
+++ b/src/rustdoc/markdown_writer.rs
@@ -56,7 +56,7 @@ fn markdown_writer(
     page: doc::page
 ) -> writer {
     let filename = make_local_filename(config, page);
-    generic_writer {|markdown|
+    do generic_writer {|markdown|
         write_file(filename, markdown);
     }
 }
@@ -78,7 +78,7 @@ fn pandoc_writer(
         "--output=" + filename
     ];
 
-    generic_writer {|markdown|
+    do generic_writer {|markdown|
         import io::writer_util;
 
         #debug("pandoc cmd: %s", pandoc_cmd);
@@ -101,14 +101,14 @@ fn pandoc_writer(
 
         let stdout_po = comm::port();
         let stdout_ch = comm::chan(stdout_po);
-        task::spawn_sched(task::single_threaded) {||
+        do task::spawn_sched(task::single_threaded) {||
             comm::send(stdout_ch, readclose(pipe_out.in));
         }
         let stdout = comm::recv(stdout_po);
 
         let stderr_po = comm::port();
         let stderr_ch = comm::chan(stderr_po);
-        task::spawn_sched(task::single_threaded) {||
+        do task::spawn_sched(task::single_threaded) {||
             comm::send(stderr_ch, readclose(pipe_err.in));
         }
         let stderr = comm::recv(stderr_po);
@@ -137,7 +137,7 @@ fn readclose(fd: libc::c_int) -> str {
 }
 
 fn generic_writer(+process: fn~(markdown: str)) -> writer {
-    let ch = task::spawn_listener {|po: comm::port<writeinstr>|
+    let ch = do task::spawn_listener {|po: comm::port<writeinstr>|
         let mut markdown = "";
         let mut keep_going = true;
         while keep_going {
@@ -236,7 +236,7 @@ fn should_name_mod_file_names_by_path() {
 #[cfg(test)]
 mod test {
     fn mk_doc(name: str, source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, name);
             let doc = path_pass::mk_pass().f(srv, doc);
             doc
@@ -262,7 +262,7 @@ fn future_writer_factory(
     let writer_factory = fn~(page: doc::page) -> writer {
         let writer_po = comm::port();
         let writer_ch = comm::chan(writer_po);
-        task::spawn {||
+        do task::spawn {||
             let (writer, future) = future_writer();
             comm::send(writer_ch, writer);
             let s = future::get(future);
@@ -280,7 +280,7 @@ fn future_writer() -> (writer, future::future<str>) {
     let writer = fn~(+instr: writeinstr) {
         comm::send(chan, copy instr);
     };
-    let future = future::from_fn {||
+    let future = do future::from_fn {||
         let mut res = "";
         loop {
             alt comm::recv(port) {
diff --git a/src/rustdoc/page_pass.rs b/src/rustdoc/page_pass.rs
index a697d3aa112..753ce879b61 100644
--- a/src/rustdoc/page_pass.rs
+++ b/src/rustdoc/page_pass.rs
@@ -32,7 +32,7 @@ fn run(
 
     let result_port = comm::port();
     let result_chan = comm::chan(result_port);
-    let page_chan = task::spawn_listener {|page_port|
+    let page_chan = do task::spawn_listener {|page_port|
         comm::send(result_chan, make_doc_from_pages(page_port));
     };
 
@@ -106,7 +106,7 @@ fn fold_mod(
 
 fn strip_mod(doc: doc::moddoc) -> doc::moddoc {
     {
-        items: vec::filter(doc.items) {|item|
+        items: do vec::filter(doc.items) {|item|
             alt item {
               doc::modtag(_) { false }
               doc::nmodtag(_) { false }
@@ -166,7 +166,7 @@ mod test {
         output_style: config::output_style,
         source: str
     ) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             run(srv, doc, output_style)
         }
diff --git a/src/rustdoc/par.rs b/src/rustdoc/par.rs
index 1f66721914f..6275e47d26c 100644
--- a/src/rustdoc/par.rs
+++ b/src/rustdoc/par.rs
@@ -9,16 +9,16 @@ fn seqmap<T, U>(v: ~[T], f: fn(T) -> U) -> ~[U] {
 }
 
 fn parmap<T:send, U:send>(v: ~[T], f: fn~(T) -> U) -> ~[U] unsafe {
-    let futures = vec::map(v) {|elt|
+    let futures = do vec::map(v) {|elt|
         let po = comm::port();
         let ch = comm::chan(po);
         let addr = ptr::addr_of(elt);
-        task::spawn {|copy f|
+        do task::spawn {|copy f|
             comm::send(ch, f(*addr));
         }
         po
     };
-    vec::map(futures) {|future|
+    do vec::map(futures) {|future|
         comm::recv(future)
     }
 }
@@ -26,6 +26,6 @@ fn parmap<T:send, U:send>(v: ~[T], f: fn~(T) -> U) -> ~[U] unsafe {
 #[test]
 fn test_parallel_map() {
     let i = ~[1, 2, 3, 4];
-    let j = parmap(i) {|e| e + 1 };
+    let j = parmap(i, {|e| e + 1 });
     assert j == ~[2, 3, 4, 5];
 }
diff --git a/src/rustdoc/path_pass.rs b/src/rustdoc/path_pass.rs
index a1d2a790280..081cd9fe293 100644
--- a/src/rustdoc/path_pass.rs
+++ b/src/rustdoc/path_pass.rs
@@ -66,7 +66,7 @@ fn fold_nmod(fold: fold::fold<ctxt>, doc: doc::nmoddoc) -> doc::nmoddoc {
 #[test]
 fn should_record_mod_paths() {
     let source = "mod a { mod b { mod c { } } mod d { mod e { } } }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].mods()[0].mods()[0].path()
@@ -79,7 +79,7 @@ fn should_record_mod_paths() {
 #[test]
 fn should_record_fn_paths() {
     let source = "mod a { fn b() { } }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].fns()[0].path() == ~["a"];
@@ -89,7 +89,7 @@ fn should_record_fn_paths() {
 #[test]
 fn should_record_foreign_mod_paths() {
     let source = "mod a { native mod b { } }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().mods()[0].nmods()[0].path() == ~["a"];
@@ -99,7 +99,7 @@ fn should_record_foreign_mod_paths() {
 #[test]
 fn should_record_foreign_fn_paths() {
     let source = "native mod a { fn b(); }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = run(srv, doc);
         assert doc.cratemod().nmods()[0].fns[0].path() == ~["a"];
diff --git a/src/rustdoc/prune_hidden_pass.rs b/src/rustdoc/prune_hidden_pass.rs
index b022b1ff55c..24c0c019ee6 100644
--- a/src/rustdoc/prune_hidden_pass.rs
+++ b/src/rustdoc/prune_hidden_pass.rs
@@ -25,9 +25,9 @@ fn fold_mod(
     let doc = fold::default_any_fold_mod(fold, doc);
 
     {
-        items: vec::filter(doc.items) {|itemtag|
+        items: vec::filter(doc.items, {|itemtag|
             !is_hidden(fold.ctxt, itemtag.item())
-        }
+        })
         with doc
     }
 }
@@ -36,7 +36,7 @@ fn is_hidden(srv: astsrv::srv, doc: doc::itemdoc) -> bool {
     import syntax::ast_map;
 
     let id = doc.id;
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         let attrs = alt ctxt.ast_map.get(id) {
           ast_map::node_item(item, _) { item.attrs }
           _ { ~[] }
@@ -54,7 +54,7 @@ fn should_prune_hidden_items() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs
index 15da9afd679..8e9d15e25ec 100644
--- a/src/rustdoc/prune_unexported_pass.rs
+++ b/src/rustdoc/prune_unexported_pass.rs
@@ -72,7 +72,7 @@ fn exported_items_from(
     doc: doc::moddoc,
     is_exported: fn(astsrv::srv, str) -> bool
 ) -> ~[doc::itemtag] {
-    vec::filter_map(doc.items) { |itemtag|
+    do vec::filter_map(doc.items) { |itemtag|
         let itemtag = alt itemtag {
           doc::enumtag(enumdoc) {
             // Also need to check variant exportedness
@@ -97,7 +97,7 @@ fn exported_variants_from(
     doc: doc::enumdoc,
     is_exported: fn(astsrv::srv, str) -> bool
 ) -> ~[doc::variantdoc] {
-    vec::filter_map(doc.variants) { |doc|
+    do vec::filter_map(doc.variants) { |doc|
         if is_exported(srv, doc.name) {
             some(doc)
         } else {
@@ -111,7 +111,7 @@ fn is_exported_from_mod(
     mod_id: doc::ast_id,
     item_name: str
 ) -> bool {
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         alt ctxt.ast_map.get(mod_id) {
           ast_map::node_item(item, _) {
             alt item.node {
@@ -132,7 +132,7 @@ fn is_exported_from_crate(
     srv: astsrv::srv,
     item_name: str
 ) -> bool {
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         ast_util::is_exported(@item_name, ctxt.ast.node.module)
     }
 }
@@ -223,7 +223,7 @@ fn should_prune_unexported_types() {
 #[test]
 fn should_not_prune_reexports() {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = reexport_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -238,7 +238,7 @@ fn should_not_prune_reexports() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs
index 13398616c7d..3232a724745 100644
--- a/src/rustdoc/reexport_pass.rs
+++ b/src/rustdoc/reexport_pass.rs
@@ -58,7 +58,7 @@ fn from_assoc_list<K:copy, V:copy>(
 ) -> map::hashmap<K, V> {
 
     let map = new_hash();
-    vec::iter(list) {|elt|
+    do vec::iter(list) {|elt|
         let (k, v) = elt;
         map.insert(k, v);
     }
@@ -78,7 +78,7 @@ fn from_str_assoc_list<V:copy>(
 }
 
 fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
-    let assoc_list = astsrv::exec(srv) {|ctxt|
+    let assoc_list = do astsrv::exec(srv) {|ctxt|
         let def_set = ast_util::new_def_hash();
         for ctxt.exp_map.each {|_id, defs|
             for defs.each {|def|
@@ -98,7 +98,7 @@ fn build_reexport_def_set(srv: astsrv::srv) -> def_set {
 
 fn find_reexport_impls(ctxt: astsrv::ctxt) -> ~[ast::def_id] {
     let defs = @mut ~[];
-    for_each_reexported_impl(ctxt) {|_mod_id, i|
+    do for_each_reexported_impl(ctxt) {|_mod_id, i|
         *defs += ~[i.did]
     }
     ret *defs;
@@ -166,7 +166,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
     let def_assoc_list = to_assoc_list(def_map);
     #debug("def_map: %?", def_assoc_list);
 
-    let assoc_list = astsrv::exec(srv) {|ctxt|
+    let assoc_list = do astsrv::exec(srv) {|ctxt|
 
         let def_map = from_def_assoc_list(def_assoc_list);
         let path_map = map::str_hash::<~[(str,doc::itemtag)]>();
@@ -194,7 +194,7 @@ fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map {
             }
 
             if reexportdocs.len() > 0u {
-                option::iter(path_map.find(modpath)) {|docs|
+                do option::iter(path_map.find(modpath)) {|docs|
                     reexportdocs = docs + vec::filter(reexportdocs, {|x|
                         !vec::contains(docs, x)
                     });
@@ -226,7 +226,7 @@ fn find_reexport_impl_docs(
 ) -> ~[(str, (str, doc::itemtag))] {
     let docs = @mut ~[];
 
-    for_each_reexported_impl(ctxt) {|mod_id, i|
+    do for_each_reexported_impl(ctxt) {|mod_id, i|
         let path = alt ctxt.ast_map.find(mod_id) {
           some(ast_map::node_item(item, path)) {
             let path = ast_map::path_to_str(*path);
@@ -338,7 +338,7 @@ fn merge_reexports(
         #debug("looking for reexports in path %?", path);
         alt path_map.find(str::connect(path, "::")) {
           some(name_docs) {
-            vec::foldl(~[], name_docs) {|v, name_doc|
+            do vec::foldl(~[], name_docs) {|v, name_doc|
                 let (name, doc) = name_doc;
                 v + ~[reexport_doc(doc, name)]
             }
@@ -462,7 +462,7 @@ fn should_duplicate_multiple_reexported_items() {
                   import a::b; import a::c; \
                   export b; export c; \
                   }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = path_pass::mk_pass().f(srv, doc);
         let doc = run(srv, doc);
@@ -484,7 +484,7 @@ fn should_rename_items_reexported_with_different_names() {
 #[test]
 fn should_reexport_in_topmod() {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "core");
             let doc = path_pass::mk_pass().f(srv, doc);
             run(srv, doc)
@@ -515,7 +515,7 @@ fn should_not_reexport_multiple_times() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = path_pass::mk_pass().f(srv, doc);
             run(srv, doc)
diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs
index fd335bcf735..c9d08567596 100755
--- a/src/rustdoc/rustdoc.rs
+++ b/src/rustdoc/rustdoc.rs
@@ -31,11 +31,11 @@ fn run_passes(
     )];
 
     let mut passno = 0;
-    vec::foldl(doc, passes) {|doc, pass|
+    do vec::foldl(doc, passes) {|doc, pass|
         log(debug, #fmt("pass #%d", passno));
         passno += 1;
         log(debug, doc);
-        time(pass.name) {||
+        do time(pass.name) {||
             pass.f(srv, doc)
         }
     }
@@ -82,7 +82,7 @@ fn test_run_passes() {
         }
     }
     let source = "";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let passes = ~[
             {
                 name: "",
@@ -129,14 +129,14 @@ fn time<T>(what: str, f: fn() -> T) -> T {
 fn run(config: config::config) {
 
     let source_file = config.input_crate;
-    astsrv::from_file(source_file) {|srv|
-        time("wait_ast") {||
-            astsrv::exec(srv) {|_ctxt| () }
+    do astsrv::from_file(source_file) {|srv|
+        do time("wait_ast") {||
+            do astsrv::exec(srv) {|_ctxt| () }
         };
-        let doc = time("extract") {||
+        let doc = time("extract", {||
             let default_name = source_file;
             extract::from_srv(srv, default_name)
-        };
+        });
         run_passes(srv, doc, ~[
             reexport_pass::mk_pass(),
             prune_unexported_pass::mk_pass(),
diff --git a/src/rustdoc/sectionalize_pass.rs b/src/rustdoc/sectionalize_pass.rs
index 9cbb826f61a..d4a453acb83 100644
--- a/src/rustdoc/sectionalize_pass.rs
+++ b/src/rustdoc/sectionalize_pass.rs
@@ -34,7 +34,7 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
     let doc = fold::default_seq_fold_iface(fold, doc);
 
     {
-        methods: par::anymap(doc.methods) {|method|
+        methods: do par::anymap(doc.methods) {|method|
             let (desc, sections) = sectionalize(method.desc);
 
             {
@@ -51,7 +51,7 @@ fn fold_impl(fold: fold::fold<()>, doc: doc::impldoc) -> doc::impldoc {
     let doc = fold::default_seq_fold_impl(fold, doc);
 
     {
-        methods: par::anymap(doc.methods) {|method|
+        methods: do par::anymap(doc.methods) {|method|
             let (desc, sections) = sectionalize(method.desc);
 
             {
@@ -228,7 +228,7 @@ fn should_sectionalize_impl_methods() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             run(srv, doc)
diff --git a/src/rustdoc/sort_item_name_pass.rs b/src/rustdoc/sort_item_name_pass.rs
index 8ed03f56d23..580286922ff 100644
--- a/src/rustdoc/sort_item_name_pass.rs
+++ b/src/rustdoc/sort_item_name_pass.rs
@@ -3,15 +3,15 @@
 export mk_pass;
 
 fn mk_pass() -> pass {
-    sort_pass::mk_pass("sort_item_name") { |item1, item2|
+    sort_pass::mk_pass("sort_item_name", { |item1, item2|
         str::le(item1.name(), item2.name())
-    }
+    })
 }
 
 #[test]
 fn test() {
     let source = "mod z { } fn y() { }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass().f(srv, doc);
         assert doc.cratemod().items[0].name() == "y";
diff --git a/src/rustdoc/sort_item_type_pass.rs b/src/rustdoc/sort_item_type_pass.rs
index 736d7c01bb3..4509a1e996d 100644
--- a/src/rustdoc/sort_item_type_pass.rs
+++ b/src/rustdoc/sort_item_type_pass.rs
@@ -3,7 +3,7 @@
 export mk_pass;
 
 fn mk_pass() -> pass {
-    sort_pass::mk_pass("sort_item_type") { |item1, item2|
+    do sort_pass::mk_pass("sort_item_type") { |item1, item2|
         fn score(item: doc::itemtag) -> int {
             alt item {
               doc::consttag(_) { 0 }
@@ -32,7 +32,7 @@ fn test() {
          iface iiface { fn a(); } \
          impl iimpl for int { fn a() { } } \
          type itype = int;";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass().f(srv, doc);
         assert doc.cratemod().items[0].name() == "iconst";
diff --git a/src/rustdoc/sort_pass.rs b/src/rustdoc/sort_pass.rs
index 794e190fa5b..838348dd99b 100644
--- a/src/rustdoc/sort_pass.rs
+++ b/src/rustdoc/sort_pass.rs
@@ -47,7 +47,7 @@ fn test() {
     }
 
     let source = "mod z { mod y { } fn x() { } } mod w { }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass("", name_lteq).f(srv, doc);
         assert doc.cratemod().mods()[0].name() == "w";
@@ -64,7 +64,7 @@ fn should_be_stable() {
     }
 
     let source = "mod a { mod b { } } mod c { mod d { } }";
-    astsrv::from_str(source) {|srv|
+    do astsrv::from_str(source) {|srv|
         let doc = extract::from_srv(srv, "");
         let doc = mk_pass("", always_eq).f(srv, doc);
         assert doc.cratemod().mods()[0].items[0].name() == "b";
diff --git a/src/rustdoc/text_pass.rs b/src/rustdoc/text_pass.rs
index 37e54fa355a..bb750491947 100644
--- a/src/rustdoc/text_pass.rs
+++ b/src/rustdoc/text_pass.rs
@@ -30,7 +30,7 @@ fn run(
 }
 
 fn maybe_apply_op(op: op, s: option<str>) -> option<str> {
-    option::map(s) {|s| op(s) }
+    option::map(s, {|s| op(s) })
 }
 
 fn fold_item(fold: fold::fold<op>, doc: doc::itemdoc) -> doc::itemdoc {
@@ -45,19 +45,19 @@ fn fold_item(fold: fold::fold<op>, doc: doc::itemdoc) -> doc::itemdoc {
 }
 
 fn apply_to_sections(op: op, sections: ~[doc::section]) -> ~[doc::section] {
-    par::anymap(sections) {|section, copy op|
+    par::anymap(sections, {|section, copy op|
         {
             header: op(section.header),
             body: op(section.body)
         }
-    }
+    })
 }
 
 fn fold_enum(fold: fold::fold<op>, doc: doc::enumdoc) -> doc::enumdoc {
     let doc = fold::default_seq_fold_enum(fold, doc);
 
     {
-        variants: par::anymap(doc.variants) {|variant, copy fold|
+        variants: do par::anymap(doc.variants) {|variant, copy fold|
             {
                 desc: maybe_apply_op(fold.ctxt, variant.desc)
                 with variant
@@ -77,7 +77,7 @@ fn fold_iface(fold: fold::fold<op>, doc: doc::ifacedoc) -> doc::ifacedoc {
 }
 
 fn apply_to_methods(op: op, docs: ~[doc::methoddoc]) -> ~[doc::methoddoc] {
-    par::anymap(docs) {|doc, copy op|
+    do par::anymap(docs) {|doc, copy op|
         {
             brief: maybe_apply_op(op, doc.brief),
             desc: maybe_apply_op(op, doc.desc),
@@ -253,7 +253,7 @@ fn should_execute_on_impl_method_section_bodies() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             let doc = desc_to_brief_pass::mk_pass().f(srv, doc);
diff --git a/src/rustdoc/trim_pass.rs b/src/rustdoc/trim_pass.rs
index e3c79de22bb..d9076516209 100644
--- a/src/rustdoc/trim_pass.rs
+++ b/src/rustdoc/trim_pass.rs
@@ -23,7 +23,7 @@ fn should_trim_text() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             let doc = attr_pass::mk_pass().f(srv, doc);
             mk_pass().f(srv, doc)
diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs
index 65499bcbe56..33410cca299 100644
--- a/src/rustdoc/tystr_pass.rs
+++ b/src/rustdoc/tystr_pass.rs
@@ -45,7 +45,7 @@ fn fold_fn(
 }
 
 fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> {
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         alt check ctxt.ast_map.get(fn_id) {
           ast_map::node_item(@{
             ident: ident,
@@ -80,7 +80,7 @@ fn fold_const(
     let srv = fold.ctxt;
 
     {
-        sig: some(astsrv::exec(srv) {|ctxt|
+        sig: some(do astsrv::exec(srv) {|ctxt|
             alt check ctxt.ast_map.get(doc.id()) {
               ast_map::node_item(@{
                 node: ast::item_const(ty, _), _
@@ -107,14 +107,14 @@ fn fold_enum(
     let srv = fold.ctxt;
 
     {
-        variants: par::anymap(doc.variants) {|variant|
-            let sig = astsrv::exec(srv) {|ctxt|
+        variants: do par::anymap(doc.variants) {|variant|
+            let sig = do astsrv::exec(srv) {|ctxt|
                 alt check ctxt.ast_map.get(doc_id) {
                   ast_map::node_item(@{
                     node: ast::item_enum(ast_variants, _, _), _
                   }, _) {
                     let ast_variant = option::get(
-                        vec::find(ast_variants) {|v|
+                        do vec::find(ast_variants) {|v|
                             *v.node.name == variant.name
                         });
 
@@ -153,7 +153,7 @@ fn merge_methods(
     item_id: doc::ast_id,
     docs: ~[doc::methoddoc]
 ) -> ~[doc::methoddoc] {
-    par::anymap(docs) {|doc|
+    do par::anymap(docs) {|doc|
         {
             sig: get_method_sig(srv, item_id, doc.name)
             with doc
@@ -166,14 +166,14 @@ fn get_method_sig(
     item_id: doc::ast_id,
     method_name: str
 ) -> option<str> {
-    astsrv::exec(srv) {|ctxt|
+    do astsrv::exec(srv) {|ctxt|
         alt check ctxt.ast_map.get(item_id) {
           ast_map::node_item(@{
             node: ast::item_iface(_, _, methods), _
           }, _) {
-            alt check vec::find(methods) {|method|
+            alt check vec::find(methods, {|method|
                 *method.ident == method_name
-            } {
+            }) {
                 some(method) {
                     some(pprust::fun_to_str(
                         method.decl,
@@ -186,9 +186,9 @@ fn get_method_sig(
           ast_map::node_item(@{
             node: ast::item_impl(_, _, _, _, methods), _
           }, _) {
-            alt check vec::find(methods) {|method|
+            alt check vec::find(methods, {|method|
                 *method.ident == method_name
-            } {
+            }) {
                 some(method) {
                     some(pprust::fun_to_str(
                         method.decl,
@@ -216,14 +216,14 @@ fn fold_impl(
 
     let srv = fold.ctxt;
 
-    let (iface_ty, self_ty) = astsrv::exec(srv) {|ctxt|
+    let (iface_ty, self_ty) = do astsrv::exec(srv) {|ctxt|
         alt ctxt.ast_map.get(doc.id()) {
           ast_map::node_item(@{
             node: ast::item_impl(_, _, iface_ty, self_ty, _), _
           }, _) {
-            let iface_ty = option::map(iface_ty) {|p|
+            let iface_ty = option::map(iface_ty, {|p|
                 pprust::path_to_str(p.path)
-            };
+            });
             (iface_ty, some(pprust::ty_to_str(self_ty)))
           }
           _ { fail "expected impl" }
@@ -271,7 +271,7 @@ fn fold_type(
     let srv = fold.ctxt;
 
     {
-        sig: astsrv::exec(srv) {|ctxt|
+        sig: do astsrv::exec(srv) {|ctxt|
             alt ctxt.ast_map.get(doc.id()) {
               ast_map::node_item(@{
                 ident: ident,
@@ -300,7 +300,7 @@ fn should_add_type_signatures() {
 #[cfg(test)]
 mod test {
     fn mk_doc(source: str) -> doc::doc {
-        astsrv::from_str(source) {|srv|
+        do astsrv::from_str(source) {|srv|
             let doc = extract::from_srv(srv, "");
             run(srv, doc)
         }
diff --git a/src/rustdoc/unindent_pass.rs b/src/rustdoc/unindent_pass.rs
index 3b63e7d5994..9e10637e8f2 100644
--- a/src/rustdoc/unindent_pass.rs
+++ b/src/rustdoc/unindent_pass.rs
@@ -21,7 +21,7 @@ fn unindent(s: str) -> str {
     let lines = str::lines_any(s);
     let mut saw_first_line = false;
     let mut saw_second_line = false;
-    let min_indent = vec::foldl(uint::max_value, lines) {|min_indent, line|
+    let min_indent = do vec::foldl(uint::max_value, lines) {|min_indent, line|
 
         // After we see the first non-whitespace line, look at
         // the line we have. If it is not whitespace, and therefore
@@ -47,7 +47,7 @@ fn unindent(s: str) -> str {
         } else {
             saw_first_line = true;
             let mut spaces = 0u;
-            str::all(line) {|char|
+            do str::all(line) {|char|
                 // Only comparing against space because I wouldn't
                 // know what to do with mixed whitespace chars
                 if char == ' ' {
@@ -63,7 +63,7 @@ fn unindent(s: str) -> str {
 
     if check vec::is_not_empty(lines) {
         let unindented = ~[str::trim(vec::head(lines))]
-            + par::anymap(vec::tail(lines)) {|line|
+            + do par::anymap(vec::tail(lines)) {|line|
             if str::is_whitespace(line) {
                 line
             } else {
diff --git a/src/test/auxiliary/cci_capture_clause.rs b/src/test/auxiliary/cci_capture_clause.rs
index 07223c10049..42e419e69ce 100644
--- a/src/test/auxiliary/cci_capture_clause.rs
+++ b/src/test/auxiliary/cci_capture_clause.rs
@@ -5,7 +5,7 @@ import comm::*;
 fn foo<T: send copy>(x: T) -> port<T> {
     let p = port();
     let c = chan(p);
-    task::spawn() {|copy c, copy x|
+    do task::spawn() {|copy c, copy x|
         c.send(x);
     }
     p
diff --git a/src/test/auxiliary/test_comm.rs b/src/test/auxiliary/test_comm.rs
index 789836c9d63..3574fc74c20 100644
--- a/src/test/auxiliary/test_comm.rs
+++ b/src/test/auxiliary/test_comm.rs
@@ -34,7 +34,7 @@ class port_ptr<T:send> {
     self.po = po; }
    drop unsafe {
     #debug("in the port_ptr destructor");
-    task::unkillable {||
+    do task::unkillable {||
         let yield = 0u;
         let yieldp = ptr::addr_of(yield);
         rustrt::rust_port_begin_detach(self.po, yieldp);
diff --git a/src/test/bench/graph500-bfs.rs b/src/test/bench/graph500-bfs.rs
index 279fcf2d61f..218d05ec30e 100644
--- a/src/test/bench/graph500-bfs.rs
+++ b/src/test/bench/graph500-bfs.rs
@@ -60,24 +60,24 @@ fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] {
         }
     }
 
-    vec::from_fn((1u << scale) * edgefactor) {|_i|
+    do vec::from_fn((1u << scale) * edgefactor) {|_i|
         choose_edge(0i64, 0i64, scale, r)
     }
 }
 
 fn make_graph(N: uint, edges: ~[(node_id, node_id)]) -> graph {
-    let graph = vec::from_fn(N) {|_i| 
+    let graph = do vec::from_fn(N) {|_i| 
         map::hashmap::<node_id, ()>({|x| x as uint }, {|x, y| x == y })
     };
 
-    vec::each(edges) {|e| 
+    do vec::each(edges) {|e| 
         let (i, j) = e;
         map::set_add(graph[i], j);
         map::set_add(graph[j], i);
         true
     }
 
-    graph.map() {|v|
+    do graph.map() {|v|
         map::vec_from_set(v)
     }
 }
@@ -89,9 +89,9 @@ fn gen_search_keys(graph: graph, n: uint) -> ~[node_id] {
     while keys.size() < n {
         let k = r.gen_uint_range(0u, graph.len());
 
-        if graph[k].len() > 0u && vec::any(graph[k]) {|i|
+        if graph[k].len() > 0u && vec::any(graph[k], {|i|
             i != k as node_id
-        } {
+        }) {
             map::set_add(keys, k as node_id);
         }
     }
@@ -113,7 +113,7 @@ fn bfs(graph: graph, key: node_id) -> bfs_result {
     while Q.size() > 0u {
         let t = Q.pop_front();
 
-        graph[t].each() {|k| 
+        do graph[t].each() {|k| 
             if marks[k] == -1i64 {
                 marks[k] = t;
                 Q.add_back(k);
@@ -140,7 +140,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
         black(node_id)
     };
 
-    let mut colors = vec::from_fn(graph.len()) {|i|
+    let mut colors = do vec::from_fn(graph.len()) {|i|
         if i as node_id == key {
             gray(key)
         }
@@ -161,7 +161,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
         // Do the BFS.
         log(info, #fmt("PBFS iteration %?", i));
         i += 1u;
-        colors = colors.mapi() {|i, c|
+        colors = do colors.mapi() {|i, c|
             let c : color = c;
             alt c {
               white {
@@ -171,7 +171,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
                 
                 let mut color = white;
 
-                neighbors.each() {|k|
+                do neighbors.each() {|k|
                     if is_gray(colors[k]) {
                         color = gray(k);
                         false
@@ -188,7 +188,7 @@ fn bfs2(graph: graph, key: node_id) -> bfs_result {
     }
 
     // Convert the results.
-    vec::map(colors) {|c|
+    do vec::map(colors) {|c|
         alt c {
           white { -1i64 }
           black(parent) { parent }
@@ -209,7 +209,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result {
         black(node_id)
     };
 
-    let mut colors = vec::from_fn((*arc::get(&graph)).len()) {|i|
+    let mut colors = do vec::from_fn((*arc::get(&graph)).len()) {|i|
         if i as node_id == key {
             gray(key)
         }
@@ -235,7 +235,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result {
 
         let color = arc::arc(colors);
 
-        colors = par::mapi_factory(*arc::get(&color)) {||
+        colors = do par::mapi_factory(*arc::get(&color)) {||
             let colors = arc::clone(&color);
             let graph = arc::clone(&graph);
             fn~(i: uint, c: color) -> color {
@@ -250,7 +250,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result {
                     
                     let mut color = white;
                     
-                    neighbors.each() {|k|
+                    do neighbors.each() {|k|
                         if is_gray(colors[k]) {
                             color = gray(k);
                             false
@@ -268,7 +268,7 @@ fn pbfs(&&graph: arc::arc<graph>, key: node_id) -> bfs_result {
     }
 
     // Convert the results.
-    par::map(colors) {|c|
+    do par::map(colors) {|c|
         alt c {
           white { -1i64 }
           black(parent) { parent }
@@ -291,7 +291,7 @@ fn validate(edges: ~[(node_id, node_id)],
     log(info, "Verifying tree structure...");
 
     let mut status = true;
-    let level = tree.map() {|parent| 
+    let level = do tree.map() {|parent| 
         let mut parent = parent;
         let mut path = ~[];
 
@@ -322,7 +322,7 @@ fn validate(edges: ~[(node_id, node_id)],
 
     log(info, "Verifying tree edges...");
 
-    let status = tree.alli() {|k, parent|
+    let status = do tree.alli() {|k, parent|
         if parent != root && parent != -1i64 {
             level[parent] == level[k] - 1
         }
@@ -338,7 +338,7 @@ fn validate(edges: ~[(node_id, node_id)],
 
     log(info, "Verifying graph edges...");
 
-    let status = edges.all() {|e| 
+    let status = do edges.all() {|e| 
         let (u, v) = e;
 
         abs(level[u] - level[v]) <= 1
@@ -355,7 +355,7 @@ fn validate(edges: ~[(node_id, node_id)],
 
     log(info, "Verifying tree and graph edges...");
 
-    let status = par::alli(tree) {|u, v|
+    let status = do par::alli(tree) {|u, v|
         let u = u as node_id;
         if v == -1i64 || u == root {
             true
@@ -397,7 +397,7 @@ fn main(args: ~[str]) {
     let stop = time::precise_time_s();
 
     let mut total_edges = 0u;
-    vec::each(graph) {|edges| total_edges += edges.len(); true };
+    vec::each(graph, {|edges| total_edges += edges.len(); true });
 
     io::stdout().write_line(#fmt("Generated graph with %? edges in %? seconds.",
                                  total_edges / 2u,
@@ -408,7 +408,7 @@ fn main(args: ~[str]) {
 
     let graph_arc = arc::arc(copy graph);
 
-    gen_search_keys(graph, num_keys).map() {|root|
+    do gen_search_keys(graph, num_keys).map() {|root|
         io::stdout().write_line("");
         io::stdout().write_line(#fmt("Search key: %?", root));
 
diff --git a/src/test/bench/msgsend-ring-new.rs b/src/test/bench/msgsend-ring-new.rs
index f65d995d6a8..daf67a9dccd 100644
--- a/src/test/bench/msgsend-ring-new.rs
+++ b/src/test/bench/msgsend-ring-new.rs
@@ -46,7 +46,7 @@ fn main(args: ~[str]) {
         let get_chan_chan = chan(get_chan);
         {
             let num_chan = num_chan.clone();
-            futures += ~[future::spawn {|move num_chan, move get_chan_chan|
+            futures += ~[do future::spawn {|move num_chan, move get_chan_chan|
                 let p = port();
                 get_chan_chan.send(chan(p));
                 thread_ring(i, msg_per_task, num_chan,  p)
diff --git a/src/test/bench/msgsend-ring.rs b/src/test/bench/msgsend-ring.rs
index fe02fe585ae..d8bffab57d7 100644
--- a/src/test/bench/msgsend-ring.rs
+++ b/src/test/bench/msgsend-ring.rs
@@ -45,7 +45,7 @@ fn main(args: ~[str]) {
         let get_chan = port();
         let get_chan_chan = chan(get_chan);
 
-        futures += ~[future::spawn {|copy num_chan, move get_chan_chan|
+        futures += ~[do future::spawn {|copy num_chan, move get_chan_chan|
             let p = port();
             get_chan_chan.send(chan(p));
             thread_ring(i, msg_per_task, num_chan,  p)
diff --git a/src/test/bench/msgsend.rs b/src/test/bench/msgsend.rs
index d1c396a73ac..e3546316a2e 100644
--- a/src/test/bench/msgsend.rs
+++ b/src/test/bench/msgsend.rs
@@ -30,7 +30,7 @@ fn server(requests: comm::port<request>, responses: comm::chan<uint>) {
 fn run(args: ~[str]) {
     let from_child = comm::port();
     let to_parent = comm::chan(from_child);
-    let to_child = task::spawn_listener {|po|
+    let to_child = do task::spawn_listener {|po|
         server(po, to_parent);
     };
     let size = option::get(uint::from_str(args[1]));
@@ -41,13 +41,13 @@ fn run(args: ~[str]) {
     for uint::range(0u, workers) {|_i|
         let builder = task::builder();
         vec::push(worker_results, task::future_result(builder));
-        task::run(builder) {||
+        do task::run(builder) {||
             for uint::range(0u, size / workers) {|_i|
                 comm::send(to_child, bytes(100u));
             }
         };
     }
-    vec::iter(worker_results) {|r| future::get(r); }
+    vec::iter(worker_results, {|r| future::get(r); });
     comm::send(to_child, stop);
     let result = comm::recv(from_child);
     let end = std::time::precise_time_s();
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index 498ae2a8afd..5ab0477c0c5 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -142,7 +142,7 @@ fn main(args: ~[str]) {
    let from_child = vec::map (sizes, { |_sz|     comm::port() });
    let to_parent  = vec::mapi(sizes, { |ii, _sz| comm::chan(from_child[ii]) });
    let to_child   = vec::mapi(sizes, fn@(ii: uint, sz: uint) -> comm::chan<~[u8]> {
-      ret task::spawn_listener { |from_parent|
+      ret do task::spawn_listener { |from_parent|
          make_sequence_processor(sz, from_parent, to_parent[ii]);
       };
    });
diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs
index b26b7747098..e3c78856bc7 100644
--- a/src/test/bench/shootout-mandelbrot.rs
+++ b/src/test/bench/shootout-mandelbrot.rs
@@ -158,12 +158,12 @@ fn main(args: ~[str]) {
 
     let writep = comm::port();
     let writech = comm::chan(writep);
-    task::spawn {||
+    do task::spawn {||
         writer(path, writech, size);
     };
     let ch = comm::recv(writep);
     for uint::range(0_u, size) {|j|
-        task::spawn {|| chanmb(j, size, ch);};
+        do task::spawn {|| chanmb(j, size, ch);};
         if j % yieldevery == 0_u {
             #debug("Y %u", j);
             task::yield();
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 28d8f1380d8..1045bafdb5c 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -32,15 +32,15 @@ fn fib(n: int) -> int {
         } else {
             let p = port();
             let ch = chan(p);
-            task::spawn {|| pfib(ch, n - 1); };
-            task::spawn {|| pfib(ch, n - 2); };
+            task::spawn({|| pfib(ch, n - 1); });
+            task::spawn({|| pfib(ch, n - 2); });
             send(c, recv(p) + recv(p));
         }
     }
 
     let p = port();
     let ch = chan(p);
-    let t = task::spawn {|| pfib(ch, n); };
+    let t = task::spawn({|| pfib(ch, n); });
     ret recv(p);
 }
 
@@ -73,7 +73,7 @@ fn stress(num_tasks: int) {
     for range(0, num_tasks) {|i|
         let builder = task::builder();
         results += ~[task::future_result(builder)];
-        task::run(builder) {|| stress_task(i); }
+        task::run(builder, {|| stress_task(i); });
     }
     for results.each {|r| future::get(r); }
 }
diff --git a/src/test/bench/shootout-threadring.rs b/src/test/bench/shootout-threadring.rs
index 96e47439bb3..b9bfc85ceed 100644
--- a/src/test/bench/shootout-threadring.rs
+++ b/src/test/bench/shootout-threadring.rs
@@ -10,7 +10,7 @@ fn start(+token: int) {
     let mut ch = comm::chan(p);
     for int::range(2, n_threads + 1) { |i|
         let id = n_threads + 2 - i;
-        let to_child = task::spawn_listener::<int> {|p, copy ch|
+        let to_child = do task::spawn_listener::<int> {|p, copy ch|
             roundtrip(id, p, ch)
         };
         ch = to_child;
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index 2149e6739ef..24ab027ef00 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -17,9 +17,9 @@ fn main() {
 }
 
 fn run(repeat: int, depth: int) {
-    iter::repeat(repeat as uint) { ||
+    do iter::repeat(repeat as uint) { ||
         #debug("starting %.4f", precise_time_s());
-        task::try { ||
+        do task::try { ||
             recurse_or_fail(depth, none)
         };
         #debug("stopping %.4f", precise_time_s());
diff --git a/src/test/bench/task-perf-one-million.rs b/src/test/bench/task-perf-one-million.rs
index a1028d40fd0..cdb16bffd6b 100644
--- a/src/test/bench/task-perf-one-million.rs
+++ b/src/test/bench/task-perf-one-million.rs
@@ -12,13 +12,13 @@ fn calc(children: uint, parent_ch: comm::chan<msg>) {
     let mut child_chs = ~[];
     let mut sum = 0;
 
-    iter::repeat (children) {||
-        task::spawn {||
+    do iter::repeat (children) {||
+        do task::spawn {||
             calc(0u, chan);
         };
     }
 
-    iter::repeat (children) {||
+    do iter::repeat (children) {||
         alt check comm::recv(port) {
           ready(child_ch) {
             vec::push(child_chs, child_ch);
@@ -30,13 +30,13 @@ fn calc(children: uint, parent_ch: comm::chan<msg>) {
 
     alt check comm::recv(port) {
         start {
-          vec::iter (child_chs) { |child_ch|
+          do vec::iter (child_chs) { |child_ch|
               comm::send(child_ch, start);
           }
         }
     }
 
-    iter::repeat (children) {||
+    do iter::repeat (children) {||
         alt check comm::recv(port) {
           done(child_sum) { sum += child_sum; }
         }
@@ -57,7 +57,7 @@ fn main(args: ~[str]) {
     let children = uint::from_str(args[1]).get();
     let port = comm::port();
     let chan = comm::chan(port);
-    task::spawn {||
+    do task::spawn {||
         calc(children, chan);
     };
     alt check comm::recv(port) {
diff --git a/src/test/bench/task-perf-spawnalot.rs b/src/test/bench/task-perf-spawnalot.rs
index abba33cdb17..15cb3a98635 100644
--- a/src/test/bench/task-perf-spawnalot.rs
+++ b/src/test/bench/task-perf-spawnalot.rs
@@ -1,7 +1,7 @@
 fn f(&&n: uint) {
     let mut i = 0u;
     while i < n {
-        task::try {|| g() };
+        do task::try {|| g() };
         i += 1u;
     }
 }
@@ -18,5 +18,5 @@ fn main(args: ~[str]) {
     };
     let n = uint::from_str(args[1]).get();
     let mut i = 0u;
-    while i < n { task::spawn {|| f(n); }; i += 1u; }
+    while i < n { task::spawn({|| f(n); }); i += 1u; }
 }
diff --git a/src/test/bench/task-perf-word-count-generic.rs b/src/test/bench/task-perf-word-count-generic.rs
index 470d2e3e097..1068e48467a 100644
--- a/src/test/bench/task-perf-word-count-generic.rs
+++ b/src/test/bench/task-perf-word-count-generic.rs
@@ -35,7 +35,7 @@ type joinable_task = port<()>;
 fn spawn_joinable(f: fn~()) -> joinable_task {
     let p = port();
     let c = chan(p);
-    task::spawn() {||
+    do task::spawn() {||
         f();
         c.send(());
     }
@@ -97,7 +97,7 @@ mod map_reduce {
     {
         let mut tasks = ~[];
         for inputs.each {|i|
-            tasks += ~[spawn_joinable {|| map_task(map, ctrl, i)}];
+            tasks += ~[spawn_joinable({|| map_task(map, ctrl, i)})];
         }
         ret tasks;
     }
@@ -208,7 +208,7 @@ mod map_reduce {
                     let ch = chan(p);
                     let r = reduce, kk = k;
                     tasks += ~[
-                        spawn_joinable {|| reduce_task(r, kk, ch) }
+                        spawn_joinable({|| reduce_task(r, kk, ch) })
                     ];
                     c = recv(p);
                     treemap::insert(reducers, k, c);
diff --git a/src/test/bench/task-perf-word-count.rs b/src/test/bench/task-perf-word-count.rs
index 58169ed1870..17fb9dab88e 100644
--- a/src/test/bench/task-perf-word-count.rs
+++ b/src/test/bench/task-perf-word-count.rs
@@ -64,7 +64,7 @@ mod map_reduce {
         for inputs.each {|i|
             let builder = task::builder();
             results += ~[task::future_result(builder)];
-            task::run(builder) {|| map_task(ctrl, i)}
+            do task::run(builder) {|| map_task(ctrl, i)}
         }
         ret results;
     }
@@ -162,7 +162,7 @@ mod map_reduce {
                     let ch = chan(p);
                     let builder = task::builder();
                     results += ~[task::future_result(builder)];
-                    task::run(builder) {||reduce_task(k, ch)}
+                    task::run(builder, {||reduce_task(k, ch)});
                     c = recv(p);
                     reducers.insert(k, c);
                   }
diff --git a/src/test/compile-fail/block-arg-as-stmt-with-value.rs b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
index 5729f24c064..b7e570b1b08 100644
--- a/src/test/compile-fail/block-arg-as-stmt-with-value.rs
+++ b/src/test/compile-fail/block-arg-as-stmt-with-value.rs
@@ -2,7 +2,7 @@
 fn compute1() -> float {
     let v = ~[0f, 1f, 2f, 3f];
 
-    vec::foldl(0f, v) { |x, y| x + y } - 10f
+    do vec::foldl(0f, v) { |x, y| x + y } - 10f
     //!^ ERROR mismatched types: expected `()`
 }
 
diff --git a/src/test/compile-fail/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck-assign-comp-idx.rs
index fc7f9ade067..c0fd5ae8e05 100644
--- a/src/test/compile-fail/borrowck-assign-comp-idx.rs
+++ b/src/test/compile-fail/borrowck-assign-comp-idx.rs
@@ -17,7 +17,7 @@ fn b() {
 
     let mut p = ~[mut 1];
 
-    borrow(p) {|| //! NOTE loan of mutable vec content granted here
+    do borrow(p) {|| //! NOTE loan of mutable vec content granted here
         p[0] = 5; //! ERROR assigning to mutable vec content prohibited due to outstanding loan
     }
 }
diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs
index b4d81aa09ae..663b6b2dd59 100644
--- a/src/test/compile-fail/borrowck-lend-flow.rs
+++ b/src/test/compile-fail/borrowck-lend-flow.rs
@@ -76,7 +76,7 @@ fn at_most_once_block() {
 
     let mut v = ~3, w = ~4;
     let mut _x = &mut w;
-    at_most_once {||
+    do at_most_once {||
         borrow(v); //! ERROR loan of mutable variable declared in an outer block as immutable conflicts with prior loan
         _x = &mut v; //! NOTE prior loan as mutable granted here
     }
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 0862af2e6fa..35743c6f200 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -5,7 +5,7 @@ fn borrow(v: &int, f: fn(x: &int)) {
 fn box_imm() {
     let mut v = ~3;
     let _w = &mut v; //! NOTE loan of mutable local variable granted here
-    task::spawn { |move v|
+    do task::spawn { |move v|
         //!^ ERROR moving out of mutable local variable prohibited due to outstanding loan
         #debug["v=%d", *v];
     }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
index a09d2e7a71b..387a5fb9fae 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
@@ -4,7 +4,7 @@ fn borrow(v: &int, f: fn(x: &int)) {
 
 fn box_imm() {
     let mut v = ~3;
-    borrow(v) { |w| //! NOTE loan of mutable local variable granted here
+    do borrow(v) { |w| //! NOTE loan of mutable local variable granted here
         v = ~4; //! ERROR assigning to mutable variable declared in an outer block prohibited due to outstanding loan
         assert *v == 3;
         assert *w == 4;
diff --git a/src/test/compile-fail/borrowck-loan-rcvr.rs b/src/test/compile-fail/borrowck-loan-rcvr.rs
index ec543bfc4f9..e057f2f53b8 100644
--- a/src/test/compile-fail/borrowck-loan-rcvr.rs
+++ b/src/test/compile-fail/borrowck-loan-rcvr.rs
@@ -19,7 +19,7 @@ fn a() {
     p.impurem();
 
     // But in this case we do not honor the loan:
-    p.blockm {||  //! NOTE loan of mutable local variable granted here
+    do p.blockm {||  //! NOTE loan of mutable local variable granted here
         p.x = 10; //! ERROR assigning to mutable field prohibited due to outstanding loan
     }
 }
diff --git a/src/test/compile-fail/borrowck-loan-vec-content.rs b/src/test/compile-fail/borrowck-loan-vec-content.rs
index 805adbda6af..7d5f1b4f3d6 100644
--- a/src/test/compile-fail/borrowck-loan-vec-content.rs
+++ b/src/test/compile-fail/borrowck-loan-vec-content.rs
@@ -8,13 +8,13 @@ fn takes_imm_elt(_v: &int, f: fn()) {
 
 fn has_mut_vec_and_does_not_try_to_change_it() {
     let v = ~[mut 1, 2, 3];
-    takes_imm_elt(&v[0]) {||
+    do takes_imm_elt(&v[0]) {||
     }
 }
 
 fn has_mut_vec_but_tries_to_change_it() {
     let v = ~[mut 1, 2, 3];
-    takes_imm_elt(&v[0]) {|| //! NOTE loan of mutable vec content granted here
+    do takes_imm_elt(&v[0]) {|| //! NOTE loan of mutable vec content granted here
         v[1] = 4; //! ERROR assigning to mutable vec content prohibited due to outstanding loan
     }
 }
@@ -25,7 +25,7 @@ fn takes_const_elt(_v: &const int, f: fn()) {
 
 fn has_mut_vec_and_tries_to_change_it() {
     let v = ~[mut 1, 2, 3];
-    takes_const_elt(&const v[0]) {||
+    do takes_const_elt(&const v[0]) {||
         v[1] = 4;
     }
 }
diff --git a/src/test/compile-fail/cap-clause-with-stack-closure.rs b/src/test/compile-fail/cap-clause-with-stack-closure.rs
index 4d9a77fb3d6..6012dd1ba25 100644
--- a/src/test/compile-fail/cap-clause-with-stack-closure.rs
+++ b/src/test/compile-fail/cap-clause-with-stack-closure.rs
@@ -3,12 +3,12 @@ fn bar(_f: @int) {}
 
 fn main() {
     let x = @3;
-    foo {|| bar(x); }
+    foo({|| bar(x); });
 
     let x = @3;
-    foo {|copy x| bar(x); } //! ERROR cannot capture values explicitly with a block closure
+    foo({|copy x| bar(x); }); //! ERROR cannot capture values explicitly with a block closure
 
     let x = @3;
-    foo {|move x| bar(x); } //! ERROR cannot capture values explicitly with a block closure
+    foo({|move x| bar(x); }); //! ERROR cannot capture values explicitly with a block closure
 }
 
diff --git a/src/test/compile-fail/do1.rs b/src/test/compile-fail/do1.rs
index 76a10c6d2f1..49ffcd86a5f 100644
--- a/src/test/compile-fail/do1.rs
+++ b/src/test/compile-fail/do1.rs
@@ -1,3 +1,3 @@
 fn main() {
-    let x = do y; //! ERROR: `do` must be followed by a block call
+    let x = do y; //! ERROR: expecting '{' but found
 }
diff --git a/src/test/compile-fail/issue-2149.rs b/src/test/compile-fail/issue-2149.rs
index af531a73038..01fe95f87c0 100644
--- a/src/test/compile-fail/issue-2149.rs
+++ b/src/test/compile-fail/issue-2149.rs
@@ -7,5 +7,5 @@ impl monad<A> for ~[A] {
    }
 }
 fn main() {
-    ["hi"].bind {|x| [x] };
+    ["hi"].bind({|x| [x] });
 }
\ No newline at end of file
diff --git a/src/test/compile-fail/issue-2151.rs b/src/test/compile-fail/issue-2151.rs
index a69b6df1106..44b0fe55ae4 100644
--- a/src/test/compile-fail/issue-2151.rs
+++ b/src/test/compile-fail/issue-2151.rs
@@ -1,5 +1,5 @@
 fn main() {
-    vec::iter(fail) {|i|
+    do vec::iter(fail) {|i|
         log (debug, i * 2);
         //!^ ERROR the type of this value must be known
    };
diff --git a/src/test/compile-fail/issue-2487-b.rs b/src/test/compile-fail/issue-2487-b.rs
index a1438c53187..4f1e337ce48 100644
--- a/src/test/compile-fail/issue-2487-b.rs
+++ b/src/test/compile-fail/issue-2487-b.rs
@@ -6,7 +6,7 @@ class socket {
     drop { }
 
     fn set_identity()  {
-      closure { ||
+      do closure { ||
         setsockopt_bytes(self.sock) //! ERROR copying a noncopyable value
       } 
     }
diff --git a/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs b/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs
index d646d6db07f..cf22f3164ed 100644
--- a/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs
+++ b/src/test/compile-fail/kindck-implicit-close-over-mut-var.rs
@@ -3,7 +3,7 @@ fn use(_i: int) {}
 fn foo() {
     // Here, i is *moved* into the closure: Not actually OK
     let mut i = 0;
-    task::spawn {||
+    do task::spawn {||
         use(i); //! ERROR mutable variables cannot be implicitly captured
     }
 }
@@ -13,7 +13,7 @@ fn bar() {
     // is mutable: bad
     let mut i = 0;
     while i < 10 {
-        task::spawn {||
+        do task::spawn {||
             use(i); //! ERROR mutable variables cannot be implicitly captured
         }
         i += 1;
@@ -24,7 +24,7 @@ fn car() {
     // Here, i is mutable, but *explicitly* copied:
     let mut i = 0;
     while i < 10 {
-        task::spawn {|copy i|
+        do task::spawn {|copy i|
             use(i);
         }
         i += 1;
diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs
index 24ffad9730d..30b6f85045e 100644
--- a/src/test/compile-fail/liveness-issue-2163.rs
+++ b/src/test/compile-fail/liveness-issue-2163.rs
@@ -1,5 +1,5 @@
 fn main(_s: ~[str]) {
     let a: ~[int] = ~[];
-    vec::each(a) { |_x| //! ERROR not all control paths return a value
+    do vec::each(a) { |_x| //! ERROR not all control paths return a value
     }
 }
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index f8822da9577..e9cc27c59ce 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -6,7 +6,7 @@ fn main() {
     let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = arc::arc(v);
     
-    task::spawn() {||
+    do task::spawn() {||
         let v = *arc::get(&arc_v);
         assert v[3] == 4;
     };
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index 4b72b8c7a9b..a4882f05b0b 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -4,7 +4,7 @@ fn main() {
     let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     let arc_v = arc::arc(v);
 
-    task::spawn() {|move arc_v| //! NOTE move of variable occurred here
+    do task::spawn() {|move arc_v| //! NOTE move of variable occurred here
         let v = *arc::get(&arc_v);
         assert v[3] == 4;
     };
diff --git a/src/test/compile-fail/no-send-res-ports.rs b/src/test/compile-fail/no-send-res-ports.rs
index 3f8fde8927e..4b060c7a593 100644
--- a/src/test/compile-fail/no-send-res-ports.rs
+++ b/src/test/compile-fail/no-send-res-ports.rs
@@ -7,7 +7,7 @@ fn main() {
    
     let x = ~mut some(foo(comm::port()));
 
-    task::spawn {|move x| //! ERROR not a sendable value
+    do task::spawn {|move x| //! ERROR not a sendable value
         let mut y = none;
         *x <-> y;
         log(error, y);
diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs
index b6a16c33a2b..9b79840b5ed 100644
--- a/src/test/compile-fail/private-method.rs
+++ b/src/test/compile-fail/private-method.rs
@@ -2,7 +2,7 @@
 class cat {
   priv {
     let mut meows : uint;
-    fn nap() { uint::range(1u, 10000u) {|_i|}}
+    fn nap() { uint::range(1u, 10000u, {|_i|})}
   }
 
   let how_hungry : int;
diff --git a/src/test/compile-fail/pure-higher-order.rs b/src/test/compile-fail/pure-higher-order.rs
index 22d43c27e1a..8dba6b695c9 100644
--- a/src/test/compile-fail/pure-higher-order.rs
+++ b/src/test/compile-fail/pure-higher-order.rs
@@ -9,7 +9,7 @@ pure fn range(from: uint, to: uint, f: fn(uint)) {
 }
 
 pure fn range2(from: uint, to: uint, f: fn(uint)) {
-    range(from, to) { |i|
+    do range(from, to) { |i|
         f(i*2u);
     }
 }
@@ -31,7 +31,7 @@ pure fn range6(from: uint, to: uint, x: @{f: fn(uint)}) {
 }
 
 pure fn range7(from: uint, to: uint) {
-    range(from, to) { |i|
+    do range(from, to) { |i|
         print(i); //! ERROR access to impure function prohibited in pure context
     }
 }
diff --git a/src/test/compile-fail/regions-addr-of-upvar-self.rs b/src/test/compile-fail/regions-addr-of-upvar-self.rs
index b0cd97d24d3..5c538481b0f 100644
--- a/src/test/compile-fail/regions-addr-of-upvar-self.rs
+++ b/src/test/compile-fail/regions-addr-of-upvar-self.rs
@@ -6,7 +6,7 @@ class dog {
     }
 
     fn chase_cat() {
-        uint::range(0u, 10u) { |i|
+        do uint::range(0u, 10u) { |i|
             let p: &static.mut uint = &mut self.food; //! ERROR mismatched types
             *p = 3u;
         }
diff --git a/src/test/compile-fail/regions-escape-loop-via-vec.rs b/src/test/compile-fail/regions-escape-loop-via-vec.rs
index b7ce9a9c4d6..d6d39041671 100644
--- a/src/test/compile-fail/regions-escape-loop-via-vec.rs
+++ b/src/test/compile-fail/regions-escape-loop-via-vec.rs
@@ -8,7 +8,7 @@ fn broken() -> int {
         y += ~[&mut z];
         x += 1;
     }
-    vec::foldl(0, y) {|v, p| v + *p }
+    vec::foldl(0, y, {|v, p| v + *p })
     //!^ ERROR reference is not valid
     //!^^ ERROR reference is not valid
     //!^^^ ERROR reference is not valid
diff --git a/src/test/compile-fail/regions-scoping.rs b/src/test/compile-fail/regions-scoping.rs
index aea02babfa0..25bd6611d40 100644
--- a/src/test/compile-fail/regions-scoping.rs
+++ b/src/test/compile-fail/regions-scoping.rs
@@ -1,7 +1,7 @@
 fn with<T>(t: T, f: fn(T)) { f(t) }
 
 fn nested(x: &x.int) {  // (1)
-    with(
+    do with(
         fn&(x: &x.int, // Refers to the region `x` at (1)
             y: &y.int, // A fresh region `y` (2)
             z: fn(x: &x.int, // Refers to `x` at (1)
@@ -26,17 +26,17 @@ fn nested(x: &x.int) {  // (1)
         }
     ) {|foo|
 
-        let a: &x.int = foo(x, x) { |_x, _y, z| z };
-        let b: &x.int = foo(x, a) { |_x, _y, z| z };
-        let c: &x.int = foo(a, a) { |_x, _y, z| z };
+        let a: &x.int = foo(x, x, { |_x, _y, z| z });
+        let b: &x.int = foo(x, a, { |_x, _y, z| z });
+        let c: &x.int = foo(a, a, { |_x, _y, z| z });
 
         let z = 3i;
-        let d: &x.int = foo(x, x) { |_x, _y, z| z };
-        let e: &x.int = foo(x, &z) { |_x, _y, z| z };
-        let f: &x.int = foo(&z, &z) { |_x, _y, z| z }; //! ERROR mismatched types: expected `&x.int` but found
+        let d: &x.int = foo(x, x, { |_x, _y, z| z });
+        let e: &x.int = foo(x, &z, { |_x, _y, z| z });
+        let f: &x.int = foo(&z, &z, { |_x, _y, z| z }); //! ERROR mismatched types: expected `&x.int` but found
 
-        foo(x, &z) { |x, _y, _z| x }; //! ERROR mismatched types: expected `&z.int` but found `&x.int`
-        foo(x, &z) { |_x, y, _z| y }; //! ERROR mismatched types: expected `&z.int` but found `&<block at
+        foo(x, &z, { |x, _y, _z| x }); //! ERROR mismatched types: expected `&z.int` but found `&x.int`
+        foo(x, &z, { |_x, y, _z| y }); //! ERROR mismatched types: expected `&z.int` but found `&<block at
     }
 }
 
diff --git a/src/test/compile-fail/vec-concat-bug.rs b/src/test/compile-fail/vec-concat-bug.rs
index 1cc38daa869..cad55808577 100644
--- a/src/test/compile-fail/vec-concat-bug.rs
+++ b/src/test/compile-fail/vec-concat-bug.rs
@@ -2,10 +2,10 @@ fn concat<T: copy>(v: ~[const ~[const T]]) -> ~[T] {
     let mut r = ~[];
 
     // Earlier versions of our type checker accepted this:
-    vec::iter(v) {|&&inner: ~[T]|
+    vec::iter(v, {|&&inner: ~[T]|
         //!^ ERROR values differ in mutability
         r += inner;
-    }
+    });
 
     ret r;
 }
diff --git a/src/test/pretty/block-arg-disambig.rs b/src/test/pretty/block-arg-disambig.rs
index e57c7be48a9..d70f4fdfa4a 100644
--- a/src/test/pretty/block-arg-disambig.rs
+++ b/src/test/pretty/block-arg-disambig.rs
@@ -1,2 +1,2 @@
 fn blk1(b: fn()) -> fn@() { ret fn@() { }; }
-fn test1() { (blk1 {|| #debug["hi"]; })(); }
+fn test1() { (do blk1 {|| #debug["hi"]; })(); }
diff --git a/src/test/pretty/disamb-stmt-expr.rs b/src/test/pretty/disamb-stmt-expr.rs
index b525d0a2da5..f48fef31b33 100644
--- a/src/test/pretty/disamb-stmt-expr.rs
+++ b/src/test/pretty/disamb-stmt-expr.rs
@@ -6,5 +6,5 @@
 
 fn id(f: fn() -> int) -> int { f() }
 
-fn wsucc(n: int) -> int { (id {|| 1 }) - 0 }
+fn wsucc(n: int) -> int { (do id {|| 1 }) - 0 }
 fn main() { }
diff --git a/src/test/run-fail/bug-2470-bounds-check-overflow.rs b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
index 2adac38436d..7d0f5c0a391 100644
--- a/src/test/run-fail/bug-2470-bounds-check-overflow.rs
+++ b/src/test/run-fail/bug-2470-bounds-check-overflow.rs
@@ -9,7 +9,7 @@ fn main() {
     // huge).
 
     let x = ~[1u,2u,3u];
-    vec::unpack_slice(x) {|p, _len|
+    do vec::unpack_slice(x) {|p, _len|
         let base = p as uint;                     // base = 0x1230 say
         let idx = base / sys::size_of::<uint>();  // idx  = 0x0246 say
         #error("ov1 base = 0x%x", base);
diff --git a/src/test/run-fail/crust-fail.rs b/src/test/run-fail/crust-fail.rs
index 7b844cc3b47..015e609af0d 100644
--- a/src/test/run-fail/crust-fail.rs
+++ b/src/test/run-fail/crust-fail.rs
@@ -21,8 +21,8 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    iter::repeat(10u) {||
-        task::spawn {||
+    do iter::repeat(10u) {||
+        do task::spawn {||
             let result = count(5u);
             #debug("result = %?", result);
             fail;
diff --git a/src/test/run-fail/for-each-loop-fail.rs b/src/test/run-fail/for-each-loop-fail.rs
index cdb054a4e8d..3f301d98007 100644
--- a/src/test/run-fail/for-each-loop-fail.rs
+++ b/src/test/run-fail/for-each-loop-fail.rs
@@ -1,4 +1,4 @@
 // error-pattern:moop
 use std;
 import uint;
-fn main() { uint::range(0u, 10u) {|_i| fail "moop"; } }
+fn main() { uint::range(0u, 10u, {|_i| fail "moop"; }); }
diff --git a/src/test/run-fail/issue-2156.rs b/src/test/run-fail/issue-2156.rs
index 90ed994ee8f..6784d4e52b6 100644
--- a/src/test/run-fail/issue-2156.rs
+++ b/src/test/run-fail/issue-2156.rs
@@ -4,7 +4,7 @@ use std;
 import io::{reader, reader_util};
 
 fn main() {
-    io::with_str_reader("") { |rdr|
+    do io::with_str_reader("") { |rdr|
         alt rdr.read_char() { '=' { } _ { fail } }
     }
 }
diff --git a/src/test/run-fail/linked-failure.rs b/src/test/run-fail/linked-failure.rs
index 62ecac925bb..89e0f566244 100644
--- a/src/test/run-fail/linked-failure.rs
+++ b/src/test/run-fail/linked-failure.rs
@@ -10,6 +10,6 @@ fn child() { assert (1 == 2); }
 
 fn main() {
     let p = port::<int>();
-    task::spawn {|| child(); };
+    task::spawn({|| child(); });
     let x = recv(p);
 }
diff --git a/src/test/run-fail/linked-failure2.rs b/src/test/run-fail/linked-failure2.rs
index 5350159475c..6f8c480b44e 100644
--- a/src/test/run-fail/linked-failure2.rs
+++ b/src/test/run-fail/linked-failure2.rs
@@ -11,6 +11,6 @@ fn child() { fail; }
 
 fn main() {
     let p = port::<int>();
-    task::spawn {|| child(); };
+    task::spawn({|| child(); });
     task::yield();
 }
diff --git a/src/test/run-fail/linked-failure3.rs b/src/test/run-fail/linked-failure3.rs
index 4c807712c65..e050dac28ed 100644
--- a/src/test/run-fail/linked-failure3.rs
+++ b/src/test/run-fail/linked-failure3.rs
@@ -10,12 +10,12 @@ fn grandchild() { fail "grandchild dies"; }
 
 fn child() {
     let p = port::<int>();
-    task::spawn {|| grandchild(); };
+    task::spawn({|| grandchild(); });
     let x = recv(p);
 }
 
 fn main() {
     let p = port::<int>();
-    task::spawn {|| child(); };
+    task::spawn({|| child(); });
     let x = recv(p);
 }
diff --git a/src/test/run-fail/linked-failure4.rs b/src/test/run-fail/linked-failure4.rs
index 629cc925749..d80669a1e6f 100644
--- a/src/test/run-fail/linked-failure4.rs
+++ b/src/test/run-fail/linked-failure4.rs
@@ -10,7 +10,7 @@ fn child() { assert (1 == 2); }
 
 fn parent() {
     let p = port::<int>();
-    task::spawn {|| child(); };
+    task::spawn({|| child(); });
     let x = recv(p);
 }
 
@@ -22,6 +22,6 @@ fn sleeper() {
 }
 
 fn main() {
-    task::spawn {|| sleeper(); };
-    task::spawn {|| parent(); };
+    task::spawn({|| sleeper(); });
+    task::spawn({|| parent(); });
 }
\ No newline at end of file
diff --git a/src/test/run-fail/morestack2.rs b/src/test/run-fail/morestack2.rs
index d68e9c49789..1d9419ccae3 100644
--- a/src/test/run-fail/morestack2.rs
+++ b/src/test/run-fail/morestack2.rs
@@ -34,7 +34,7 @@ class and_then_get_big_again {
 }
 
 fn main() {
-    task::spawn {||
+    do task::spawn {||
         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 0f0aea5ccd1..cfae8dc9182 100644
--- a/src/test/run-fail/morestack3.rs
+++ b/src/test/run-fail/morestack3.rs
@@ -27,7 +27,7 @@ class and_then_get_big_again {
 }
 
 fn main() {
-    task::spawn {||
+    do task::spawn {||
         getbig_and_fail(400);
     };
 }
\ No newline at end of file
diff --git a/src/test/run-fail/morestack4.rs b/src/test/run-fail/morestack4.rs
index b1c86d5110a..c3deca6f080 100644
--- a/src/test/run-fail/morestack4.rs
+++ b/src/test/run-fail/morestack4.rs
@@ -20,7 +20,7 @@ class and_then_get_big_again {
 }
 
 fn main() {
-    task::spawn {||
+    do task::spawn {||
         getbig_and_fail(1);
     };
 }
\ No newline at end of file
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 2c2665446cd..30fcfdc5977 100644
--- a/src/test/run-fail/rt-set-exit-status-fail2.rs
+++ b/src/test/run-fail/rt-set-exit-status-fail2.rs
@@ -13,7 +13,7 @@ class r {
 
 fn main() {
     log(error, "whatever");
-    task::spawn {||
+    do task::spawn {||
       let i = r(5);
     };
     fail;
diff --git a/src/test/run-fail/small-negative-indexing.rs b/src/test/run-fail/small-negative-indexing.rs
index 0d73cc3e6c5..96f0c12c760 100644
--- a/src/test/run-fail/small-negative-indexing.rs
+++ b/src/test/run-fail/small-negative-indexing.rs
@@ -1,6 +1,6 @@
 // error-pattern:bounds check
 fn main() {
-    let v = vec::from_fn(1024u) {|n| n};
+    let v = vec::from_fn(1024u, {|n| n});
     // this should trip a bounds check
     log(error, v[-1i8]);
 }
diff --git a/src/test/run-fail/spawnfail.rs b/src/test/run-fail/spawnfail.rs
index 8d342d7fe74..896cf7902b2 100644
--- a/src/test/run-fail/spawnfail.rs
+++ b/src/test/run-fail/spawnfail.rs
@@ -8,5 +8,5 @@ fn main() {
     fn f() {
         fail;
     }
-    task::spawn {|| f(); };
+    task::spawn({|| f(); });
 }
\ No newline at end of file
diff --git a/src/test/run-fail/task-comm-recv-block.rs b/src/test/run-fail/task-comm-recv-block.rs
index 50a32ed296c..fcfc2046d9d 100644
--- a/src/test/run-fail/task-comm-recv-block.rs
+++ b/src/test/run-fail/task-comm-recv-block.rs
@@ -10,7 +10,7 @@ fn goodfail() {
 }
 
 fn main() {
-    task::spawn {|| goodfail(); };
+    task::spawn({|| goodfail(); });
     let po = comm::port();
     // We shouldn't be able to get past this recv since there's no
     // message available
diff --git a/src/test/run-fail/unwind-iter.rs b/src/test/run-fail/unwind-iter.rs
index bc272ab3b97..5c504c8ba59 100644
--- a/src/test/run-fail/unwind-iter.rs
+++ b/src/test/run-fail/unwind-iter.rs
@@ -7,5 +7,5 @@ fn x(it: fn(int)) {
 
 fn main() {
     let a = @0;
-    x {|_i|};
+    x({|_i|});
 }
\ No newline at end of file
diff --git a/src/test/run-fail/unwind-iter2.rs b/src/test/run-fail/unwind-iter2.rs
index e1e93ac94cd..1bf4cbbc109 100644
--- a/src/test/run-fail/unwind-iter2.rs
+++ b/src/test/run-fail/unwind-iter2.rs
@@ -6,5 +6,5 @@ fn x(it: fn(int)) {
 }
 
 fn main() {
-    x {|_x| fail; };
+    x({|_x| fail; });
 }
\ No newline at end of file
diff --git a/src/test/run-pass-fulldeps/qquote.rs b/src/test/run-pass-fulldeps/qquote.rs
index 2b595dcb6b3..ee28c18e6da 100644
--- a/src/test/run-pass-fulldeps/qquote.rs
+++ b/src/test/run-pass-fulldeps/qquote.rs
@@ -79,8 +79,8 @@ fn main() {
     // issue #1926
     let s = #ast(expr){__s};
     let e = #ast(expr){__e};
-    let call = #ast(expr){$(s).foo {|__e| $(e)}};
-    check_pp(call, pprust::print_expr, "__s.foo {|__e| __e }")
+    let call = #ast(expr){$(s).foo({|__e| $(e)})};
+    check_pp(call, pprust::print_expr, "__s.foo({|__e| __e })")
 }
 
 fn check_pp<T>(expr: T, f: fn(pprust::ps, T), expect: str) {
diff --git a/src/test/run-pass/alt-phi.rs b/src/test/run-pass/alt-phi.rs
index 58b19eeeed2..2a995e4b47f 100644
--- a/src/test/run-pass/alt-phi.rs
+++ b/src/test/run-pass/alt-phi.rs
@@ -7,7 +7,7 @@ fn foo(it: fn(int)) { it(10); }
 fn main() {
     let mut x = true;
     alt a {
-      a { x = true; foo {|_i|} }
+      a { x = true; foo({|_i|}) }
       b { x = false; }
       c { x = false; }
     }
diff --git a/src/test/run-pass/auto_serialize.rs b/src/test/run-pass/auto_serialize.rs
index 6054091db35..1fe8dc77ac6 100644
--- a/src/test/run-pass/auto_serialize.rs
+++ b/src/test/run-pass/auto_serialize.rs
@@ -18,7 +18,7 @@ fn test_ser_and_deser<A>(a1: A,
 
     // check the pretty printer:
     io_ser_fn(io::stdout(), a1);
-    let s = io::with_str_writer {|w| io_ser_fn(w, a1) };
+    let s = io::with_str_writer({|w| io_ser_fn(w, a1) });
     #debug["s == %?", s];
     assert s == expected;
 
diff --git a/src/test/run-pass/basic-1.rs b/src/test/run-pass/basic-1.rs
index 55a5ac7314c..a361f980408 100644
--- a/src/test/run-pass/basic-1.rs
+++ b/src/test/run-pass/basic-1.rs
@@ -12,8 +12,8 @@ fn a(c: chan<int>) { send(c, 10); }
 fn main() {
     let p = port();
     let ch = chan(p);
-    task::spawn {|| a(ch); };
-    task::spawn {|| a(ch); };
+    task::spawn({|| a(ch); });
+    task::spawn({|| a(ch); });
     let mut n: int = 0;
     n = recv(p);
     n = recv(p);
diff --git a/src/test/run-pass/basic-2.rs b/src/test/run-pass/basic-2.rs
index e45ff2c4c71..51653c5514e 100644
--- a/src/test/run-pass/basic-2.rs
+++ b/src/test/run-pass/basic-2.rs
@@ -13,8 +13,8 @@ fn a(c: chan<int>) { #debug("task a0"); #debug("task a1"); send(c, 10); }
 fn main() {
     let p = port();
     let ch = chan(p);
-    task::spawn {|| a(ch); };
-    task::spawn {|| b(ch); };
+    task::spawn({|| a(ch); });
+    task::spawn({|| b(ch); });
     let mut n: int = 0;
     n = recv(p);
     n = recv(p);
diff --git a/src/test/run-pass/basic.rs b/src/test/run-pass/basic.rs
index 9a53eb358e9..54bc671dbff 100644
--- a/src/test/run-pass/basic.rs
+++ b/src/test/run-pass/basic.rs
@@ -32,8 +32,8 @@ fn main() {
     let s: str = "hello there";
     let p = comm::port();
     let ch = comm::chan(p);
-    task::spawn {|| a(ch); };
-    task::spawn {|| b(ch); };
+    task::spawn({|| a(ch); });
+    task::spawn({|| b(ch); });
     let mut x: int = 10;
     x = g(n, s);
     log(debug, x);
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
index f1c94e37bec..7ba4698016b 100644
--- 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
@@ -2,7 +2,7 @@ fn main() {
     let v = ~[-1f, 0f, 1f, 2f, 3f];
 
     // Trailing expressions require parentheses:
-    let y = vec::foldl(0f, v) { |x, y| x + y } + 10f;
+    let y = vec::foldl(0f, v, { |x, y| x + y }) + 10f;
 
     assert y == 15f;
 }
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
index 0742c08b60a..65d03610aeb 100644
--- 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
@@ -1,6 +1,6 @@
 fn main() {
     fn f(i: fn() -> uint) -> uint { i() }
     let v = ~[-1f, 0f, 1f, 2f, 3f];
-    let z = vec::foldl(f, v) { |x, _y| x } { || 22u };
+    let z = do do vec::foldl(f, v) { |x, _y| x } { || 22u };
     assert z == 22u;
 }
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
index 31da3cb1045..d77b1bf0e0c 100644
--- 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
@@ -1,6 +1,6 @@
 fn main() {
     fn f(i: uint) -> uint { i }
     let v = ~[-1f, 0f, 1f, 2f, 3f];
-    let z = vec::foldl(f, v) { |x, _y| x } (22u);
+    let z = do vec::foldl(f, v) { |x, _y| x } (22u);
     assert z == 22u;
 }
diff --git a/src/test/run-pass/block-arg-in-parentheses.rs b/src/test/run-pass/block-arg-in-parentheses.rs
index 1237e0888a6..701acd23bd2 100644
--- a/src/test/run-pass/block-arg-in-parentheses.rs
+++ b/src/test/run-pass/block-arg-in-parentheses.rs
@@ -1,20 +1,20 @@
 fn w_semi(v: ~[int]) -> int {
     // the semicolon causes compiler not to
     // complain about the ignored return value:
-    vec::foldl(0, v) {|x,y| x+y};
+    do vec::foldl(0, v) {|x,y| x+y};
     -10
 }
 
 fn w_paren1(v: ~[int]) -> int {
-    (vec::foldl(0, v) {|x,y| x+y}) - 10
+    (do vec::foldl(0, v) {|x,y| x+y}) - 10
 }
 
 fn w_paren2(v: ~[int]) -> int {
-    (vec::foldl(0, v) {|x,y| x+y} - 10)
+    (do vec::foldl(0, v) {|x,y| x+y} - 10)
 }
 
 fn w_ret(v: ~[int]) -> int {
-    ret vec::foldl(0, v) {|x,y| x+y} - 10;
+    ret do vec::foldl(0, v) {|x,y| x+y} - 10;
 }
 
 fn main() {
diff --git a/src/test/run-pass/block-arg-used-as-any.rs b/src/test/run-pass/block-arg-used-as-any.rs
index a13e03d94ce..fbf60b6ffb3 100644
--- a/src/test/run-pass/block-arg-used-as-any.rs
+++ b/src/test/run-pass/block-arg-used-as-any.rs
@@ -3,6 +3,6 @@ fn call_any(f: fn() -> uint) -> uint {
 }
 
 fn main() {
-    let x_r = call_any {|| 22u };
+    let x_r = do call_any {|| 22u };
     assert x_r == 22u;
 }
diff --git a/src/test/run-pass/block-arg.rs b/src/test/run-pass/block-arg.rs
index a0afa8d462c..14794df5190 100644
--- a/src/test/run-pass/block-arg.rs
+++ b/src/test/run-pass/block-arg.rs
@@ -3,33 +3,33 @@ fn main() {
     let v = ~[-1f, 0f, 1f, 2f, 3f];
 
     // Statement form does not require parentheses:
-    vec::iter(v) { |i|
+    vec::iter(v, { |i|
         log(info, i);
-    }
+    });
 
     // Usable at all:
-    let mut any_negative = vec::any(v) { |e| float::is_negative(e) };
+    let mut any_negative = vec::any(v, { |e| float::is_negative(e) });
     assert any_negative;
 
     // Higher precedence than assignments:
-    any_negative = vec::any(v) { |e| float::is_negative(e) };
+    any_negative = vec::any(v, { |e| float::is_negative(e) });
     assert any_negative;
 
     // Higher precedence than unary operations:
-    let abs_v = vec::map(v) { |e| float::abs(e) };
-    assert vec::all(abs_v) { |e| float::is_nonnegative(e) };
-    assert !vec::any(abs_v) { |e| float::is_negative(e) };
+    let abs_v = vec::map(v, { |e| float::abs(e) });
+    assert vec::all(abs_v, { |e| float::is_nonnegative(e) });
+    assert !vec::any(abs_v, { |e| float::is_negative(e) });
 
     // Usable in funny statement-like forms:
-    if !vec::any(v) { |e| float::is_positive(e) } {
+    if !vec::any(v, { |e| float::is_positive(e) }) {
         assert false;
     }
-    alt vec::all(v) { |e| float::is_negative(e) } {
+    alt vec::all(v, { |e| float::is_negative(e) }) {
         true { fail "incorrect answer."; }
         false { }
     }
     alt 3 {
-      _ if vec::any(v) { |e| float::is_negative(e) } {
+      _ if vec::any(v, { |e| float::is_negative(e) }) {
       }
       _ {
         fail "wrong answer.";
@@ -39,8 +39,8 @@ fn main() {
 
     // Lower precedence than binary operations:
     let w = vec::foldl(0f, v, { |x, y| x + y }) + 10f;
-    let y = vec::foldl(0f, v) { |x, y| x + y } + 10f;
-    let z = 10f + vec::foldl(0f, v) { |x, y| x + y };
+    let y = vec::foldl(0f, v, { |x, y| x + y }) + 10f;
+    let z = 10f + vec::foldl(0f, v, { |x, y| x + y });
     assert w == y;
     assert y == z;
 
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index 08e102af4e8..e7606a39304 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -4,7 +4,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 
 fn test1(x: @~int) {
     // Right now, at least, this induces a copy of the unique pointer:
-    borrow({*x}) { |p|
+    do borrow({*x}) { |p|
         let x_a = ptr::addr_of(**x);
         assert (x_a as uint) != (p as uint);
         assert unsafe{*x_a} == *p;
diff --git a/src/test/run-pass/borrowck-preserve-box-in-field.rs b/src/test/run-pass/borrowck-preserve-box-in-field.rs
index 09353e3d39f..f2517d17694 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-field.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-field.rs
@@ -9,7 +9,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 
 fn main() {
     let mut x = @{f: ~3};
-    borrow(x.f) {|b_x|
+    do borrow(x.f) {|b_x|
         assert *b_x == 3;
         assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
         x = @{f: ~4};
diff --git a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
index 475e5eaea8c..431e456575b 100644
--- a/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
+++ b/src/test/run-pass/borrowck-preserve-box-in-uniq.rs
@@ -9,7 +9,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 
 fn main() {
     let mut x = ~mut @{f: ~3};
-    borrow(x.f) {|b_x|
+    do borrow(x.f) {|b_x|
         assert *b_x == 3;
         assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
         *x = @{f: ~4};
diff --git a/src/test/run-pass/borrowck-preserve-box.rs b/src/test/run-pass/borrowck-preserve-box.rs
index d4d2f5a2055..2a2edbac259 100644
--- a/src/test/run-pass/borrowck-preserve-box.rs
+++ b/src/test/run-pass/borrowck-preserve-box.rs
@@ -9,7 +9,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 
 fn main() {
     let mut x = @3;
-    borrow(x) {|b_x|
+    do borrow(x) {|b_x|
         assert *b_x == 3;
         assert ptr::addr_of(*x) == ptr::addr_of(*b_x);
         x = @22;
diff --git a/src/test/run-pass/borrowck-preserve-expl-deref.rs b/src/test/run-pass/borrowck-preserve-expl-deref.rs
index 0778b895137..80f009e525d 100644
--- a/src/test/run-pass/borrowck-preserve-expl-deref.rs
+++ b/src/test/run-pass/borrowck-preserve-expl-deref.rs
@@ -9,7 +9,7 @@ fn borrow(x: &int, f: fn(x: &int)) {
 
 fn main() {
     let mut x = @{f: ~3};
-    borrow((*x).f) {|b_x|
+    do borrow((*x).f) {|b_x|
         assert *b_x == 3;
         assert ptr::addr_of(*x.f) == ptr::addr_of(*b_x);
         x = @{f: ~4};
diff --git a/src/test/run-pass/cci_impl_exe.rs b/src/test/run-pass/cci_impl_exe.rs
index c5811d775c0..6a62f111609 100644
--- a/src/test/run-pass/cci_impl_exe.rs
+++ b/src/test/run-pass/cci_impl_exe.rs
@@ -8,7 +8,7 @@ fn main() {
     //let bt0 = sys::frame_address();
     //#debug["%?", bt0];
 
-    3u.to(10u) {|i|
+    do 3u.to(10u) {|i|
         io::print(#fmt["%u\n", i]);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index c76602a28e0..84ca7015583 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -6,7 +6,7 @@ use cci_iter_lib;
 fn main() {
     //let bt0 = sys::rusti::frame_address(1u32);
     //#debug["%?", bt0];
-    cci_iter_lib::iter(~[1, 2, 3]) {|i|
+    do cci_iter_lib::iter(~[1, 2, 3]) {|i|
         io::print(#fmt["%d", i]);
         //assert bt0 == sys::rusti::frame_address(2u32);
     }
diff --git a/src/test/run-pass/cci_no_inline_exe.rs b/src/test/run-pass/cci_no_inline_exe.rs
index 415baf011ae..ddd70ff7960 100644
--- a/src/test/run-pass/cci_no_inline_exe.rs
+++ b/src/test/run-pass/cci_no_inline_exe.rs
@@ -12,7 +12,7 @@ fn main() {
     // actually working.
     //let bt0 = sys::frame_address();
     //#debug["%?", bt0];
-    iter(~[1u, 2u, 3u]) {|i|
+    do iter(~[1u, 2u, 3u]) {|i|
         io::print(#fmt["%u\n", i]);
 
         //let bt1 = sys::frame_address();
diff --git a/src/test/run-pass/chan-leak.rs b/src/test/run-pass/chan-leak.rs
index 152f74d683d..eebc93fd514 100644
--- a/src/test/run-pass/chan-leak.rs
+++ b/src/test/run-pass/chan-leak.rs
@@ -24,7 +24,7 @@ fn request_task(c: chan<ctx>) {
 fn new_cx() -> ctx {
     let p = port();
     let ch = chan(p);
-    let t = task::spawn {|| request_task(ch); };
+    let t = task::spawn({|| request_task(ch); });
     let mut cx: ctx;
     cx = recv(p);
     ret cx;
diff --git a/src/test/run-pass/child-outlives-parent.rs b/src/test/run-pass/child-outlives-parent.rs
index 4eabfa478a7..97a53856ec7 100644
--- a/src/test/run-pass/child-outlives-parent.rs
+++ b/src/test/run-pass/child-outlives-parent.rs
@@ -5,4 +5,4 @@ import task;
 
 fn child2(&&s: str) { }
 
-fn main() { let x = task::spawn {|| child2("hi"); }; }
+fn main() { let x = task::spawn({|| child2("hi"); }); }
diff --git a/src/test/run-pass/class-iface-bounded-param.rs b/src/test/run-pass/class-iface-bounded-param.rs
index 63a38e8dda4..5613517102e 100644
--- a/src/test/run-pass/class-iface-bounded-param.rs
+++ b/src/test/run-pass/class-iface-bounded-param.rs
@@ -10,7 +10,7 @@ class keys<K: copy, V: copy, M: copy map<K,V>>
         self.map = map;
     }
 
-    fn each(blk: fn(K) -> bool) { self.map.each { |k, _v| blk(k)} }
+    fn each(blk: fn(K) -> bool) { self.map.each({ |k, _v| blk(k)}) }
     fn size_hint() -> option<uint> { some(self.map.size()) }
     fn eachi(blk: fn(uint, K) -> bool) { iter::eachi(self, blk) }
 }
diff --git a/src/test/run-pass/class-implements-multiple-ifaces.rs b/src/test/run-pass/class-implements-multiple-ifaces.rs
index 1227de3f870..1feddf0c3e1 100644
--- a/src/test/run-pass/class-implements-multiple-ifaces.rs
+++ b/src/test/run-pass/class-implements-multiple-ifaces.rs
@@ -53,7 +53,7 @@ class cat : noisy, scratchy, bitey {
       let t : hashmap<body_part, uint> =
         hashmap::<body_part, uint>(hsher, eqer);
       self.bite_counts = t;
-      iter(~[finger, toe, nose, ear]) {|p|
+      do iter(~[finger, toe, nose, ear]) {|p|
           self.bite_counts.insert(p, 0u);
       };
     }
@@ -73,7 +73,7 @@ class cat : noisy, scratchy, bitey {
     #error("In bite()");
     let all = ~[toe, nose, ear];
     let mut min = finger;
-    iter(all) {|next|
+    do iter(all) {|next|
       #debug("min = %?", min);
         if self.bite_counts.get(next) < self.bite_counts.get(min) {
             min = next;
diff --git a/src/test/run-pass/cleanup-copy-mode.rs b/src/test/run-pass/cleanup-copy-mode.rs
index 3f5e92cdb75..59260fa1bf3 100644
--- a/src/test/run-pass/cleanup-copy-mode.rs
+++ b/src/test/run-pass/cleanup-copy-mode.rs
@@ -2,8 +2,8 @@
 fn adder(+x: @int, +y: @int) -> int { ret *x + *y; }
 fn failer() -> @int { fail; }
 fn main() {
-    assert(result::is_err(task::try {||
+    assert(result::is_err(task::try({||
         adder(@2, failer()); ()
-    }));
+    })));
 }
 
diff --git a/src/test/run-pass/comm.rs b/src/test/run-pass/comm.rs
index d3b648e4475..58aaeeea258 100644
--- a/src/test/run-pass/comm.rs
+++ b/src/test/run-pass/comm.rs
@@ -10,7 +10,7 @@ import task;
 fn main() {
     let p = comm::port();
     let ch = comm::chan(p);
-    let t = task::spawn {|| child(ch); };
+    let t = task::spawn({|| child(ch); });
     let y = recv(p);
     #error("received");
     log(error, y);
diff --git a/src/test/run-pass/crust-call-deep2.rs b/src/test/run-pass/crust-call-deep2.rs
index a79a05ebde2..ba9b78c75b4 100644
--- a/src/test/run-pass/crust-call-deep2.rs
+++ b/src/test/run-pass/crust-call-deep2.rs
@@ -19,7 +19,7 @@ fn count(n: uint) -> uint {
 fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    task::spawn {||
+    do task::spawn {||
         let result = count(1000u);
         #debug("result = %?", result);
         assert result == 1000u;
diff --git a/src/test/run-pass/crust-call-scrub.rs b/src/test/run-pass/crust-call-scrub.rs
index ea8897b1519..ba920acb601 100644
--- a/src/test/run-pass/crust-call-scrub.rs
+++ b/src/test/run-pass/crust-call-scrub.rs
@@ -23,7 +23,7 @@ fn count(n: uint) -> uint {
 fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    task::spawn {||
+    do task::spawn {||
         let result = count(12u);
         #debug("result = %?", result);
         assert result == 2048u;
diff --git a/src/test/run-pass/crust-stress.rs b/src/test/run-pass/crust-stress.rs
index e96c45a8cdf..dcc78c862c0 100644
--- a/src/test/run-pass/crust-stress.rs
+++ b/src/test/run-pass/crust-stress.rs
@@ -20,8 +20,8 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    iter::repeat(100u) {||
-        task::spawn {||
+    do iter::repeat(100u) {||
+        do task::spawn {||
             assert count(5u) == 16u;
         };
     }
diff --git a/src/test/run-pass/crust-yield.rs b/src/test/run-pass/crust-yield.rs
index d7dc4c6cf51..9eb5533b90c 100644
--- a/src/test/run-pass/crust-yield.rs
+++ b/src/test/run-pass/crust-yield.rs
@@ -17,8 +17,8 @@ fn count(n: uint) -> uint {
 }
 
 fn main() {
-    iter::repeat(10u) {||
-        task::spawn {||
+    do iter::repeat(10u) {||
+        do task::spawn {||
             let result = count(5u);
             #debug("result = %?", result);
             assert result == 16u;
diff --git a/src/test/run-pass/foreach-nested.rs b/src/test/run-pass/foreach-nested.rs
index c41628af780..e2ce7fe6e7e 100644
--- a/src/test/run-pass/foreach-nested.rs
+++ b/src/test/run-pass/foreach-nested.rs
@@ -7,9 +7,9 @@ fn two(it: fn(int)) { it(0); it(1); }
 fn main() {
     let a: ~[mut int] = ~[mut -1, -1, -1, -1];
     let mut p: int = 0;
-    two {|i|
-        two {|j| a[p] = 10 * i + j; p += 1; };
-    };
+    do two {|i|
+        do two {|j| a[p] = 10 * i + j; p += 1; }
+    }
     assert (a[0] == 0);
     assert (a[1] == 1);
     assert (a[2] == 10);
diff --git a/src/test/run-pass/foreach-put-structured.rs b/src/test/run-pass/foreach-put-structured.rs
index 4bf37df776d..f10bfbe851a 100644
--- a/src/test/run-pass/foreach-put-structured.rs
+++ b/src/test/run-pass/foreach-put-structured.rs
@@ -9,7 +9,7 @@ fn pairs(it: fn((int, int))) {
 fn main() {
     let mut i: int = 10;
     let mut j: int = 0;
-    pairs() {|p|
+    do pairs() {|p|
         let (_0, _1) = p;
         log(debug, _0);
         log(debug, _1);
diff --git a/src/test/run-pass/foreach-simple-outer-slot.rs b/src/test/run-pass/foreach-simple-outer-slot.rs
index c27b2606664..3f9060733a2 100644
--- a/src/test/run-pass/foreach-simple-outer-slot.rs
+++ b/src/test/run-pass/foreach-simple-outer-slot.rs
@@ -4,7 +4,7 @@
 // -*- rust -*-
 fn main() {
     let mut sum: int = 0;
-    first_ten {|i| #debug("main"); log(debug, i); sum = sum + i; };
+    do first_ten {|i| #debug("main"); log(debug, i); sum = sum + i; }
     #debug("sum");
     log(debug, sum);
     assert (sum == 45);
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 93869d19453..3d26c653d03 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -35,7 +35,7 @@ mod map_reduce {
 
     fn start_mappers(ctrl: chan<ctrl_proto>, inputs: ~[str]) {
         for inputs.each {|i|
-            task::spawn {|| map_task(ctrl, i); };
+            do task::spawn {|| map_task(ctrl, i); }
         }
     }
 
diff --git a/src/test/run-pass/intrinsic-frame-address.rs b/src/test/run-pass/intrinsic-frame-address.rs
index 84b2a1c995d..25511ec2e89 100644
--- a/src/test/run-pass/intrinsic-frame-address.rs
+++ b/src/test/run-pass/intrinsic-frame-address.rs
@@ -4,7 +4,7 @@ native mod rusti {
 }
 
 fn main() {
-    rusti::frame_address {|addr|
+    do rusti::frame_address {|addr|
         assert addr.is_not_null();
     }
 }
diff --git a/src/test/run-pass/issue-2185.rs b/src/test/run-pass/issue-2185.rs
index 151361660f5..6a90e98c6b2 100644
--- a/src/test/run-pass/issue-2185.rs
+++ b/src/test/run-pass/issue-2185.rs
@@ -11,18 +11,18 @@ impl<A> of iterable<A> for fn@(fn(A)) {
 }
 
 impl of iterable<uint> for fn@(fn(uint)) {
-    fn iter(blk: fn(&&uint)) { self { |i| blk(i) } }
+    fn iter(blk: fn(&&uint)) { self({ |i| blk(i) }) }
 }
 
 fn filter<A,IA:iterable<A>>(self: IA, prd: fn@(A) -> bool, blk: fn(A)) {
-    self.iter {|a|
+    do self.iter {|a|
         if prd(a) { blk(a) }
     }
 }
 
 fn foldl<A,B,IA:iterable<A>>(self: IA, +b0: B, blk: fn(B, A) -> B) -> B {
     let mut b <- b0;
-    self.iter { |a|
+    do self.iter { |a|
         b <- blk(b, a);
     }
     ret b;
@@ -42,7 +42,7 @@ fn main() {
         range,
         {|&&n: uint| n % 3u != 0u && n % 5u != 0u },
         a)};
-    let sum = foldl(filt, 0u) {|accum, &&n: uint| accum + n };
+    let sum = foldl(filt, 0u, {|accum, &&n: uint| accum + n });
 
     io::println(#fmt("%u", sum));
 }
\ No newline at end of file
diff --git a/src/test/run-pass/issue-2487-a.rs b/src/test/run-pass/issue-2487-a.rs
index ab1d9ccb3be..348e750a484 100644
--- a/src/test/run-pass/issue-2487-a.rs
+++ b/src/test/run-pass/issue-2487-a.rs
@@ -6,7 +6,7 @@ class socket {
     drop { }
 
     fn set_identity()  {
-        closure { ||
+        do closure { ||
             setsockopt_bytes(copy self.sock)
         }
     }
diff --git a/src/test/run-pass/issue-507.rs b/src/test/run-pass/issue-507.rs
index 7490f06d548..0c840864fd5 100644
--- a/src/test/run-pass/issue-507.rs
+++ b/src/test/run-pass/issue-507.rs
@@ -17,14 +17,14 @@ import comm::recv;
 fn grandchild(c: chan<int>) { send(c, 42); }
 
 fn child(c: chan<int>) {
-    task::spawn {|| grandchild(c); }
+    task::spawn({|| grandchild(c); })
 }
 
 fn main() {
     let p = comm::port();
     let ch = chan(p);
 
-    task::spawn {|| child(ch); }
+    task::spawn({|| child(ch); });
 
     let x: int = recv(p);
 
diff --git a/src/test/run-pass/issue-687.rs b/src/test/run-pass/issue-687.rs
index 6a594e84899..4d15b3c387a 100644
--- a/src/test/run-pass/issue-687.rs
+++ b/src/test/run-pass/issue-687.rs
@@ -41,10 +41,10 @@ fn main() {
     let ch = chan(p);
     let recv_reader: port<chan<~[u8]>> = port();
     let recv_reader_chan = chan(recv_reader);
-    let pack = task::spawn {|| packager(recv_reader_chan, ch); };
+    let pack = task::spawn({|| packager(recv_reader_chan, ch); });
 
     let source_chan: chan<~[u8]> = recv(recv_reader);
-    let prod = task::spawn {|| producer(source_chan); };
+    let prod = task::spawn({|| producer(source_chan); });
 
     loop {
         let msg = recv(p);
diff --git a/src/test/run-pass/issue-783.rs b/src/test/run-pass/issue-783.rs
index 76d26e0b025..85a125b0149 100644
--- a/src/test/run-pass/issue-783.rs
+++ b/src/test/run-pass/issue-783.rs
@@ -10,7 +10,7 @@ fn a() {
         }
         let p = port();
         let ch = chan(p);
-        spawn {|| b(ch); };
+        spawn({|| b(ch); });
         recv(p);
     }
     let mut i = 0;
@@ -21,7 +21,7 @@ fn a() {
 }
 
 fn main() {
-    iter::repeat(100u) {||
-        spawn {|| a(); }
+    do iter::repeat(100u) {||
+        spawn({|| a(); });
     }
 }
diff --git a/src/test/run-pass/iter-range.rs b/src/test/run-pass/iter-range.rs
index 797049b5d51..93b9542bd10 100644
--- a/src/test/run-pass/iter-range.rs
+++ b/src/test/run-pass/iter-range.rs
@@ -8,6 +8,6 @@ fn range(a: int, b: int, it: fn(int)) {
 
 fn main() {
     let mut sum: int = 0;
-    range(0, 100) {|x| sum += x; }
+    range(0, 100, {|x| sum += x; });
     log(debug, sum);
 }
diff --git a/src/test/run-pass/ivec-tag.rs b/src/test/run-pass/ivec-tag.rs
index 37e1cac1bd2..1d59957fbd7 100644
--- a/src/test/run-pass/ivec-tag.rs
+++ b/src/test/run-pass/ivec-tag.rs
@@ -16,7 +16,7 @@ fn producer(c: chan<~[u8]>) {
 fn main() {
     let p: port<~[u8]> = port();
     let ch = chan(p);
-    let prod = task::spawn {|| producer(ch); };
+    let prod = task::spawn({|| producer(ch); });
 
     let data: ~[u8] = recv(p);
 }
diff --git a/src/test/run-pass/last-use-in-block.rs b/src/test/run-pass/last-use-in-block.rs
index 6915c35b2f6..9f3eebc8f22 100644
--- a/src/test/run-pass/last-use-in-block.rs
+++ b/src/test/run-pass/last-use-in-block.rs
@@ -10,7 +10,7 @@ fn lp<T>(s: str, f: fn(str) -> T) -> T {
 
 fn apply<T>(s: str, f: fn(str) -> T) -> T {
     fn g<T>(s: str, f: fn(str) -> T) -> T {f(s)}
-    g(s) {|v| let r = f(v); r }
+    g(s, {|v| let r = f(v); r })
 }
 
 fn main() {}
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index b238dab3026..fe1a18f0750 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -4,5 +4,5 @@ fn main() {
     fn invoke(f: fn@()) { f(); }
     let k = ~22;
     let _u = {a: k};
-    invoke {||log(error, k);}
+    invoke({||log(error, k);})
 }
diff --git a/src/test/run-pass/lazychan.rs b/src/test/run-pass/lazychan.rs
index 8651c81a41f..643a7b56f4a 100644
--- a/src/test/run-pass/lazychan.rs
+++ b/src/test/run-pass/lazychan.rs
@@ -9,13 +9,13 @@ fn main() {
     let ch = chan(p);
     let mut y: int;
 
-    task::spawn {|| child(ch); };
+    task::spawn({|| child(ch); });
     y = recv(p);
     #debug("received 1");
     log(debug, y);
     assert (y == 10);
 
-    task::spawn {|| child(ch); };
+    task::spawn({|| child(ch); });
     y = recv(p);
     #debug("received 2");
     log(debug, y);
diff --git a/src/test/run-pass/lots-a-fail.rs b/src/test/run-pass/lots-a-fail.rs
index 820fe715b39..19ee9a66f8d 100644
--- a/src/test/run-pass/lots-a-fail.rs
+++ b/src/test/run-pass/lots-a-fail.rs
@@ -9,13 +9,13 @@ fn die() {
 }
 
 fn iloop() {
-    task::spawn {|| die(); };
+    task::spawn({|| die(); });
 }
 
 fn main() {
     for uint::range(0u, 100u) {|_i|
         let builder = task::builder();
         task::unsupervise(builder);
-        task::run(builder) {|| iloop(); };
+        task::run(builder, {|| iloop(); });
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/many.rs b/src/test/run-pass/many.rs
index 0914e059b95..c13f6c02def 100644
--- a/src/test/run-pass/many.rs
+++ b/src/test/run-pass/many.rs
@@ -10,7 +10,7 @@ fn sub(parent: comm::chan<int>, id: int) {
     } else {
         let p = comm::port();
         let ch = comm::chan(p);
-        let child = task::spawn {|| sub(ch, id - 1); };
+        let child = task::spawn({|| sub(ch, id - 1); });
         let y = comm::recv(p);
         comm::send(parent, y + 1);
     }
@@ -19,7 +19,7 @@ fn sub(parent: comm::chan<int>, id: int) {
 fn main() {
     let p = comm::port();
     let ch = comm::chan(p);
-    let child = task::spawn {|| sub(ch, 200); };
+    let child = task::spawn({|| sub(ch, 200); });
     let y = comm::recv(p);
     #debug("transmission complete");
     log(debug, y);
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index ee695c1d793..466dd101dae 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -16,12 +16,12 @@ impl monad<A> for option<A> {
 }
 
 fn transform(x: option<int>) -> option<str> {
-    x.bind {|n| some(n + 1)}.bind {|n| some(int::str(n))}
+    x.bind({|n| some(n + 1)}).bind({|n| some(int::str(n))})
 }
 
 fn main() {
     assert transform(some(10)) == some("11");
     assert transform(none) == none;
-    assert (~["hi"]).bind {|x| ~[x, x + "!"]}.bind {|x| ~[x, x + "?"]} ==
+    assert (~["hi"]).bind({|x| ~[x, x + "!"]}).bind({|x| ~[x, x + "?"]}) ==
         ~["hi", "hi?", "hi!", "hi!?"];
 }
diff --git a/src/test/run-pass/morestack5.rs b/src/test/run-pass/morestack5.rs
index ea4f6466ae8..20fe8e027bf 100644
--- a/src/test/run-pass/morestack5.rs
+++ b/src/test/run-pass/morestack5.rs
@@ -12,7 +12,7 @@ fn getbig(&&i: int) {
 fn main() {
     let mut sz = 400u;
     while sz < 500u {
-        task::try {|| getbig(200) };
+        task::try({|| getbig(200) });
         sz += 1u;
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/morestack6.rs b/src/test/run-pass/morestack6.rs
index 56433d5a1e1..d4290fd81eb 100644
--- a/src/test/run-pass/morestack6.rs
+++ b/src/test/run-pass/morestack6.rs
@@ -58,6 +58,6 @@ fn main() {
     for fns.each {|f|
         let sz = rng.next() % 256u32 + 256u32;
         let frame_backoff = rng.next() % 10u32 + 1u32;
-        task::try {|| runtest(f, frame_backoff) };
+        task::try({|| runtest(f, frame_backoff) });
     }
 }
diff --git a/src/test/run-pass/osmain.rs b/src/test/run-pass/osmain.rs
index 981426ce62a..92eb1d93dd9 100644
--- a/src/test/run-pass/osmain.rs
+++ b/src/test/run-pass/osmain.rs
@@ -24,7 +24,7 @@ fn run(i: int) {
     };
     task::set_opts(builder, opts);
     task::unsupervise(builder);
-    task::run(builder) {||
+    do task::run(builder) {||
         task::yield();
         let builder = task::builder();
         let opts = {
@@ -36,7 +36,7 @@ fn run(i: int) {
         };
         task::set_opts(builder, opts);
         task::unsupervise(builder);
-        task::run(builder) {||
+        do task::run(builder) {||
             task::yield();
             run(i - 1);
             task::yield();
diff --git a/src/test/run-pass/regions-params.rs b/src/test/run-pass/regions-params.rs
index 9e483f063a2..0a378235682 100644
--- a/src/test/run-pass/regions-params.rs
+++ b/src/test/run-pass/regions-params.rs
@@ -3,9 +3,9 @@ fn region_identity(x: &r.uint) -> &r.uint { x }
 fn apply<T>(t: T, f: fn(T) -> T) -> T { f(t) }
 
 fn parameterized(x: &uint) -> uint {
-    let z = apply(x) {|y|
+    let z = apply(x, ({|y|
         region_identity(y)
-    };
+    }));
     *z
 }
 
diff --git a/src/test/run-pass/send-iloop.rs b/src/test/run-pass/send-iloop.rs
index 904eef7a2e8..b691676f861 100644
--- a/src/test/run-pass/send-iloop.rs
+++ b/src/test/run-pass/send-iloop.rs
@@ -9,7 +9,7 @@ fn die() {
 }
 
 fn iloop() {
-    task::spawn {|| die(); };
+    task::spawn({|| die(); });
     let p = comm::port::<()>();
     let c = comm::chan(p);
     loop {
@@ -24,6 +24,6 @@ fn main() {
     for uint::range(0u, 16u) {|_i|
         let builder = task::builder();
         task::unsupervise(builder);
-        task::run(builder) {|| iloop(); }
+        task::run(builder, {|| iloop(); });
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/send-resource.rs b/src/test/run-pass/send-resource.rs
index a733f998160..0be6e71d66f 100644
--- a/src/test/run-pass/send-resource.rs
+++ b/src/test/run-pass/send-resource.rs
@@ -11,7 +11,7 @@ fn main() {
     let p = port();
     let c = chan(p);
 
-    spawn() {||
+    do spawn() {||
         let p = port();
         c.send(chan(p));
 
diff --git a/src/test/run-pass/sendfn-generic-fn.rs b/src/test/run-pass/sendfn-generic-fn.rs
index 9e1e5127a24..ee5fa5dc4f3 100644
--- a/src/test/run-pass/sendfn-generic-fn.rs
+++ b/src/test/run-pass/sendfn-generic-fn.rs
@@ -27,7 +27,7 @@ fn spawn<A: copy, B: copy>(f: native fn(fn~(A,B)->pair<A,B>)) {
     let arg = fn~(a: A, b: B) -> pair<A,B> {
         ret make_generic_record(a, b);
     };
-    task::spawn {|| f(arg); };
+    task::spawn({|| f(arg); });
 }
 
 fn test05() {
diff --git a/src/test/run-pass/spawn-fn.rs b/src/test/run-pass/spawn-fn.rs
index a7daf058abe..02d8fd1b437 100644
--- a/src/test/run-pass/spawn-fn.rs
+++ b/src/test/run-pass/spawn-fn.rs
@@ -10,9 +10,9 @@ fn x(s: str, n: int) {
 }
 
 fn main() {
-    task::spawn {|| x("hello from first spawned fn", 65); };
-    task::spawn {|| x("hello from second spawned fn", 66); };
-    task::spawn {|| x("hello from third spawned fn", 67); };
+    task::spawn({|| x("hello from first spawned fn", 65); });
+    task::spawn({|| x("hello from second spawned fn", 66); });
+    task::spawn({|| x("hello from third spawned fn", 67); });
     let mut i: int = 30;
     while i > 0 { i = i - 1; #debug("parent sleeping"); yield(); }
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index 727d8326b4e..9abe4f6a3ef 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -19,5 +19,5 @@ fn iotask(cx: ctx, ip: str) {
 fn main() {
     let p = comm::port::<int>();
     let ch = comm::chan(p);
-    task::spawn {|| iotask(ch, "localhost"); };
+    task::spawn({|| iotask(ch, "localhost"); });
 }
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index 600cbdb06b8..110284920d3 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -5,7 +5,7 @@ use std;
 import task;
 
 fn main() {
-    task::spawn {|| child(10); };
+    task::spawn({|| child(10); });
 }
 
 fn child(&&i: int) { log(error, i); assert (i == 10); }
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 86e2c996517..3a9506cc278 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -3,7 +3,7 @@
 use std;
 import task::spawn;
 
-fn main() { spawn {|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)); }; }
+fn main() { spawn({|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)); }); }
 
 fn child(&&args: (int, int, int, int, int, int, int, int, int)) {
     let (i1, i2, i3, i4, i5, i6, i7, i8, i9) = args;
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 184b681bfb2..ad2324a34c2 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -37,6 +37,6 @@ fn main() {
     assert (~[3, 4]).map_({|a| a + 4})[0] == 7;
     assert (~[3, 4]).map_::<uint>({|a| a as uint + 4u})[0] == 7u;
     let mut x = 0u;
-    10u.times {|_n| x += 2u;}
+    10u.times({|_n| x += 2u;});
     assert x == 20u;
 }
diff --git a/src/test/run-pass/task-comm-0.rs b/src/test/run-pass/task-comm-0.rs
index 75c282e7a90..ab16868caf1 100644
--- a/src/test/run-pass/task-comm-0.rs
+++ b/src/test/run-pass/task-comm-0.rs
@@ -20,7 +20,7 @@ fn test05_start(ch : chan<int>) {
 fn test05() {
     let po = comm::port();
     let ch = comm::chan(po);
-    task::spawn {|| test05_start(ch); };
+    task::spawn({|| test05_start(ch); });
     let mut value = comm::recv(po);
     log(error, value);
     value = comm::recv(po);
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index 713d487f3d8..4995bfa0422 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -3,6 +3,6 @@ fn main() { test00(); }
 fn start() { #debug("Started / Finished task."); }
 
 fn test00() {
-    task::try {|| start() };
+    task::try({|| start() });
     #debug("Completing.");
 }
diff --git a/src/test/run-pass/task-comm-10.rs b/src/test/run-pass/task-comm-10.rs
index 907b4fc769d..f06d694bdce 100644
--- a/src/test/run-pass/task-comm-10.rs
+++ b/src/test/run-pass/task-comm-10.rs
@@ -19,7 +19,7 @@ fn start(c: comm::chan<comm::chan<str>>) {
 fn main() {
     let p = comm::port();
     let ch = comm::chan(p);
-    let child = task::spawn {|| start(ch); };
+    let child = task::spawn({|| start(ch); });
 
     let c = comm::recv(p);
     comm::send(c, "A");
diff --git a/src/test/run-pass/task-comm-11.rs b/src/test/run-pass/task-comm-11.rs
index b1e23b2443a..df159fa5285 100644
--- a/src/test/run-pass/task-comm-11.rs
+++ b/src/test/run-pass/task-comm-11.rs
@@ -10,6 +10,6 @@ fn start(c: comm::chan<comm::chan<int>>) {
 fn main() {
     let p = comm::port();
     let ch = comm::chan(p);
-    let child = task::spawn {|| start(ch); };
+    let child = task::spawn({|| start(ch); });
     let c = comm::recv(p);
 }
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index 51e61298290..aff0eb5cf76 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -9,7 +9,7 @@ fn test00() {
     let i: int = 0;
     let builder = task::builder();
     let r = task::future_result(builder);
-    task::run(builder) {|| start(i); };
+    task::run(builder, {|| start(i); });
 
     // Sleep long enough for the task to finish.
     let mut i = 0;
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index eb8ffc6b8a8..a3608173978 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -12,6 +12,6 @@ fn main() {
     #debug("Check that we don't deadlock.");
     let p = comm::port::<int>();
     let ch = comm::chan(p);
-    task::try {|| start(ch, 0, 10) };
+    task::try({|| start(ch, 0, 10) });
     #debug("Joined task");
 }
diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index 6efcd8e6eed..1adc04f6e1c 100644
--- a/src/test/run-pass/task-comm-14.rs
+++ b/src/test/run-pass/task-comm-14.rs
@@ -10,7 +10,7 @@ fn main() {
     let mut i = 10;
     while (i > 0) {
         log(debug, i);
-        task::spawn {|copy i| child(i, ch); };
+        task::spawn({|copy i| child(i, ch); });
         i = i - 1;
     }
 
diff --git a/src/test/run-pass/task-comm-15.rs b/src/test/run-pass/task-comm-15.rs
index 952306bebe1..816e41eb017 100644
--- a/src/test/run-pass/task-comm-15.rs
+++ b/src/test/run-pass/task-comm-15.rs
@@ -18,6 +18,6 @@ fn main() {
     // the child's point of view the receiver may die. We should
     // drop messages on the floor in this case, and not crash!
     let ch = comm::chan(p);
-    let child = task::spawn {|| start(ch, 10); };
+    let child = task::spawn({|| start(ch, 10); });
     let c = comm::recv(p);
 }
diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs
index 0db319c4c35..b3462d87f5a 100644
--- a/src/test/run-pass/task-comm-17.rs
+++ b/src/test/run-pass/task-comm-17.rs
@@ -9,5 +9,5 @@ fn f() {
 }
 
 fn main() {
-    task::spawn {|| f() };
+    task::spawn({|| f() });
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index e4cb8ccee7f..f0bb3818d86 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -34,7 +34,7 @@ fn test00() {
     while i < number_of_tasks {
         let builder = task::builder();
         results += ~[task::future_result(builder)];
-        task::run(builder) {|copy i|
+        do task::run(builder) {|copy i|
             test00_start(ch, i, number_of_messages)
         }
         i = i + 1;
diff --git a/src/test/run-pass/task-comm-7.rs b/src/test/run-pass/task-comm-7.rs
index 61ce4009c21..2498dc3d043 100644
--- a/src/test/run-pass/task-comm-7.rs
+++ b/src/test/run-pass/task-comm-7.rs
@@ -16,16 +16,16 @@ fn test00() {
     let number_of_messages: int = 10;
     let c = comm::chan(p);
 
-    task::spawn {||
+    do task::spawn {||
         test00_start(c, number_of_messages * 0, number_of_messages);
     }
-    task::spawn {||
+    do task::spawn {||
         test00_start(c, number_of_messages * 1, number_of_messages);
     }
-    task::spawn {||
+    do task::spawn {||
         test00_start(c, number_of_messages * 2, number_of_messages);
     }
-    task::spawn {||
+    do task::spawn {||
         test00_start(c, number_of_messages * 3, number_of_messages);
     }
 
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index e5c24334734..4469f8194c8 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -18,7 +18,7 @@ fn test00() {
 
     let builder = task::builder();
     let r = task::future_result(builder);
-    task::run(builder) {||
+    do task::run(builder) {||
         test00_start(ch, number_of_messages);
     }
 
diff --git a/src/test/run-pass/task-comm-chan-cleanup4.rs b/src/test/run-pass/task-comm-chan-cleanup4.rs
index 7c32b978ae8..8fba7565341 100644
--- a/src/test/run-pass/task-comm-chan-cleanup4.rs
+++ b/src/test/run-pass/task-comm-chan-cleanup4.rs
@@ -16,13 +16,13 @@ fn starbase() {
     for int::range(0, 10) { |_i|
         let p = comm::port();
         let c = comm::chan(p);
-        task::spawn {|| starship(c);};
+        task::spawn({|| starship(c);});
         task::yield();
     }
 }
 
 fn main() {
     for int::range(0, 10) { |_i|
-        task::spawn {|| starbase();};
+        task::spawn({|| starbase();});
     }
 }
\ No newline at end of file
diff --git a/src/test/run-pass/task-comm.rs b/src/test/run-pass/task-comm.rs
index 74777ab140b..a929c2237b0 100644
--- a/src/test/run-pass/task-comm.rs
+++ b/src/test/run-pass/task-comm.rs
@@ -43,7 +43,7 @@ fn test00() {
         i = i + 1;
         let builder = task::builder();
         results += ~[task::future_result(builder)];
-        task::run(builder) {|copy i|
+        do task::run(builder) {|copy i|
             test00_start(ch, i, number_of_messages);
         }
     }
@@ -89,7 +89,7 @@ fn test04_start() {
 fn test04() {
     #debug("Spawning lots of tasks.");
     let mut i: int = 4;
-    while i > 0 { i = i - 1; task::spawn {|| test04_start(); }; }
+    while i > 0 { i = i - 1; task::spawn({|| test04_start(); }); }
     #debug("Finishing up.");
 }
 
@@ -104,7 +104,7 @@ fn test05_start(ch: chan<int>) {
 fn test05() {
     let po = comm::port();
     let ch = chan(po);
-    task::spawn {|| test05_start(ch); };
+    task::spawn({|| test05_start(ch); });
     let mut value: int;
     value = recv(po);
     value = recv(po);
@@ -130,7 +130,7 @@ fn test06() {
         i = i + 1;
         let builder = task::builder();
         results += ~[task::future_result(builder)];
-        task::run(builder) {|copy i|
+        do task::run(builder) {|copy i|
             test06_start(i);
         };
     }
diff --git a/src/test/run-pass/task-killjoin.rs b/src/test/run-pass/task-killjoin.rs
index 77d6bc9e565..9038667e90b 100644
--- a/src/test/run-pass/task-killjoin.rs
+++ b/src/test/run-pass/task-killjoin.rs
@@ -20,13 +20,13 @@ fn supervisor() {
     // Unsupervise this task so the process doesn't return a failure status as
     // a result of the main task being killed.
     let f = supervised;
-    task::try {|| supervised() };
+    task::try({|| supervised() });
 }
 
 fn main() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {|| supervisor(); }
+    task::run(builder, {|| supervisor(); })
 }
 
 // Local Variables:
diff --git a/src/test/run-pass/task-life-0.rs b/src/test/run-pass/task-life-0.rs
index 1aead283758..bf19f937bcf 100644
--- a/src/test/run-pass/task-life-0.rs
+++ b/src/test/run-pass/task-life-0.rs
@@ -1,7 +1,7 @@
 use std;
 import task;
 fn main() {
-    task::spawn {|| child("Hello"); };
+    task::spawn({|| child("Hello"); });
 }
 
 fn child(&&s: str) {
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index aee8b9ab641..3b26722f497 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -12,13 +12,13 @@ fn test_ret() { let x: @int = ret; }
 
 fn test_fail() {
     fn f() { let x: @int = fail; }
-    task::try {|| f() };
+    task::try({|| f() });
 }
 
 fn test_fail_indirect() {
     fn f() -> ! { fail; }
     fn g() { let x: @int = f(); }
-    task::try {|| g() };
+    task::try({|| g() });
 }
 
 fn main() {
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 358074fecf8..efc530aac4b 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -5,7 +5,7 @@ import task;
 
 fn main() {
     let mut i = 10;
-    while i > 0 { task::spawn {|copy i| child(i); }; i = i - 1; }
+    while i > 0 { task::spawn({|copy i| child(i); }); i = i - 1; }
     #debug("main thread exiting");
 }
 
diff --git a/src/test/run-pass/too-much-recursion.rs b/src/test/run-pass/too-much-recursion.rs
index 3dd2ebb3859..4b19981887b 100644
--- a/src/test/run-pass/too-much-recursion.rs
+++ b/src/test/run-pass/too-much-recursion.rs
@@ -7,7 +7,7 @@
 fn main() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {||
+    do task::run(builder) {||
         fn f() { f() };
         f();
     };
diff --git a/src/test/run-pass/type-params-in-for-each.rs b/src/test/run-pass/type-params-in-for-each.rs
index f208b6a362f..2aec1c3f8da 100644
--- a/src/test/run-pass/type-params-in-for-each.rs
+++ b/src/test/run-pass/type-params-in-for-each.rs
@@ -6,7 +6,7 @@ fn range(lo: uint, hi: uint, it: fn(uint)) {
 }
 
 fn create_index<T>(index: ~[{a: T, b: uint}], hash_fn: native fn(T) -> uint) {
-    range(0u, 256u) {|_i| let bucket: ~[T] = ~[]; }
+    range(0u, 256u, {|_i| let bucket: ~[T] = ~[]; })
 }
 
 fn main() { }
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index 9fce7de19c4..e9d7d91ba33 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -13,7 +13,7 @@ fn main() {
     let n = 100u;
     let mut expected = 0u;
     for uint::range(0u, n) {|i|
-        task::spawn {|| child(ch, i); };
+        task::spawn({|| child(ch, i); });
         expected += i;
     }
 
diff --git a/src/test/run-pass/unwind-box.rs b/src/test/run-pass/unwind-box.rs
index 5634b818794..7791c396b10 100644
--- a/src/test/run-pass/unwind-box.rs
+++ b/src/test/run-pass/unwind-box.rs
@@ -10,5 +10,5 @@ fn f() {
 fn main() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {|| f(); }
+    task::run(builder, {|| f(); });
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index 7e09b5cca99..e9222c21b91 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -23,7 +23,7 @@ fn main() {
     let c = comm::chan(p);
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {|| f(c); }
+    task::run(builder, {|| f(c); });
     #error("hiiiiiiiii");
     assert comm::recv(p);
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unwind-resource2.rs b/src/test/run-pass/unwind-resource2.rs
index 20120cd6ddd..73ee572acb1 100644
--- a/src/test/run-pass/unwind-resource2.rs
+++ b/src/test/run-pass/unwind-resource2.rs
@@ -17,5 +17,5 @@ fn f() {
 fn main() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {|| f(); }
+    task::run(builder, {|| f(); });
 }
\ No newline at end of file
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 2b733dcf9c1..2039b3d63d7 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -10,5 +10,5 @@ fn f() {
 fn main() {
     let builder = task::builder();
     task::unsupervise(builder);
-    task::run(builder) {|| f(); }
+    task::run(builder, {|| f(); });
 }
\ No newline at end of file
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
index 041d8470a6f..fdb1b52b277 100644
--- a/src/test/run-pass/yield.rs
+++ b/src/test/run-pass/yield.rs
@@ -6,7 +6,7 @@ import task::*;
 fn main() {
     let builder = task::builder();
     let result = task::future_result(builder);
-    task::run(builder) {|| child(); }
+    task::run(builder, {|| child(); });
     #error("1");
     yield();
     #error("2");
diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs
index 6218baa29bc..04467107256 100644
--- a/src/test/run-pass/yield1.rs
+++ b/src/test/run-pass/yield1.rs
@@ -6,7 +6,7 @@ import task::*;
 fn main() {
     let builder = task::builder();
     let result = task::future_result(builder);
-    task::run(builder) {|| child(); }
+    task::run(builder, {|| child(); });
     #error("1");
     yield();
     future::get(result);