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

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

Author: pcwalton

src/compiletest/compiletest.rs

@@ -266,12 +266,12 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
         let file = file.clone();
         debug!("inspecting file {}", file.display());
         if is_test(config, &file) {
-            let t = do make_test(config, &file) {
+            let t = make_test(config, &file, || {
                 match config.mode {
                     mode_codegen => make_metrics_test_closure(config, &file),
                     _ => make_test_closure(config, &file)
                 }
-            };
+            });
             tests.push(t)
         }
     }

src/compiletest/header.rs

@@ -39,7 +39,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pp_exact = None;
     let mut debugger_cmds = ~[];
     let mut check_lines = ~[];
-    do iter_header(testfile) |ln| {
+    iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
           None => ()
@@ -74,7 +74,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         };
 
         true
-    };
+    });
     return TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
@@ -91,13 +91,13 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
         ~"xfail-" + util::get_os(config.target)
     }
 
-    let val = do iter_header(testfile) |ln| {
+    let val = iter_header(testfile, |ln| {
         if parse_name_directive(ln, "xfail-test") { false }
         else if parse_name_directive(ln, xfail_target(config)) { false }
         else if config.mode == common::mode_pretty &&
             parse_name_directive(ln, "xfail-pretty") { false }
         else { true }
-    };
+    });
 
     !val
 }
@@ -143,7 +143,7 @@ fn parse_check_line(line: &str) -> Option<~str> {
 }
 
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
-    do parse_name_value_directive(line, ~"exec-env").map |nv| {
+    parse_name_value_directive(line, ~"exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR
         let mut strs: ~[~str] = nv.splitn_iter('=', 1).map(|s| s.to_owned()).collect();
 
@@ -155,7 +155,7 @@ fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
           }
           n => fail!("Expected 1 or 2 strings, not {}", n)
         }
-    }
+    })
 }
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<Path> {

src/compiletest/procsrv.rs

@@ -22,11 +22,11 @@ fn target_env(lib_path: &str, prog: &str) -> ~[(~str,~str)] {
     assert!(prog.ends_with(".exe"));
     let aux_path = prog.slice(0u, prog.len() - 4u).to_owned() + ".libaux";
 
-    env = do env.map() |pair| {
+    env = env.map(|pair| {
         let (k,v) = (*pair).clone();
         if k == ~"PATH" { (~"PATH", v + ";" + lib_path + ";" + aux_path) }
         else { (k,v) }
-    };
+    });
     if prog.ends_with("rustc.exe") {
         env.push((~"RUST_THREADS", ~"1"));
     }

src/compiletest/runtest.rs

@@ -427,9 +427,9 @@ fn check_error_patterns(props: &TestProps,
                         testfile: &Path,
                         ProcRes: &ProcRes) {
     if props.error_patterns.is_empty() {
-        do testfile.display().with_str |s| {
+        testfile.display().with_str(|s| {
             fatal(~"no error pattern specified in " + s);
-        }
+        })
     }
 
     if ProcRes.status.success() {

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

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]

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

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,31 +240,31 @@ 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);
     }
 
     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);
             }
         }

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