src/tools/compiletest/src/header.rs

   1 use std::collections::HashSet;
   2 use std::env;
   3 use std::fs::File;
   4 use std::io::prelude::*;
   5 use std::io::BufReader;
   6 use std::path::{Path, PathBuf};
   7
   8 use tracing::*;
   9
  10 use crate::common::{CompareMode, Config, Debugger, FailMode, Mode, PanicStrategy, PassMode};
  11 use crate::util;
  12 use crate::{extract_cdb_version, extract_gdb_version};
  13
  14 #[cfg(test)]
  15 mod tests;
  16
  17 /// The result of parse_cfg_name_directive.
  18 #[derive(Clone, Copy, PartialEq, Debug)]
  19 enum ParsedNameDirective {
  20     /// No match.
  21     NoMatch,
  22     /// Match.
  23     Match,
  24 }
  25
  26 /// Properties which must be known very early, before actually running
  27 /// the test.
  28 #[derive(Default)]
  29 pub struct EarlyProps {
  30     pub aux: Vec<String>,
  31     pub aux_crate: Vec<(String, String)>,
  32     pub revisions: Vec<String>,
  33 }
  34
  35 impl EarlyProps {
  36     pub fn from_file(config: &Config, testfile: &Path) -> Self {
  37         let file = File::open(testfile).expect("open test file to parse earlyprops");
  38         Self::from_reader(config, testfile, file)
  39     }
  40
  41     pub fn from_reader<R: Read>(config: &Config, testfile: &Path, rdr: R) -> Self {
  42         let mut props = EarlyProps::default();
  43         iter_header(testfile, rdr, &mut |_, ln| {
  44             if let Some(s) = config.parse_aux_build(ln) {
  45                 props.aux.push(s);
  46             }
  47             if let Some(ac) = config.parse_aux_crate(ln) {
  48                 props.aux_crate.push(ac);
  49             }
  50             config.parse_and_update_revisions(ln, &mut props.revisions);
  51         });
  52         return props;
  53     }
  54 }
  55
  56 #[derive(Clone, Debug)]
  57 pub struct TestProps {
  58     // Lines that should be expected, in order, on standard out
  59     pub error_patterns: Vec<String>,
  60     // Extra flags to pass to the compiler
  61     pub compile_flags: Vec<String>,
  62     // Extra flags to pass when the compiled code is run (such as --bench)
  63     pub run_flags: Option<String>,
  64     // If present, the name of a file that this test should match when
  65     // pretty-printed
  66     pub pp_exact: Option<PathBuf>,
  67     // Other crates that should be compiled (typically from the same
  68     // directory as the test, but for backwards compatibility reasons
  69     // we also check the auxiliary directory)
  70     pub aux_builds: Vec<String>,
  71     // Similar to `aux_builds`, but a list of NAME=somelib.rs of dependencies
  72     // to build and pass with the `--extern` flag.
  73     pub aux_crates: Vec<(String, String)>,
  74     // Environment settings to use for compiling
  75     pub rustc_env: Vec<(String, String)>,
  76     // Environment variables to unset prior to compiling.
  77     // Variables are unset before applying 'rustc_env'.
  78     pub unset_rustc_env: Vec<String>,
  79     // Environment settings to use during execution
  80     pub exec_env: Vec<(String, String)>,
  81     // Lines to check if they appear in the expected debugger output
  82     pub check_lines: Vec<String>,
  83     // Build documentation for all specified aux-builds as well
  84     pub build_aux_docs: bool,
  85     // Flag to force a crate to be built with the host architecture
  86     pub force_host: bool,
  87     // Check stdout for error-pattern output as well as stderr
  88     pub check_stdout: bool,
  89     // Check stdout & stderr for output of run-pass test
  90     pub check_run_results: bool,
  91     // For UI tests, allows compiler to generate arbitrary output to stdout
  92     pub dont_check_compiler_stdout: bool,
  93     // For UI tests, allows compiler to generate arbitrary output to stderr
  94     pub dont_check_compiler_stderr: bool,
  95     // Don't force a --crate-type=dylib flag on the command line
  96     //
  97     // Set this for example if you have an auxiliary test file that contains
  98     // a proc-macro and needs `#![crate_type = "proc-macro"]`. This ensures
  99     // that the aux file is compiled as a `proc-macro` and not as a `dylib`.
 100     pub no_prefer_dynamic: bool,
 101     // Run -Zunpretty expanded when running pretty printing tests
 102     pub pretty_expanded: bool,
 103     // Which pretty mode are we testing with, default to 'normal'
 104     pub pretty_mode: String,
 105     // Only compare pretty output and don't try compiling
 106     pub pretty_compare_only: bool,
 107     // Patterns which must not appear in the output of a cfail test.
 108     pub forbid_output: Vec<String>,
 109     // Revisions to test for incremental compilation.
 110     pub revisions: Vec<String>,
 111     // Directory (if any) to use for incremental compilation.  This is
 112     // not set by end-users; rather it is set by the incremental
 113     // testing harness and used when generating compilation
 114     // arguments. (In particular, it propagates to the aux-builds.)
 115     pub incremental_dir: Option<PathBuf>,
 116     // If `true`, this test will use incremental compilation.
 117     //
 118     // This can be set manually with the `incremental` header, or implicitly
 119     // by being a part of an incremental mode test. Using the `incremental`
 120     // header should be avoided if possible; using an incremental mode test is
 121     // preferred. Incremental mode tests support multiple passes, which can
 122     // verify that the incremental cache can be loaded properly after being
 123     // created. Just setting the header will only verify the behavior with
 124     // creating an incremental cache, but doesn't check that it is created
 125     // correctly.
 126     //
 127     // Compiletest will create the incremental directory, and ensure it is
 128     // empty before the test starts. Incremental mode tests will reuse the
 129     // incremental directory between passes in the same test.
 130     pub incremental: bool,
 131     // How far should the test proceed while still passing.
 132     pass_mode: Option<PassMode>,
 133     // Ignore `--pass` overrides from the command line for this test.
 134     ignore_pass: bool,
 135     // How far this test should proceed to start failing.
 136     pub fail_mode: Option<FailMode>,
 137     // rustdoc will test the output of the `--test` option
 138     pub check_test_line_numbers_match: bool,
 139     // customized normalization rules
 140     pub normalize_stdout: Vec<(String, String)>,
 141     pub normalize_stderr: Vec<(String, String)>,
 142     pub failure_status: i32,
 143     // Whether or not `rustfix` should apply the `CodeSuggestion`s of this test and compile the
 144     // resulting Rust code.
 145     pub run_rustfix: bool,
 146     // If true, `rustfix` will only apply `MachineApplicable` suggestions.
 147     pub rustfix_only_machine_applicable: bool,
 148     pub assembly_output: Option<String>,
 149     // If true, the test is expected to ICE
 150     pub should_ice: bool,
 151     // If true, the stderr is expected to be different across bit-widths.
 152     pub stderr_per_bitwidth: bool,
 153 }
 154
 155 impl TestProps {
 156     pub fn new() -> Self {
 157         TestProps {
 158             error_patterns: vec![],
 159             compile_flags: vec![],
 160             run_flags: None,
 161             pp_exact: None,
 162             aux_builds: vec![],
 163             aux_crates: vec![],
 164             revisions: vec![],
 165             rustc_env: vec![],
 166             unset_rustc_env: vec![],
 167             exec_env: vec![],
 168             check_lines: vec![],
 169             build_aux_docs: false,
 170             force_host: false,
 171             check_stdout: false,
 172             check_run_results: false,
 173             dont_check_compiler_stdout: false,
 174             dont_check_compiler_stderr: false,
 175             no_prefer_dynamic: false,
 176             pretty_expanded: false,
 177             pretty_mode: "normal".to_string(),
 178             pretty_compare_only: false,
 179             forbid_output: vec![],
 180             incremental_dir: None,
 181             incremental: false,
 182             pass_mode: None,
 183             fail_mode: None,
 184             ignore_pass: false,
 185             check_test_line_numbers_match: false,
 186             normalize_stdout: vec![],
 187             normalize_stderr: vec![],
 188             failure_status: -1,
 189             run_rustfix: false,
 190             rustfix_only_machine_applicable: false,
 191             assembly_output: None,
 192             should_ice: false,
 193             stderr_per_bitwidth: false,
 194         }
 195     }
 196
 197     pub fn from_aux_file(&self, testfile: &Path, cfg: Option<&str>, config: &Config) -> Self {
 198         let mut props = TestProps::new();
 199
 200         // copy over select properties to the aux build:
 201         props.incremental_dir = self.incremental_dir.clone();
 202         props.load_from(testfile, cfg, config);
 203
 204         props
 205     }
 206
 207     pub fn from_file(testfile: &Path, cfg: Option<&str>, config: &Config) -> Self {
 208         let mut props = TestProps::new();
 209         props.load_from(testfile, cfg, config);
 210
 211         match (props.pass_mode, props.fail_mode) {
 212             (None, None) => props.fail_mode = Some(FailMode::Check),
 213             (Some(_), None) | (None, Some(_)) => {}
 214             (Some(_), Some(_)) => panic!("cannot use a *-fail and *-pass mode together"),
 215         }
 216
 217         props
 218     }
 219
 220     /// Loads properties from `testfile` into `props`. If a property is
 221     /// tied to a particular revision `foo` (indicated by writing
 222     /// `//[foo]`), then the property is ignored unless `cfg` is
 223     /// `Some("foo")`.
 224     fn load_from(&mut self, testfile: &Path, cfg: Option<&str>, config: &Config) {
 225         let mut has_edition = false;
 226         if !testfile.is_dir() {
 227             let file = File::open(testfile).unwrap();
 228
 229             iter_header(testfile, file, &mut |revision, ln| {
 230                 if revision.is_some() && revision != cfg {
 231                     return;
 232                 }
 233
 234                 if let Some(ep) = config.parse_error_pattern(ln) {
 235                     self.error_patterns.push(ep);
 236                 }
 237
 238                 if let Some(flags) = config.parse_compile_flags(ln) {
 239                     self.compile_flags.extend(flags.split_whitespace().map(|s| s.to_owned()));
 240                 }
 241
 242                 if let Some(edition) = config.parse_edition(ln) {
 243                     self.compile_flags.push(format!("--edition={}", edition));
 244                     has_edition = true;
 245                     if edition == "2021" {
 246                         self.compile_flags.push("-Zunstable-options".to_string());
 247                     }
 248                 }
 249
 250                 config.parse_and_update_revisions(ln, &mut self.revisions);
 251
 252                 if self.run_flags.is_none() {
 253                     self.run_flags = config.parse_run_flags(ln);
 254                 }
 255
 256                 if self.pp_exact.is_none() {
 257                     self.pp_exact = config.parse_pp_exact(ln, testfile);
 258                 }
 259
 260                 if !self.should_ice {
 261                     self.should_ice = config.parse_should_ice(ln);
 262                 }
 263
 264                 if !self.build_aux_docs {
 265                     self.build_aux_docs = config.parse_build_aux_docs(ln);
 266                 }
 267
 268                 if !self.force_host {
 269                     self.force_host = config.parse_force_host(ln);
 270                 }
 271
 272                 if !self.check_stdout {
 273                     self.check_stdout = config.parse_check_stdout(ln);
 274                 }
 275
 276                 if !self.check_run_results {
 277                     self.check_run_results = config.parse_check_run_results(ln);
 278                 }
 279
 280                 if !self.dont_check_compiler_stdout {
 281                     self.dont_check_compiler_stdout = config.parse_dont_check_compiler_stdout(ln);
 282                 }
 283
 284                 if !self.dont_check_compiler_stderr {
 285                     self.dont_check_compiler_stderr = config.parse_dont_check_compiler_stderr(ln);
 286                 }
 287
 288                 if !self.no_prefer_dynamic {
 289                     self.no_prefer_dynamic = config.parse_no_prefer_dynamic(ln);
 290                 }
 291
 292                 if !self.pretty_expanded {
 293                     self.pretty_expanded = config.parse_pretty_expanded(ln);
 294                 }
 295
 296                 if let Some(m) = config.parse_pretty_mode(ln) {
 297                     self.pretty_mode = m;
 298                 }
 299
 300                 if !self.pretty_compare_only {
 301                     self.pretty_compare_only = config.parse_pretty_compare_only(ln);
 302                 }
 303
 304                 if let Some(ab) = config.parse_aux_build(ln) {
 305                     self.aux_builds.push(ab);
 306                 }
 307
 308                 if let Some(ac) = config.parse_aux_crate(ln) {
 309                     self.aux_crates.push(ac);
 310                 }
 311
 312                 if let Some(ee) = config.parse_env(ln, "exec-env") {
 313                     self.exec_env.push(ee);
 314                 }
 315
 316                 if let Some(ee) = config.parse_env(ln, "rustc-env") {
 317                     self.rustc_env.push(ee);
 318                 }
 319
 320                 if let Some(ev) = config.parse_name_value_directive(ln, "unset-rustc-env") {
 321                     self.unset_rustc_env.push(ev);
 322                 }
 323
 324                 if let Some(cl) = config.parse_check_line(ln) {
 325                     self.check_lines.push(cl);
 326                 }
 327
 328                 if let Some(of) = config.parse_forbid_output(ln) {
 329                     self.forbid_output.push(of);
 330                 }
 331
 332                 if !self.check_test_line_numbers_match {
 333                     self.check_test_line_numbers_match =
 334                         config.parse_check_test_line_numbers_match(ln);
 335                 }
 336
 337                 self.update_pass_mode(ln, cfg, config);
 338                 self.update_fail_mode(ln, config);
 339
 340                 if !self.ignore_pass {
 341                     self.ignore_pass = config.parse_ignore_pass(ln);
 342                 }
 343
 344                 if let Some(rule) = config.parse_custom_normalization(ln, "normalize-stdout") {
 345                     self.normalize_stdout.push(rule);
 346                 }
 347                 if let Some(rule) = config.parse_custom_normalization(ln, "normalize-stderr") {
 348                     self.normalize_stderr.push(rule);
 349                 }
 350
 351                 if let Some(code) = config.parse_failure_status(ln) {
 352                     self.failure_status = code;
 353                 }
 354
 355                 if !self.run_rustfix {
 356                     self.run_rustfix = config.parse_run_rustfix(ln);
 357                 }
 358
 359                 if !self.rustfix_only_machine_applicable {
 360                     self.rustfix_only_machine_applicable =
 361                         config.parse_rustfix_only_machine_applicable(ln);
 362                 }
 363
 364                 if self.assembly_output.is_none() {
 365                     self.assembly_output = config.parse_assembly_output(ln);
 366                 }
 367
 368                 if !self.stderr_per_bitwidth {
 369                     self.stderr_per_bitwidth = config.parse_stderr_per_bitwidth(ln);
 370                 }
 371
 372                 if !self.incremental {
 373                     self.incremental = config.parse_incremental(ln);
 374                 }
 375             });
 376         }
 377
 378         if self.failure_status == -1 {
 379             self.failure_status = 1;
 380         }
 381         if self.should_ice {
 382             self.failure_status = 101;
 383         }
 384
 385         if config.mode == Mode::Incremental {
 386             self.incremental = true;
 387         }
 388
 389         for key in &["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
 390             if let Ok(val) = env::var(key) {
 391                 if self.exec_env.iter().find(|&&(ref x, _)| x == key).is_none() {
 392                     self.exec_env.push(((*key).to_owned(), val))
 393                 }
 394             }
 395         }
 396
 397         if let (Some(edition), false) = (&config.edition, has_edition) {
 398             self.compile_flags.push(format!("--edition={}", edition));
 399         }
 400     }
 401
 402     fn update_fail_mode(&mut self, ln: &str, config: &Config) {
 403         let check_ui = |mode: &str| {
 404             if config.mode != Mode::Ui {
 405                 panic!("`{}-fail` header is only supported in UI tests", mode);
 406             }
 407         };
 408         if config.mode == Mode::Ui && config.parse_name_directive(ln, "compile-fail") {
 409             panic!("`compile-fail` header is useless in UI tests");
 410         }
 411         let fail_mode = if config.parse_name_directive(ln, "check-fail") {
 412             check_ui("check");
 413             Some(FailMode::Check)
 414         } else if config.parse_name_directive(ln, "build-fail") {
 415             check_ui("build");
 416             Some(FailMode::Build)
 417         } else if config.parse_name_directive(ln, "run-fail") {
 418             check_ui("run");
 419             Some(FailMode::Run)
 420         } else {
 421             None
 422         };
 423         match (self.fail_mode, fail_mode) {
 424             (None, Some(_)) => self.fail_mode = fail_mode,
 425             (Some(_), Some(_)) => panic!("multiple `*-fail` headers in a single test"),
 426             (_, None) => {}
 427         }
 428     }
 429
 430     fn update_pass_mode(&mut self, ln: &str, revision: Option<&str>, config: &Config) {
 431         let check_no_run = |s| {
 432             if config.mode != Mode::Ui && config.mode != Mode::Incremental {
 433                 panic!("`{}` header is only supported in UI and incremental tests", s);
 434             }
 435             if config.mode == Mode::Incremental
 436                 && !revision.map_or(false, |r| r.starts_with("cfail"))
 437                 && !self.revisions.iter().all(|r| r.starts_with("cfail"))
 438             {
 439                 panic!("`{}` header is only supported in `cfail` incremental tests", s);
 440             }
 441         };
 442         let pass_mode = if config.parse_name_directive(ln, "check-pass") {
 443             check_no_run("check-pass");
 444             Some(PassMode::Check)
 445         } else if config.parse_name_directive(ln, "build-pass") {
 446             check_no_run("build-pass");
 447             Some(PassMode::Build)
 448         } else if config.parse_name_directive(ln, "run-pass") {
 449             if config.mode != Mode::Ui {
 450                 panic!("`run-pass` header is only supported in UI tests")
 451             }
 452             Some(PassMode::Run)
 453         } else {
 454             None
 455         };
 456         match (self.pass_mode, pass_mode) {
 457             (None, Some(_)) => self.pass_mode = pass_mode,
 458             (Some(_), Some(_)) => panic!("multiple `*-pass` headers in a single test"),
 459             (_, None) => {}
 460         }
 461     }
 462
 463     pub fn pass_mode(&self, config: &Config) -> Option<PassMode> {
 464         if !self.ignore_pass && self.fail_mode.is_none() && config.mode == Mode::Ui {
 465             if let (mode @ Some(_), Some(_)) = (config.force_pass_mode, self.pass_mode) {
 466                 return mode;
 467             }
 468         }
 469         self.pass_mode
 470     }
 471
 472     // does not consider CLI override for pass mode
 473     pub fn local_pass_mode(&self) -> Option<PassMode> {
 474         self.pass_mode
 475     }
 476 }
 477
 478 fn iter_header<R: Read>(testfile: &Path, rdr: R, it: &mut dyn FnMut(Option<&str>, &str)) {
 479     if testfile.is_dir() {
 480         return;
 481     }
 482
 483     let comment = if testfile.extension().map(|e| e == "rs") == Some(true) { "//" } else { "#" };
 484
 485     let mut rdr = BufReader::new(rdr);
 486     let mut ln = String::new();
 487
 488     loop {
 489         ln.clear();
 490         if rdr.read_line(&mut ln).unwrap() == 0 {
 491             break;
 492         }
 493
 494         // Assume that any directives will be found before the first
 495         // module or function. This doesn't seem to be an optimization
 496         // with a warm page cache. Maybe with a cold one.
 497         let ln = ln.trim();
 498         if ln.starts_with("fn") || ln.starts_with("mod") {
 499             return;
 500         } else if ln.starts_with(comment) && ln[comment.len()..].trim_start().starts_with('[') {
 501             // A comment like `//[foo]` is specific to revision `foo`
 502             if let Some(close_brace) = ln.find(']') {
 503                 let open_brace = ln.find('[').unwrap();
 504                 let lncfg = &ln[open_brace + 1..close_brace];
 505                 it(Some(lncfg), ln[(close_brace + 1)..].trim_start());
 506             } else {
 507                 panic!("malformed condition directive: expected `{}[foo]`, found `{}`", comment, ln)
 508             }
 509         } else if ln.starts_with(comment) {
 510             it(None, ln[comment.len()..].trim_start());
 511         }
 512     }
 513 }
 514
 515 impl Config {
 516     fn parse_should_ice(&self, line: &str) -> bool {
 517         self.parse_name_directive(line, "should-ice")
 518     }
 519     fn parse_error_pattern(&self, line: &str) -> Option<String> {
 520         self.parse_name_value_directive(line, "error-pattern")
 521     }
 522
 523     fn parse_forbid_output(&self, line: &str) -> Option<String> {
 524         self.parse_name_value_directive(line, "forbid-output")
 525     }
 526
 527     fn parse_aux_build(&self, line: &str) -> Option<String> {
 528         self.parse_name_value_directive(line, "aux-build").map(|r| r.trim().to_string())
 529     }
 530
 531     fn parse_aux_crate(&self, line: &str) -> Option<(String, String)> {
 532         self.parse_name_value_directive(line, "aux-crate").map(|r| {
 533             let mut parts = r.trim().splitn(2, '=');
 534             (
 535                 parts.next().expect("missing aux-crate name (e.g. log=log.rs)").to_string(),
 536                 parts.next().expect("missing aux-crate value (e.g. log=log.rs)").to_string(),
 537             )
 538         })
 539     }
 540
 541     fn parse_compile_flags(&self, line: &str) -> Option<String> {
 542         self.parse_name_value_directive(line, "compile-flags")
 543     }
 544
 545     fn parse_and_update_revisions(&self, line: &str, existing: &mut Vec<String>) {
 546         if let Some(raw) = self.parse_name_value_directive(line, "revisions") {
 547             let mut duplicates: HashSet<_> = existing.iter().cloned().collect();
 548             for revision in raw.split_whitespace().map(|r| r.to_string()) {
 549                 if !duplicates.insert(revision.clone()) {
 550                     panic!("Duplicate revision: `{}` in line `{}`", revision, raw);
 551                 }
 552                 existing.push(revision);
 553             }
 554         }
 555     }
 556
 557     fn parse_run_flags(&self, line: &str) -> Option<String> {
 558         self.parse_name_value_directive(line, "run-flags")
 559     }
 560
 561     fn parse_check_line(&self, line: &str) -> Option<String> {
 562         self.parse_name_value_directive(line, "check")
 563     }
 564
 565     fn parse_force_host(&self, line: &str) -> bool {
 566         self.parse_name_directive(line, "force-host")
 567     }
 568
 569     fn parse_build_aux_docs(&self, line: &str) -> bool {
 570         self.parse_name_directive(line, "build-aux-docs")
 571     }
 572
 573     fn parse_check_stdout(&self, line: &str) -> bool {
 574         self.parse_name_directive(line, "check-stdout")
 575     }
 576
 577     fn parse_check_run_results(&self, line: &str) -> bool {
 578         self.parse_name_directive(line, "check-run-results")
 579     }
 580
 581     fn parse_dont_check_compiler_stdout(&self, line: &str) -> bool {
 582         self.parse_name_directive(line, "dont-check-compiler-stdout")
 583     }
 584
 585     fn parse_dont_check_compiler_stderr(&self, line: &str) -> bool {
 586         self.parse_name_directive(line, "dont-check-compiler-stderr")
 587     }
 588
 589     fn parse_no_prefer_dynamic(&self, line: &str) -> bool {
 590         self.parse_name_directive(line, "no-prefer-dynamic")
 591     }
 592
 593     fn parse_pretty_expanded(&self, line: &str) -> bool {
 594         self.parse_name_directive(line, "pretty-expanded")
 595     }
 596
 597     fn parse_pretty_mode(&self, line: &str) -> Option<String> {
 598         self.parse_name_value_directive(line, "pretty-mode")
 599     }
 600
 601     fn parse_pretty_compare_only(&self, line: &str) -> bool {
 602         self.parse_name_directive(line, "pretty-compare-only")
 603     }
 604
 605     fn parse_failure_status(&self, line: &str) -> Option<i32> {
 606         match self.parse_name_value_directive(line, "failure-status") {
 607             Some(code) => code.trim().parse::<i32>().ok(),
 608             _ => None,
 609         }
 610     }
 611
 612     fn parse_check_test_line_numbers_match(&self, line: &str) -> bool {
 613         self.parse_name_directive(line, "check-test-line-numbers-match")
 614     }
 615
 616     fn parse_ignore_pass(&self, line: &str) -> bool {
 617         self.parse_name_directive(line, "ignore-pass")
 618     }
 619
 620     fn parse_stderr_per_bitwidth(&self, line: &str) -> bool {
 621         self.parse_name_directive(line, "stderr-per-bitwidth")
 622     }
 623
 624     fn parse_assembly_output(&self, line: &str) -> Option<String> {
 625         self.parse_name_value_directive(line, "assembly-output").map(|r| r.trim().to_string())
 626     }
 627
 628     fn parse_env(&self, line: &str, name: &str) -> Option<(String, String)> {
 629         self.parse_name_value_directive(line, name).map(|nv| {
 630             // nv is either FOO or FOO=BAR
 631             let mut strs: Vec<String> = nv.splitn(2, '=').map(str::to_owned).collect();
 632
 633             match strs.len() {
 634                 1 => (strs.pop().unwrap(), String::new()),
 635                 2 => {
 636                     let end = strs.pop().unwrap();
 637                     (strs.pop().unwrap(), end)
 638                 }
 639                 n => panic!("Expected 1 or 2 strings, not {}", n),
 640             }
 641         })
 642     }
 643
 644     fn parse_pp_exact(&self, line: &str, testfile: &Path) -> Option<PathBuf> {
 645         if let Some(s) = self.parse_name_value_directive(line, "pp-exact") {
 646             Some(PathBuf::from(&s))
 647         } else if self.parse_name_directive(line, "pp-exact") {
 648             testfile.file_name().map(PathBuf::from)
 649         } else {
 650             None
 651         }
 652     }
 653
 654     fn parse_custom_normalization(&self, mut line: &str, prefix: &str) -> Option<(String, String)> {
 655         if self.parse_cfg_name_directive(line, prefix) == ParsedNameDirective::Match {
 656             let from = parse_normalization_string(&mut line)?;
 657             let to = parse_normalization_string(&mut line)?;
 658             Some((from, to))
 659         } else {
 660             None
 661         }
 662     }
 663
 664     fn parse_needs_matching_clang(&self, line: &str) -> bool {
 665         self.parse_name_directive(line, "needs-matching-clang")
 666     }
 667
 668     fn parse_needs_profiler_support(&self, line: &str) -> bool {
 669         self.parse_name_directive(line, "needs-profiler-support")
 670     }
 671
 672     /// Parses a name-value directive which contains config-specific information, e.g., `ignore-x86`
 673     /// or `normalize-stderr-32bit`.
 674     fn parse_cfg_name_directive(&self, line: &str, prefix: &str) -> ParsedNameDirective {
 675         if !line.as_bytes().starts_with(prefix.as_bytes()) {
 676             return ParsedNameDirective::NoMatch;
 677         }
 678         if line.as_bytes().get(prefix.len()) != Some(&b'-') {
 679             return ParsedNameDirective::NoMatch;
 680         }
 681
 682         let name = line[prefix.len() + 1..].split(&[':', ' '][..]).next().unwrap();
 683
 684         let is_match = name == "test" ||
 685             self.target == name ||                              // triple
 686             util::matches_os(&self.target, name) ||             // target
 687             util::matches_env(&self.target, name) ||            // env
 688             self.target.ends_with(name) ||                      // target and env
 689             name == util::get_arch(&self.target) ||             // architecture
 690             name == util::get_pointer_width(&self.target) ||    // pointer width
 691             name == self.stage_id.split('-').next().unwrap() || // stage
 692             name == self.channel ||                             // channel
 693             (self.target != self.host && name == "cross-compile") ||
 694             (name == "endian-big" && util::is_big_endian(&self.target)) ||
 695             (self.remote_test_client.is_some() && name == "remote") ||
 696             match self.compare_mode {
 697                 Some(CompareMode::Nll) => name == "compare-mode-nll",
 698                 Some(CompareMode::Polonius) => name == "compare-mode-polonius",
 699                 Some(CompareMode::Chalk) => name == "compare-mode-chalk",
 700                 Some(CompareMode::SplitDwarf) => name == "compare-mode-split-dwarf",
 701                 Some(CompareMode::SplitDwarfSingle) => name == "compare-mode-split-dwarf-single",
 702                 None => false,
 703             } ||
 704             (cfg!(debug_assertions) && name == "debug") ||
 705             match self.debugger {
 706                 Some(Debugger::Cdb) => name == "cdb",
 707                 Some(Debugger::Gdb) => name == "gdb",
 708                 Some(Debugger::Lldb) => name == "lldb",
 709                 None => false,
 710             };
 711
 712         if is_match { ParsedNameDirective::Match } else { ParsedNameDirective::NoMatch }
 713     }
 714
 715     fn has_cfg_prefix(&self, line: &str, prefix: &str) -> bool {
 716         // returns whether this line contains this prefix or not. For prefix
 717         // "ignore", returns true if line says "ignore-x86_64", "ignore-arch",
 718         // "ignore-android" etc.
 719         line.starts_with(prefix) && line.as_bytes().get(prefix.len()) == Some(&b'-')
 720     }
 721
 722     fn parse_name_directive(&self, line: &str, directive: &str) -> bool {
 723         // Ensure the directive is a whole word. Do not match "ignore-x86" when
 724         // the line says "ignore-x86_64".
 725         line.starts_with(directive)
 726             && matches!(line.as_bytes().get(directive.len()), None | Some(&b' ') | Some(&b':'))
 727     }
 728
 729     pub fn parse_name_value_directive(&self, line: &str, directive: &str) -> Option<String> {
 730         let colon = directive.len();
 731         if line.starts_with(directive) && line.as_bytes().get(colon) == Some(&b':') {
 732             let value = line[(colon + 1)..].to_owned();
 733             debug!("{}: {}", directive, value);
 734             Some(expand_variables(value, self))
 735         } else {
 736             None
 737         }
 738     }
 739
 740     pub fn find_rust_src_root(&self) -> Option<PathBuf> {
 741         let mut path = self.src_base.clone();
 742         let path_postfix = Path::new("src/etc/lldb_batchmode.py");
 743
 744         while path.pop() {
 745             if path.join(&path_postfix).is_file() {
 746                 return Some(path);
 747             }
 748         }
 749
 750         None
 751     }
 752
 753     fn parse_run_rustfix(&self, line: &str) -> bool {
 754         self.parse_name_directive(line, "run-rustfix")
 755     }
 756
 757     fn parse_rustfix_only_machine_applicable(&self, line: &str) -> bool {
 758         self.parse_name_directive(line, "rustfix-only-machine-applicable")
 759     }
 760
 761     fn parse_edition(&self, line: &str) -> Option<String> {
 762         self.parse_name_value_directive(line, "edition")
 763     }
 764
 765     fn parse_incremental(&self, line: &str) -> bool {
 766         self.parse_name_directive(line, "incremental")
 767     }
 768 }
 769
 770 fn expand_variables(mut value: String, config: &Config) -> String {
 771     const CWD: &str = "{{cwd}}";
 772     const SRC_BASE: &str = "{{src-base}}";
 773     const BUILD_BASE: &str = "{{build-base}}";
 774
 775     if value.contains(CWD) {
 776         let cwd = env::current_dir().unwrap();
 777         value = value.replace(CWD, &cwd.to_string_lossy());
 778     }
 779
 780     if value.contains(SRC_BASE) {
 781         value = value.replace(SRC_BASE, &config.src_base.to_string_lossy());
 782     }
 783
 784     if value.contains(BUILD_BASE) {
 785         value = value.replace(BUILD_BASE, &config.build_base.to_string_lossy());
 786     }
 787
 788     value
 789 }
 790
 791 /// Finds the next quoted string `"..."` in `line`, and extract the content from it. Move the `line`
 792 /// variable after the end of the quoted string.
 793 ///
 794 /// # Examples
 795 ///
 796 /// ```
 797 /// let mut s = "normalize-stderr-32bit: \"something (32 bits)\" -> \"something ($WORD bits)\".";
 798 /// let first = parse_normalization_string(&mut s);
 799 /// assert_eq!(first, Some("something (32 bits)".to_owned()));
 800 /// assert_eq!(s, " -> \"something ($WORD bits)\".");
 801 /// ```
 802 fn parse_normalization_string(line: &mut &str) -> Option<String> {
 803     // FIXME support escapes in strings.
 804     let begin = line.find('"')? + 1;
 805     let end = line[begin..].find('"')? + begin;
 806     let result = line[begin..end].to_owned();
 807     *line = &line[end + 1..];
 808     Some(result)
 809 }
 810
 811 pub fn extract_llvm_version(version: &str) -> Option<u32> {
 812     let pat = |c: char| !c.is_ascii_digit() && c != '.';
 813     let version_without_suffix = match version.find(pat) {
 814         Some(pos) => &version[..pos],
 815         None => version,
 816     };
 817     let components: Vec<u32> = version_without_suffix
 818         .split('.')
 819         .map(|s| s.parse().expect("Malformed version component"))
 820         .collect();
 821     let version = match *components {
 822         [a] => a * 10_000,
 823         [a, b] => a * 10_000 + b * 100,
 824         [a, b, c] => a * 10_000 + b * 100 + c,
 825         _ => panic!("Malformed version"),
 826     };
 827     Some(version)
 828 }
 829
 830 /// Takes a directive of the form "<version1> [- <version2>]",
 831 /// returns the numeric representation of <version1> and <version2> as
 832 /// tuple: (<version1> as u32, <version2> as u32)
 833 ///
 834 /// If the <version2> part is omitted, the second component of the tuple
 835 /// is the same as <version1>.
 836 fn extract_version_range<F>(line: &str, parse: F) -> Option<(u32, u32)>
 837 where
 838     F: Fn(&str) -> Option<u32>,
 839 {
 840     let mut splits = line.splitn(2, "- ").map(str::trim);
 841     let min = splits.next().unwrap();
 842     if min.ends_with('-') {
 843         return None;
 844     }
 845
 846     let max = splits.next();
 847
 848     if min.is_empty() {
 849         return None;
 850     }
 851
 852     let min = parse(min)?;
 853     let max = match max {
 854         Some(max) if max.is_empty() => return None,
 855         Some(max) => parse(max)?,
 856         _ => min,
 857     };
 858
 859     Some((min, max))
 860 }
 861
 862 pub fn make_test_description<R: Read>(
 863     config: &Config,
 864     name: test::TestName,
 865     path: &Path,
 866     src: R,
 867     cfg: Option<&str>,
 868 ) -> test::TestDesc {
 869     let mut ignore = false;
 870     let mut should_fail = false;
 871
 872     let rustc_has_profiler_support = env::var_os("RUSTC_PROFILER_SUPPORT").is_some();
 873     let rustc_has_sanitizer_support = env::var_os("RUSTC_SANITIZER_SUPPORT").is_some();
 874     let has_asm_support = util::has_asm_support(&config.target);
 875     let has_asan = util::ASAN_SUPPORTED_TARGETS.contains(&&*config.target);
 876     let has_lsan = util::LSAN_SUPPORTED_TARGETS.contains(&&*config.target);
 877     let has_msan = util::MSAN_SUPPORTED_TARGETS.contains(&&*config.target);
 878     let has_tsan = util::TSAN_SUPPORTED_TARGETS.contains(&&*config.target);
 879     let has_hwasan = util::HWASAN_SUPPORTED_TARGETS.contains(&&*config.target);
 880     // for `-Z gcc-ld=lld`
 881     let has_rust_lld = config
 882         .compile_lib_path
 883         .join("rustlib")
 884         .join(&config.target)
 885         .join("bin")
 886         .join("gcc-ld")
 887         .join(if config.host.contains("windows") { "ld.exe" } else { "ld" })
 888         .exists();
 889     iter_header(path, src, &mut |revision, ln| {
 890         if revision.is_some() && revision != cfg {
 891             return;
 892         }
 893         ignore = match config.parse_cfg_name_directive(ln, "ignore") {
 894             ParsedNameDirective::Match => true,
 895             ParsedNameDirective::NoMatch => ignore,
 896         };
 897         if config.has_cfg_prefix(ln, "only") {
 898             ignore = match config.parse_cfg_name_directive(ln, "only") {
 899                 ParsedNameDirective::Match => ignore,
 900                 ParsedNameDirective::NoMatch => true,
 901             };
 902         }
 903         ignore |= ignore_llvm(config, ln);
 904         ignore |=
 905             config.run_clang_based_tests_with.is_none() && config.parse_needs_matching_clang(ln);
 906         ignore |= !has_asm_support && config.parse_name_directive(ln, "needs-asm-support");
 907         ignore |= !rustc_has_profiler_support && config.parse_needs_profiler_support(ln);
 908         ignore |= !config.run_enabled() && config.parse_name_directive(ln, "needs-run-enabled");
 909         ignore |= !rustc_has_sanitizer_support
 910             && config.parse_name_directive(ln, "needs-sanitizer-support");
 911         ignore |= !has_asan && config.parse_name_directive(ln, "needs-sanitizer-address");
 912         ignore |= !has_lsan && config.parse_name_directive(ln, "needs-sanitizer-leak");
 913         ignore |= !has_msan && config.parse_name_directive(ln, "needs-sanitizer-memory");
 914         ignore |= !has_tsan && config.parse_name_directive(ln, "needs-sanitizer-thread");
 915         ignore |= !has_hwasan && config.parse_name_directive(ln, "needs-sanitizer-hwaddress");
 916         ignore |= config.target_panic == PanicStrategy::Abort
 917             && config.parse_name_directive(ln, "needs-unwind");
 918         ignore |= config.target == "wasm32-unknown-unknown" && config.parse_check_run_results(ln);
 919         ignore |= config.debugger == Some(Debugger::Cdb) && ignore_cdb(config, ln);
 920         ignore |= config.debugger == Some(Debugger::Gdb) && ignore_gdb(config, ln);
 921         ignore |= config.debugger == Some(Debugger::Lldb) && ignore_lldb(config, ln);
 922         ignore |= !has_rust_lld && config.parse_name_directive(ln, "needs-rust-lld");
 923         should_fail |= config.parse_name_directive(ln, "should-fail");
 924     });
 925
 926     // The `should-fail` annotation doesn't apply to pretty tests,
 927     // since we run the pretty printer across all tests by default.
 928     // If desired, we could add a `should-fail-pretty` annotation.
 929     let should_panic = match config.mode {
 930         crate::common::Pretty => test::ShouldPanic::No,
 931         _ if should_fail => test::ShouldPanic::Yes,
 932         _ => test::ShouldPanic::No,
 933     };
 934
 935     test::TestDesc {
 936         name,
 937         ignore,
 938         should_panic,
 939         allow_fail: false,
 940         compile_fail: false,
 941         no_run: false,
 942         test_type: test::TestType::Unknown,
 943     }
 944 }
 945
 946 fn ignore_cdb(config: &Config, line: &str) -> bool {
 947     if let Some(actual_version) = config.cdb_version {
 948         if let Some(min_version) = line.strip_prefix("min-cdb-version:").map(str::trim) {
 949             let min_version = extract_cdb_version(min_version).unwrap_or_else(|| {
 950                 panic!("couldn't parse version range: {:?}", min_version);
 951             });
 952
 953             // Ignore if actual version is smaller than the minimum
 954             // required version
 955             return actual_version < min_version;
 956         }
 957     }
 958     false
 959 }
 960
 961 fn ignore_gdb(config: &Config, line: &str) -> bool {
 962     if let Some(actual_version) = config.gdb_version {
 963         if let Some(rest) = line.strip_prefix("min-gdb-version:").map(str::trim) {
 964             let (start_ver, end_ver) = extract_version_range(rest, extract_gdb_version)
 965                 .unwrap_or_else(|| {
 966                     panic!("couldn't parse version range: {:?}", rest);
 967                 });
 968
 969             if start_ver != end_ver {
 970                 panic!("Expected single GDB version")
 971             }
 972             // Ignore if actual version is smaller than the minimum
 973             // required version
 974             return actual_version < start_ver;
 975         } else if let Some(rest) = line.strip_prefix("ignore-gdb-version:").map(str::trim) {
 976             let (min_version, max_version) = extract_version_range(rest, extract_gdb_version)
 977                 .unwrap_or_else(|| {
 978                     panic!("couldn't parse version range: {:?}", rest);
 979                 });
 980
 981             if max_version < min_version {
 982                 panic!("Malformed GDB version range: max < min")
 983             }
 984
 985             return actual_version >= min_version && actual_version <= max_version;
 986         }
 987     }
 988     false
 989 }
 990
 991 fn ignore_lldb(config: &Config, line: &str) -> bool {
 992     if let Some(actual_version) = config.lldb_version {
 993         if let Some(min_version) = line.strip_prefix("min-lldb-version:").map(str::trim) {
 994             let min_version = min_version.parse().unwrap_or_else(|e| {
 995                 panic!("Unexpected format of LLDB version string: {}\n{:?}", min_version, e);
 996             });
 997             // Ignore if actual version is smaller the minimum required
 998             // version
 999             actual_version < min_version
1000         } else {
1001             line.starts_with("rust-lldb") && !config.lldb_native_rust
1002         }
1003     } else {
1004         false
1005     }
1006 }
1007
1008 fn ignore_llvm(config: &Config, line: &str) -> bool {
1009     if config.system_llvm && line.starts_with("no-system-llvm") {
1010         return true;
1011     }
1012     if let Some(needed_components) =
1013         config.parse_name_value_directive(line, "needs-llvm-components")
1014     {
1015         let components: HashSet<_> = config.llvm_components.split_whitespace().collect();
1016         if let Some(missing_component) = needed_components
1017             .split_whitespace()
1018             .find(|needed_component| !components.contains(needed_component))
1019         {
1020             if env::var_os("COMPILETEST_NEEDS_ALL_LLVM_COMPONENTS").is_some() {
1021                 panic!("missing LLVM component: {}", missing_component);
1022             }
1023             return true;
1024         }
1025     }
1026     if let Some(actual_version) = config.llvm_version {
1027         if let Some(rest) = line.strip_prefix("min-llvm-version:").map(str::trim) {
1028             let min_version = extract_llvm_version(rest).unwrap();
1029             // Ignore if actual version is smaller the minimum required
1030             // version
1031             actual_version < min_version
1032         } else if let Some(rest) = line.strip_prefix("min-system-llvm-version:").map(str::trim) {
1033             let min_version = extract_llvm_version(rest).unwrap();
1034             // Ignore if using system LLVM and actual version
1035             // is smaller the minimum required version
1036             config.system_llvm && actual_version < min_version
1037         } else if let Some(rest) = line.strip_prefix("ignore-llvm-version:").map(str::trim) {
1038             // Syntax is: "ignore-llvm-version: <version1> [- <version2>]"
1039             let (v_min, v_max) =
1040                 extract_version_range(rest, extract_llvm_version).unwrap_or_else(|| {
1041                     panic!("couldn't parse version range: {:?}", rest);
1042                 });
1043             if v_max < v_min {
1044                 panic!("Malformed LLVM version range: max < min")
1045             }
1046             // Ignore if version lies inside of range.
1047             actual_version >= v_min && actual_version <= v_max
1048         } else {
1049             false
1050         }
1051     } else {
1052         false
1053     }
1054 }