src/vendor/compiletest_rs/src/runtest.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use common::{Config, TestPaths};
  12 use common::{CompileFail, ParseFail, Pretty, RunFail, RunPass, RunPassValgrind};
  13 use common::{Codegen, DebugInfoLldb, DebugInfoGdb, Rustdoc, CodegenUnits};
  14 use common::{Incremental, RunMake, Ui, MirOpt};
  15 use diff;
  16 use errors::{self, ErrorKind, Error};
  17 use filetime::FileTime;
  18 use json;
  19 use header::TestProps;
  20 use util::logv;
  21
  22 use std::collections::HashMap;
  23 use std::collections::HashSet;
  24 use std::env;
  25 use std::ffi::OsString;
  26 use std::fs::{self, File, create_dir_all};
  27 use std::fmt;
  28 use std::io::prelude::*;
  29 use std::io::{self, BufReader};
  30 use std::path::{Path, PathBuf};
  31 use std::process::{Command, Output, ExitStatus, Stdio, Child};
  32 use std::str;
  33
  34 use extract_gdb_version;
  35
  36 /// The name of the environment variable that holds dynamic library locations.
  37 pub fn dylib_env_var() -> &'static str {
  38     if cfg!(windows) {
  39         "PATH"
  40     } else if cfg!(target_os = "macos") {
  41         "DYLD_LIBRARY_PATH"
  42     } else if cfg!(target_os = "haiku") {
  43         "LIBRARY_PATH"
  44     } else {
  45         "LD_LIBRARY_PATH"
  46     }
  47 }
  48
  49 pub fn run(config: Config, testpaths: &TestPaths) {
  50     match &*config.target {
  51
  52         "arm-linux-androideabi" | "armv7-linux-androideabi" | "aarch64-linux-android" => {
  53             if !config.adb_device_status {
  54                 panic!("android device not available");
  55             }
  56         }
  57
  58         _ => {
  59             // android has its own gdb handling
  60             if config.mode == DebugInfoGdb && config.gdb.is_none() {
  61                 panic!("gdb not available but debuginfo gdb debuginfo test requested");
  62             }
  63         }
  64     }
  65
  66     if config.verbose {
  67         // We're going to be dumping a lot of info. Start on a new line.
  68         print!("\n\n");
  69     }
  70     debug!("running {:?}", testpaths.file.display());
  71     let base_props = TestProps::from_file(&testpaths.file, None, &config);
  72
  73     let base_cx = TestCx { config: &config,
  74                            props: &base_props,
  75                            testpaths,
  76                            revision: None };
  77     base_cx.init_all();
  78
  79     if base_props.revisions.is_empty() {
  80         base_cx.run_revision()
  81     } else {
  82         for revision in &base_props.revisions {
  83             let revision_props = TestProps::from_file(&testpaths.file,
  84                                                       Some(revision),
  85                                                       &config);
  86             let rev_cx = TestCx {
  87                 config: &config,
  88                 props: &revision_props,
  89                 testpaths,
  90                 revision: Some(revision)
  91             };
  92             rev_cx.run_revision();
  93         }
  94     }
  95
  96     base_cx.complete_all();
  97
  98     File::create(::stamp(&config, testpaths)).unwrap();
  99 }
 100
 101 struct TestCx<'test> {
 102     config: &'test Config,
 103     props: &'test TestProps,
 104     testpaths: &'test TestPaths,
 105     revision: Option<&'test str>
 106 }
 107
 108 struct DebuggerCommands {
 109     commands: Vec<String>,
 110     check_lines: Vec<String>,
 111     breakpoint_lines: Vec<usize>,
 112 }
 113
 114 impl<'test> TestCx<'test> {
 115     /// invoked once before any revisions have been processed
 116     fn init_all(&self) {
 117         assert!(self.revision.is_none(), "init_all invoked for a revision");
 118         if let Incremental = self.config.mode {
 119             self.init_incremental_test()
 120         }
 121     }
 122
 123     /// Code executed for each revision in turn (or, if there are no
 124     /// revisions, exactly once, with revision == None).
 125     fn run_revision(&self) {
 126         match self.config.mode {
 127             CompileFail |
 128             ParseFail => self.run_cfail_test(),
 129             RunFail => self.run_rfail_test(),
 130             RunPass => self.run_rpass_test(),
 131             RunPassValgrind => self.run_valgrind_test(),
 132             Pretty => self.run_pretty_test(),
 133             DebugInfoGdb => self.run_debuginfo_gdb_test(),
 134             DebugInfoLldb => self.run_debuginfo_lldb_test(),
 135             Codegen => self.run_codegen_test(),
 136             Rustdoc => self.run_rustdoc_test(),
 137             CodegenUnits => self.run_codegen_units_test(),
 138             Incremental => self.run_incremental_test(),
 139             RunMake => self.run_rmake_test(),
 140             Ui => self.run_ui_test(),
 141             MirOpt => self.run_mir_opt_test(),
 142         }
 143     }
 144
 145     /// Invoked after all revisions have executed.
 146     fn complete_all(&self) {
 147         assert!(self.revision.is_none(), "init_all invoked for a revision");
 148     }
 149
 150     fn run_cfail_test(&self) {
 151         let proc_res = self.compile_test();
 152
 153         if self.props.must_compile_successfully {
 154             if !proc_res.status.success() {
 155                 self.fatal_proc_rec(
 156                     "test compilation failed although it shouldn't!",
 157                     &proc_res);
 158             }
 159         } else {
 160             if proc_res.status.success() {
 161                 self.fatal_proc_rec(
 162                     &format!("{} test compiled successfully!", self.config.mode)[..],
 163                     &proc_res);
 164             }
 165
 166             self.check_correct_failure_status(&proc_res);
 167         }
 168
 169         let output_to_check = self.get_output(&proc_res);
 170         let expected_errors = errors::load_errors(&self.testpaths.file, self.revision);
 171         if !expected_errors.is_empty() {
 172             if !self.props.error_patterns.is_empty() {
 173                 self.fatal("both error pattern and expected errors specified");
 174             }
 175             self.check_expected_errors(expected_errors, &proc_res);
 176         } else {
 177             self.check_error_patterns(&output_to_check, &proc_res);
 178         }
 179
 180         self.check_no_compiler_crash(&proc_res);
 181         self.check_forbid_output(&output_to_check, &proc_res);
 182     }
 183
 184     fn run_rfail_test(&self) {
 185         let proc_res = self.compile_test();
 186
 187         if !proc_res.status.success() {
 188             self.fatal_proc_rec("compilation failed!", &proc_res);
 189         }
 190
 191         let proc_res = self.exec_compiled_test();
 192
 193         // The value our Makefile configures valgrind to return on failure
 194         const VALGRIND_ERR: i32 = 100;
 195         if proc_res.status.code() == Some(VALGRIND_ERR) {
 196             self.fatal_proc_rec("run-fail test isn't valgrind-clean!", &proc_res);
 197         }
 198
 199         let output_to_check = self.get_output(&proc_res);
 200         self.check_correct_failure_status(&proc_res);
 201         self.check_error_patterns(&output_to_check, &proc_res);
 202     }
 203
 204     fn get_output(&self, proc_res: &ProcRes) -> String {
 205         if self.props.check_stdout {
 206             format!("{}{}", proc_res.stdout, proc_res.stderr)
 207         } else {
 208             proc_res.stderr.clone()
 209         }
 210     }
 211
 212     fn check_correct_failure_status(&self, proc_res: &ProcRes) {
 213         // The value the rust runtime returns on failure
 214         const RUST_ERR: i32 = 101;
 215         if proc_res.status.code() != Some(RUST_ERR) {
 216             self.fatal_proc_rec(
 217                 &format!("failure produced the wrong error: {}",
 218                          proc_res.status),
 219                 proc_res);
 220         }
 221     }
 222
 223     fn run_rpass_test(&self) {
 224         let proc_res = self.compile_test();
 225
 226         if !proc_res.status.success() {
 227             self.fatal_proc_rec("compilation failed!", &proc_res);
 228         }
 229
 230         // FIXME(#41968): Move this check to tidy?
 231         let expected_errors = errors::load_errors(&self.testpaths.file, self.revision);
 232         assert!(expected_errors.is_empty(),
 233                 "run-pass tests with expected warnings should be moved to ui/");
 234
 235         let proc_res = self.exec_compiled_test();
 236
 237         if !proc_res.status.success() {
 238             self.fatal_proc_rec("test run failed!", &proc_res);
 239         }
 240     }
 241
 242     fn run_valgrind_test(&self) {
 243         assert!(self.revision.is_none(), "revisions not relevant here");
 244
 245         if self.config.valgrind_path.is_none() {
 246             assert!(!self.config.force_valgrind);
 247             return self.run_rpass_test();
 248         }
 249
 250         let mut proc_res = self.compile_test();
 251
 252         if !proc_res.status.success() {
 253             self.fatal_proc_rec("compilation failed!", &proc_res);
 254         }
 255
 256         let mut new_config = self.config.clone();
 257         new_config.runtool = new_config.valgrind_path.clone();
 258         let new_cx = TestCx { config: &new_config, ..*self };
 259         proc_res = new_cx.exec_compiled_test();
 260
 261         if !proc_res.status.success() {
 262             self.fatal_proc_rec("test run failed!", &proc_res);
 263         }
 264     }
 265
 266     fn run_pretty_test(&self) {
 267         if self.props.pp_exact.is_some() {
 268             logv(self.config, "testing for exact pretty-printing".to_owned());
 269         } else {
 270             logv(self.config, "testing for converging pretty-printing".to_owned());
 271         }
 272
 273         let rounds = match self.props.pp_exact { Some(_) => 1, None => 2 };
 274
 275         let mut src = String::new();
 276         File::open(&self.testpaths.file).unwrap().read_to_string(&mut src).unwrap();
 277         let mut srcs = vec![src];
 278
 279         let mut round = 0;
 280         while round < rounds {
 281             logv(self.config, format!("pretty-printing round {} revision {:?}",
 282                                       round, self.revision));
 283             let proc_res = self.print_source(srcs[round].to_owned(), &self.props.pretty_mode);
 284
 285             if !proc_res.status.success() {
 286                 self.fatal_proc_rec(&format!("pretty-printing failed in round {} revision {:?}",
 287                                              round, self.revision),
 288                                     &proc_res);
 289             }
 290
 291             let ProcRes{ stdout, .. } = proc_res;
 292             srcs.push(stdout);
 293             round += 1;
 294         }
 295
 296         let mut expected = match self.props.pp_exact {
 297             Some(ref file) => {
 298                 let filepath = self.testpaths.file.parent().unwrap().join(file);
 299                 let mut s = String::new();
 300                 File::open(&filepath).unwrap().read_to_string(&mut s).unwrap();
 301                 s
 302             }
 303             None => { srcs[srcs.len() - 2].clone() }
 304         };
 305         let mut actual = srcs[srcs.len() - 1].clone();
 306
 307         if self.props.pp_exact.is_some() {
 308             // Now we have to care about line endings
 309             let cr = "\r".to_owned();
 310             actual = actual.replace(&cr, "").to_owned();
 311             expected = expected.replace(&cr, "").to_owned();
 312         }
 313
 314         self.compare_source(&expected, &actual);
 315
 316         // If we're only making sure that the output matches then just stop here
 317         if self.props.pretty_compare_only { return; }
 318
 319         // Finally, let's make sure it actually appears to remain valid code
 320         let proc_res = self.typecheck_source(actual);
 321         if !proc_res.status.success() {
 322             self.fatal_proc_rec("pretty-printed source does not typecheck", &proc_res);
 323         }
 324
 325         if !self.props.pretty_expanded { return }
 326
 327         // additionally, run `--pretty expanded` and try to build it.
 328         let proc_res = self.print_source(srcs[round].clone(), "expanded");
 329         if !proc_res.status.success() {
 330             self.fatal_proc_rec("pretty-printing (expanded) failed", &proc_res);
 331         }
 332
 333         let ProcRes{ stdout: expanded_src, .. } = proc_res;
 334         let proc_res = self.typecheck_source(expanded_src);
 335         if !proc_res.status.success() {
 336             self.fatal_proc_rec(
 337                 "pretty-printed source (expanded) does not typecheck",
 338                 &proc_res);
 339         }
 340     }
 341
 342     fn print_source(&self, src: String, pretty_type: &str) -> ProcRes {
 343         let aux_dir = self.aux_output_dir_name();
 344
 345         let mut rustc = Command::new(&self.config.rustc_path);
 346         rustc.arg("-")
 347             .arg("-Zunstable-options")
 348             .args(&["--unpretty", &pretty_type])
 349             .args(&["--target", &self.config.target])
 350             .arg("-L").arg(&aux_dir)
 351             .args(self.split_maybe_args(&self.config.target_rustcflags))
 352             .args(&self.props.compile_flags)
 353             .envs(self.props.exec_env.clone());
 354
 355         self.compose_and_run(rustc,
 356                              self.config.compile_lib_path.to_str().unwrap(),
 357                              Some(aux_dir.to_str().unwrap()),
 358                              Some(src))
 359     }
 360
 361     fn compare_source(&self,
 362                       expected: &str,
 363                       actual: &str) {
 364         if expected != actual {
 365             self.error("pretty-printed source does not match expected source");
 366             println!("\n\
 367 expected:\n\
 368 ------------------------------------------\n\
 369 {}\n\
 370 ------------------------------------------\n\
 371 actual:\n\
 372 ------------------------------------------\n\
 373 {}\n\
 374 ------------------------------------------\n\
 375 \n",
 376                      expected, actual);
 377             panic!();
 378         }
 379     }
 380
 381     fn typecheck_source(&self, src: String) -> ProcRes {
 382         let mut rustc = Command::new(&self.config.rustc_path);
 383
 384         let out_dir = self.output_base_name().with_extension("pretty-out");
 385         let _ = fs::remove_dir_all(&out_dir);
 386         create_dir_all(&out_dir).unwrap();
 387
 388         let target = if self.props.force_host {
 389             &*self.config.host
 390         } else {
 391             &*self.config.target
 392         };
 393
 394         let aux_dir = self.aux_output_dir_name();
 395
 396         rustc.arg("-")
 397             .arg("-Zno-trans")
 398             .arg("--out-dir").arg(&out_dir)
 399             .arg(&format!("--target={}", target))
 400             .arg("-L").arg(&self.config.build_base)
 401             .arg("-L").arg(aux_dir);
 402
 403         if let Some(revision) = self.revision {
 404             rustc.args(&["--cfg", revision]);
 405         }
 406
 407         rustc.args(self.split_maybe_args(&self.config.target_rustcflags));
 408         rustc.args(&self.props.compile_flags);
 409
 410         self.compose_and_run_compiler(rustc, Some(src))
 411     }
 412
 413     fn run_debuginfo_gdb_test(&self) {
 414         assert!(self.revision.is_none(), "revisions not relevant here");
 415
 416         let config = Config {
 417             target_rustcflags: self.cleanup_debug_info_options(&self.config.target_rustcflags),
 418             host_rustcflags: self.cleanup_debug_info_options(&self.config.host_rustcflags),
 419             .. self.config.clone()
 420         };
 421
 422         let test_cx = TestCx {
 423             config: &config,
 424             ..*self
 425         };
 426
 427         test_cx.run_debuginfo_gdb_test_no_opt();
 428     }
 429
 430     fn run_debuginfo_gdb_test_no_opt(&self) {
 431         let prefixes = if self.config.gdb_native_rust {
 432             // GDB with Rust
 433             static PREFIXES: &'static [&'static str] = &["gdb", "gdbr"];
 434             println!("NOTE: compiletest thinks it is using GDB with native rust support");
 435             PREFIXES
 436         } else {
 437             // Generic GDB
 438             static PREFIXES: &'static [&'static str] = &["gdb", "gdbg"];
 439             println!("NOTE: compiletest thinks it is using GDB without native rust support");
 440             PREFIXES
 441         };
 442
 443         let DebuggerCommands {
 444             commands,
 445             check_lines,
 446             breakpoint_lines
 447         } = self.parse_debugger_commands(prefixes);
 448         let mut cmds = commands.join("\n");
 449
 450         // compile test file (it should have 'compile-flags:-g' in the header)
 451         let compiler_run_result = self.compile_test();
 452         if !compiler_run_result.status.success() {
 453             self.fatal_proc_rec("compilation failed!", &compiler_run_result);
 454         }
 455
 456         let exe_file = self.make_exe_name();
 457
 458         let debugger_run_result;
 459         match &*self.config.target {
 460             "arm-linux-androideabi" |
 461             "armv7-linux-androideabi" |
 462             "aarch64-linux-android" => {
 463
 464                 cmds = cmds.replace("run", "continue");
 465
 466                 let tool_path = match self.config.android_cross_path.to_str() {
 467                     Some(x) => x.to_owned(),
 468                     None => self.fatal("cannot find android cross path")
 469                 };
 470
 471                 // write debugger script
 472                 let mut script_str = String::with_capacity(2048);
 473                 script_str.push_str(&format!("set charset {}\n", Self::charset()));
 474                 script_str.push_str(&format!("set sysroot {}\n", tool_path));
 475                 script_str.push_str(&format!("file {}\n", exe_file.to_str().unwrap()));
 476                 script_str.push_str("target remote :5039\n");
 477                 script_str.push_str(&format!("set solib-search-path \
 478                                               ./{}/stage2/lib/rustlib/{}/lib/\n",
 479                                              self.config.host, self.config.target));
 480                 for line in &breakpoint_lines {
 481                     script_str.push_str(&format!("break {:?}:{}\n",
 482                                                  self.testpaths.file.file_name()
 483                                                  .unwrap()
 484                                                  .to_string_lossy(),
 485                                                  *line)[..]);
 486                 }
 487                 script_str.push_str(&cmds);
 488                 script_str.push_str("\nquit\n");
 489
 490                 debug!("script_str = {}", script_str);
 491                 self.dump_output_file(&script_str, "debugger.script");
 492
 493                 let adb_path = &self.config.adb_path;
 494
 495                 Command::new(adb_path)
 496                     .arg("push")
 497                     .arg(&exe_file)
 498                     .arg(&self.config.adb_test_dir)
 499                     .status()
 500                     .expect(&format!("failed to exec `{:?}`", adb_path));
 501
 502                 Command::new(adb_path)
 503                     .args(&["forward", "tcp:5039", "tcp:5039"])
 504                     .status()
 505                     .expect(&format!("failed to exec `{:?}`", adb_path));
 506
 507                 let adb_arg = format!("export LD_LIBRARY_PATH={}; \
 508                                        gdbserver{} :5039 {}/{}",
 509                                       self.config.adb_test_dir.clone(),
 510                                       if self.config.target.contains("aarch64")
 511                                       {"64"} else {""},
 512                                       self.config.adb_test_dir.clone(),
 513                                       exe_file.file_name().unwrap().to_str()
 514                                       .unwrap());
 515
 516                 debug!("adb arg: {}", adb_arg);
 517                 let mut adb = Command::new(adb_path)
 518                     .args(&["shell", &adb_arg])
 519                     .stdout(Stdio::piped())
 520                     .stderr(Stdio::inherit())
 521                     .spawn()
 522                     .expect(&format!("failed to exec `{:?}`", adb_path));
 523
 524                 // Wait for the gdbserver to print out "Listening on port ..."
 525                 // at which point we know that it's started and then we can
 526                 // execute the debugger below.
 527                 let mut stdout = BufReader::new(adb.stdout.take().unwrap());
 528                 let mut line = String::new();
 529                 loop {
 530                     line.truncate(0);
 531                     stdout.read_line(&mut line).unwrap();
 532                     if line.starts_with("Listening on port 5039") {
 533                         break
 534                     }
 535                 }
 536                 drop(stdout);
 537
 538                 let debugger_script = self.make_out_name("debugger.script");
 539                 // FIXME (#9639): This needs to handle non-utf8 paths
 540                 let debugger_opts =
 541                     vec!["-quiet".to_owned(),
 542                          "-batch".to_owned(),
 543                          "-nx".to_owned(),
 544                          format!("-command={}", debugger_script.to_str().unwrap())];
 545
 546                 let mut gdb_path = tool_path;
 547                 gdb_path.push_str("/bin/gdb");
 548                 let Output {
 549                     status,
 550                     stdout,
 551                     stderr
 552                 } = Command::new(&gdb_path)
 553                     .args(&debugger_opts)
 554                     .output()
 555                     .expect(&format!("failed to exec `{:?}`", gdb_path));
 556                 let cmdline = {
 557                     let mut gdb = Command::new(&format!("{}-gdb", self.config.target));
 558                     gdb.args(&debugger_opts);
 559                     let cmdline = self.make_cmdline(&gdb, "");
 560                     logv(self.config, format!("executing {}", cmdline));
 561                     cmdline
 562                 };
 563
 564                 debugger_run_result = ProcRes {
 565                     status,
 566                     stdout: String::from_utf8(stdout).unwrap(),
 567                     stderr: String::from_utf8(stderr).unwrap(),
 568                     cmdline,
 569                 };
 570                 if adb.kill().is_err() {
 571                     println!("Adb process is already finished.");
 572                 }
 573             }
 574
 575             _ => {
 576                 let rust_src_root = self.config.find_rust_src_root().expect(
 577                     "Could not find Rust source root",
 578                 );
 579                 let rust_pp_module_rel_path = Path::new("./src/etc");
 580                 let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path)
 581                                                            .to_str()
 582                                                            .unwrap()
 583                                                            .to_owned();
 584                 // write debugger script
 585                 let mut script_str = String::with_capacity(2048);
 586                 script_str.push_str(&format!("set charset {}\n", Self::charset()));
 587                 script_str.push_str("show version\n");
 588
 589                 match self.config.gdb_version {
 590                     Some(version) => {
 591                         println!("NOTE: compiletest thinks it is using GDB version {}",
 592                                  version);
 593
 594                         if version > extract_gdb_version("7.4").unwrap() {
 595                             // Add the directory containing the pretty printers to
 596                             // GDB's script auto loading safe path
 597                             script_str.push_str(
 598                                 &format!("add-auto-load-safe-path {}\n",
 599                                          rust_pp_module_abs_path.replace(r"\", r"\\"))
 600                             );
 601                         }
 602                     }
 603                     _ => {
 604                         println!("NOTE: compiletest does not know which version of \
 605                                   GDB it is using");
 606                     }
 607                 }
 608
 609                 // The following line actually doesn't have to do anything with
 610                 // pretty printing, it just tells GDB to print values on one line:
 611                 script_str.push_str("set print pretty off\n");
 612
 613                 // Add the pretty printer directory to GDB's source-file search path
 614                 script_str.push_str(&format!("directory {}\n",
 615                                              rust_pp_module_abs_path));
 616
 617                 // Load the target executable
 618                 script_str.push_str(&format!("file {}\n",
 619                                              exe_file.to_str().unwrap()
 620                                              .replace(r"\", r"\\")));
 621
 622                 // Force GDB to print values in the Rust format.
 623                 if self.config.gdb_native_rust {
 624                     script_str.push_str("set language rust\n");
 625                 }
 626
 627                 // Add line breakpoints
 628                 for line in &breakpoint_lines {
 629                     script_str.push_str(&format!("break '{}':{}\n",
 630                                                  self.testpaths.file.file_name().unwrap()
 631                                                  .to_string_lossy(),
 632                                                  *line));
 633                 }
 634
 635                 script_str.push_str(&cmds);
 636                 script_str.push_str("\nquit\n");
 637
 638                 debug!("script_str = {}", script_str);
 639                 self.dump_output_file(&script_str, "debugger.script");
 640
 641                 let debugger_script = self.make_out_name("debugger.script");
 642
 643                 // FIXME (#9639): This needs to handle non-utf8 paths
 644                 let debugger_opts =
 645                     vec!["-quiet".to_owned(),
 646                          "-batch".to_owned(),
 647                          "-nx".to_owned(),
 648                          format!("-command={}", debugger_script.to_str().unwrap())];
 649
 650                 let mut gdb = Command::new(self.config.gdb.as_ref().unwrap());
 651                 gdb.args(&debugger_opts)
 652                     .env("PYTHONPATH", rust_pp_module_abs_path);
 653
 654                 debugger_run_result =
 655                     self.compose_and_run(gdb,
 656                                          self.config.run_lib_path.to_str().unwrap(),
 657                                          None,
 658                                          None);
 659             }
 660         }
 661
 662         if !debugger_run_result.status.success() {
 663             self.fatal_proc_rec("gdb failed to execute", &debugger_run_result);
 664         }
 665
 666         self.check_debugger_output(&debugger_run_result, &check_lines);
 667     }
 668
 669     fn run_debuginfo_lldb_test(&self) {
 670         assert!(self.revision.is_none(), "revisions not relevant here");
 671
 672         if self.config.lldb_python_dir.is_none() {
 673             self.fatal("Can't run LLDB test because LLDB's python path is not set.");
 674         }
 675
 676         let config = Config {
 677             target_rustcflags: self.cleanup_debug_info_options(&self.config.target_rustcflags),
 678             host_rustcflags: self.cleanup_debug_info_options(&self.config.host_rustcflags),
 679             .. self.config.clone()
 680         };
 681
 682
 683         let test_cx = TestCx {
 684             config: &config,
 685             ..*self
 686         };
 687
 688         test_cx.run_debuginfo_lldb_test_no_opt();
 689     }
 690
 691     fn run_debuginfo_lldb_test_no_opt(&self) {
 692         // compile test file (it should have 'compile-flags:-g' in the header)
 693         let compile_result = self.compile_test();
 694         if !compile_result.status.success() {
 695             self.fatal_proc_rec("compilation failed!", &compile_result);
 696         }
 697
 698         let exe_file = self.make_exe_name();
 699
 700         match self.config.lldb_version {
 701             Some(ref version) => {
 702                 println!("NOTE: compiletest thinks it is using LLDB version {}",
 703                          version);
 704             }
 705             _ => {
 706                 println!("NOTE: compiletest does not know which version of \
 707                           LLDB it is using");
 708             }
 709         }
 710
 711         // Parse debugger commands etc from test files
 712         let DebuggerCommands {
 713             commands,
 714             check_lines,
 715             breakpoint_lines,
 716             ..
 717         } = self.parse_debugger_commands(&["lldb"]);
 718
 719         // Write debugger script:
 720         // We don't want to hang when calling `quit` while the process is still running
 721         let mut script_str = String::from("settings set auto-confirm true\n");
 722
 723         // Make LLDB emit its version, so we have it documented in the test output
 724         script_str.push_str("version\n");
 725
 726         // Switch LLDB into "Rust mode"
 727         let rust_src_root = self.config.find_rust_src_root().expect(
 728             "Could not find Rust source root",
 729         );
 730         let rust_pp_module_rel_path = Path::new("./src/etc/lldb_rust_formatters.py");
 731         let rust_pp_module_abs_path = rust_src_root.join(rust_pp_module_rel_path)
 732                                                    .to_str()
 733                                                    .unwrap()
 734                                                    .to_owned();
 735
 736         script_str.push_str(&format!("command script import {}\n",
 737                                      &rust_pp_module_abs_path[..])[..]);
 738         script_str.push_str("type summary add --no-value ");
 739         script_str.push_str("--python-function lldb_rust_formatters.print_val ");
 740         script_str.push_str("-x \".*\" --category Rust\n");
 741         script_str.push_str("type category enable Rust\n");
 742
 743         // Set breakpoints on every line that contains the string "#break"
 744         let source_file_name = self.testpaths.file.file_name().unwrap().to_string_lossy();
 745         for line in &breakpoint_lines {
 746             script_str.push_str(&format!("breakpoint set --file '{}' --line {}\n",
 747                                          source_file_name,
 748                                          line));
 749         }
 750
 751         // Append the other commands
 752         for line in &commands {
 753             script_str.push_str(line);
 754             script_str.push_str("\n");
 755         }
 756
 757         // Finally, quit the debugger
 758         script_str.push_str("\nquit\n");
 759
 760         // Write the script into a file
 761         debug!("script_str = {}", script_str);
 762         self.dump_output_file(&script_str, "debugger.script");
 763         let debugger_script = self.make_out_name("debugger.script");
 764
 765         // Let LLDB execute the script via lldb_batchmode.py
 766         let debugger_run_result = self.run_lldb(&exe_file,
 767                                                 &debugger_script,
 768                                                 &rust_src_root);
 769
 770         if !debugger_run_result.status.success() {
 771             self.fatal_proc_rec("Error while running LLDB", &debugger_run_result);
 772         }
 773
 774         self.check_debugger_output(&debugger_run_result, &check_lines);
 775     }
 776
 777     fn run_lldb(&self,
 778                 test_executable: &Path,
 779                 debugger_script: &Path,
 780                 rust_src_root: &Path)
 781                 -> ProcRes {
 782         // Prepare the lldb_batchmode which executes the debugger script
 783         let lldb_script_path = rust_src_root.join("src/etc/lldb_batchmode.py");
 784         self.cmd2procres(Command::new(&self.config.lldb_python)
 785                          .arg(&lldb_script_path)
 786                          .arg(test_executable)
 787                          .arg(debugger_script)
 788                          .env("PYTHONPATH",
 789                               self.config.lldb_python_dir.as_ref().unwrap()))
 790     }
 791
 792     fn cmd2procres(&self, cmd: &mut Command) -> ProcRes {
 793         let (status, out, err) = match cmd.output() {
 794             Ok(Output { status, stdout, stderr }) => {
 795                 (status,
 796                  String::from_utf8(stdout).unwrap(),
 797                  String::from_utf8(stderr).unwrap())
 798             },
 799             Err(e) => {
 800                 self.fatal(&format!("Failed to setup Python process for \
 801                                       LLDB script: {}", e))
 802             }
 803         };
 804
 805         self.dump_output(&out, &err);
 806         ProcRes {
 807             status,
 808             stdout: out,
 809             stderr: err,
 810             cmdline: format!("{:?}", cmd)
 811         }
 812     }
 813
 814     fn parse_debugger_commands(&self, debugger_prefixes: &[&str]) -> DebuggerCommands {
 815         let directives = debugger_prefixes.iter().map(|prefix| (
 816             format!("{}-command", prefix),
 817             format!("{}-check", prefix),
 818         )).collect::<Vec<_>>();
 819
 820         let mut breakpoint_lines = vec![];
 821         let mut commands = vec![];
 822         let mut check_lines = vec![];
 823         let mut counter = 1;
 824         let reader = BufReader::new(File::open(&self.testpaths.file).unwrap());
 825         for line in reader.lines() {
 826             match line {
 827                 Ok(line) => {
 828                     if line.contains("#break") {
 829                         breakpoint_lines.push(counter);
 830                     }
 831
 832                     for &(ref command_directive, ref check_directive) in &directives {
 833                         self.config.parse_name_value_directive(
 834                             &line,
 835                             command_directive).map(|cmd| {
 836                                 commands.push(cmd)
 837                             });
 838
 839                         self.config.parse_name_value_directive(
 840                             &line,
 841                             check_directive).map(|cmd| {
 842                                 check_lines.push(cmd)
 843                             });
 844                     }
 845                 }
 846                 Err(e) => {
 847                     self.fatal(&format!("Error while parsing debugger commands: {}", e))
 848                 }
 849             }
 850             counter += 1;
 851         }
 852
 853         DebuggerCommands {
 854             commands,
 855             check_lines,
 856             breakpoint_lines,
 857         }
 858     }
 859
 860     fn cleanup_debug_info_options(&self, options: &Option<String>) -> Option<String> {
 861         if options.is_none() {
 862             return None;
 863         }
 864
 865         // Remove options that are either unwanted (-O) or may lead to duplicates due to RUSTFLAGS.
 866         let options_to_remove = [
 867             "-O".to_owned(),
 868             "-g".to_owned(),
 869             "--debuginfo".to_owned()
 870         ];
 871         let new_options =
 872             self.split_maybe_args(options).into_iter()
 873                                           .filter(|x| !options_to_remove.contains(x))
 874                                           .collect::<Vec<String>>();
 875
 876         Some(new_options.join(" "))
 877     }
 878
 879     fn check_debugger_output(&self, debugger_run_result: &ProcRes, check_lines: &[String]) {
 880         let num_check_lines = check_lines.len();
 881
 882         let mut check_line_index = 0;
 883         for line in debugger_run_result.stdout.lines() {
 884             if check_line_index >= num_check_lines {
 885                 break;
 886             }
 887
 888             if check_single_line(line, &(check_lines[check_line_index])[..]) {
 889                 check_line_index += 1;
 890             }
 891         }
 892         if check_line_index != num_check_lines && num_check_lines > 0 {
 893             self.fatal_proc_rec(&format!("line not found in debugger output: {}",
 894                                          check_lines[check_line_index]),
 895                                 debugger_run_result);
 896         }
 897
 898         fn check_single_line(line: &str, check_line: &str) -> bool {
 899             // Allow check lines to leave parts unspecified (e.g., uninitialized
 900             // bits in the  wrong case of an enum) with the notation "[...]".
 901             let line = line.trim();
 902             let check_line = check_line.trim();
 903             let can_start_anywhere = check_line.starts_with("[...]");
 904             let can_end_anywhere = check_line.ends_with("[...]");
 905
 906             let check_fragments: Vec<&str> = check_line.split("[...]")
 907                                                        .filter(|frag| !frag.is_empty())
 908                                                        .collect();
 909             if check_fragments.is_empty() {
 910                 return true;
 911             }
 912
 913             let (mut rest, first_fragment) = if can_start_anywhere {
 914                 match line.find(check_fragments[0]) {
 915                     Some(pos) => (&line[pos + check_fragments[0].len() ..], 1),
 916                     None => return false
 917                 }
 918             } else {
 919                 (line, 0)
 920             };
 921
 922             for current_fragment in &check_fragments[first_fragment..] {
 923                 match rest.find(current_fragment) {
 924                     Some(pos) => {
 925                         rest = &rest[pos + current_fragment.len() .. ];
 926                     }
 927                     None => return false
 928                 }
 929             }
 930
 931             if !can_end_anywhere && !rest.is_empty() {
 932                 return false;
 933             }
 934
 935             true
 936         }
 937     }
 938
 939     fn check_error_patterns(&self,
 940                             output_to_check: &str,
 941                             proc_res: &ProcRes) {
 942         if self.props.error_patterns.is_empty() {
 943             if self.props.must_compile_successfully {
 944                 return
 945             } else {
 946                 self.fatal(&format!("no error pattern specified in {:?}",
 947                                     self.testpaths.file.display()));
 948             }
 949         }
 950         let mut next_err_idx = 0;
 951         let mut next_err_pat = self.props.error_patterns[next_err_idx].trim();
 952         let mut done = false;
 953         for line in output_to_check.lines() {
 954             if line.contains(next_err_pat) {
 955                 debug!("found error pattern {}", next_err_pat);
 956                 next_err_idx += 1;
 957                 if next_err_idx == self.props.error_patterns.len() {
 958                     debug!("found all error patterns");
 959                     done = true;
 960                     break;
 961                 }
 962                 next_err_pat = self.props.error_patterns[next_err_idx].trim();
 963             }
 964         }
 965         if done { return; }
 966
 967         let missing_patterns = &self.props.error_patterns[next_err_idx..];
 968         if missing_patterns.len() == 1 {
 969             self.fatal_proc_rec(
 970                 &format!("error pattern '{}' not found!", missing_patterns[0]),
 971                 proc_res);
 972         } else {
 973             for pattern in missing_patterns {
 974                 self.error(&format!("error pattern '{}' not found!", *pattern));
 975             }
 976             self.fatal_proc_rec("multiple error patterns not found", proc_res);
 977         }
 978     }
 979
 980     fn check_no_compiler_crash(&self, proc_res: &ProcRes) {
 981         for line in proc_res.stderr.lines() {
 982             if line.contains("error: internal compiler error") {
 983                 self.fatal_proc_rec("compiler encountered internal error", proc_res);
 984             }
 985         }
 986     }
 987
 988     fn check_forbid_output(&self,
 989                            output_to_check: &str,
 990                            proc_res: &ProcRes) {
 991         for pat in &self.props.forbid_output {
 992             if output_to_check.contains(pat) {
 993                 self.fatal_proc_rec("forbidden pattern found in compiler output", proc_res);
 994             }
 995         }
 996     }
 997
 998     fn check_expected_errors(&self,
 999                              expected_errors: Vec<errors::Error>,
1000                              proc_res: &ProcRes) {
1001         if proc_res.status.success() &&
1002             expected_errors.iter().any(|x| x.kind == Some(ErrorKind::Error)) {
1003             self.fatal_proc_rec("process did not return an error status", proc_res);
1004         }
1005
1006         let file_name =
1007             format!("{}", self.testpaths.file.display())
1008             .replace(r"\", "/"); // on windows, translate all '\' path separators to '/'
1009
1010         // If the testcase being checked contains at least one expected "help"
1011         // message, then we'll ensure that all "help" messages are expected.
1012         // Otherwise, all "help" messages reported by the compiler will be ignored.
1013         // This logic also applies to "note" messages.
1014         let expect_help = expected_errors.iter().any(|ee| ee.kind == Some(ErrorKind::Help));
1015         let expect_note = expected_errors.iter().any(|ee| ee.kind == Some(ErrorKind::Note));
1016
1017         // Parse the JSON output from the compiler and extract out the messages.
1018         let actual_errors = json::parse_output(&file_name, &proc_res.stderr, proc_res);
1019         let mut unexpected = Vec::new();
1020         let mut found = vec![false; expected_errors.len()];
1021         for actual_error in &actual_errors {
1022             let opt_index =
1023                 expected_errors
1024                 .iter()
1025                 .enumerate()
1026                 .position(|(index, expected_error)| {
1027                     !found[index] &&
1028                         actual_error.line_num == expected_error.line_num &&
1029                         (expected_error.kind.is_none() ||
1030                          actual_error.kind == expected_error.kind) &&
1031                         actual_error.msg.contains(&expected_error.msg)
1032                 });
1033
1034             match opt_index {
1035                 Some(index) => {
1036                     // found a match, everybody is happy
1037                     assert!(!found[index]);
1038                     found[index] = true;
1039                 }
1040
1041                 None => {
1042                     if self.is_unexpected_compiler_message(actual_error, expect_help, expect_note) {
1043                         self.error(
1044                             &format!("{}:{}: unexpected {}: '{}'",
1045                                      file_name,
1046                                      actual_error.line_num,
1047                                      actual_error.kind.as_ref()
1048                                      .map_or(String::from("message"),
1049                                              |k| k.to_string()),
1050                                      actual_error.msg));
1051                         unexpected.push(actual_error);
1052                     }
1053                 }
1054             }
1055         }
1056
1057         let mut not_found = Vec::new();
1058         // anything not yet found is a problem
1059         for (index, expected_error) in expected_errors.iter().enumerate() {
1060             if !found[index] {
1061                 self.error(
1062                     &format!("{}:{}: expected {} not found: {}",
1063                              file_name,
1064                              expected_error.line_num,
1065                              expected_error.kind.as_ref()
1066                              .map_or("message".into(),
1067                                      |k| k.to_string()),
1068                              expected_error.msg));
1069                 not_found.push(expected_error);
1070             }
1071         }
1072
1073         if !unexpected.is_empty() || !not_found.is_empty() {
1074             self.error(
1075                 &format!("{} unexpected errors found, {} expected errors not found",
1076                          unexpected.len(), not_found.len()));
1077             println!("status: {}\ncommand: {}",
1078                    proc_res.status, proc_res.cmdline);
1079             if !unexpected.is_empty() {
1080                 println!("unexpected errors (from JSON output): {:#?}\n", unexpected);
1081             }
1082             if !not_found.is_empty() {
1083                 println!("not found errors (from test file): {:#?}\n", not_found);
1084             }
1085             panic!();
1086         }
1087     }
1088
1089     /// Returns true if we should report an error about `actual_error`,
1090     /// which did not match any of the expected error. We always require
1091     /// errors/warnings to be explicitly listed, but only require
1092     /// helps/notes if there are explicit helps/notes given.
1093     fn is_unexpected_compiler_message(&self,
1094                                       actual_error: &Error,
1095                                       expect_help: bool,
1096                                       expect_note: bool)
1097                                       -> bool {
1098         match actual_error.kind {
1099             Some(ErrorKind::Help) => expect_help,
1100             Some(ErrorKind::Note) => expect_note,
1101             Some(ErrorKind::Error) |
1102             Some(ErrorKind::Warning) => true,
1103             Some(ErrorKind::Suggestion) |
1104             None => false
1105         }
1106     }
1107
1108     fn compile_test(&self) -> ProcRes {
1109         let mut rustc = self.make_compile_args(
1110             &self.testpaths.file, TargetLocation::ThisFile(self.make_exe_name()));
1111
1112         rustc.arg("-L").arg(&self.aux_output_dir_name());
1113
1114         match self.config.mode {
1115             CompileFail | Ui => {
1116                 // compile-fail and ui tests tend to have tons of unused code as
1117                 // it's just testing various pieces of the compile, but we don't
1118                 // want to actually assert warnings about all this code. Instead
1119                 // let's just ignore unused code warnings by defaults and tests
1120                 // can turn it back on if needed.
1121                 rustc.args(&["-A", "unused"]);
1122             }
1123             _ => {}
1124         }
1125
1126         self.compose_and_run_compiler(rustc, None)
1127     }
1128
1129     fn document(&self, out_dir: &Path) -> ProcRes {
1130         if self.props.build_aux_docs {
1131             for rel_ab in &self.props.aux_builds {
1132                 let aux_testpaths = self.compute_aux_test_paths(rel_ab);
1133                 let aux_props = self.props.from_aux_file(&aux_testpaths.file,
1134                                                          self.revision,
1135                                                          self.config);
1136                 let aux_cx = TestCx {
1137                     config: self.config,
1138                     props: &aux_props,
1139                     testpaths: &aux_testpaths,
1140                     revision: self.revision
1141                 };
1142                 let auxres = aux_cx.document(out_dir);
1143                 if !auxres.status.success() {
1144                     return auxres;
1145                 }
1146             }
1147         }
1148
1149         let aux_dir = self.aux_output_dir_name();
1150
1151         let rustdoc_path = self.config.rustdoc_path.as_ref().expect("--rustdoc-path passed");
1152         let mut rustdoc = Command::new(rustdoc_path);
1153
1154         rustdoc.arg("-L").arg(aux_dir)
1155             .arg("-o").arg(out_dir)
1156             .arg(&self.testpaths.file)
1157             .args(&self.props.compile_flags);
1158         if let Some(ref linker) = self.config.linker {
1159             rustdoc.arg("--linker").arg(linker).arg("-Z").arg("unstable-options");
1160         }
1161
1162         self.compose_and_run_compiler(rustdoc, None)
1163     }
1164
1165     fn exec_compiled_test(&self) -> ProcRes {
1166         let env = &self.props.exec_env;
1167
1168         match &*self.config.target {
1169             // This is pretty similar to below, we're transforming:
1170             //
1171             //      program arg1 arg2
1172             //
1173             // into
1174             //
1175             //      remote-test-client run program:support-lib.so arg1 arg2
1176             //
1177             // The test-client program will upload `program` to the emulator
1178             // along with all other support libraries listed (in this case
1179             // `support-lib.so`. It will then execute the program on the
1180             // emulator with the arguments specified (in the environment we give
1181             // the process) and then report back the same result.
1182             _ if self.config.remote_test_client.is_some() => {
1183                 let aux_dir = self.aux_output_dir_name();
1184                 let ProcArgs { mut prog, args } = self.make_run_args();
1185                 if let Ok(entries) = aux_dir.read_dir() {
1186                     for entry in entries {
1187                         let entry = entry.unwrap();
1188                         if !entry.path().is_file() {
1189                             continue
1190                         }
1191                         prog.push_str(":");
1192                         prog.push_str(entry.path().to_str().unwrap());
1193                     }
1194                 }
1195                 let mut test_client = Command::new(
1196                     self.config.remote_test_client.as_ref().unwrap());
1197                 test_client
1198                     .args(&["run", &prog])
1199                     .args(args)
1200                     .envs(env.clone());
1201                 self.compose_and_run(test_client,
1202                                      self.config.run_lib_path.to_str().unwrap(),
1203                                      Some(aux_dir.to_str().unwrap()),
1204                                      None)
1205             }
1206             _ => {
1207                 let aux_dir = self.aux_output_dir_name();
1208                 let ProcArgs { prog, args } = self.make_run_args();
1209                 let mut program = Command::new(&prog);
1210                 program.args(args)
1211                     .current_dir(&self.output_base_name().parent().unwrap())
1212                     .envs(env.clone());
1213                 self.compose_and_run(program,
1214                                      self.config.run_lib_path.to_str().unwrap(),
1215                                      Some(aux_dir.to_str().unwrap()),
1216                                      None)
1217             }
1218         }
1219     }
1220
1221     /// For each `aux-build: foo/bar` annotation, we check to find the
1222     /// file in a `aux` directory relative to the test itself.
1223     fn compute_aux_test_paths(&self, rel_ab: &str) -> TestPaths {
1224         let test_ab = self.testpaths.file
1225                                     .parent()
1226                                     .expect("test file path has no parent")
1227                                     .join("auxiliary")
1228                                     .join(rel_ab);
1229         if !test_ab.exists() {
1230             self.fatal(&format!("aux-build `{}` source not found", test_ab.display()))
1231         }
1232
1233         TestPaths {
1234             file: test_ab,
1235             base: self.testpaths.base.clone(),
1236             relative_dir: self.testpaths.relative_dir
1237                                         .join("auxiliary")
1238                                         .join(rel_ab)
1239                                         .parent()
1240                                         .expect("aux-build path has no parent")
1241                                         .to_path_buf()
1242         }
1243     }
1244
1245     fn compose_and_run_compiler(&self, mut rustc: Command, input: Option<String>) -> ProcRes {
1246         if !self.props.aux_builds.is_empty() {
1247             create_dir_all(&self.aux_output_dir_name()).unwrap();
1248         }
1249
1250         let aux_dir = self.aux_output_dir_name();
1251
1252         for rel_ab in &self.props.aux_builds {
1253             let aux_testpaths = self.compute_aux_test_paths(rel_ab);
1254             let aux_props = self.props.from_aux_file(&aux_testpaths.file,
1255                                                      self.revision,
1256                                                      self.config);
1257             let aux_output = {
1258                 let f = self.make_lib_name(&self.testpaths.file);
1259                 let parent = f.parent().unwrap();
1260                 TargetLocation::ThisDirectory(parent.to_path_buf())
1261             };
1262             let aux_cx = TestCx {
1263                 config: self.config,
1264                 props: &aux_props,
1265                 testpaths: &aux_testpaths,
1266                 revision: self.revision
1267             };
1268             let mut aux_rustc = aux_cx.make_compile_args(&aux_testpaths.file, aux_output);
1269
1270             let crate_type = if aux_props.no_prefer_dynamic {
1271                 None
1272             } else if (self.config.target.contains("musl") && !aux_props.force_host) ||
1273                       self.config.target.contains("wasm32") ||
1274                       self.config.target.contains("emscripten") {
1275                 // We primarily compile all auxiliary libraries as dynamic libraries
1276                 // to avoid code size bloat and large binaries as much as possible
1277                 // for the test suite (otherwise including libstd statically in all
1278                 // executables takes up quite a bit of space).
1279                 //
1280                 // For targets like MUSL or Emscripten, however, there is no support for
1281                 // dynamic libraries so we just go back to building a normal library. Note,
1282                 // however, that for MUSL if the library is built with `force_host` then
1283                 // it's ok to be a dylib as the host should always support dylibs.
1284                 Some("lib")
1285             } else {
1286                 Some("dylib")
1287             };
1288
1289             if let Some(crate_type) = crate_type {
1290                 aux_rustc.args(&["--crate-type", crate_type]);
1291             }
1292
1293             aux_rustc.arg("-L").arg(&aux_dir);
1294
1295             let auxres = aux_cx.compose_and_run(aux_rustc,
1296                                                 aux_cx.config.compile_lib_path.to_str().unwrap(),
1297                                                 Some(aux_dir.to_str().unwrap()),
1298                                                 None);
1299             if !auxres.status.success() {
1300                 self.fatal_proc_rec(
1301                     &format!("auxiliary build of {:?} failed to compile: ",
1302                              aux_testpaths.file.display()),
1303                     &auxres);
1304             }
1305         }
1306
1307         rustc.envs(self.props.rustc_env.clone());
1308         self.compose_and_run(rustc,
1309                              self.config.compile_lib_path.to_str().unwrap(),
1310                              Some(aux_dir.to_str().unwrap()),
1311                              input)
1312     }
1313
1314     fn compose_and_run(&self,
1315                        mut command: Command,
1316                        lib_path: &str,
1317                        aux_path: Option<&str>,
1318                        input: Option<String>) -> ProcRes {
1319         let cmdline =
1320         {
1321             let cmdline = self.make_cmdline(&command, lib_path);
1322             logv(self.config, format!("executing {}", cmdline));
1323             cmdline
1324         };
1325
1326         command
1327             .stdout(Stdio::piped())
1328             .stderr(Stdio::piped())
1329             .stdin(Stdio::piped());
1330
1331         // Need to be sure to put both the lib_path and the aux path in the dylib
1332         // search path for the child.
1333         let mut path = env::split_paths(&env::var_os(dylib_env_var()).unwrap_or(OsString::new()))
1334             .collect::<Vec<_>>();
1335         if let Some(p) = aux_path {
1336             path.insert(0, PathBuf::from(p))
1337         }
1338         path.insert(0, PathBuf::from(lib_path));
1339
1340         // Add the new dylib search path var
1341         let newpath = env::join_paths(&path).unwrap();
1342         command.env(dylib_env_var(), newpath);
1343
1344         let mut child = command.spawn().expect(&format!("failed to exec `{:?}`", &command));
1345         if let Some(input) = input {
1346             child.stdin.as_mut().unwrap().write_all(input.as_bytes()).unwrap();
1347         }
1348
1349         let Output { status, stdout, stderr } = read2_abbreviated(child)
1350             .expect("failed to read output");
1351
1352         let result = ProcRes {
1353             status,
1354             stdout: String::from_utf8_lossy(&stdout).into_owned(),
1355             stderr: String::from_utf8_lossy(&stderr).into_owned(),
1356             cmdline,
1357         };
1358
1359         self.dump_output(&result.stdout, &result.stderr);
1360
1361         result
1362     }
1363
1364     fn make_compile_args(&self, input_file: &Path, output_file: TargetLocation) -> Command {
1365         let mut rustc = Command::new(&self.config.rustc_path);
1366         rustc.arg(input_file)
1367             .arg("-L").arg(&self.config.build_base);
1368
1369         // Optionally prevent default --target if specified in test compile-flags.
1370         let custom_target = self.props.compile_flags
1371             .iter()
1372             .fold(false, |acc, x| acc || x.starts_with("--target"));
1373
1374         if !custom_target {
1375             let target = if self.props.force_host {
1376                 &*self.config.host
1377             } else {
1378                 &*self.config.target
1379             };
1380
1381             rustc.arg(&format!("--target={}", target));
1382         }
1383
1384         if let Some(revision) = self.revision {
1385             rustc.args(&["--cfg", revision]);
1386         }
1387
1388         if let Some(ref incremental_dir) = self.props.incremental_dir {
1389             rustc.args(&["-Z", &format!("incremental={}", incremental_dir.display())]);
1390             rustc.args(&["-Z", "incremental-verify-ich"]);
1391             rustc.args(&["-Z", "incremental-queries"]);
1392         }
1393
1394         match self.config.mode {
1395             CompileFail |
1396             ParseFail |
1397             Incremental => {
1398                 // If we are extracting and matching errors in the new
1399                 // fashion, then you want JSON mode. Old-skool error
1400                 // patterns still match the raw compiler output.
1401                 if self.props.error_patterns.is_empty() {
1402                     rustc.args(&["--error-format", "json"]);
1403                 }
1404             }
1405             MirOpt => {
1406                 rustc.args(&[
1407                     "-Zdump-mir=all",
1408                     "-Zmir-opt-level=3",
1409                     "-Zdump-mir-exclude-pass-number"]);
1410
1411                 let mir_dump_dir = self.get_mir_dump_dir();
1412                 let _ = fs::remove_dir_all(&mir_dump_dir);
1413                 create_dir_all(mir_dump_dir.as_path()).unwrap();
1414                 let mut dir_opt = "-Zdump-mir-dir=".to_string();
1415                 dir_opt.push_str(mir_dump_dir.to_str().unwrap());
1416                 debug!("dir_opt: {:?}", dir_opt);
1417
1418                 rustc.arg(dir_opt);
1419             }
1420             RunPass |
1421             RunFail |
1422             RunPassValgrind |
1423             Pretty |
1424             DebugInfoGdb |
1425             DebugInfoLldb |
1426             Codegen |
1427             Rustdoc |
1428             RunMake |
1429             Ui |
1430             CodegenUnits => {
1431                 // do not use JSON output
1432             }
1433         }
1434
1435
1436         if self.config.target == "wasm32-unknown-unknown" {
1437             // rustc.arg("-g"); // get any backtrace at all on errors
1438         } else if !self.props.no_prefer_dynamic {
1439             rustc.args(&["-C", "prefer-dynamic"]);
1440         }
1441
1442         match output_file {
1443             TargetLocation::ThisFile(path) => {
1444                 rustc.arg("-o").arg(path);
1445             }
1446             TargetLocation::ThisDirectory(path) => {
1447                 rustc.arg("--out-dir").arg(path);
1448             }
1449         }
1450
1451         if self.props.force_host {
1452             rustc.args(self.split_maybe_args(&self.config.host_rustcflags));
1453         } else {
1454             rustc.args(self.split_maybe_args(&self.config.target_rustcflags));
1455         }
1456         if let Some(ref linker) = self.config.linker {
1457             rustc.arg(format!("-Clinker={}", linker));
1458         }
1459
1460         rustc.args(&self.props.compile_flags);
1461
1462         rustc
1463     }
1464
1465     fn make_lib_name(&self, auxfile: &Path) -> PathBuf {
1466         // what we return here is not particularly important, as it
1467         // happens; rustc ignores everything except for the directory.
1468         let auxname = self.output_testname(auxfile);
1469         self.aux_output_dir_name().join(&auxname)
1470     }
1471
1472     fn make_exe_name(&self) -> PathBuf {
1473         let mut f = self.output_base_name();
1474         // FIXME: This is using the host architecture exe suffix, not target!
1475         if self.config.target.contains("emscripten") {
1476             let mut fname = f.file_name().unwrap().to_os_string();
1477             fname.push(".js");
1478             f.set_file_name(&fname);
1479         } else if self.config.target.contains("wasm32") {
1480             let mut fname = f.file_name().unwrap().to_os_string();
1481             fname.push(".wasm");
1482             f.set_file_name(&fname);
1483         } else if !env::consts::EXE_SUFFIX.is_empty() {
1484             let mut fname = f.file_name().unwrap().to_os_string();
1485             fname.push(env::consts::EXE_SUFFIX);
1486             f.set_file_name(&fname);
1487         }
1488         f
1489     }
1490
1491     fn make_run_args(&self) -> ProcArgs {
1492         // If we've got another tool to run under (valgrind),
1493         // then split apart its command
1494         let mut args = self.split_maybe_args(&self.config.runtool);
1495
1496         // If this is emscripten, then run tests under nodejs
1497         if self.config.target.contains("emscripten") {
1498             if let Some(ref p) = self.config.nodejs {
1499                 args.push(p.clone());
1500             } else {
1501                 self.fatal("no NodeJS binary found (--nodejs)");
1502             }
1503         }
1504
1505         // If this is otherwise wasm , then run tests under nodejs with our
1506         // shim
1507         if self.config.target.contains("wasm32") {
1508             if let Some(ref p) = self.config.nodejs {
1509                 args.push(p.clone());
1510             } else {
1511                 self.fatal("no NodeJS binary found (--nodejs)");
1512             }
1513
1514             let src = self.config.src_base
1515                 .parent().unwrap() // chop off `run-pass`
1516                 .parent().unwrap() // chop off `test`
1517                 .parent().unwrap(); // chop off `src`
1518             args.push(src.join("src/etc/wasm32-shim.js").display().to_string());
1519         }
1520
1521         let exe_file = self.make_exe_name();
1522
1523         // FIXME (#9639): This needs to handle non-utf8 paths
1524         args.push(exe_file.to_str().unwrap().to_owned());
1525
1526         // Add the arguments in the run_flags directive
1527         args.extend(self.split_maybe_args(&self.props.run_flags));
1528
1529         let prog = args.remove(0);
1530          ProcArgs {
1531             prog,
1532             args,
1533         }
1534     }
1535
1536     fn split_maybe_args(&self, argstr: &Option<String>) -> Vec<String> {
1537         match *argstr {
1538             Some(ref s) => {
1539                 s
1540                     .split(' ')
1541                     .filter_map(|s| {
1542                         if s.chars().all(|c| c.is_whitespace()) {
1543                             None
1544                         } else {
1545                             Some(s.to_owned())
1546                         }
1547                     }).collect()
1548             }
1549             None => Vec::new()
1550         }
1551     }
1552
1553     fn make_cmdline(&self, command: &Command, libpath: &str) -> String {
1554         use util;
1555
1556         // Linux and mac don't require adjusting the library search path
1557         if cfg!(unix) {
1558             format!("{:?}", command)
1559         } else {
1560             // Build the LD_LIBRARY_PATH variable as it would be seen on the command line
1561             // for diagnostic purposes
1562             fn lib_path_cmd_prefix(path: &str) -> String {
1563                 format!("{}=\"{}\"", util::lib_path_env_var(), util::make_new_path(path))
1564             }
1565
1566             format!("{} {:?}", lib_path_cmd_prefix(libpath), command)
1567         }
1568     }
1569
1570     fn dump_output(&self, out: &str, err: &str) {
1571         let revision = if let Some(r) = self.revision {
1572             format!("{}.", r)
1573         } else {
1574             String::new()
1575         };
1576
1577         self.dump_output_file(out, &format!("{}out", revision));
1578         self.dump_output_file(err, &format!("{}err", revision));
1579         self.maybe_dump_to_stdout(out, err);
1580     }
1581
1582     fn dump_output_file(&self,
1583                         out: &str,
1584                         extension: &str) {
1585         let outfile = self.make_out_name(extension);
1586         File::create(&outfile).unwrap().write_all(out.as_bytes()).unwrap();
1587     }
1588
1589     fn make_out_name(&self, extension: &str) -> PathBuf {
1590         self.output_base_name().with_extension(extension)
1591     }
1592
1593     fn aux_output_dir_name(&self) -> PathBuf {
1594         let f = self.output_base_name();
1595         let mut fname = f.file_name().unwrap().to_os_string();
1596         fname.push(&format!("{}.aux", self.config.mode.disambiguator()));
1597         f.with_file_name(&fname)
1598     }
1599
1600     fn output_testname(&self, filepath: &Path) -> PathBuf {
1601         PathBuf::from(filepath.file_stem().unwrap())
1602     }
1603
1604     /// Given a test path like `compile-fail/foo/bar.rs` Returns a name like
1605     /// `<output>/foo/bar-stage1`
1606     fn output_base_name(&self) -> PathBuf {
1607         let dir = self.config.build_base.join(&self.testpaths.relative_dir);
1608
1609         // Note: The directory `dir` is created during `collect_tests_from_dir`
1610         dir
1611             .join(&self.output_testname(&self.testpaths.file))
1612             .with_extension(&self.config.stage_id)
1613     }
1614
1615     fn maybe_dump_to_stdout(&self, out: &str, err: &str) {
1616         if self.config.verbose {
1617             println!("------{}------------------------------", "stdout");
1618             println!("{}", out);
1619             println!("------{}------------------------------", "stderr");
1620             println!("{}", err);
1621             println!("------------------------------------------");
1622         }
1623     }
1624
1625     fn error(&self, err: &str) {
1626         match self.revision {
1627             Some(rev) => println!("\nerror in revision `{}`: {}", rev, err),
1628             None => println!("\nerror: {}", err)
1629         }
1630     }
1631
1632     fn fatal(&self, err: &str) -> ! {
1633         self.error(err); panic!();
1634     }
1635
1636     fn fatal_proc_rec(&self, err: &str, proc_res: &ProcRes) -> ! {
1637         self.try_print_open_handles();
1638         self.error(err);
1639         proc_res.fatal(None);
1640     }
1641
1642     // This function is a poor man's attempt to debug rust-lang/rust#38620, if
1643     // that's closed then this should be deleted
1644     //
1645     // This is a very "opportunistic" debugging attempt, so we ignore all
1646     // errors here.
1647     fn try_print_open_handles(&self) {
1648         if !cfg!(windows) {
1649             return
1650         }
1651         if self.config.mode != Incremental {
1652             return
1653         }
1654
1655         let filename = match self.testpaths.file.file_stem() {
1656             Some(path) => path,
1657             None => return,
1658         };
1659
1660         let mut cmd = Command::new("handle.exe");
1661         cmd.arg("-a").arg("-u");
1662         cmd.arg(filename);
1663         cmd.arg("-nobanner");
1664         cmd.stdout(Stdio::piped());
1665         cmd.stderr(Stdio::piped());
1666         let output = match cmd.spawn().and_then(read2_abbreviated) {
1667             Ok(output) => output,
1668             Err(_) => return,
1669         };
1670         println!("---------------------------------------------------");
1671         println!("ran extra command to debug rust-lang/rust#38620: ");
1672         println!("{:?}", cmd);
1673         println!("result: {}", output.status);
1674         println!("--- stdout ----------------------------------------");
1675         println!("{}", String::from_utf8_lossy(&output.stdout));
1676         println!("--- stderr ----------------------------------------");
1677         println!("{}", String::from_utf8_lossy(&output.stderr));
1678         println!("---------------------------------------------------");
1679     }
1680
1681     // codegen tests (using FileCheck)
1682
1683     fn compile_test_and_save_ir(&self) -> ProcRes {
1684         let aux_dir = self.aux_output_dir_name();
1685
1686         let output_file = TargetLocation::ThisDirectory(
1687             self.output_base_name().parent().unwrap().to_path_buf());
1688         let mut rustc = self.make_compile_args(&self.testpaths.file, output_file);
1689         rustc.arg("-L").arg(aux_dir)
1690             .arg("--emit=llvm-ir");
1691
1692         self.compose_and_run_compiler(rustc, None)
1693     }
1694
1695     fn check_ir_with_filecheck(&self) -> ProcRes {
1696         let irfile = self.output_base_name().with_extension("ll");
1697         let mut filecheck = Command::new(self.config.llvm_filecheck.as_ref().unwrap());
1698         filecheck.arg("--input-file").arg(irfile)
1699             .arg(&self.testpaths.file);
1700         self.compose_and_run(filecheck, "", None, None)
1701     }
1702
1703     fn run_codegen_test(&self) {
1704         assert!(self.revision.is_none(), "revisions not relevant here");
1705
1706         if self.config.llvm_filecheck.is_none() {
1707             self.fatal("missing --llvm-filecheck");
1708         }
1709
1710         let mut proc_res = self.compile_test_and_save_ir();
1711         if !proc_res.status.success() {
1712             self.fatal_proc_rec("compilation failed!", &proc_res);
1713         }
1714
1715         proc_res = self.check_ir_with_filecheck();
1716         if !proc_res.status.success() {
1717             self.fatal_proc_rec("verification with 'FileCheck' failed", &proc_res);
1718         }
1719     }
1720
1721     fn charset() -> &'static str {
1722         // FreeBSD 10.1 defaults to GDB 6.1.1 which doesn't support "auto" charset
1723         if cfg!(target_os = "bitrig") {
1724             "auto"
1725         } else if cfg!(target_os = "freebsd") {
1726             "ISO-8859-1"
1727         } else {
1728             "UTF-8"
1729         }
1730     }
1731
1732     fn run_rustdoc_test(&self) {
1733         assert!(self.revision.is_none(), "revisions not relevant here");
1734
1735         let out_dir = self.output_base_name();
1736         let _ = fs::remove_dir_all(&out_dir);
1737         create_dir_all(&out_dir).unwrap();
1738
1739         let proc_res = self.document(&out_dir);
1740         if !proc_res.status.success() {
1741             self.fatal_proc_rec("rustdoc failed!", &proc_res);
1742         }
1743
1744         if self.props.check_test_line_numbers_match {
1745             self.check_rustdoc_test_option(proc_res);
1746         } else {
1747             let root = self.config.find_rust_src_root().unwrap();
1748             let res = self.cmd2procres(
1749                 Command::new(&self.config.docck_python)
1750                     .arg(root.join("src/etc/htmldocck.py"))
1751                     .arg(out_dir)
1752                     .arg(&self.testpaths.file),
1753             );
1754             if !res.status.success() {
1755                 self.fatal_proc_rec("htmldocck failed!", &res);
1756             }
1757         }
1758     }
1759
1760     fn get_lines<P: AsRef<Path>>(&self, path: &P,
1761                                  mut other_files: Option<&mut Vec<String>>) -> Vec<usize> {
1762         let mut file = fs::File::open(path)
1763                                 .expect("markdown_test_output_check_entry File::open failed");
1764         let mut content = String::new();
1765         file.read_to_string(&mut content)
1766             .expect("markdown_test_output_check_entry read_to_string failed");
1767         let mut ignore = false;
1768         content.lines()
1769                .enumerate()
1770                .filter_map(|(line_nb, line)| {
1771                    if (line.trim_left().starts_with("pub mod ") ||
1772                        line.trim_left().starts_with("mod ")) &&
1773                       line.ends_with(';') {
1774                        if let Some(ref mut other_files) = other_files {
1775                            other_files.push(line.rsplit("mod ")
1776                                       .next()
1777                                       .unwrap()
1778                                       .replace(";", ""));
1779                        }
1780                        None
1781                    } else {
1782                        let sline = line.split("///").last().unwrap_or("");
1783                        let line = sline.trim_left();
1784                        if line.starts_with("```") {
1785                            if ignore {
1786                                ignore = false;
1787                                None
1788                            } else {
1789                                ignore = true;
1790                                Some(line_nb + 1)
1791                            }
1792                        } else {
1793                            None
1794                        }
1795                    }
1796                })
1797                .collect()
1798     }
1799
1800     fn check_rustdoc_test_option(&self, res: ProcRes) {
1801         let mut other_files = Vec::new();
1802         let mut files: HashMap<String, Vec<usize>> = HashMap::new();
1803         let cwd = env::current_dir().unwrap();
1804         files.insert(self.testpaths.file.strip_prefix(&cwd)
1805                                         .unwrap_or(&self.testpaths.file)
1806                                         .to_str()
1807                                         .unwrap()
1808                                         .replace('\\', "/"),
1809                      self.get_lines(&self.testpaths.file, Some(&mut other_files)));
1810         for other_file in other_files {
1811             let mut path = self.testpaths.file.clone();
1812             path.set_file_name(&format!("{}.rs", other_file));
1813             files.insert(path.strip_prefix(&cwd)
1814                              .unwrap_or(&path)
1815                              .to_str()
1816                              .unwrap()
1817                              .replace('\\', "/"),
1818                          self.get_lines(&path, None));
1819         }
1820
1821         let mut tested = 0;
1822         for _ in res.stdout.split('\n')
1823                            .filter(|s| s.starts_with("test "))
1824                            .inspect(|s| {
1825                                let tmp: Vec<&str> = s.split(" - ").collect();
1826                                if tmp.len() == 2 {
1827                                    let path = tmp[0].rsplit("test ").next().unwrap();
1828                                    if let Some(ref mut v) = files.get_mut(
1829                                                                 &path.replace('\\', "/")) {
1830                                        tested += 1;
1831                                        let mut iter = tmp[1].split("(line ");
1832                                        iter.next();
1833                                        let line = iter.next()
1834                                                       .unwrap_or(")")
1835                                                       .split(')')
1836                                                       .next()
1837                                                       .unwrap_or("0")
1838                                                       .parse()
1839                                                       .unwrap_or(0);
1840                                        if let Ok(pos) = v.binary_search(&line) {
1841                                            v.remove(pos);
1842                                        } else {
1843                                            self.fatal_proc_rec(
1844                                                &format!("Not found doc test: \"{}\" in \"{}\":{:?}",
1845                                                         s, path, v),
1846                                                &res);
1847                                        }
1848                                    }
1849                                }
1850                            }) {}
1851         if tested == 0 {
1852             self.fatal_proc_rec(&format!("No test has been found... {:?}", files), &res);
1853         } else {
1854             for (entry, v) in &files {
1855                 if !v.is_empty() {
1856                     self.fatal_proc_rec(&format!("Not found test at line{} \"{}\":{:?}",
1857                                                  if v.len() > 1 { "s" } else { "" }, entry, v),
1858                                         &res);
1859                 }
1860             }
1861         }
1862     }
1863
1864     fn run_codegen_units_test(&self) {
1865         assert!(self.revision.is_none(), "revisions not relevant here");
1866
1867         let proc_res = self.compile_test();
1868
1869         if !proc_res.status.success() {
1870             self.fatal_proc_rec("compilation failed!", &proc_res);
1871         }
1872
1873         self.check_no_compiler_crash(&proc_res);
1874
1875         const PREFIX: &'static str = "TRANS_ITEM ";
1876         const CGU_MARKER: &'static str = "@@";
1877
1878         let actual: Vec<TransItem> = proc_res
1879             .stdout
1880             .lines()
1881             .filter(|line| line.starts_with(PREFIX))
1882             .map(str_to_trans_item)
1883             .collect();
1884
1885         let expected: Vec<TransItem> = errors::load_errors(&self.testpaths.file, None)
1886             .iter()
1887             .map(|e| str_to_trans_item(&e.msg[..]))
1888             .collect();
1889
1890         let mut missing = Vec::new();
1891         let mut wrong_cgus = Vec::new();
1892
1893         for expected_item in &expected {
1894             let actual_item_with_same_name = actual.iter()
1895                                                    .find(|ti| ti.name == expected_item.name);
1896
1897             if let Some(actual_item) = actual_item_with_same_name {
1898                 if !expected_item.codegen_units.is_empty() &&
1899                    // Also check for codegen units
1900                    expected_item.codegen_units != actual_item.codegen_units {
1901                     wrong_cgus.push((expected_item.clone(), actual_item.clone()));
1902                 }
1903             } else {
1904                 missing.push(expected_item.string.clone());
1905             }
1906         }
1907
1908         let unexpected: Vec<_> =
1909             actual.iter()
1910                   .filter(|acgu| !expected.iter().any(|ecgu| acgu.name == ecgu.name))
1911                   .map(|acgu| acgu.string.clone())
1912                   .collect();
1913
1914         if !missing.is_empty() {
1915             missing.sort();
1916
1917             println!("\nThese items should have been contained but were not:\n");
1918
1919             for item in &missing {
1920                 println!("{}", item);
1921             }
1922
1923             println!("\n");
1924         }
1925
1926         if !unexpected.is_empty() {
1927             let sorted = {
1928                 let mut sorted = unexpected.clone();
1929                 sorted.sort();
1930                 sorted
1931             };
1932
1933             println!("\nThese items were contained but should not have been:\n");
1934
1935             for item in sorted {
1936                 println!("{}", item);
1937             }
1938
1939             println!("\n");
1940         }
1941
1942         if !wrong_cgus.is_empty() {
1943             wrong_cgus.sort_by_key(|pair| pair.0.name.clone());
1944             println!("\nThe following items were assigned to wrong codegen units:\n");
1945
1946             for &(ref expected_item, ref actual_item) in &wrong_cgus {
1947                 println!("{}", expected_item.name);
1948                 println!("  expected: {}", codegen_units_to_str(&expected_item.codegen_units));
1949                 println!("  actual:   {}", codegen_units_to_str(&actual_item.codegen_units));
1950                 println!("");
1951             }
1952         }
1953
1954         if !(missing.is_empty() && unexpected.is_empty() && wrong_cgus.is_empty())
1955         {
1956             panic!();
1957         }
1958
1959         #[derive(Clone, Eq, PartialEq)]
1960         struct TransItem {
1961             name: String,
1962             codegen_units: HashSet<String>,
1963             string: String,
1964         }
1965
1966         // [TRANS_ITEM] name [@@ (cgu)+]
1967         fn str_to_trans_item(s: &str) -> TransItem {
1968             let s = if s.starts_with(PREFIX) {
1969                 (&s[PREFIX.len()..]).trim()
1970             } else {
1971                 s.trim()
1972             };
1973
1974             let full_string = format!("{}{}", PREFIX, s.trim().to_owned());
1975
1976             let parts: Vec<&str> = s.split(CGU_MARKER)
1977                                     .map(str::trim)
1978                                     .filter(|s| !s.is_empty())
1979                                     .collect();
1980
1981             let name = parts[0].trim();
1982
1983             let cgus = if parts.len() > 1 {
1984                 let cgus_str = parts[1];
1985
1986                 cgus_str.split(' ')
1987                         .map(str::trim)
1988                         .filter(|s| !s.is_empty())
1989                         .map(str::to_owned)
1990                         .collect()
1991             }
1992             else {
1993                 HashSet::new()
1994             };
1995
1996             TransItem {
1997                 name: name.to_owned(),
1998                 codegen_units: cgus,
1999                 string: full_string,
2000             }
2001         }
2002
2003         fn codegen_units_to_str(cgus: &HashSet<String>) -> String
2004         {
2005             let mut cgus: Vec<_> = cgus.iter().collect();
2006             cgus.sort();
2007
2008             let mut string = String::new();
2009             for cgu in cgus {
2010                 string.push_str(&cgu[..]);
2011                 string.push_str(" ");
2012             }
2013
2014             string
2015         }
2016     }
2017
2018     fn init_incremental_test(&self) {
2019         // (See `run_incremental_test` for an overview of how incremental tests work.)
2020
2021         // Before any of the revisions have executed, create the
2022         // incremental workproduct directory.  Delete any old
2023         // incremental work products that may be there from prior
2024         // runs.
2025         let incremental_dir = self.incremental_dir();
2026         if incremental_dir.exists() {
2027             // Canonicalizing the path will convert it to the //?/ format
2028             // on Windows, which enables paths longer than 260 character
2029             let canonicalized = incremental_dir.canonicalize().unwrap();
2030             fs::remove_dir_all(canonicalized).unwrap();
2031         }
2032         fs::create_dir_all(&incremental_dir).unwrap();
2033
2034         if self.config.verbose {
2035             print!("init_incremental_test: incremental_dir={}", incremental_dir.display());
2036         }
2037     }
2038
2039     fn run_incremental_test(&self) {
2040         // Basic plan for a test incremental/foo/bar.rs:
2041         // - load list of revisions rpass1, cfail2, rpass3
2042         //   - each should begin with `rpass`, `cfail`, or `cfail`
2043         //   - if `rpass`, expect compile and execution to succeed
2044         //   - if `cfail`, expect compilation to fail
2045         //   - if `rfail`, expect execution to fail
2046         // - create a directory build/foo/bar.incremental
2047         // - compile foo/bar.rs with -Z incremental=.../foo/bar.incremental and -C rpass1
2048         //   - because name of revision starts with "rpass", expect success
2049         // - compile foo/bar.rs with -Z incremental=.../foo/bar.incremental and -C cfail2
2050         //   - because name of revision starts with "cfail", expect an error
2051         //   - load expected errors as usual, but filter for those that end in `[rfail2]`
2052         // - compile foo/bar.rs with -Z incremental=.../foo/bar.incremental and -C rpass3
2053         //   - because name of revision starts with "rpass", expect success
2054         // - execute build/foo/bar.exe and save output
2055         //
2056         // FIXME -- use non-incremental mode as an oracle? That doesn't apply
2057         // to #[rustc_dirty] and clean tests I guess
2058
2059         let revision = self.revision.expect("incremental tests require a list of revisions");
2060
2061         // Incremental workproduct directory should have already been created.
2062         let incremental_dir = self.incremental_dir();
2063         assert!(incremental_dir.exists(), "init_incremental_test failed to create incremental dir");
2064
2065         // Add an extra flag pointing at the incremental directory.
2066         let mut revision_props = self.props.clone();
2067         revision_props.incremental_dir = Some(incremental_dir);
2068
2069         let revision_cx = TestCx {
2070             config: self.config,
2071             props: &revision_props,
2072             testpaths: self.testpaths,
2073             revision: self.revision,
2074         };
2075
2076         if self.config.verbose {
2077             print!("revision={:?} revision_props={:#?}", revision, revision_props);
2078         }
2079
2080         if revision.starts_with("rpass") {
2081             revision_cx.run_rpass_test();
2082         } else if revision.starts_with("rfail") {
2083             revision_cx.run_rfail_test();
2084         } else if revision.starts_with("cfail") {
2085             revision_cx.run_cfail_test();
2086         } else {
2087             revision_cx.fatal(
2088                 "revision name must begin with rpass, rfail, or cfail");
2089         }
2090     }
2091
2092     /// Directory where incremental work products are stored.
2093     fn incremental_dir(&self) -> PathBuf {
2094         self.output_base_name().with_extension("inc")
2095     }
2096
2097     fn run_rmake_test(&self) {
2098         // FIXME(#11094): we should fix these tests
2099         if self.config.host != self.config.target {
2100             return
2101         }
2102
2103         let cwd = env::current_dir().unwrap();
2104         let src_root = self.config.src_base.parent().unwrap()
2105                                            .parent().unwrap()
2106                                            .parent().unwrap();
2107         let src_root = cwd.join(&src_root);
2108
2109         let tmpdir = cwd.join(self.output_base_name());
2110         if tmpdir.exists() {
2111             self.aggressive_rm_rf(&tmpdir).unwrap();
2112         }
2113         create_dir_all(&tmpdir).unwrap();
2114
2115         let host = &self.config.host;
2116         let make = if host.contains("bitrig") || host.contains("dragonfly") ||
2117             host.contains("freebsd") || host.contains("netbsd") ||
2118             host.contains("openbsd") {
2119             "gmake"
2120         } else {
2121             "make"
2122         };
2123
2124         let mut cmd = Command::new(make);
2125         cmd.current_dir(&self.testpaths.file)
2126            .stdout(Stdio::piped())
2127            .stderr(Stdio::piped())
2128            .env("TARGET", &self.config.target)
2129            .env("PYTHON", &self.config.docck_python)
2130            .env("S", src_root)
2131            .env("RUST_BUILD_STAGE", &self.config.stage_id)
2132            .env("RUSTC", cwd.join(&self.config.rustc_path))
2133            .env("RUSTDOC",
2134                cwd.join(&self.config.rustdoc_path.as_ref().expect("--rustdoc-path passed")))
2135            .env("TMPDIR", &tmpdir)
2136            .env("LD_LIB_PATH_ENVVAR", dylib_env_var())
2137            .env("HOST_RPATH_DIR", cwd.join(&self.config.compile_lib_path))
2138            .env("TARGET_RPATH_DIR", cwd.join(&self.config.run_lib_path))
2139            .env("LLVM_COMPONENTS", &self.config.llvm_components)
2140            .env("LLVM_CXXFLAGS", &self.config.llvm_cxxflags);
2141
2142         if let Some(ref linker) = self.config.linker {
2143             cmd.env("RUSTC_LINKER", linker);
2144         }
2145
2146         // We don't want RUSTFLAGS set from the outside to interfere with
2147         // compiler flags set in the test cases:
2148         cmd.env_remove("RUSTFLAGS");
2149
2150         if self.config.target.contains("msvc") {
2151             // We need to pass a path to `lib.exe`, so assume that `cc` is `cl.exe`
2152             // and that `lib.exe` lives next to it.
2153             let lib = Path::new(&self.config.cc).parent().unwrap().join("lib.exe");
2154
2155             // MSYS doesn't like passing flags of the form `/foo` as it thinks it's
2156             // a path and instead passes `C:\msys64\foo`, so convert all
2157             // `/`-arguments to MSVC here to `-` arguments.
2158             let cflags = self.config.cflags.split(' ').map(|s| s.replace("/", "-"))
2159                                                  .collect::<Vec<_>>().join(" ");
2160
2161             cmd.env("IS_MSVC", "1")
2162                .env("IS_WINDOWS", "1")
2163                .env("MSVC_LIB", format!("'{}' -nologo", lib.display()))
2164                .env("CC", format!("'{}' {}", self.config.cc, cflags))
2165                .env("CXX", &self.config.cxx);
2166         } else {
2167             cmd.env("CC", format!("{} {}", self.config.cc, self.config.cflags))
2168                .env("CXX", format!("{} {}", self.config.cxx, self.config.cflags))
2169                .env("AR", &self.config.ar);
2170
2171             if self.config.target.contains("windows") {
2172                 cmd.env("IS_WINDOWS", "1");
2173             }
2174         }
2175
2176         let output = cmd.spawn().and_then(read2_abbreviated).expect("failed to spawn `make`");
2177         if !output.status.success() {
2178             let res = ProcRes {
2179                 status: output.status,
2180                 stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
2181                 stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
2182                 cmdline: format!("{:?}", cmd),
2183             };
2184             self.fatal_proc_rec("make failed", &res);
2185         }
2186     }
2187
2188     fn aggressive_rm_rf(&self, path: &Path) -> io::Result<()> {
2189         for e in path.read_dir()? {
2190             let entry = e?;
2191             let path = entry.path();
2192             if entry.file_type()?.is_dir() {
2193                 self.aggressive_rm_rf(&path)?;
2194             } else {
2195                 // Remove readonly files as well on windows (by default we can't)
2196                 fs::remove_file(&path).or_else(|e| {
2197                     if cfg!(windows) && e.kind() == io::ErrorKind::PermissionDenied {
2198                         let mut meta = entry.metadata()?.permissions();
2199                         meta.set_readonly(false);
2200                         fs::set_permissions(&path, meta)?;
2201                         fs::remove_file(&path)
2202                     } else {
2203                         Err(e)
2204                     }
2205                 })?;
2206             }
2207         }
2208         fs::remove_dir(path)
2209     }
2210
2211     fn run_ui_test(&self) {
2212         let proc_res = self.compile_test();
2213
2214         let expected_stderr_path = self.expected_output_path("stderr");
2215         let expected_stderr = self.load_expected_output(&expected_stderr_path);
2216
2217         let expected_stdout_path = self.expected_output_path("stdout");
2218         let expected_stdout = self.load_expected_output(&expected_stdout_path);
2219
2220         let normalized_stdout =
2221             self.normalize_output(&proc_res.stdout, &self.props.normalize_stdout);
2222         let normalized_stderr =
2223             self.normalize_output(&proc_res.stderr, &self.props.normalize_stderr);
2224
2225         let mut errors = 0;
2226         errors += self.compare_output("stdout", &normalized_stdout, &expected_stdout);
2227         errors += self.compare_output("stderr", &normalized_stderr, &expected_stderr);
2228
2229         if errors > 0 {
2230             println!("To update references, run this command from build directory:");
2231             let relative_path_to_file =
2232                 self.testpaths.relative_dir
2233                               .join(self.testpaths.file.file_name().unwrap());
2234             println!("{}/update-references.sh '{}' '{}'",
2235                      self.config.src_base.display(),
2236                      self.config.build_base.display(),
2237                      relative_path_to_file.display());
2238             self.fatal_proc_rec(&format!("{} errors occurred comparing output.", errors),
2239                                 &proc_res);
2240         }
2241
2242         if self.props.run_pass {
2243             let proc_res = self.exec_compiled_test();
2244
2245             if !proc_res.status.success() {
2246                 self.fatal_proc_rec("test run failed!", &proc_res);
2247             }
2248         }
2249     }
2250
2251     fn run_mir_opt_test(&self) {
2252         let proc_res = self.compile_test();
2253
2254         if !proc_res.status.success() {
2255             self.fatal_proc_rec("compilation failed!", &proc_res);
2256         }
2257
2258         let proc_res = self.exec_compiled_test();
2259
2260         if !proc_res.status.success() {
2261             self.fatal_proc_rec("test run failed!", &proc_res);
2262         }
2263         self.check_mir_dump();
2264     }
2265
2266     fn check_mir_dump(&self) {
2267         let mut test_file_contents = String::new();
2268         fs::File::open(self.testpaths.file.clone()).unwrap()
2269                                                    .read_to_string(&mut test_file_contents)
2270                                                    .unwrap();
2271         if let Some(idx) =  test_file_contents.find("// END RUST SOURCE") {
2272             let (_, tests_text) = test_file_contents.split_at(idx + "// END_RUST SOURCE".len());
2273             let tests_text_str = String::from(tests_text);
2274             let mut curr_test : Option<&str> = None;
2275             let mut curr_test_contents = vec![ExpectedLine::Elision];
2276             for l in tests_text_str.lines() {
2277                 debug!("line: {:?}", l);
2278                 if l.starts_with("// START ") {
2279                     let (_, t) = l.split_at("// START ".len());
2280                     curr_test = Some(t);
2281                 } else if l.starts_with("// END") {
2282                     let (_, t) = l.split_at("// END ".len());
2283                     if Some(t) != curr_test {
2284                         panic!("mismatched START END test name");
2285                     }
2286                     self.compare_mir_test_output(curr_test.unwrap(), &curr_test_contents);
2287                     curr_test = None;
2288                     curr_test_contents.clear();
2289                     curr_test_contents.push(ExpectedLine::Elision);
2290                 } else if l.is_empty() {
2291                     // ignore
2292                 } else if l.starts_with("//") && l.split_at("//".len()).1.trim() == "..." {
2293                     curr_test_contents.push(ExpectedLine::Elision)
2294                 } else if l.starts_with("// ") {
2295                     let (_, test_content) = l.split_at("// ".len());
2296                     curr_test_contents.push(ExpectedLine::Text(test_content));
2297                 }
2298             }
2299         }
2300     }
2301
2302     fn check_mir_test_timestamp(&self, test_name: &str, output_file: &Path) {
2303         let t = |file| FileTime::from_last_modification_time(&fs::metadata(file).unwrap());
2304         let source_file = &self.testpaths.file;
2305         let output_time = t(output_file);
2306         let source_time = t(source_file);
2307         if source_time > output_time {
2308             debug!("source file time: {:?} output file time: {:?}", source_time, output_time);
2309             panic!("test source file `{}` is newer than potentially stale output file `{}`.",
2310                    source_file.display(), test_name);
2311         }
2312     }
2313
2314     fn compare_mir_test_output(&self, test_name: &str, expected_content: &[ExpectedLine<&str>]) {
2315         let mut output_file = PathBuf::new();
2316         output_file.push(self.get_mir_dump_dir());
2317         output_file.push(test_name);
2318         debug!("comparing the contests of: {:?}", output_file);
2319         debug!("with: {:?}", expected_content);
2320         if !output_file.exists() {
2321             panic!("Output file `{}` from test does not exist",
2322                    output_file.into_os_string().to_string_lossy());
2323         }
2324         self.check_mir_test_timestamp(test_name, &output_file);
2325
2326         let mut dumped_file = fs::File::open(output_file.clone()).unwrap();
2327         let mut dumped_string = String::new();
2328         dumped_file.read_to_string(&mut dumped_string).unwrap();
2329         let mut dumped_lines = dumped_string.lines().filter(|l| !l.is_empty());
2330         let mut expected_lines = expected_content.iter().filter(|&l| {
2331             if let &ExpectedLine::Text(l) = l {
2332                 !l.is_empty()
2333             } else {
2334                 true
2335             }
2336         }).peekable();
2337
2338         let compare = |expected_line, dumped_line| {
2339             let e_norm = normalize_mir_line(expected_line);
2340             let d_norm = normalize_mir_line(dumped_line);
2341             debug!("found: {:?}", d_norm);
2342             debug!("expected: {:?}", e_norm);
2343             e_norm == d_norm
2344         };
2345
2346         let error = |expected_line, extra_msg| {
2347             let normalize_all = dumped_string.lines()
2348                                              .map(nocomment_mir_line)
2349                                              .filter(|l| !l.is_empty())
2350                                              .collect::<Vec<_>>()
2351                                              .join("\n");
2352             let f = |l: &ExpectedLine<_>| match l {
2353                 &ExpectedLine::Elision => "... (elided)".into(),
2354                 &ExpectedLine::Text(t) => t
2355             };
2356             let expected_content = expected_content.iter()
2357                                                    .map(|l| f(l))
2358                                                    .collect::<Vec<_>>()
2359                                                    .join("\n");
2360             panic!("Did not find expected line, error: {}\n\
2361                    Actual Line: {:?}\n\
2362                    Expected:\n{}\n\
2363                    Actual:\n{}",
2364                    extra_msg,
2365                    expected_line,
2366                    expected_content,
2367                    normalize_all);
2368         };
2369
2370         // We expect each non-empty line to appear consecutively, non-consecutive lines
2371         // must be separated by at least one Elision
2372         let mut start_block_line = None;
2373         while let Some(dumped_line) = dumped_lines.next() {
2374             match expected_lines.next() {
2375                 Some(&ExpectedLine::Text(expected_line)) => {
2376                     let normalized_expected_line = normalize_mir_line(expected_line);
2377                     if normalized_expected_line.contains(":{") {
2378                         start_block_line = Some(expected_line);
2379                     }
2380
2381                     if !compare(expected_line, dumped_line) {
2382                         error!("{:?}", start_block_line);
2383                         error(expected_line,
2384                               format!("Mismatch in lines\nCurrnt block: {}\nExpected Line: {:?}",
2385                                       start_block_line.unwrap_or("None"), dumped_line));
2386                     }
2387                 },
2388                 Some(&ExpectedLine::Elision) => {
2389                     // skip any number of elisions in a row.
2390                     while let Some(&&ExpectedLine::Elision) = expected_lines.peek() {
2391                         expected_lines.next();
2392                     }
2393                     if let Some(&ExpectedLine::Text(expected_line)) = expected_lines.next() {
2394                         let mut found = compare(expected_line, dumped_line);
2395                         if found {
2396                             continue;
2397                         }
2398                         while let Some(dumped_line) = dumped_lines.next() {
2399                             found = compare(expected_line, dumped_line);
2400                             if found {
2401                                 break;
2402                             }
2403                         }
2404                         if !found {
2405                             error(expected_line, "ran out of mir dump to match against".into());
2406                         }
2407                     }
2408                 },
2409                 None => {},
2410             }
2411         }
2412     }
2413
2414     fn get_mir_dump_dir(&self) -> PathBuf {
2415         let mut mir_dump_dir = PathBuf::from(self.config.build_base.as_path());
2416         debug!("input_file: {:?}", self.testpaths.file);
2417         mir_dump_dir.push(&self.testpaths.relative_dir);
2418         mir_dump_dir.push(self.testpaths.file.file_stem().unwrap());
2419         mir_dump_dir
2420     }
2421
2422     fn normalize_output(&self, output: &str, custom_rules: &[(String, String)]) -> String {
2423         let parent_dir = self.testpaths.file.parent().unwrap();
2424         let cflags = self.props.compile_flags.join(" ");
2425         let json = cflags.contains("--error-format json") ||
2426                    cflags.contains("--error-format pretty-json");
2427         let parent_dir_str = if json {
2428             parent_dir.display().to_string().replace("\\", "\\\\")
2429         } else {
2430             parent_dir.display().to_string()
2431         };
2432
2433         let mut normalized = output.replace(&parent_dir_str, "$DIR");
2434
2435         if json {
2436             // escaped newlines in json strings should be readable
2437             // in the stderr files. There's no point int being correct,
2438             // since only humans process the stderr files.
2439             // Thus we just turn escaped newlines back into newlines.
2440             normalized = normalized.replace("\\n", "\n");
2441         }
2442
2443         normalized = normalized.replace("\\\\", "\\") // denormalize for paths on windows
2444               .replace("\\", "/") // normalize for paths on windows
2445               .replace("\r\n", "\n") // normalize for linebreaks on windows
2446               .replace("\t", "\\t"); // makes tabs visible
2447         for rule in custom_rules {
2448             normalized = normalized.replace(&rule.0, &rule.1);
2449         }
2450         normalized
2451     }
2452
2453     fn expected_output_path(&self, kind: &str) -> PathBuf {
2454         let extension = match self.revision {
2455             Some(r) => format!("{}.{}", r, kind),
2456             None => kind.to_string(),
2457         };
2458         self.testpaths.file.with_extension(extension)
2459     }
2460
2461     fn load_expected_output(&self, path: &Path) -> String {
2462         if !path.exists() {
2463             return String::new();
2464         }
2465
2466         let mut result = String::new();
2467         match File::open(path).and_then(|mut f| f.read_to_string(&mut result)) {
2468             Ok(_) => result,
2469             Err(e) => {
2470                 self.fatal(&format!("failed to load expected output from `{}`: {}",
2471                                     path.display(), e))
2472             }
2473         }
2474     }
2475
2476     fn compare_output(&self, kind: &str, actual: &str, expected: &str) -> usize {
2477         if actual == expected {
2478             return 0;
2479         }
2480
2481         println!("normalized {}:\n{}\n", kind, actual);
2482         println!("expected {}:\n{}\n", kind, expected);
2483         println!("diff of {}:\n", kind);
2484
2485         for diff in diff::lines(expected, actual) {
2486             match diff {
2487                 diff::Result::Left(l)    => println!("-{}", l),
2488                 diff::Result::Both(l, _) => println!(" {}", l),
2489                 diff::Result::Right(r)   => println!("+{}", r),
2490             }
2491         }
2492
2493         let output_file = self.output_base_name().with_extension(kind);
2494         match File::create(&output_file).and_then(|mut f| f.write_all(actual.as_bytes())) {
2495             Ok(()) => { }
2496             Err(e) => {
2497                 self.fatal(&format!("failed to write {} to `{}`: {}",
2498                                     kind, output_file.display(), e))
2499             }
2500         }
2501
2502         println!("\nThe actual {0} differed from the expected {0}.", kind);
2503         println!("Actual {} saved to {}", kind, output_file.display());
2504         1
2505     }
2506 }
2507
2508 struct ProcArgs {
2509     prog: String,
2510     args: Vec<String>,
2511 }
2512
2513 pub struct ProcRes {
2514     status: ExitStatus,
2515     stdout: String,
2516     stderr: String,
2517     cmdline: String,
2518 }
2519
2520 impl ProcRes {
2521     pub fn fatal(&self, err: Option<&str>) -> ! {
2522         if let Some(e) = err {
2523             println!("\nerror: {}", e);
2524         }
2525         print!("\
2526             status: {}\n\
2527             command: {}\n\
2528             stdout:\n\
2529             ------------------------------------------\n\
2530             {}\n\
2531             ------------------------------------------\n\
2532             stderr:\n\
2533             ------------------------------------------\n\
2534             {}\n\
2535             ------------------------------------------\n\
2536             \n",
2537                self.status, self.cmdline, self.stdout,
2538                self.stderr);
2539         panic!();
2540     }
2541 }
2542
2543 enum TargetLocation {
2544     ThisFile(PathBuf),
2545     ThisDirectory(PathBuf),
2546 }
2547
2548 #[derive(Clone, PartialEq, Eq)]
2549 enum ExpectedLine<T: AsRef<str>> {
2550     Elision,
2551     Text(T)
2552 }
2553
2554 impl<T> fmt::Debug for ExpectedLine<T>
2555 where
2556     T: AsRef<str> + fmt::Debug
2557 {
2558     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2559         if let &ExpectedLine::Text(ref t) = self {
2560             write!(formatter, "{:?}", t)
2561         } else {
2562             write!(formatter, "\"...\" (Elision)")
2563         }
2564     }
2565 }
2566
2567 fn normalize_mir_line(line: &str) -> String {
2568     nocomment_mir_line(line).replace(char::is_whitespace, "")
2569 }
2570
2571 fn nocomment_mir_line(line: &str) -> &str {
2572     if let Some(idx) = line.find("//") {
2573         let (l, _) = line.split_at(idx);
2574         l.trim_right()
2575     } else {
2576         line
2577     }
2578 }
2579
2580 fn read2_abbreviated(mut child: Child) -> io::Result<Output> {
2581     use std::mem::replace;
2582     use read2::read2;
2583
2584     const HEAD_LEN: usize = 160 * 1024;
2585     const TAIL_LEN: usize = 256 * 1024;
2586
2587     enum ProcOutput {
2588         Full(Vec<u8>),
2589         Abbreviated {
2590             head: Vec<u8>,
2591             skipped: usize,
2592             tail: Box<[u8]>,
2593         }
2594     }
2595
2596     impl ProcOutput {
2597         fn extend(&mut self, data: &[u8]) {
2598             let new_self = match *self {
2599                 ProcOutput::Full(ref mut bytes) => {
2600                     bytes.extend_from_slice(data);
2601                     let new_len = bytes.len();
2602                     if new_len <= HEAD_LEN + TAIL_LEN {
2603                         return;
2604                     }
2605                     let tail = bytes.split_off(new_len - TAIL_LEN).into_boxed_slice();
2606                     let head = replace(bytes, Vec::new());
2607                     let skipped = new_len - HEAD_LEN - TAIL_LEN;
2608                     ProcOutput::Abbreviated { head, skipped, tail }
2609                 }
2610                 ProcOutput::Abbreviated { ref mut skipped, ref mut tail, .. } => {
2611                     *skipped += data.len();
2612                     if data.len() <= TAIL_LEN {
2613                         tail[..data.len()].copy_from_slice(data);
2614                         tail.rotate(data.len());
2615                     } else {
2616                         tail.copy_from_slice(&data[(data.len() - TAIL_LEN)..]);
2617                     }
2618                     return;
2619                 }
2620             };
2621             *self = new_self;
2622         }
2623
2624         fn into_bytes(self) -> Vec<u8> {
2625             match self {
2626                 ProcOutput::Full(bytes) => bytes,
2627                 ProcOutput::Abbreviated { mut head, skipped, tail } => {
2628                     write!(&mut head, "\n\n<<<<<< SKIPPED {} BYTES >>>>>>\n\n", skipped).unwrap();
2629                     head.extend_from_slice(&tail);
2630                     head
2631                 }
2632             }
2633         }
2634     }
2635
2636     let mut stdout = ProcOutput::Full(Vec::new());
2637     let mut stderr = ProcOutput::Full(Vec::new());
2638
2639     drop(child.stdin.take());
2640     read2(child.stdout.take().unwrap(), child.stderr.take().unwrap(), &mut |is_stdout, data, _| {
2641         if is_stdout { &mut stdout } else { &mut stderr }.extend(data);
2642         data.clear();
2643     })?;
2644     let status = child.wait()?;
2645
2646     Ok(Output {
2647         status,
2648         stdout: stdout.into_bytes(),
2649         stderr: stderr.into_bytes(),
2650     })
2651 }