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

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

7 files changed, 75 insertions, 75 deletions

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);
     }
 }