Auto merge of #50400 - ehuss:compiletest-revisions, r=alexcrichton

 compiletest: Run revisions as independent tests.

Fixes #47604.

- The output of each test is now in its own directory.
- "auxiliary" output is now under the respective test directory.
- `stage_id` removed from filenames, and instead placed in the stamp file as a hash.  This helps keep path lengths down for Windows.

In brief, the new layout looks like this:
```
<build_base>/<relative_dir>/<testname>.<revision>.<mode>/
    stamp
    <testname>.err
    <testname>.out
    a (binary)
    auxiliary/lib<auxname>.dylib
    auxiliary/<auxname>/<auxname>.err
    auxiliary/<auxname>/<auxname>.out
```
(revision and mode are optional)

src/test/ui-fulldeps/update-references.sh

@@ -31,18 +31,18 @@ MYDIR=$(dirname $0)
 BUILD_DIR="$1"
 shift
 
+shopt -s nullglob
+
 while [[ "$1" != "" ]]; do
-    STDERR_NAME="${1/%.rs/.stderr}"
-    STDOUT_NAME="${1/%.rs/.stdout}"
+    for EXT in "stderr" "stdout"; do
+        for OUT_NAME in $BUILD_DIR/${1%.rs}*/*$EXT; do
+            OUT_DIR=`dirname "$1"`
+            OUT_BASE=`basename "$OUT_NAME"`
+            if ! (diff $OUT_NAME $MYDIR/$OUT_DIR/$OUT_BASE >& /dev/null); then
+                echo updating $MYDIR/$OUT_DIR/$OUT_BASE
+                cp $OUT_NAME $MYDIR/$OUT_DIR
+            fi
+        done
+    done
     shift
-    if [ -f $BUILD_DIR/$STDOUT_NAME ] && \
-           ! (diff $BUILD_DIR/$STDOUT_NAME $MYDIR/$STDOUT_NAME >& /dev/null); then
-        echo updating $MYDIR/$STDOUT_NAME
-        cp $BUILD_DIR/$STDOUT_NAME $MYDIR/$STDOUT_NAME
-    fi
-    if [ -f $BUILD_DIR/$STDERR_NAME ] && \
-           ! (diff $BUILD_DIR/$STDERR_NAME $MYDIR/$STDERR_NAME >& /dev/null); then
-        echo updating $MYDIR/$STDERR_NAME
-        cp $BUILD_DIR/$STDERR_NAME $MYDIR/$STDERR_NAME
-    fi
 done

src/test/ui/update-references.sh

@@ -35,7 +35,7 @@ shopt -s nullglob
 
 while [[ "$1" != "" ]]; do
     for EXT in "stderr" "stdout" "fixed"; do
-        for OUT_NAME in $BUILD_DIR/${1%.rs}.*$EXT; do
+        for OUT_NAME in $BUILD_DIR/${1%.rs}*/*$EXT; do
             OUT_DIR=`dirname "$1"`
             OUT_BASE=`basename "$OUT_NAME"`
             if ! (diff $OUT_NAME $MYDIR/$OUT_DIR/$OUT_BASE >& /dev/null); then

src/tools/compiletest/src/common.rs

@@ -10,10 +10,11 @@
 pub use self::Mode::*;
 
 use std::fmt;
+use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use std::path::PathBuf;
 
 use test::ColorConfig;
+use util::PathBufExt;
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Mode {
@@ -103,7 +104,7 @@ pub enum CompareMode {
 impl CompareMode {
     pub(crate) fn to_str(&self) -> &'static str {
         match *self {
-            CompareMode::Nll => "nll"
+            CompareMode::Nll => "nll",
         }
     }
 
@@ -245,24 +246,28 @@ pub struct Config {
     pub nodejs: Option<String>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct TestPaths {
     pub file: PathBuf,         // e.g., compile-test/foo/bar/baz.rs
-    pub base: PathBuf,         // e.g., compile-test, auxiliary
     pub relative_dir: PathBuf, // e.g., foo/bar
 }
 
 /// Used by `ui` tests to generate things like `foo.stderr` from `foo.rs`.
-pub fn expected_output_path(testpaths: &TestPaths,
-                            revision: Option<&str>,
-                            compare_mode: &Option<CompareMode>,
-                            kind: &str) -> PathBuf {
-
+pub fn expected_output_path(
+    testpaths: &TestPaths,
+    revision: Option<&str>,
+    compare_mode: &Option<CompareMode>,
+    kind: &str,
+) -> PathBuf {
     assert!(UI_EXTENSIONS.contains(&kind));
     let mut parts = Vec::new();
 
-    if let Some(x) = revision { parts.push(x); }
-    if let Some(ref x) = *compare_mode { parts.push(x.to_str()); }
+    if let Some(x) = revision {
+        parts.push(x);
+    }
+    if let Some(ref x) = *compare_mode {
+        parts.push(x.to_str());
+    }
     parts.push(kind);
 
     let extension = parts.join(".");
@@ -273,3 +278,38 @@ pub const UI_EXTENSIONS: &[&str] = &[UI_STDERR, UI_STDOUT, UI_FIXED];
 pub const UI_STDERR: &str = "stderr";
 pub const UI_STDOUT: &str = "stdout";
 pub const UI_FIXED: &str = "fixed";
+
+/// Absolute path to the directory where all output for all tests in the given
+/// `relative_dir` group should reside. Example:
+///   /path/to/build/host-triple/test/ui/relative/
+/// This is created early when tests are collected to avoid race conditions.
+pub fn output_relative_path(config: &Config, relative_dir: &Path) -> PathBuf {
+    config.build_base.join(relative_dir)
+}
+
+/// Generates a unique name for the test, such as `testname.revision.mode`.
+pub fn output_testname_unique(
+    config: &Config,
+    testpaths: &TestPaths,
+    revision: Option<&str>,
+) -> PathBuf {
+    let mode = config.compare_mode.as_ref().map_or("", |m| m.to_str());
+    PathBuf::from(&testpaths.file.file_stem().unwrap())
+        .with_extra_extension(revision.unwrap_or(""))
+        .with_extra_extension(mode)
+}
+
+/// Absolute path to the directory where all output for the given
+/// test/revision should reside.  Example:
+///   /path/to/build/host-triple/test/ui/relative/testname.revision.mode/
+pub fn output_base_dir(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> PathBuf {
+    output_relative_path(config, &testpaths.relative_dir)
+        .join(output_testname_unique(config, testpaths, revision))
+}
+
+/// Absolute path to the base filename used as output for the given
+/// test/revision.  Example:
+///   /path/to/build/host-triple/test/ui/relative/testname.revision.mode/testname
+pub fn output_base_name(config: &Config, testpaths: &TestPaths, revision: Option<&str>) -> PathBuf {
+    output_base_dir(config, testpaths, revision).join(testpaths.file.file_stem().unwrap())
+}

src/tools/compiletest/src/errors.rs

@@ -11,8 +11,8 @@ use self::WhichLine::*;
 
 use std::fmt;
 use std::fs::File;
-use std::io::BufReader;
 use std::io::prelude::*;
+use std::io::BufReader;
 use std::path::Path;
 use std::str::FromStr;
 
@@ -35,8 +35,7 @@ impl FromStr for ErrorKind {
             "ERROR" => Ok(ErrorKind::Error),
             "NOTE" => Ok(ErrorKind::Note),
             "SUGGESTION" => Ok(ErrorKind::Suggestion),
-            "WARN" |
-            "WARNING" => Ok(ErrorKind::Warning),
+            "WARN" | "WARNING" => Ok(ErrorKind::Warning),
             _ => Err(()),
         }
     }
@@ -101,61 +100,74 @@ pub fn load_errors(testfile: &Path, cfg: Option<&str>) -> Vec<Error> {
     rdr.lines()
         .enumerate()
         .filter_map(|(line_num, line)| {
-            parse_expected(last_nonfollow_error, line_num + 1, &line.unwrap(), &tag)
-                .map(|(which, error)| {
+            parse_expected(last_nonfollow_error, line_num + 1, &line.unwrap(), &tag).map(
+                |(which, error)| {
                     match which {
                         FollowPrevious(_) => {}
                         _ => last_nonfollow_error = Some(error.line_num),
                     }
                     error
-                })
+                },
+            )
         })
         .collect()
 }
 
-fn parse_expected(last_nonfollow_error: Option<usize>,
-                  line_num: usize,
-                  line: &str,
-                  tag: &str)
-                  -> Option<(WhichLine, Error)> {
+fn parse_expected(
+    last_nonfollow_error: Option<usize>,
+    line_num: usize,
+    line: &str,
+    tag: &str,
+) -> Option<(WhichLine, Error)> {
     let start = match line.find(tag) {
         Some(i) => i,
         None => return None,
     };
     let (follow, adjusts) = if line[start + tag.len()..].chars().next().unwrap() == '|' {
         (true, 0)
     } else {
-        (false, line[start + tag.len()..].chars().take_while(|c| *c == '^').count())
+        (
+            false,
+            line[start + tag.len()..]
+                .chars()
+                .take_while(|c| *c == '^')
+                .count(),
+        )
     };
     let kind_start = start + tag.len() + adjusts + (follow as usize);
     let (kind, msg);
     match line[kind_start..]
         .split_whitespace()
         .next()
         .expect("Encountered unexpected empty comment")
-        .parse::<ErrorKind>() {
+        .parse::<ErrorKind>()
+    {
         Ok(k) => {
             // If we find `//~ ERROR foo` or something like that:
             kind = Some(k);
             let letters = line[kind_start..].chars();
-            msg = letters.skip_while(|c| c.is_whitespace())
+            msg = letters
+                .skip_while(|c| c.is_whitespace())
                 .skip_while(|c| !c.is_whitespace())
                 .collect::<String>();
         }
         Err(_) => {
             // Otherwise we found `//~ foo`:
             kind = None;
             let letters = line[kind_start..].chars();
-            msg = letters.skip_while(|c| c.is_whitespace())
+            msg = letters
+                .skip_while(|c| c.is_whitespace())
                 .collect::<String>();
         }
     }
     let msg = msg.trim().to_owned();
 
     let (which, line_num) = if follow {
         assert_eq!(adjusts, 0, "use either //~| or //~^, not both.");
-        let line_num = last_nonfollow_error.expect("encountered //~| without \
-                                                    preceding //~^ line.");
+        let line_num = last_nonfollow_error.expect(
+            "encountered //~| without \
+             preceding //~^ line.",
+        );
         (FollowPrevious(line_num), line_num)
     } else {
         let which = if adjusts > 0 {
@@ -167,16 +179,16 @@ fn parse_expected(last_nonfollow_error: Option<usize>,
         (which, line_num)
     };
 
-    debug!("line={} tag={:?} which={:?} kind={:?} msg={:?}",
-           line_num,
-           tag,
-           which,
-           kind,
-           msg);
-    Some((which,
-          Error {
-        line_num,
-        kind,
-        msg,
-    }))
+    debug!(
+        "line={} tag={:?} which={:?} kind={:?} msg={:?}",
+        line_num, tag, which, kind, msg
+    );
+    Some((
+        which,
+        Error {
+            line_num,
+            kind,
+            msg,
+        },
+    ))
 }