use find not echo; this also brings fuzzer under the iron fist of tidy.py!

7 files changed, 94 insertions, 76 deletions

diff --git a/mk/tests.mk b/mk/tests.mk
index f519db29e61..49dc7d1d9eb 100644
--- a/mk/tests.mk
+++ b/mk/tests.mk
@@ -2,11 +2,6 @@
 # Testing variables
 ######################################################################
 
-SOME_TEST_INPUTS = $(wildcard $(S)src/test/*/*.rs)
-
-SOME_MOAR_TEST_INPUTS = $(wildcard $(S)src/test/*/*/*.rs \
-                                   $(S)src/test/*/*.rc)
-
 RPASS_RC := $(wildcard $(S)src/test/run-pass/*.rc)
 RPASS_RS := $(wildcard $(S)src/test/run-pass/*.rs)
 RFAIL_RC := $(wildcard $(S)src/test/run-fail/*.rc)
@@ -124,34 +119,13 @@ ALL_HS := $(filter-out $(S)src/rt/vg/valgrind.h \
 
 tidy:
 		@$(call E, check: formatting)
-		$(Q)echo \
-              $(wildcard $(S)src/etc/*.py)  \
-              $(COMPILER_CRATE) \
-              $(COMPILER_INPUTS) \
-              $(LIBRUSTSYNTAX_CRATE) \
-              $(LIBRUSTSYNTAX_INPUTS) \
-              $(CORELIB_CRATE) \
-              $(CORELIB_INPUTS) \
+		$(Q)find $(S)src -name '*.r[sc]' \
 		| xargs -n 10 python $(S)src/etc/tidy.py
-		$(Q)echo \
-              $(STDLIB_CRATE) \
-              $(STDLIB_INPUTS) \
-              $(COMPILETEST_CRATE) \
-              $(COMPILETEST_INPUTS) \
-              $(CARGO_CRATE) \
-              $(CARGO_INPUTS) \
-              $(RUSTDOC_CRATE) \
-              $(RUSTDOC_INPUTS) \
+		$(Q)find $(S)src/etc -name '*.py' \
 		| xargs -n 10 python $(S)src/etc/tidy.py
-		$(Q)echo \
-              $(SOME_TEST_INPUTS) \
-	  	| xargs -n 10 python $(S)src/etc/tidy.py
-		$(Q)echo \
-              $(SOME_MOAR_TEST_INPUTS) \
+		$(Q)echo $(ALL_CS) \
 	  	| xargs -n 10 python $(S)src/etc/tidy.py
-		$(Q)echo \
-              $(ALL_CS) \
-              $(ALL_HS) \
+		$(Q)echo $(ALL_HS) \
 	  	| xargs -n 10 python $(S)src/etc/tidy.py
 
 endif
diff --git a/src/fuzzer/ast_match.rs b/src/fuzzer/ast_match.rs
index be719017dd6..3f2bf940aa1 100644
--- a/src/fuzzer/ast_match.rs
+++ b/src/fuzzer/ast_match.rs
@@ -1,7 +1,8 @@
 use std;
 import vec;
 
-fn vec_equal<T>(v: [T], u: [T], element_equality_test: fn@(&&T, &&T) -> bool) ->
+fn vec_equal<T>(v: [T], u: [T],
+                element_equality_test: fn@(&&T, &&T) -> bool) ->
    bool {
     let Lv = vec::len(v);
     if Lv != vec::len(u) { ret false; }
diff --git a/src/fuzzer/cycles.rs b/src/fuzzer/cycles.rs
index c07ad4a4cda..e604d4a2357 100644
--- a/src/fuzzer/cycles.rs
+++ b/src/fuzzer/cycles.rs
@@ -3,10 +3,14 @@ import std::rand;
 import uint::range;
 
 // random uint less than n
-fn under(r : rand::rng, n : uint) -> uint { assert n != 0u; r.next() as uint % n }
+fn under(r : rand::rng, n : uint) -> uint {
+    assert n != 0u; r.next() as uint % n
+}
 
 // random choice from a vec
-fn choice<T: copy>(r : rand::rng, v : [const T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
+fn choice<T: copy>(r : rand::rng, v : [const T]) -> T {
+    assert vec::len(v) != 0u; v[under(r, vec::len(v))]
+}
 
 // k in n chance of being true
 fn likelihood(r : rand::rng, k : uint, n : uint) -> bool { under(r, n) < k }
@@ -68,7 +72,8 @@ fn test_cycles(r : rand::rng, k: uint, n: uint)
         if (likelihood(r, k, n)) { v[i].c = @p(choice(r, v)); }
 
         if (likelihood(r, k, n)) { v[i].f = bind nopP(choice(r, v)); }
-        //if (false)               { v[i].g = bind (fn~(_x: @pointy) { })(choice(r, v)); }
+        //if (false)               { v[i].g = bind (fn~(_x: @pointy) { })(
+        // choice(r, v)); }
           // https://github.com/mozilla/rust/issues/1899
 
         if (likelihood(r, k, n)) { v[i].m = [p(choice(r, v))]; }
diff --git a/src/fuzzer/fuzzer.rs b/src/fuzzer/fuzzer.rs
index 7b76487baf7..0d30f9c89a0 100644
--- a/src/fuzzer/fuzzer.rs
+++ b/src/fuzzer/fuzzer.rs
@@ -44,7 +44,8 @@ fn common_exprs() -> [ast::expr] {
     [dse(ast::expr_break),
      dse(ast::expr_cont),
      dse(ast::expr_fail(option::none)),
-     dse(ast::expr_fail(option::some(@dse(ast::expr_lit(@dsl(ast::lit_str("boo"))))))),
+     dse(ast::expr_fail(option::some(
+         @dse(ast::expr_lit(@dsl(ast::lit_str("boo"))))))),
      dse(ast::expr_ret(option::none)),
      dse(ast::expr_lit(@dsl(ast::lit_nil))),
      dse(ast::expr_lit(@dsl(ast::lit_bool(false)))),
@@ -64,9 +65,9 @@ pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
     alt tm {
       tm_converge {
         alt e.node {
-          // If the fuzzer moves a block-ending-in-semicolon into callee position,
-          // the pretty-printer can't preserve this even by parenthesizing!!
-          // See email to marijn.
+          // If the fuzzer moves a block-ending-in-semicolon into callee
+          // position, the pretty-printer can't preserve this even by
+          // parenthesizing!!  See email to marijn.
           ast::expr_if(_, _, _) { false }
           ast::expr_if_check(_, _, _) { false }
           ast::expr_block(_) { false }
@@ -166,18 +167,21 @@ fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
 fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
     alt t {
       ast::ty_infer { false } // always implicit, always top level
-      ast::ty_bot { false }   // in source, can only appear as the out type of a function
+      ast::ty_bot { false }   // in source, can only appear
+                              // as the out type of a function
       ast::ty_mac(_) { false }
       _ { true }
     }
 }
 
 // Replace the |i|th expr (in fold order) of |crate| with |newexpr|.
-fn replace_expr_in_crate(crate: ast::crate, i: uint, newexpr: ast::expr, tm: test_mode) ->
+fn replace_expr_in_crate(crate: ast::crate, i: uint,
+                         newexpr: ast::expr, tm: test_mode) ->
    ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_expr_rep(j_: @mut uint, i_: uint, newexpr_: ast::expr_,
-                     original: ast::expr_, fld: fold::ast_fold, tm_: test_mode) ->
+                     original: ast::expr_, fld: fold::ast_fold,
+                     tm_: test_mode) ->
        ast::expr_ {
         *j_ += 1u;
         if i_ + 1u == *j_ && safe_to_replace_expr(original, tm_) {
@@ -187,8 +191,9 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint, newexpr: ast::expr, tm: tes
         }
     }
     let afp =
-        {fold_expr: fold::wrap(bind fold_expr_rep(j, i, newexpr.node, _, _, tm))
-            with *fold::default_ast_fold()};
+        {fold_expr: fold::wrap(bind fold_expr_rep(j, i,
+                                                  newexpr.node, _, _, tm))
+         with *fold::default_ast_fold()};
     let af = fold::make_fold(afp);
     let crate2: @ast::crate = @af.fold_crate(crate);
     *crate2
@@ -196,11 +201,12 @@ fn replace_expr_in_crate(crate: ast::crate, i: uint, newexpr: ast::expr, tm: tes
 
 
 // Replace the |i|th ty (in fold order) of |crate| with |newty|.
-fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::ty, tm: test_mode) ->
-   ast::crate {
+fn replace_ty_in_crate(crate: ast::crate, i: uint, newty: ast::ty,
+                       tm: test_mode) -> ast::crate {
     let j: @mut uint = @mut 0u;
     fn fold_ty_rep(j_: @mut uint, i_: uint, newty_: ast::ty_,
-                     original: ast::ty_, fld: fold::ast_fold, tm_: test_mode) ->
+                   original: ast::ty_, fld: fold::ast_fold,
+                   tm_: test_mode) ->
        ast::ty_ {
         *j_ += 1u;
         if i_ + 1u == *j_ && safe_to_replace_ty(original, tm_) {
@@ -233,8 +239,11 @@ fn check_variants_of_ast(crate: ast::crate, codemap: codemap::codemap,
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
                                   bind safe_to_use_expr(_, cx.mode));
-    check_variants_T(crate, codemap, filename, "expr", extra_exprs + stolen.exprs, pprust::expr_to_str, replace_expr_in_crate, cx);
-    check_variants_T(crate, codemap, filename, "ty", stolen.tys, pprust::ty_to_str, replace_ty_in_crate, cx);
+    check_variants_T(crate, codemap, filename, "expr",
+                     extra_exprs + stolen.exprs, pprust::expr_to_str,
+                     replace_expr_in_crate, cx);
+    check_variants_T(crate, codemap, filename, "ty", stolen.tys,
+                     pprust::ty_to_str, replace_ty_in_crate, cx);
 }
 
 fn check_variants_T<T: copy>(
@@ -247,7 +256,8 @@ fn check_variants_T<T: copy>(
   replacer: fn@(ast::crate, uint, T, test_mode) -> ast::crate,
   cx: context
   ) {
-    #error("%s contains %u %s objects", filename, vec::len(things), thing_label);
+    #error("%s contains %u %s objects", filename,
+           vec::len(things), thing_label);
 
     let L = vec::len(things);
 
@@ -257,8 +267,8 @@ fn check_variants_T<T: copy>(
             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 testing the
-                // string for stability is easier and ok for now.
+                // It would be best to test the *crate* for stability, but
+                // testing the string for stability is easier and ok for now.
                 let handler = diagnostic::mk_handler(none);
                 let str3 =
                     @as_str(bind pprust::print_crate(
@@ -273,8 +283,11 @@ fn check_variants_T<T: copy>(
                     check_roundtrip_convergence(str3, 1u);
                   }
                   tm_run {
-                    let file_label = #fmt("rusttmp/%s_%s_%u_%u", last_part(filename), thing_label, i, j);
-                    let safe_to_run = !(content_is_dangerous_to_run(*str3) || has_raw_pointers(*crate2));
+                    let file_label = #fmt("rusttmp/%s_%s_%u_%u",
+                                          last_part(filename),
+                                          thing_label, i, j);
+                    let safe_to_run = !(content_is_dangerous_to_run(*str3)
+                                        || has_raw_pointers(*crate2));
                     check_whole_compiler(*str3, file_label, safe_to_run);
                   }
                 }
@@ -292,9 +305,11 @@ enum happiness { passed, cleanly_rejected(str), known_bug(str), failed(str), }
 
 // We'd find more bugs if we could take an AST here, but
 // - that would find many "false positives" or unimportant bugs
-// - that would be tricky, requiring use of tasks or serialization or randomness.
+// - that would be tricky, requiring use of tasks or serialization
+//   or randomness.
 // This seems to find plenty of bugs as it is :)
-fn check_whole_compiler(code: str, suggested_filename_prefix: str, allow_running: bool) {
+fn check_whole_compiler(code: str, suggested_filename_prefix: str,
+                        allow_running: bool) {
     let filename = suggested_filename_prefix + ".rs";
     write_file(filename, code);
 
@@ -331,7 +346,9 @@ fn removeDirIfExists(filename: str) {
 }
 
 fn check_running(exe_filename: str) -> happiness {
-    let p = run::program_output("/Users/jruderman/scripts/timed_run_rust_program.py", [exe_filename]);
+    let p = run::program_output(
+        "/Users/jruderman/scripts/timed_run_rust_program.py",
+        [exe_filename]);
     let comb = p.out + "\n" + p.err;
     if str::len(comb) > 1u {
         log(error, "comb comb comb: " + comb);
@@ -352,17 +369,26 @@ fn check_running(exe_filename: str) -> happiness {
             0         { passed }
             100       { cleanly_rejected("running: explicit fail") }
             101 | 247 { cleanly_rejected("running: timed out") }
-            245 | 246 | 138 | 252 { known_bug("https://github.com/mozilla/rust/issues/1466") }
-            136 | 248 { known_bug("SIGFPE - https://github.com/mozilla/rust/issues/944") }
-            rc        { failed("Rust program ran but exited with status " + int::str(rc)) }
+            245 | 246 | 138 | 252 {
+              known_bug("https://github.com/mozilla/rust/issues/1466")
+            }
+            136 | 248 {
+              known_bug(
+                  "SIGFPE - https://github.com/mozilla/rust/issues/944")
+            }
+            rc {
+              failed("Rust program ran but exited with status " +
+                     int::str(rc))
+            }
         }
     }
 }
 
 fn check_compiling(filename: str) -> happiness {
     let p = run::program_output(
-            "/Users/jruderman/code/rust/build/x86_64-apple-darwin/stage1/bin/rustc",
-            [filename]);
+        "/Users/jruderman/code/rust/build/x86_64-apple-darwin/\
+         stage1/bin/rustc",
+        [filename]);
 
     //#error("Status: %d", p.status);
     if p.status == 0 {
@@ -454,10 +480,11 @@ fn content_might_not_converge(code: str) -> bool {
     let confusing_patterns =
         ["xfail-test",
          "xfail-pretty",
-         "self",       // crazy rules enforced by parser rather than typechecker?
+         "self",       // crazy rules enforced by parser not typechecker?
          "spawn",      // precedence issues?
          "bind",       // precedence issues?
-         " be ",       // don't want to replace its child with a non-call: "Non-call expression in tail call"
+         " be ",       // don't want to replace its child with a non-call:
+                       // "Non-call expression in tail call"
          "\n\n\n\n\n"  // https://github.com/mozilla/rust/issues/850
         ];
 
@@ -467,7 +494,8 @@ fn content_might_not_converge(code: str) -> bool {
 
 fn file_might_not_converge(filename: str) -> bool {
     let confusing_files = [
-      "expr-alt.rs", // pretty-printing "(a = b) = c" vs "a = b = c" and wrapping
+      "expr-alt.rs", // pretty-printing "(a = b) = c"
+                     // vs "a = b = c" and wrapping
       "block-arg-in-ternary.rs", // wrapping
       "move-3-unique.rs", // 0 becomes (0), but both seem reasonable. wtf?
       "move-3.rs"  // 0 becomes (0), but both seem reasonable. wtf?
@@ -513,7 +541,8 @@ fn check_convergence(files: [str]) {
             let s = @result::get(io::read_whole_file_str(file));
             if !content_might_not_converge(*s) {
                 #error("pp converge: %s", file);
-                // Change from 7u to 2u once https://github.com/mozilla/rust/issues/850 is fixed
+                // Change from 7u to 2u once
+                // https://github.com/mozilla/rust/issues/850 is fixed
                 check_roundtrip_convergence(s, 7u);
             }
         }
@@ -523,7 +552,8 @@ fn check_convergence(files: [str]) {
 fn check_variants(files: [str], cx: context) {
     for files.each {|file|
         if cx.mode == tm_converge && file_might_not_converge(file) {
-            #error("Skipping convergence test based on file_might_not_converge");
+            #error("Skipping convergence test based on\
+                    file_might_not_converge");
             cont;
         }
 
diff --git a/src/fuzzer/ivec_fuzz.rs b/src/fuzzer/ivec_fuzz.rs
index 4555b7327a5..ed02550bb13 100644
--- a/src/fuzzer/ivec_fuzz.rs
+++ b/src/fuzzer/ivec_fuzz.rs
@@ -2,14 +2,16 @@
 
 Idea: provide functions for 'exhaustive' and 'random' modification of vecs.
 
-  two functions, "return all edits" and "return a random edit" <-- leaning toward this model
-    or
-  two functions, "return the number of possible edits" and "return edit #n"
+  two functions, "return all edits" and "return a random edit" <--
+    leaning toward this model or two functions, "return the number of
+    possible edits" and "return edit #n"
 
-It would be nice if this could be data-driven, so the two functions could share information:
+It would be nice if this could be data-driven, so the two functions
+could share information:
   type vec_modifier = rec(fn (<T> v, uint i) -> [T] fun, uint lo, uint di);
   const [vec_modifier] vec_modifiers = ~[rec(fun=vec_omit, 0u, 1u), ...];
-But that gives me "error: internal compiler error unimplemented consts that's not a plain literal".
+But that gives me "error: internal compiler error unimplemented consts
+that's not a plain literal".
 https://github.com/graydon/rust/issues/570
 
 vec_edits is not an iter because iters might go away.
@@ -47,7 +49,8 @@ fn ix(skip_low: uint, skip_high: uint, length: uint, it: block(uint)) {
     while i + skip_high <= length { it(i); i += 1u; }
 }
 
-// Returns a bunch of modified versions of v, some of which introduce new elements (borrowed from xs).
+// Returns a bunch of modified versions of v, some of which introduce
+// new elements (borrowed from xs).
 fn vec_edits<T: copy>(v: [T], xs: [T]) -> [[T]] {
     let edits: [[T]] = [];
     let Lv: uint = len(v);
@@ -78,7 +81,8 @@ fn vec_edits<T: copy>(v: [T], xs: [T]) -> [[T]] {
     edits
 }
 
-// Would be nice if this were built in: https://github.com/graydon/rust/issues/424
+// Would be nice if this were built in:
+// https://github.com/graydon/rust/issues/424
 fn vec_to_str(v: [int]) -> str {
     let i = 0u;
     let s = "[";
diff --git a/src/fuzzer/rand_util.rs b/src/fuzzer/rand_util.rs
index a20e7651627..1a51ab0cd41 100644
--- a/src/fuzzer/rand_util.rs
+++ b/src/fuzzer/rand_util.rs
@@ -3,10 +3,14 @@ import std::rand;
 import vec;
 
 // random uint less than n
-fn under(r : rand::rng, n : uint) -> uint { assert n != 0u; r.next() as uint % n }
+fn under(r : rand::rng, n : uint) -> uint {
+    assert n != 0u; r.next() as uint % n
+}
 
 // random choice from a vec
-fn choice<T: copy>(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] }
+fn choice<T: copy>(r : rand::rng, v : [T]) -> T {
+    assert vec::len(v) != 0u; v[under(r, vec::len(v))]
+}
 
 // 1 in n chance of being true
 fn unlikely(r : rand::rng, n : uint) -> bool { under(r, n) == 0u }
diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs
index 0654691242a..fd14c90f00a 100644
--- a/src/rustc/driver/rustc.rs
+++ b/src/rustc/driver/rustc.rs
@@ -48,7 +48,7 @@ Options:
     --out-dir <dir>    Write output to compiler-chosen filename in <dir>
     --parse-only       Parse only; do not compile, assemble, or link
     --pretty [type]    Pretty-print the input instead of compiling;
-                       valid types are: normal (un-annotated source), 
+                       valid types are: normal (un-annotated source),
                        expanded (crates expanded), typed (crates expanded,
                        with type annotations), or identified (fully
                        parenthesized, AST nodes and blocks with IDs)