test: Remove non-procedure uses of `do` from compiletest, libstd tests,

compile-fail tests, run-fail tests, and run-pass tests.

37 files changed, 337 insertions, 315 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 4405d5be388..2b105a3fa7d 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -333,47 +333,57 @@ mod test {
     #[bench]
     fn bench_capacity(b: &mut bh) {
         let x = @[1, 2, 3];
-        b.iter(|| capacity(x));
+        b.iter(|| {
+            let _ = capacity(x);
+        });
     }
 
     #[bench]
     fn bench_build_sized(b: &mut bh) {
         let len = 64;
-        do b.iter {
+        b.iter(|| {
             build(Some(len), |push| for i in range(0, 1024) { push(i) });
-        }
+        });
     }
 
     #[bench]
     fn bench_build(b: &mut bh) {
-        do b.iter {
+        b.iter(|| {
             for i in range(0, 95) {
                 build(None, |push| push(i));
             }
-        }
+        });
     }
 
     #[bench]
     fn bench_append(b: &mut bh) {
         let lhs = @[7, ..128];
         let rhs = range(0, 256).to_owned_vec();
-        b.iter(|| append(lhs, rhs))
+        b.iter(|| {
+            let _ = append(lhs, rhs);
+        })
     }
 
     #[bench]
     fn bench_map(b: &mut bh) {
         let elts = range(0, 256).to_owned_vec();
-        b.iter(|| map(elts, |x| x*2))
+        b.iter(|| {
+            let _ = map(elts, |x| x*2);
+        })
     }
 
     #[bench]
     fn bench_from_fn(b: &mut bh) {
-        b.iter(|| from_fn(1024, |x| x));
+        b.iter(|| {
+            let _ = from_fn(1024, |x| x);
+        });
     }
 
     #[bench]
     fn bench_from_elem(b: &mut bh) {
-        b.iter(|| from_elem(1024, 0u64));
+        b.iter(|| {
+            let _ = from_elem(1024, 0u64);
+        });
     }
 
     #[bench]
@@ -387,12 +397,16 @@ mod test {
     #[bench]
     fn bench_to_managed(b: &mut bh) {
         let elts = range(0, 1024).to_owned_vec();
-        b.iter(|| to_managed(elts));
+        b.iter(|| {
+            let _ = to_managed(elts);
+        });
     }
 
     #[bench]
     fn bench_clone(b: &mut bh) {
         let elts = to_managed(range(0, 1024).to_owned_vec());
-        b.iter(|| elts.clone());
+        b.iter(|| {
+            let _ = elts.clone();
+        });
     }
 }
diff --git a/src/libstd/bool.rs b/src/libstd/bool.rs
index ce0a6696596..29c304f9ac5 100644
--- a/src/libstd/bool.rs
+++ b/src/libstd/bool.rs
@@ -53,9 +53,9 @@ use num::FromPrimitive;
 /// # Examples
 ///
 /// ```
-/// do std::bool::all_values |x: bool| {
+/// std::bool::all_values(|x: bool| {
 ///     println(x.to_str());
-/// }
+/// })
 /// ```
 #[inline]
 pub fn all_values(blk: |v: bool|) {
@@ -396,9 +396,9 @@ mod tests {
 
     #[test]
     fn test_bool_from_str() {
-        do all_values |v| {
+        all_values(|v| {
             assert!(Some(v) == FromStr::from_str(v.to_str()))
-        }
+        });
     }
 
     #[test]
@@ -409,11 +409,11 @@ mod tests {
 
     #[test]
     fn test_bool_to_bit() {
-        do all_values |v| {
+        all_values(|v| {
             assert_eq!(v.to_bit::<u8>(), if v { 1u8 } else { 0u8 });
             assert_eq!(v.to_bit::<uint>(), if v { 1u } else { 0u });
             assert_eq!(v.to_bit::<int>(), if v { 1i } else { 0i });
-        }
+        });
     }
 
     #[test]
diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index 634558b9b97..e49cf3e5303 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -82,7 +82,6 @@ pub struct RefCell<T> {
     priv nc: NonCopyable
 }
 
-<<<<<<< HEAD
 // Values [1, MAX-1] represent the number of `Ref` active
 // (will not outgrow its range since `uint` is the size of the address space)
 type BorrowFlag = uint;
diff --git a/src/libstd/char.rs b/src/libstd/char.rs
index c5a4dd1631d..b372993e3e5 100644
--- a/src/libstd/char.rs
+++ b/src/libstd/char.rs
@@ -532,7 +532,7 @@ fn test_is_digit() {
 fn test_escape_default() {
     fn string(c: char) -> ~str {
         let mut result = ~"";
-        do escape_default(c) |c| { result.push_char(c); }
+        escape_default(c, |c| { result.push_char(c); });
         return result;
     }
     assert_eq!(string('\n'), ~"\\n");
@@ -554,7 +554,7 @@ fn test_escape_default() {
 fn test_escape_unicode() {
     fn string(c: char) -> ~str {
         let mut result = ~"";
-        do escape_unicode(c) |c| { result.push_char(c); }
+        escape_unicode(c, |c| { result.push_char(c); });
         return result;
     }
     assert_eq!(string('\x00'), ~"\\x00");
diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index 03994043dcf..80ff104e830 100644
--- a/src/libstd/condition.rs
+++ b/src/libstd/condition.rs
@@ -224,14 +224,14 @@ mod test {
     fn nested_trap_test_inner() {
         let mut inner_trapped = false;
 
-        do sadness::cond.trap(|_j| {
+        sadness::cond.trap(|_j| {
             debug!("nested_trap_test_inner: in handler");
             inner_trapped = true;
             0
-        }).inside {
+        }).inside(|| {
             debug!("nested_trap_test_inner: in protected block");
             trouble(1);
-        }
+        });
 
         assert!(inner_trapped);
     }
@@ -240,14 +240,14 @@ mod test {
     fn nested_trap_test_outer() {
         let mut outer_trapped = false;
 
-        do sadness::cond.trap(|_j| {
+        sadness::cond.trap(|_j| {
             debug!("nested_trap_test_outer: in handler");
             outer_trapped = true; 0
-        }).inside {
+        }).inside(|| {
             debug!("nested_guard_test_outer: in protected block");
             nested_trap_test_inner();
             trouble(1);
-        }
+        });
 
         assert!(outer_trapped);
     }
@@ -255,16 +255,16 @@ mod test {
     fn nested_reraise_trap_test_inner() {
         let mut inner_trapped = false;
 
-        do sadness::cond.trap(|_j| {
+        sadness::cond.trap(|_j| {
             debug!("nested_reraise_trap_test_inner: in handler");
             inner_trapped = true;
             let i = 10;
             debug!("nested_reraise_trap_test_inner: handler re-raising");
             sadness::cond.raise(i)
-        }).inside {
+        }).inside(|| {
             debug!("nested_reraise_trap_test_inner: in protected block");
             trouble(1);
-        }
+        });
 
         assert!(inner_trapped);
     }
@@ -273,13 +273,13 @@ mod test {
     fn nested_reraise_trap_test_outer() {
         let mut outer_trapped = false;
 
-        do sadness::cond.trap(|_j| {
+        sadness::cond.trap(|_j| {
             debug!("nested_reraise_trap_test_outer: in handler");
             outer_trapped = true; 0
-        }).inside {
+        }).inside(|| {
             debug!("nested_reraise_trap_test_outer: in protected block");
             nested_reraise_trap_test_inner();
-        }
+        });
 
         assert!(outer_trapped);
     }
@@ -288,13 +288,13 @@ mod test {
     fn test_default() {
         let mut trapped = false;
 
-        do sadness::cond.trap(|j| {
+        sadness::cond.trap(|j| {
             debug!("test_default: in handler");
             sadness::cond.raise_default(j, || { trapped=true; 5 })
-        }).inside {
+        }).inside(|| {
             debug!("test_default: in protected block");
             trouble(1);
-        }
+        });
 
         assert!(trapped);
     }
@@ -312,12 +312,12 @@ mod test {
             #[test]
             fn test_conditions_are_public() {
                 let mut trapped = false;
-                do sadness::cond.trap(|_| {
+                sadness::cond.trap(|_| {
                     trapped = true;
                     0
-                }).inside {
+                }).inside(|| {
                     sadness::cond.raise(0);
-                }
+                });
                 assert!(trapped);
             }
         }
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index d74acb5f59b..8c1897339cb 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -438,22 +438,22 @@ mod test {
 
     #[bench]
     fn bench_buffered_reader(bh: &mut Harness) {
-        do bh.iter {
+        bh.iter(|| {
             BufferedReader::new(NullStream);
-        }
+        });
     }
 
     #[bench]
     fn bench_buffered_writer(bh: &mut Harness) {
-        do bh.iter {
+        bh.iter(|| {
             BufferedWriter::new(NullStream);
-        }
+        });
     }
 
     #[bench]
     fn bench_buffered_stream(bh: &mut Harness) {
-        do bh.iter {
+        bh.iter(|| {
             BufferedStream::new(NullStream);
-        }
+        });
     }
 }
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 5eb2e72e96b..564e664027f 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -276,11 +276,11 @@ mod test {
     #[test]
     fn read_byte_error() {
         let mut reader = ErroringReader;
-        do io_error::cond.trap(|_| {
-        }).inside {
+        io_error::cond.trap(|_| {
+        }).inside(|| {
             let byte = reader.read_byte();
             assert!(byte == None);
-        }
+        });
     }
 
     #[test]
@@ -303,10 +303,10 @@ mod test {
     fn bytes_error() {
         let reader = ErroringReader;
         let mut it = reader.bytes();
-        do io_error::cond.trap(|_| ()).inside {
+        io_error::cond.trap(|_| ()).inside(|| {
             let byte = it.next();
             assert!(byte == None);
-        }
+        })
     }
 
     #[test]
@@ -328,10 +328,10 @@ mod test {
     #[test]
     fn read_bytes_eof() {
         let mut reader = MemReader::new(~[10, 11]);
-        do io_error::cond.trap(|_| {
-        }).inside {
+        io_error::cond.trap(|_| {
+        }).inside(|| {
             assert!(reader.read_bytes(4) == ~[10, 11]);
-        }
+        })
     }
 
     #[test]
@@ -356,11 +356,11 @@ mod test {
     fn push_bytes_eof() {
         let mut reader = MemReader::new(~[10, 11]);
         let mut buf = ~[8, 9];
-        do io_error::cond.trap(|_| {
-        }).inside {
+        io_error::cond.trap(|_| {
+        }).inside(|| {
             reader.push_bytes(&mut buf, 4);
             assert!(buf == ~[8, 9, 10, 11]);
-        }
+        })
     }
 
     #[test]
@@ -369,9 +369,9 @@ mod test {
             count: 0,
         };
         let mut buf = ~[8, 9];
-        do io_error::cond.trap(|_| { } ).inside {
+        io_error::cond.trap(|_| { } ).inside(|| {
             reader.push_bytes(&mut buf, 4);
-        }
+        });
         assert!(buf == ~[8, 9, 10]);
     }
 
@@ -384,13 +384,13 @@ mod test {
             count: 0,
         };
         let buf = @mut ~[8, 9];
-        do (|| {
+        (|| {
             reader.push_bytes(&mut *buf, 4);
-        }).finally {
+        }).finally(|| {
             // NB: Using rtassert here to trigger abort on failure since this is a should_fail test
             // FIXME: #7049 This fails because buf is still borrowed
             //rtassert!(*buf == ~[8, 9, 10]);
-        }
+        })
     }
 
     #[test]
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index decdfb60bfb..b08f4af9a54 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -331,12 +331,12 @@ mod test {
         writer.write([0]);
 
         let mut called = false;
-        do io_error::cond.trap(|err| {
+        io_error::cond.trap(|err| {
             assert_eq!(err.kind, OtherIoError);
             called = true;
-        }).inside {
+        }).inside(|| {
             writer.write([0, 0]);
-        }
+        });
         assert!(called);
     }
 
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index ac099e67f79..aa7a64d2210 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -157,14 +157,14 @@ mod test {
     fn bind_error() {
         do run_in_mt_newsched_task {
             let mut called = false;
-            do io_error::cond.trap(|e| {
+            io_error::cond.trap(|e| {
                 assert!(e.kind == PermissionDenied);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
                 let listener = TcpListener::bind(addr);
                 assert!(listener.is_none());
-            }
+            });
             assert!(called);
         }
     }
@@ -173,7 +173,7 @@ mod test {
     fn connect_error() {
         do run_in_mt_newsched_task {
             let mut called = false;
-            do io_error::cond.trap(|e| {
+            io_error::cond.trap(|e| {
                 let expected_error = if cfg!(unix) {
                     ConnectionRefused
                 } else {
@@ -182,11 +182,11 @@ mod test {
                 };
                 assert_eq!(e.kind, expected_error);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
                 let stream = TcpStream::connect(addr);
                 assert!(stream.is_none());
-            }
+            });
             assert!(called);
         }
     }
@@ -306,16 +306,16 @@ mod test {
                 let mut buf = [0];
                 let nread = stream.read(buf);
                 assert!(nread.is_none());
-                do io_error::cond.trap(|e| {
+                io_error::cond.trap(|e| {
                     if cfg!(windows) {
                         assert_eq!(e.kind, NotConnected);
                     } else {
                         fail!();
                     }
-                }).inside {
+                }).inside(|| {
                     let nread = stream.read(buf);
                     assert!(nread.is_none());
-                }
+                })
             }
 
             do spawntask {
@@ -341,16 +341,16 @@ mod test {
                 let mut buf = [0];
                 let nread = stream.read(buf);
                 assert!(nread.is_none());
-                do io_error::cond.trap(|e| {
+                io_error::cond.trap(|e| {
                     if cfg!(windows) {
                         assert_eq!(e.kind, NotConnected);
                     } else {
                         fail!();
                     }
-                }).inside {
+                }).inside(|| {
                     let nread = stream.read(buf);
                     assert!(nread.is_none());
-                }
+                })
             }
 
             do spawntask {
@@ -376,7 +376,7 @@ mod test {
                 let buf = [0];
                 loop {
                     let mut stop = false;
-                    do io_error::cond.trap(|e| {
+                    io_error::cond.trap(|e| {
                         // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
                         //     on windows
                         assert!(e.kind == ConnectionReset ||
@@ -384,9 +384,9 @@ mod test {
                                 e.kind == ConnectionAborted,
                                 "unknown error: {:?}", e);
                         stop = true;
-                    }).inside {
+                    }).inside(|| {
                         stream.write(buf);
-                    }
+                    });
                     if stop { break }
                 }
             }
@@ -414,7 +414,7 @@ mod test {
                 let buf = [0];
                 loop {
                     let mut stop = false;
-                    do io_error::cond.trap(|e| {
+                    io_error::cond.trap(|e| {
                         // NB: ECONNRESET on linux, EPIPE on mac, ECONNABORTED
                         //     on windows
                         assert!(e.kind == ConnectionReset ||
@@ -422,9 +422,9 @@ mod test {
                                 e.kind == ConnectionAborted,
                                 "unknown error: {:?}", e);
                         stop = true;
-                    }).inside {
+                    }).inside(|| {
                         stream.write(buf);
-                    }
+                    });
                     if stop { break }
                 }
             }
@@ -458,10 +458,10 @@ mod test {
 
             do spawntask {
                 port.take().recv();
-                do max.times {
+                max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
-                }
+                });
             }
         }
     }
@@ -487,10 +487,10 @@ mod test {
 
             do spawntask {
                 port.take().recv();
-                do max.times {
+                max.times(|| {
                     let mut stream = TcpStream::connect(addr);
                     stream.write([99]);
-                }
+                });
             }
         }
     }
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 38def44d9d0..f02fc1ae447 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -116,14 +116,14 @@ mod test {
     fn bind_error() {
         do run_in_mt_newsched_task {
             let mut called = false;
-            do io_error::cond.trap(|e| {
+            io_error::cond.trap(|e| {
                 assert!(e.kind == PermissionDenied);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
                 let socket = UdpSocket::bind(addr);
                 assert!(socket.is_none());
-            }
+            });
             assert!(called);
         }
     }
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index eb86f0ef97f..809473d64c6 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -186,13 +186,13 @@ mod tests {
     fn bind_error() {
         do run_in_mt_newsched_task {
             let mut called = false;
-            do io_error::cond.trap(|e| {
+            io_error::cond.trap(|e| {
                 assert!(e.kind == PermissionDenied);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 let listener = UnixListener::bind(&("path/to/nowhere"));
                 assert!(listener.is_none());
-            }
+            });
             assert!(called);
         }
     }
@@ -201,13 +201,13 @@ mod tests {
     fn connect_error() {
         do run_in_mt_newsched_task {
             let mut called = false;
-            do io_error::cond.trap(|e| {
+            io_error::cond.trap(|e| {
                 assert_eq!(e.kind, OtherIoError);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 let stream = UnixStream::connect(&("path/to/nowhere"));
                 assert!(stream.is_none());
-            }
+            });
             assert!(called);
         }
     }
@@ -240,13 +240,13 @@ mod tests {
             let buf = [0];
             let mut stop = false;
             while !stop{
-                do io_error::cond.trap(|e| {
+                io_error::cond.trap(|e| {
                     assert!(e.kind == BrokenPipe || e.kind == NotConnected,
                             "unknown error {:?}", e);
                     stop = true;
-                }).inside {
+                }).inside(|| {
                     server.write(buf);
-                }
+                })
             }
         }, |_client| {
             // drop the client
@@ -266,20 +266,20 @@ mod tests {
             do spawntask {
                 let mut acceptor = UnixListener::bind(&path1).listen();
                 chan.take().send(());
-                do times.times {
+                times.times(|| {
                     let mut client = acceptor.accept();
                     let mut buf = [0];
                     client.read(buf);
                     assert_eq!(buf[0], 100);
-                }
+                })
             }
 
             do spawntask {
                 port.take().recv();
-                do times.times {
+                times.times(|| {
                     let mut stream = UnixStream::connect(&path2);
                     stream.write([100]);
-                }
+                })
             }
         }
     }
diff --git a/src/libstd/io/option.rs b/src/libstd/io/option.rs
index 5938252571f..61c5411f360 100644
--- a/src/libstd/io/option.rs
+++ b/src/libstd/io/option.rs
@@ -125,21 +125,21 @@ mod test {
             let mut writer: Option<MemWriter> = None;
 
             let mut called = false;
-            do io_error::cond.trap(|err| {
+            io_error::cond.trap(|err| {
                 assert_eq!(err.kind, PreviousIoError);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 writer.write([0, 0, 0]);
-            }
+            });
             assert!(called);
 
             let mut called = false;
-            do io_error::cond.trap(|err| {
+            io_error::cond.trap(|err| {
                 assert_eq!(err.kind, PreviousIoError);
                 called = true;
-            }).inside {
+            }).inside(|| {
                 writer.flush();
-            }
+            });
             assert!(called);
         }
     }
@@ -161,21 +161,21 @@ mod test {
         let mut buf = [];
 
         let mut called = false;
-        do io_error::cond.trap(|err| {
+        io_error::cond.trap(|err| {
             assert_eq!(err.kind, PreviousIoError);
             called = true;
-        }).inside {
+        }).inside(|| {
             reader.read(buf);
-        }
+        });
         assert!(called);
 
         let mut called = false;
-        do io_error::cond.trap(|err| {
+        io_error::cond.trap(|err| {
             assert_eq!(err.kind, PreviousIoError);
             called = true;
-        }).inside {
+        }).inside(|| {
             assert!(reader.eof());
-        }
+        });
         assert!(called);
     }
 }
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index b1958bde60d..75a7d5db132 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -2674,13 +2674,13 @@ mod tests {
     fn test_rposition_fail() {
         let v = [(~0, @0), (~0, @0), (~0, @0), (~0, @0)];
         let mut i = 0;
-        do v.iter().rposition |_elt| {
+        v.iter().rposition(|_elt| {
             if i == 2 {
                 fail!()
             }
             i += 1;
             false
-        };
+        });
     }
 
 
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 89907c7434c..335bbc8b1da 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -479,19 +479,19 @@ mod tests {
         static key: Key<~int> = &Key;
         set(key, ~1);
 
-        do get(key) |v| {
-            do get(key) |v| {
-                do get(key) |v| {
+        get(key, |v| {
+            get(key, |v| {
+                get(key, |v| {
                     assert_eq!(**v.unwrap(), 1);
-                }
+                });
                 assert_eq!(**v.unwrap(), 1);
-            }
+            });
             assert_eq!(**v.unwrap(), 1);
-        }
+        });
         set(key, ~2);
-        do get(key) |v| {
+        get(key, |v| {
             assert_eq!(**v.unwrap(), 2);
-        }
+        })
     }
 
     #[test]
@@ -499,13 +499,13 @@ mod tests {
         static key: Key<int> = &Key;
         set(key, 1);
 
-        do get_mut(key) |v| {
+        get_mut(key, |v| {
             *v.unwrap() = 2;
-        }
+        });
 
-        do get(key) |v| {
+        get(key, |v| {
             assert_eq!(*v.unwrap(), 2);
-        }
+        })
     }
 
     #[test]
@@ -533,9 +533,9 @@ mod tests {
     fn test_nested_get_set1() {
         static key: Key<int> = &Key;
         set(key, 4);
-        do get(key) |_| {
+        get(key, |_| {
             set(key, 4);
-        }
+        })
     }
 
     #[test]
@@ -543,9 +543,9 @@ mod tests {
     fn test_nested_get_mut2() {
         static key: Key<int> = &Key;
         set(key, 4);
-        do get(key) |_| {
+        get(key, |_| {
             get_mut(key, |_| {})
-        }
+        })
     }
 
     #[test]
@@ -553,9 +553,9 @@ mod tests {
     fn test_nested_get_mut3() {
         static key: Key<int> = &Key;
         set(key, 4);
-        do get_mut(key) |_| {
+        get_mut(key, |_| {
             get(key, |_| {})
-        }
+        })
     }
 
     #[test]
@@ -563,8 +563,8 @@ mod tests {
     fn test_nested_get_mut4() {
         static key: Key<int> = &Key;
         set(key, 4);
-        do get_mut(key) |_| {
+        get_mut(key, |_| {
             get_mut(key, |_| {})
-        }
+        })
     }
 }
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 5d713f1a622..1028cef9dc6 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -750,16 +750,16 @@ mod bench {
     #[bench]
     fn uint_to_str_rand(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();
-        do bh.iter {
+        bh.iter(|| {
             rng.gen::<uint>().to_str();
-        }
+        })
     }
 
     #[bench]
     fn float_to_str_rand(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();
-        do bh.iter {
+        bh.iter(|| {
             f64::to_str(rng.gen());
-        }
+        })
     }
 }
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 1cc0c191501..cf7047bd068 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -244,6 +244,6 @@ pub fn test_times() {
     use num::Times;
     let ten = 10 as uint;
     let mut accum = 0;
-    do ten.times { accum += 1; }
+    ten.times(|| { accum += 1; });
     assert!((accum == 10));
 }
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index c5a10c75640..715072653a7 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -612,14 +612,14 @@ mod tests {
     #[test]
     fn test_option_while_some() {
         let mut i = 0;
-        do Some(10).while_some |j| {
+        Some(10).while_some(|j| {
             i += 1;
             if (j > 0) {
                 Some(j-1)
             } else {
                 None
             }
-        }
+        });
         assert_eq!(i, 11);
     }
 
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index dcd08295331..ddfb43ed56f 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -523,35 +523,35 @@ mod tests {
         use path::null_byte::cond;
 
         let mut handled = false;
-        let mut p = do cond.trap(|v| {
+        let mut p = cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("foo/bar", 0));
             (b!("/bar").to_owned())
-        }).inside {
+        }).inside(|| {
             Path::new(b!("foo/bar", 0))
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("/bar"));
 
         handled = false;
-        do cond.trap(|v| {
+        cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("f", 0, "o"));
             (b!("foo").to_owned())
-        }).inside {
+        }).inside(|| {
             p.set_filename(b!("f", 0, "o"))
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("/foo"));
 
         handled = false;
-        do cond.trap(|v| {
+        cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("f", 0, "o"));
             (b!("foo").to_owned())
-        }).inside {
+        }).inside(|| {
             p.push(b!("f", 0, "o"));
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("/foo/foo"));
     }
@@ -573,29 +573,29 @@ mod tests {
         )
 
         t!(~"new() w/nul" => {
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 Path::new(b!("foo/bar", 0))
-            };
+            });
         })
 
         t!(~"set_filename w/nul" => {
             let mut p = Path::new(b!("foo/bar"));
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 p.set_filename(b!("foo", 0))
-            };
+            });
         })
 
         t!(~"push w/nul" => {
             let mut p = Path::new(b!("foo/bar"));
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 p.push(b!("foo", 0))
-            };
+            });
         })
     }
 
@@ -621,10 +621,10 @@ mod tests {
                 {
                     let mut called = false;
                     let path = Path::new($path);
-                    do path.display().with_str |s| {
+                    path.display().with_str(|s| {
                         assert_eq!(s, $exp);
                         called = true;
-                    };
+                    });
                     assert!(called);
                 }
             );
@@ -632,11 +632,10 @@ mod tests {
                 {
                     let mut called = false;
                     let path = Path::new($path);
-                    do path.filename_display().with_str |s| {
+                    path.filename_display().with_str(|s| {
                         assert_eq!(s, $exp);
                         called = true;
-
-                    };
+                    });
                     assert!(called);
                 }
             )
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 4e736458fd8..cc2af54fd10 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -1248,35 +1248,35 @@ mod tests {
         use path::null_byte::cond;
 
         let mut handled = false;
-        let mut p = do cond.trap(|v| {
+        let mut p = cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("foo\\bar", 0));
             (b!("\\bar").to_owned())
-        }).inside {
+        }).inside(|| {
             Path::new(b!("foo\\bar", 0))
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("\\bar"));
 
         handled = false;
-        do cond.trap(|v| {
+        cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("f", 0, "o"));
             (b!("foo").to_owned())
-        }).inside {
+        }).inside(|| {
             p.set_filename(b!("f", 0, "o"))
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("\\foo"));
 
         handled = false;
-        do cond.trap(|v| {
+        cond.trap(|v| {
             handled = true;
             assert_eq!(v.as_slice(), b!("f", 0, "o"));
             (b!("foo").to_owned())
-        }).inside {
+        }).inside(|| {
             p.push(b!("f", 0, "o"));
-        };
+        });
         assert!(handled);
         assert_eq!(p.as_vec(), b!("\\foo\\foo"));
     }
@@ -1298,29 +1298,29 @@ mod tests {
         )
 
         t!(~"from_vec() w\\nul" => {
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 Path::new(b!("foo\\bar", 0))
-            };
+            });
         })
 
         t!(~"set_filename w\\nul" => {
             let mut p = Path::new(b!("foo\\bar"));
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 p.set_filename(b!("foo", 0))
-            };
+            });
         })
 
         t!(~"push w\\nul" => {
             let mut p = Path::new(b!("foo\\bar"));
-            do cond.trap(|_| {
+            cond.trap(|_| {
                 (b!("null", 0).to_owned())
-            }).inside {
+            }).inside(|| {
                 p.push(b!("foo", 0))
-            };
+            });
         })
     }
 
@@ -1339,17 +1339,17 @@ mod tests {
 
         let mut called = false;
         let path = Path::new("foo");
-        do path.display().with_str |s| {
+        path.display().with_str(|s| {
             assert_eq!(s, "foo");
             called = true;
-        };
+        });
         assert!(called);
         called = false;
         let path = Path::new(b!("\\"));
-        do path.filename_display().with_str |s| {
+        path.filename_display().with_str(|s| {
             assert_eq!(s, "");
             called = true;
-        }
+        });
         assert!(called);
     }
 
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 9f60c3a32b2..9b9636af901 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -492,28 +492,28 @@ pub mod ptr_tests {
     fn test_position() {
         use libc::c_char;
 
-        do "hello".with_c_str |p| {
+        "hello".with_c_str(|p| {
             unsafe {
                 assert!(2u == position(p, |c| *c == 'l' as c_char));
                 assert!(4u == position(p, |c| *c == 'o' as c_char));
                 assert!(5u == position(p, |c| *c == 0 as c_char));
             }
-        }
+        })
     }
 
     #[test]
     fn test_buf_len() {
-        do "hello".with_c_str |p0| {
-            do "there".with_c_str |p1| {
-                do "thing".with_c_str |p2| {
+        "hello".with_c_str(|p0| {
+            "there".with_c_str(|p1| {
+                "thing".with_c_str(|p2| {
                     let v = ~[p0, p1, p2, null()];
-                    do v.as_imm_buf |vp, len| {
+                    v.as_imm_buf(|vp, len| {
                         assert_eq!(unsafe { buf_len(vp) }, 3u);
                         assert_eq!(len, 4u);
-                    }
-                }
-            }
-        }
+                    })
+                })
+            })
+        })
     }
 
     #[test]
@@ -621,23 +621,23 @@ pub mod ptr_tests {
                 one, two, three
             ];
 
-            do arr.as_imm_buf |arr_ptr, arr_len| {
+            arr.as_imm_buf(|arr_ptr, arr_len| {
                 let mut ctr = 0;
                 let mut iteration_count = 0;
-                do array_each_with_len(arr_ptr, arr_len) |e| {
+                array_each_with_len(arr_ptr, arr_len, |e| {
                      let actual = str::raw::from_c_str(e);
-                     let expected = do expected_arr[ctr].with_ref |buf| {
+                     let expected = expected_arr[ctr].with_ref(|buf| {
                          str::raw::from_c_str(buf)
-                     };
+                     });
                      debug!(
                          "test_ptr_array_each_with_len e: {}, a: {}",
                          expected, actual);
                      assert_eq!(actual, expected);
                      ctr += 1;
                      iteration_count += 1;
-                 }
+                });
                 assert_eq!(iteration_count, 3u);
-            }
+            })
         }
     }
 
@@ -658,23 +658,23 @@ pub mod ptr_tests {
                 one, two, three
             ];
 
-            do arr.as_imm_buf |arr_ptr, _| {
+            arr.as_imm_buf(|arr_ptr, _| {
                 let mut ctr = 0;
                 let mut iteration_count = 0;
-                do array_each(arr_ptr) |e| {
+                array_each(arr_ptr, |e| {
                      let actual = str::raw::from_c_str(e);
-                     let expected = do expected_arr[ctr].with_ref |buf| {
+                     let expected = expected_arr[ctr].with_ref(|buf| {
                          str::raw::from_c_str(buf)
-                     };
+                     });
                      debug!(
                          "test_ptr_array_each e: {}, a: {}",
                          expected, actual);
                      assert_eq!(actual, expected);
                      ctr += 1;
                      iteration_count += 1;
-                 }
+                });
                 assert_eq!(iteration_count, 3);
-            }
+            })
         }
     }
 
diff --git a/src/libstd/rand/distributions/gamma.rs b/src/libstd/rand/distributions/gamma.rs
index 7e8c193cb77..e0428742459 100644
--- a/src/libstd/rand/distributions/gamma.rs
+++ b/src/libstd/rand/distributions/gamma.rs
@@ -184,11 +184,11 @@ mod bench {
         let gamma = Gamma::new(10., 1.0);
         let mut rng = StdRng::new();
 
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 gamma.ind_sample(&mut rng);
             }
-        }
+        });
         bh.bytes = size_of::<f64>() as u64 * RAND_BENCH_N;
     }
 
@@ -197,11 +197,11 @@ mod bench {
         let gamma = Gamma::new(0.1, 1.0);
         let mut rng = StdRng::new();
 
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 gamma.ind_sample(&mut rng);
             }
-        }
+        });
         bh.bytes = size_of::<f64>() as u64 * RAND_BENCH_N;
     }
 }
diff --git a/src/libstd/rand/distributions/mod.rs b/src/libstd/rand/distributions/mod.rs
index 247a7824a44..4778e81f951 100644
--- a/src/libstd/rand/distributions/mod.rs
+++ b/src/libstd/rand/distributions/mod.rs
@@ -571,11 +571,11 @@ mod bench {
         let mut rng = XorShiftRng::new();
         let mut normal = Normal::new(-2.71828, 3.14159);
 
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 normal.sample(&mut rng);
             }
-        }
+        });
         bh.bytes = size_of::<f64>() as u64 * RAND_BENCH_N;
     }
     #[bench]
@@ -583,11 +583,11 @@ mod bench {
         let mut rng = XorShiftRng::new();
         let mut exp = Exp::new(2.71828 * 3.14159);
 
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 exp.sample(&mut rng);
             }
-        }
+        });
         bh.bytes = size_of::<f64>() as u64 * RAND_BENCH_N;
     }
 }
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 39b4cca2063..ae53ef8b7c0 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -899,44 +899,44 @@ mod bench {
     #[bench]
     fn rand_xorshift(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 rng.gen::<uint>();
             }
-        }
+        });
         bh.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
     }
 
     #[bench]
     fn rand_isaac(bh: &mut BenchHarness) {
         let mut rng = IsaacRng::new();
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 rng.gen::<uint>();
             }
-        }
+        });
         bh.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
     }
 
     #[bench]
     fn rand_isaac64(bh: &mut BenchHarness) {
         let mut rng = Isaac64Rng::new();
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 rng.gen::<uint>();
             }
-        }
+        });
         bh.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
     }
 
     #[bench]
     fn rand_std(bh: &mut BenchHarness) {
         let mut rng = StdRng::new();
-        do bh.iter {
+        bh.iter(|| {
             for _ in range(0, RAND_BENCH_N) {
                 rng.gen::<uint>();
             }
-        }
+        });
         bh.bytes = size_of::<uint>() as u64 * RAND_BENCH_N;
     }
 
@@ -944,8 +944,8 @@ mod bench {
     fn rand_shuffle_100(bh: &mut BenchHarness) {
         let mut rng = XorShiftRng::new();
         let x : &mut[uint] = [1,..100];
-        do bh.iter {
+        bh.iter(|| {
             rng.shuffle_mut(x);
-        }
+        })
     }
 }
diff --git a/src/libstd/result.rs b/src/libstd/result.rs
index 97daf8d7e60..ff425a8a73b 100644
--- a/src/libstd/result.rs
+++ b/src/libstd/result.rs
@@ -139,9 +139,9 @@ impl<T, E: ToStr> Result<T, E> {
     ///
     /// Example:
     ///
-    ///     let res = do read_file(file).map |buf| {
+    ///     let res = read_file(file).map(|buf| {
     ///         parse_bytes(buf)
-    ///     }
+    ///     })
     #[inline]
     pub fn map<U>(self, op: |T| -> U) -> Result<U,E> {
         match self {
@@ -462,11 +462,11 @@ mod tests {
     pub fn test_impl_iter() {
         let mut valid = false;
         let okval = Ok::<~str, ~str>(~"a");
-        do okval.iter().next().map |_| { valid = true; };
+        okval.iter().next().map(|_| { valid = true; });
         assert!(valid);
 
         let errval = Err::<~str, ~str>(~"b");
-        do errval.iter().next().map |_| { valid = false; };
+        errval.iter().next().map(|_| { valid = false; });
         assert!(valid);
     }
 
@@ -474,12 +474,12 @@ mod tests {
     pub fn test_impl_iter_err() {
         let mut valid = true;
         let okval = Ok::<~str, ~str>(~"a");
-        do okval.iter_err().next().map |_| { valid = false };
+        okval.iter_err().next().map(|_| { valid = false });
         assert!(valid);
 
         valid = false;
         let errval = Err::<~str, ~str>(~"b");
-        do errval.iter_err().next().map |_| { valid = true };
+        errval.iter_err().next().map(|_| { valid = true });
         assert!(valid);
     }
 
diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index e3e425f620b..52a6d67cb05 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -1013,7 +1013,7 @@ mod test {
 
             total.times(|| {
                 port.recv();
-            })
+            });
         }
     }
 
@@ -1041,7 +1041,7 @@ mod test {
 
             total.times(|| {
                 end_port.recv();
-            })
+            });
         }
     }
 
@@ -1071,7 +1071,7 @@ mod test {
                     do spawntask_random {
                         chan_clone.send(());
                     }
-                })
+                });
             }
             let end_chan_clone = end_chan.clone();
             do spawntask_random {
@@ -1082,7 +1082,7 @@ mod test {
                         let recvd = port_clone.try_recv().is_some();
                         end_chan_clone.send(recvd);
                     }
-                })
+                });
             }
 
             let mut recvd = 0;
@@ -1112,12 +1112,12 @@ mod test {
                 let pipe_clone = pipe.clone();
                 let end_chan_clone = end_chan.clone();
                 do spawntask_random {
-                    do msgs.times {
+                    msgs.times(|| {
                         pipe_clone.send(());
-                    }
-                    do msgs.times {
+                    });
+                    msgs.times(|| {
                         pipe_clone.recv();
-                    }
+                    });
                 }
 
                 end_chan_clone.send(());
@@ -1125,7 +1125,7 @@ mod test {
 
             total.times(|| {
                 end_port.recv();
-            })
+            });
         }
     }
 
diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index 76ccacb331f..6dcbd4a129e 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -61,9 +61,9 @@ pub fn get_crate_map() -> Option<&'static CrateMap<'static>> {
         } else {
             "_rust_crate_map_toplevel"
         };
-        let sym = do rust_crate_map_toplevel.with_c_str |buf| {
+        let sym = rust_crate_map_toplevel.with_c_str(|buf| {
             dl::symbol(module, buf)
-        };
+        });
         dl::close(module);
         sym
     };
@@ -141,10 +141,10 @@ mod tests {
 
         let mut cnt = 0;
         unsafe {
-            do iter_crate_map(&root_crate) |entry| {
+            iter_crate_map(&root_crate, |entry| {
                 assert!(*entry.log_level == 3);
                 cnt += 1;
-            }
+            });
             assert!(cnt == 1);
         }
     }
@@ -183,10 +183,10 @@ mod tests {
 
         let mut cnt = 0;
         unsafe {
-            do iter_crate_map(&root_crate) |entry| {
+            iter_crate_map(&root_crate, |entry| {
                 assert!(*entry.log_level == cnt);
                 cnt += 1;
-            }
+            });
             assert!(cnt == 4);
         }
     }
diff --git a/src/libstd/rt/global_heap.rs b/src/libstd/rt/global_heap.rs
index 08d111da351..3147e3c8a07 100644
--- a/src/libstd/rt/global_heap.rs
+++ b/src/libstd/rt/global_heap.rs
@@ -103,15 +103,15 @@ mod bench {
 
     #[bench]
     fn alloc_owned_small(bh: &mut BenchHarness) {
-        do bh.iter {
+        bh.iter(|| {
             ~10;
-        }
+        })
     }
 
     #[bench]
     fn alloc_owned_big(bh: &mut BenchHarness) {
-        do bh.iter {
+        bh.iter(|| {
             ~[10, ..1000];
-        }
+        })
     }
 }
diff --git a/src/libstd/rt/local.rs b/src/libstd/rt/local.rs
index 23345926543..d5b0e384ca2 100644
--- a/src/libstd/rt/local.rs
+++ b/src/libstd/rt/local.rs
@@ -182,9 +182,9 @@ mod test {
             let task = ~Task::new_root(&mut sched.stack_pool, None, || {});
             Local::put(task);
 
-            let res = do Local::borrow |_task: &mut Task| {
+            let res = Local::borrow(|_task: &mut Task| {
                 true
-            };
+            });
             assert!(res)
                 let task: ~Task = Local::take();
             cleanup_task(task);
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index a7805a9f559..c98a66453eb 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -311,11 +311,11 @@ mod bench {
 
     #[bench]
     fn alloc_managed_small(bh: &mut BenchHarness) {
-        bh.iter(|| @10);
+        bh.iter(|| { @10; });
     }
 
     #[bench]
     fn alloc_managed_big(bh: &mut BenchHarness) {
-        bh.iter(|| @[10, ..1000]);
+        bh.iter(|| { @[10, ..1000]; });
     }
 }
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 519274bb131..ccc786242e6 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -1176,7 +1176,7 @@ mod test {
         use util;
 
         do run_in_bare_thread {
-            do stress_factor().times {
+            stress_factor().times(|| {
                 let sleepers = SleeperList::new();
                 let queue = WorkQueue::new();
                 let queues = ~[queue.clone()];
@@ -1205,7 +1205,7 @@ mod test {
                 util::ignore(handle);
 
                 thread.join();
-            }
+            })
         }
     }
 
@@ -1218,14 +1218,14 @@ mod test {
 
         do run_in_mt_newsched_task {
             let mut ports = ~[];
-            do 10.times {
+            10.times(|| {
                 let (port, chan) = oneshot();
                 let chan_cell = Cell::new(chan);
                 do spawntask_later {
                     chan_cell.take().send(());
                 }
                 ports.push(port);
-            }
+            });
 
             while !ports.is_empty() {
                 ports.pop().recv();
@@ -1315,7 +1315,7 @@ mod test {
     fn dont_starve_1() {
         use rt::comm::oneshot;
 
-        do stress_factor().times {
+        stress_factor().times(|| {
             do run_in_mt_newsched_task {
                 let (port, chan) = oneshot();
 
@@ -1327,14 +1327,14 @@ mod test {
 
                 chan.send(());
             }
-        }
+        })
     }
 
     #[test]
     fn dont_starve_2() {
         use rt::comm::oneshot;
 
-        do stress_factor().times {
+        stress_factor().times(|| {
             do run_in_newsched_task {
                 let (port, chan) = oneshot();
                 let (_port2, chan2) = stream();
@@ -1349,7 +1349,7 @@ mod test {
 
                 chan.send(());
             }
-        }
+        })
     }
 
     // Regression test for a logic bug that would cause single-threaded schedulers
@@ -1360,7 +1360,7 @@ mod test {
         use num::Times;
 
         do spawn_sched(SingleThreaded) {
-            do 5.times { deschedule(); }
+            5.times(|| { deschedule(); })
         }
         do spawn { }
         do spawn { }
diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs
index 360764daf15..0d4171d5a64 100644
--- a/src/libstd/rt/tube.rs
+++ b/src/libstd/rt/tube.rs
@@ -103,11 +103,11 @@ mod test {
             let tube_clone = tube.clone();
             let tube_clone_cell = Cell::new(tube_clone);
             let sched: ~Scheduler = Local::take();
-            do sched.deschedule_running_task_and_then |sched, task| {
+            sched.deschedule_running_task_and_then(|sched, task| {
                 let mut tube_clone = tube_clone_cell.take();
                 tube_clone.send(1);
                 sched.enqueue_blocked_task(task);
-            }
+            });
 
             assert!(tube.recv() == 1);
         }
@@ -120,7 +120,7 @@ mod test {
             let tube_clone = tube.clone();
             let tube_clone = Cell::new(tube_clone);
             let sched: ~Scheduler = Local::take();
-            do sched.deschedule_running_task_and_then |sched, task| {
+            sched.deschedule_running_task_and_then(|sched, task| {
                 let tube_clone = Cell::new(tube_clone.take());
                 do sched.event_loop.callback {
                     let mut tube_clone = tube_clone.take();
@@ -129,7 +129,7 @@ mod test {
                     tube_clone.send(1);
                 }
                 sched.enqueue_blocked_task(task);
-            }
+            });
 
             assert!(tube.recv() == 1);
         }
@@ -144,14 +144,14 @@ mod test {
             let tube_clone = tube.clone();
             let tube_clone = Cell::new(tube_clone);
             let sched: ~Scheduler = Local::take();
-            do sched.deschedule_running_task_and_then |sched, task| {
+            sched.deschedule_running_task_and_then(|sched, task| {
                 callback_send(tube_clone.take(), 0);
 
                 fn callback_send(tube: Tube<int>, i: int) {
                     if i == 100 { return; }
 
                     let tube = Cell::new(Cell::new(tube));
-                    do Local::borrow |sched: &mut Scheduler| {
+                    Local::borrow(|sched: &mut Scheduler| {
                         let tube = tube.take();
                         do sched.event_loop.callback {
                             let mut tube = tube.take();
@@ -160,11 +160,11 @@ mod test {
                             tube.send(i);
                             callback_send(tube, i + 1);
                         }
-                    }
+                    })
                 }
 
                 sched.enqueue_blocked_task(task);
-            }
+            });
 
             for i in range(0, MAX) {
                 let j = tube.recv();
diff --git a/src/libstd/select.rs b/src/libstd/select.rs
index b619085e201..9b83c493065 100644
--- a/src/libstd/select.rs
+++ b/src/libstd/select.rs
@@ -211,7 +211,7 @@ mod test {
         do run_in_uv_task {
             let (ports, _) = unzip(range(0u, 10).map(|_| stream::<int>()));
             let (port, chan) = stream();
-            do 10.times { chan.send(31337); }
+            10.times(|| { chan.send(31337); });
             let mut ports = ports;
             let mut port = Some(port);
             let order = [5u,0,4,3,2,6,9,8,7,1];
@@ -276,7 +276,7 @@ mod test {
 
             do run_in_uv_task {
                 // A bit of stress, since ordinarily this is just smoke and mirrors.
-                do 4.times {
+                4.times(|| {
                     let send_on_chans = send_on_chans.clone();
                     do task::spawn {
                         let mut ports = ~[];
@@ -294,7 +294,7 @@ mod test {
                         // nondeterministic result, but should succeed
                         select(ports);
                     }
-                }
+                })
             }
         }
     }
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index b2ded6ab754..f65ec6971ab 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -3966,19 +3966,25 @@ mod bench {
                         Lorem ipsum dolor sit amet, consectetur. ");
 
         assert_eq!(100, s.len());
-        bh.iter(|| is_utf8(s));
+        bh.iter(|| {
+            let _ = is_utf8(s);
+        });
     }
 
     #[bench]
     fn is_utf8_100_multibyte(bh: &mut BenchHarness) {
         let s = bytes!("𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰");
         assert_eq!(100, s.len());
-        bh.iter(|| is_utf8(s));
+        bh.iter(|| {
+            let _ = is_utf8(s);
+        });
     }
 
     #[bench]
     fn bench_with_capacity(bh: &mut BenchHarness) {
-        bh.iter(|| with_capacity(100));
+        bh.iter(|| {
+            let _ = with_capacity(100);
+        });
     }
 
     #[bench]
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index 85f66d4ada8..189f1436d42 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -477,9 +477,9 @@ fn test_unnamed_task() {
 
     do run_in_uv_task {
         do spawn {
-            do with_task_name |name| {
+            with_task_name(|name| {
                 assert!(name.is_none());
-            }
+            })
         }
     }
 }
@@ -492,9 +492,9 @@ fn test_owned_named_task() {
         let mut t = task();
         t.name(~"ada lovelace");
         do t.spawn {
-            do with_task_name |name| {
+            with_task_name(|name| {
                 assert!(name.unwrap() == "ada lovelace");
-            }
+            })
         }
     }
 }
@@ -507,9 +507,9 @@ fn test_static_named_task() {
         let mut t = task();
         t.name("ada lovelace");
         do t.spawn {
-            do with_task_name |name| {
+            with_task_name(|name| {
                 assert!(name.unwrap() == "ada lovelace");
-            }
+            })
         }
     }
 }
@@ -522,9 +522,9 @@ fn test_send_named_task() {
         let mut t = task();
         t.name("ada lovelace".into_send_str());
         do t.spawn {
-            do with_task_name |name| {
+            with_task_name(|name| {
                 assert!(name.unwrap() == "ada lovelace");
-            }
+            })
         }
     }
 }
@@ -606,9 +606,9 @@ fn test_try_fail() {
 
 #[cfg(test)]
 fn get_sched_id() -> int {
-    do Local::borrow |sched: &mut ::rt::sched::Scheduler| {
+    Local::borrow(|sched: &mut ::rt::sched::Scheduler| {
         sched.sched_id() as int
-    }
+    })
 }
 
 #[test]
@@ -666,7 +666,7 @@ fn test_spawn_sched_blocking() {
 
         // Testing that a task in one scheduler can block in foreign code
         // without affecting other schedulers
-        do 20u.times {
+        20u.times(|| {
             let (start_po, start_ch) = stream();
             let (fin_po, fin_ch) = stream();
 
@@ -713,7 +713,7 @@ fn test_spawn_sched_blocking() {
             lock.unlock();
             fin_po.recv();
             lock.destroy();
-        }
+        })
     }
 }
 
@@ -740,21 +740,21 @@ fn test_avoid_copying_the_body_spawn() {
 
 #[test]
 fn test_avoid_copying_the_body_task_spawn() {
-    do avoid_copying_the_body |f| {
+    avoid_copying_the_body(|f| {
         let builder = task();
         do builder.spawn || {
             f();
         }
-    }
+    })
 }
 
 #[test]
 fn test_avoid_copying_the_body_try() {
-    do avoid_copying_the_body |f| {
+    avoid_copying_the_body(|f| {
         do try || {
             f()
         };
-    }
+    })
 }
 
 #[test]
diff --git a/src/libstd/unstable/finally.rs b/src/libstd/unstable/finally.rs
index 226ce9ef6f2..57aff6031ba 100644
--- a/src/libstd/unstable/finally.rs
+++ b/src/libstd/unstable/finally.rs
@@ -15,11 +15,11 @@ stack closures that emulates Java-style try/finally blocks.
 # Example
 
  ```
-do || {
+(|| {
     ...
-}.finally {
+}).finally(|| {
     always_run_this();
-}
+})
  ```
 */
 
@@ -70,13 +70,13 @@ impl<'self> Drop for Finallyalizer<'self> {
 #[test]
 fn test_success() {
     let mut i = 0;
-    do (|| {
+    (|| {
         i = 10;
-    }).finally {
+    }).finally(|| {
         assert!(!failing());
         assert_eq!(i, 10);
         i = 20;
-    }
+    });
     assert_eq!(i, 20);
 }
 
@@ -84,19 +84,19 @@ fn test_success() {
 #[should_fail]
 fn test_fail() {
     let mut i = 0;
-    do (|| {
+    (|| {
         i = 10;
         fail!();
-    }).finally {
+    }).finally(|| {
         assert!(failing());
         assert_eq!(i, 10);
-    }
+    })
 }
 
 #[test]
 fn test_retval() {
     let closure: || -> int = || 10;
-    let i = do closure.finally { };
+    let i = closure.finally(|| { });
     assert_eq!(i, 10);
 }
 
diff --git a/src/libstd/util.rs b/src/libstd/util.rs
index 8e939caf756..ddcf408189e 100644
--- a/src/libstd/util.rs
+++ b/src/libstd/util.rs
@@ -178,17 +178,17 @@ mod bench {
     fn trait_vtable_method_call(bh: &mut BenchHarness) {
         let s = Struct { field: 10 };
         let t = &s as &Trait;
-        do bh.iter {
+        bh.iter(|| {
             t.method();
-        }
+        });
     }
 
     #[bench]
     fn trait_static_method_call(bh: &mut BenchHarness) {
         let s = Struct { field: 10 };
-        do bh.iter {
+        bh.iter(|| {
             s.method();
-        }
+        });
     }
 
     // Overhead of various match forms
@@ -196,22 +196,22 @@ mod bench {
     #[bench]
     fn match_option_some(bh: &mut BenchHarness) {
         let x = Some(10);
-        do bh.iter {
+        bh.iter(|| {
             let _q = match x {
                 Some(y) => y,
                 None => 11
             };
-        }
+        });
     }
 
     #[bench]
     fn match_vec_pattern(bh: &mut BenchHarness) {
         let x = [1,2,3,4,5,6];
-        do bh.iter {
+        bh.iter(|| {
             let _q = match x {
                 [1,2,3,.._] => 10,
                 _ => 11
             };
-        }
+        });
     }
 }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index 30627327d73..9dc4f6ae377 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -3878,13 +3878,17 @@ mod bench {
     #[bench]
     fn concat(bh: &mut BenchHarness) {
         let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect());
-        bh.iter(|| xss.concat_vec());
+        bh.iter(|| {
+            let _ = xss.concat_vec();
+        });
     }
 
     #[bench]
     fn connect(bh: &mut BenchHarness) {
         let xss: &[~[uint]] = vec::from_fn(100, |i| range(0, i).collect());
-        bh.iter(|| xss.connect_vec(&0));
+        bh.iter(|| {
+            let _ = xss.connect_vec(&0);
+        });
     }
 
     #[bench]