---

yaml
---
r: 134074
b: refs/heads/master
c: 04c41eb
h: refs/heads/master
v: v3

Author: vadimcn

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b8599ecdb30de6c54852e863d748e70171c8c5f8
+refs/heads/master: 04c41eb3726e5bd34d4bbdc7e405813a5a7e8cb3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 437179ed8bf7f7672f84b19265df1ce569e70490
 refs/heads/try: 777654cfccbfa39bc7f671d8e9629018ed8ca12d

trunk/src/compiletest/header.rs

@@ -42,8 +42,6 @@ pub struct TestProps {
     pub pretty_mode: String,
     // Only compare pretty output and don't try compiling
     pub pretty_compare_only: bool,
-    // Patterns which must not appear in the output of a cfail test.
-    pub forbid_output: Vec<String>,
 }
 
 // Load any test directives embedded in the file
@@ -61,7 +59,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut no_pretty_expanded = false;
     let mut pretty_mode = None;
     let mut pretty_compare_only = false;
-    let mut forbid_output = Vec::new();
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -119,11 +116,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             None => ()
         };
 
-        match parse_forbid_output(ln) {
-            Some(of) => forbid_output.push(of),
-            None => (),
-        }
-
         true
     });
 
@@ -140,8 +132,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         no_prefer_dynamic: no_prefer_dynamic,
         no_pretty_expanded: no_pretty_expanded,
         pretty_mode: pretty_mode.unwrap_or("normal".to_string()),
-        pretty_compare_only: pretty_compare_only,
-        forbid_output: forbid_output,
+        pretty_compare_only: pretty_compare_only
     }
 }
 
@@ -219,10 +210,6 @@ fn parse_error_pattern(line: &str) -> Option<String> {
     parse_name_value_directive(line, "error-pattern")
 }
 
-fn parse_forbid_output(line: &str) -> Option<String> {
-    parse_name_value_directive(line, "forbid-output")
-}
-
 fn parse_aux_build(line: &str) -> Option<String> {
     parse_name_value_directive(line, "aux-build")
 }

trunk/src/compiletest/runtest.rs

@@ -71,14 +71,6 @@ pub fn run_metrics(config: Config, testfile: String, mm: &mut MetricMap) {
     }
 }
 
-fn get_output(props: &TestProps, proc_res: &ProcRes) -> String {
-    if props.check_stdout {
-        format!("{}{}", proc_res.stdout, proc_res.stderr)
-    } else {
-        proc_res.stderr.clone()
-    }
-}
-
 fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = compile_test(config, props, testfile);
 
@@ -89,22 +81,16 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
 
     check_correct_failure_status(&proc_res);
 
-    if proc_res.status.success() {
-        fatal("process did not return an error status");
-    }
-
-    let output_to_check = get_output(props, &proc_res);
     let expected_errors = errors::load_errors(&config.cfail_regex, testfile);
     if !expected_errors.is_empty() {
         if !props.error_patterns.is_empty() {
             fatal("both error pattern and expected errors specified");
         }
         check_expected_errors(expected_errors, testfile, &proc_res);
     } else {
-        check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
+        check_error_patterns(props, testfile, &proc_res);
     }
     check_no_compiler_crash(&proc_res);
-    check_forbid_output(props, output_to_check.as_slice(), &proc_res);
 }
 
 fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
@@ -126,9 +112,8 @@ fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
         fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res);
     }
 
-    let output_to_check = get_output(props, &proc_res);
     check_correct_failure_status(&proc_res);
-    check_error_patterns(props, testfile, output_to_check.as_slice(), &proc_res);
+    check_error_patterns(props, testfile, &proc_res);
 }
 
 fn check_correct_failure_status(proc_res: &ProcRes) {
@@ -849,15 +834,24 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
 
 fn check_error_patterns(props: &TestProps,
                         testfile: &Path,
-                        output_to_check: &str,
                         proc_res: &ProcRes) {
     if props.error_patterns.is_empty() {
         fatal(format!("no error pattern specified in {}",
                       testfile.display()).as_slice());
     }
+
+    if proc_res.status.success() {
+        fatal("process did not return an error status");
+    }
+
     let mut next_err_idx = 0u;
     let mut next_err_pat = &props.error_patterns[next_err_idx];
     let mut done = false;
+    let output_to_check = if props.check_stdout {
+        format!("{}{}", proc_res.stdout, proc_res.stderr)
+    } else {
+        proc_res.stderr.clone()
+    };
     for line in output_to_check.as_slice().lines() {
         if line.contains(next_err_pat.as_slice()) {
             debug!("found error pattern {}", next_err_pat);
@@ -896,16 +890,6 @@ fn check_no_compiler_crash(proc_res: &ProcRes) {
     }
 }
 
-fn check_forbid_output(props: &TestProps,
-                       output_to_check: &str,
-                       proc_res: &ProcRes) {
-    for pat in props.forbid_output.iter() {
-        if output_to_check.contains(pat.as_slice()) {
-            fatal_proc_rec("forbidden pattern found in compiler output", proc_res);
-        }
-    }
-}
-
 fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {

trunk/src/doc/guide.md

@@ -1575,6 +1575,8 @@ we haven't seen before. Here's a simple program that reads some input,
 and then prints it back out:
 
 ```{rust,ignore}
+use std::io;
+
 fn main() {
     println!("Type something!");
 

trunk/src/etc/make-win-dist.py

@@ -58,15 +58,15 @@ def make_win_dist(dist_root, target_triple):
     for src in rustc_dlls:
         shutil.copy(src, dist_bin_dir)
 
-    # Copy platform tools (and another copy of runtime dlls) to platform-spcific bin directory
-    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "bin")
+    # Copy platform tools to platform-specific bin directory
+    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "bin")
     if not os.path.exists(target_bin_dir):
         os.makedirs(target_bin_dir)
     for src in target_tools:
         shutil.copy(src, target_bin_dir)
 
     # Copy platform libs to platform-spcific lib directory
-    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "lib")
+    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "lib")
     if not os.path.exists(target_lib_dir):
         os.makedirs(target_lib_dir)
     for src in target_libs: