From d2482fd7631d05b1888e3beac0df3f25d33867b8 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Fri, 13 Apr 2012 11:59:17 -0700 Subject: [PATCH] use find not echo; this also brings fuzzer under the iron fist of tidy.py! --- mk/tests.mk | 34 ++------------ src/fuzzer/ast_match.rs | 3 +- src/fuzzer/cycles.rs | 11 +++-- src/fuzzer/fuzzer.rs | 94 ++++++++++++++++++++++++++------------- src/fuzzer/ivec_fuzz.rs | 18 +++++--- src/fuzzer/rand_util.rs | 8 +++- src/rustc/driver/rustc.rs | 2 +- 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) \ + $(Q)echo $(ALL_CS) \ | xargs -n 10 python $(S)src/etc/tidy.py - $(Q)echo \ - $(SOME_MOAR_TEST_INPUTS) \ - | 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(v: [T], u: [T], element_equality_test: fn@(&&T, &&T) -> bool) -> +fn vec_equal(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(r : rand::rng, v : [const T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] } +fn choice(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( @@ -247,7 +256,8 @@ fn check_variants_T( 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( 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( 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 ( 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(v: [T], xs: [T]) -> [[T]] { let edits: [[T]] = []; let Lv: uint = len(v); @@ -78,7 +81,8 @@ fn vec_edits(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(r : rand::rng, v : [T]) -> T { assert vec::len(v) != 0u; v[under(r, vec::len(v))] } +fn choice(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 Write output to compiler-chosen filename in --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)