Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

18 files changed, 4098 insertions, 0 deletions

diff --git a/vendor/ui_test/.cargo-checksum.json b/vendor/ui_test/.cargo-checksum.json
new file mode 100644
index 000000000..f76028178
--- /dev/null
+++ b/vendor/ui_test/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CONTRIBUTING.md":"e030432e8f8830a0c6e6fb783dcae14c19d20f770d4e2e274a48693748d7bd68","Cargo.toml":"e5ea7eaf370e6c185588d14835b2168b186895729431930452542b7fff4d72a2","README.md":"c846bb425130a0e3542797ef7d7cdc0dc508d1cb6e8db812821ee8d053d97f35","src/cmd.rs":"5a095efafc7e015f5f27383100cae9d553e8d9f18b5fd298d3f0192bff90d620","src/config.rs":"5c71a3ad1f4c404238b9066cfade4f4dcf1b7f55f9c2ed291bdc317413415f40","src/dependencies.rs":"06083293ea5243e424da7b7af0967ee03cd1270e160edb52e3cb00231f1dc85c","src/diff.rs":"6d399e7a6eb354aa420d683bdab4fcd27ab5b7bcfe6787d515fd579429b22f99","src/error.rs":"8fdb38126aafb5bbbb8e8ad0f2af87f0d78ced23cbc5872672a8669104177dc1","src/github_actions.rs":"81a78130b4e22ca703433f4bec90be4191711c1ffdc1e59dd136f678a167ce2c","src/lib.rs":"d1d2afd1e468cda79b5811178220030ba771db8e1800e8dfb434d061614dc2fa","src/mode.rs":"4565cb37f7399789fdd46dd73de20b58a25762a1a7543cfc06c04bb972622a56","src/parser.rs":"0a3c549ff3752c03c2fcf767a375e30a7c97a80b4263c00abe5e5d7025dfd5a8","src/parser/tests.rs":"c6e2fa9587791daab294b87f3fabd01d908885175e4a94182d960e5e7e86664f","src/rustc_stderr.rs":"3771e4f6716b6a0d81f2454750f9b6d65c6c0faf199a33b396e78a04a4512e5a","src/status_emitter.rs":"f9e5fad26a2a702147ec1d20b044cb2d96c6aa24853c03387c61ca2748f6a2da","src/tests.rs":"67b56d2135bb106de6660abd8889e7236b8d5c0619a20ccaf6ceb32bcd372668","tests/integration.rs":"da0a1629c5c65253eb58a56a68fb98d8e369f8a069326a0c8b0589e408450c0f"},"package":"24a2e70adc9d18b9b4dd80ea57aeec447103c6fbb354a07c080adad451c645e1"}
\ No newline at end of file
diff --git a/vendor/ui_test/CONTRIBUTING.md b/vendor/ui_test/CONTRIBUTING.md
new file mode 100644
index 000000000..d5165080c
--- /dev/null
+++ b/vendor/ui_test/CONTRIBUTING.md
@@ -0,0 +1,7 @@
+## Running the test suite
+
+Running `cargo test` will automatically update the `.stderr`
+and `.stdout` files.
+
+If you only want to check that the output files match and not
+update them, use `cargo test -- -- --check`
diff --git a/vendor/ui_test/Cargo.toml b/vendor/ui_test/Cargo.toml
new file mode 100644
index 000000000..df5908843
--- /dev/null
+++ b/vendor/ui_test/Cargo.toml
@@ -0,0 +1,78 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.63"
+name = "ui_test"
+version = "0.11.6"
+description = "A test framework for testing rustc diagnostics output"
+readme = "README.md"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/oli-obk/ui_test"
+
+[lib]
+test = true
+doctest = false
+
+[[test]]
+name = "integration"
+harness = false
+
+[dependencies.bstr]
+version = "1.0.1"
+
+[dependencies.cargo-platform]
+version = "0.1.2"
+
+[dependencies.cargo_metadata]
+version = "0.15"
+
+[dependencies.color-eyre]
+version = "0.6.1"
+features = ["capture-spantrace"]
+default-features = false
+
+[dependencies.colored]
+version = "2"
+
+[dependencies.crossbeam-channel]
+version = "0.5.6"
+
+[dependencies.diff]
+version = "0.1.13"
+
+[dependencies.lazy_static]
+version = "1.4.0"
+
+[dependencies.regex]
+version = "1.5.5"
+features = [
+    "perf",
+    "std",
+]
+default-features = false
+
+[dependencies.rustc_version]
+version = "0.4"
+
+[dependencies.rustfix]
+version = "0.6.1"
+
+[dependencies.serde]
+version = "1.0"
+features = ["derive"]
+
+[dependencies.serde_json]
+version = "1.0"
+
+[dependencies.tempfile]
+version = "3.3.0"
diff --git a/vendor/ui_test/README.md b/vendor/ui_test/README.md
new file mode 100644
index 000000000..ca3650579
--- /dev/null
+++ b/vendor/ui_test/README.md
@@ -0,0 +1,62 @@
+A smaller version of compiletest-rs
+
+## Magic behavior
+
+* Tests are run in order of their filenames (files first, then recursing into folders).
+  So if you have any slow tests, prepend them with a small integral number to make them get run first, taking advantage of parallelism as much as possible (instead of waiting for the slow tests at the end).
+
+## Supported magic comment annotations
+
+If your test tests for failure, you need to add a `//~` annotation where the error is happening
+to make sure that the test will always keep failing with a specific message at the annotated line.
+
+`//~ ERROR: XXX` make sure the stderr output contains `XXX` for an error in the line where this comment is written
+
+* Also supports `HELP`, `WARN` or `NOTE` for different kind of message
+    * if one of those levels is specified explicitly, *all* diagnostics of this level or higher need an annotation. If you want to avoid this, just leave out the all caps level note entirely.
+* If the all caps note is left out, a message of any level is matched. Leaving it out is not allowed for `ERROR` levels.
+* This checks the output *before* normalization, so you can check things that get normalized away, but need to
+    be careful not to accidentally have a pattern that differs between platforms.
+* if `XXX` is of the form `/XXX/` it is treated as a regex instead of a substring and will succeed if the regex matches.
+
+In order to change how a single test is tested, you can add various `//@` comments to the test.
+Any other comments will be ignored, and all `//@` comments must be formatted precisely as
+their command specifies, or the test will fail without even being run.
+
+* `//@ignore-C` avoids running the test when condition `C` is met.
+    * `C` can be `target-XXX`, which checks whether the target triple contains `XXX`.
+    * `C` can also be one of `64bit`, `32bit` or `16bit`.
+    * `C` can also be `on-host`, which will only run the test during cross compilation testing.
+* `//@only-C` **only** runs the test when condition `C` is met. The conditions are the same as with `ignore`.
+* `//@needs-asm-support` **only** runs the test when the target supports `asm!`.
+* `//@stderr-per-bitwidth` produces one stderr file per bitwidth, as they may differ significantly sometimes
+* `//@error-in-other-file: XXX` can be used to check for errors that can't have `//~` patterns due to being reported in other files.
+* `//@revisions: XXX YYY` runs the test once for each space separated name in the list
+    * emits one stderr file per revision
+    * `//~` comments can be restricted to specific revisions by adding the revision name after the `~` in square brackets: `//~[XXX]`
+    * `//@` comments can be restricted to specific revisions by adding the revision name after the `@` in square brackets: `//@[XXX]`
+        * Note that you cannot add revisions to the `revisions` command.
+* `//@compile-flags: XXX` appends `XXX` to the command line arguments passed to the rustc driver
+    * you can specify this multiple times, and all the flags will accumulate
+* `//@rustc-env: XXX=YYY` sets the env var `XXX` to `YYY` for the rustc driver execution.
+    * for Miri these env vars are used during compilation via rustc and during the emulation of the program
+    * you can specify this multiple times, accumulating all the env vars
+* `//@normalize-stderr-test: "REGEX" -> "REPLACEMENT"` replaces all matches of `REGEX` in the stderr with `REPLACEMENT`. The replacement may specify `$1` and similar backreferences to paste captures.
+    * you can specify multiple such commands, there is no need to create a single regex that handles multiple replacements that you want to perform.
+* `//@require-annotations-for-level: LEVEL` can be used to change the level of diagnostics that require a corresponding annotation.
+    * this is only useful if there are any annotations like `HELP`, `WARN` or `NOTE`, as these would automatically require annotations for all other diagnostics of the same or higher level.
+* `//@check-pass` overrides the `Config::mode` and will make the test behave as if the test suite were in `Mode::Pass`.
+* `//@edition: EDITION` overwrites the default edition (2021) to the given edition.
+* `//@run-rustfix` runs rustfix on the output and recompiles the result. The result must suceed to compile.
+* `//@aux-build: filename` looks for a file in the `auxiliary` directory (within the directory of the test), compiles it as a library and links the current crate against it. This allows you import the crate with `extern crate` or just via `use` statements.
+    * you can optionally specify a crate type via `//@aux-build: filename.rs:proc-macro`. This is necessary for some crates (like proc macros), but can also be used to change the linkage against the aux build.
+* `//@run` compiles the test and runs the resulting binary. The resulting binary must exit successfully. Stdout and stderr are taken from the resulting binary. Any warnings during compilation are ignored.
+    * You can also specify a different exit code/status that is expected via e.g. `//@run: 1` or `//@run: 101` (the latter is the standard Rust exit code for panics).
+
+## Significant differences to compiletest-rs
+
+* `ignore-target-*` and `only-target-*` operate solely on the triple, instead of supporting things like `macos`
+* only supports `ui` tests
+* tests are run in named order, so you can prefix slow tests with `0` in order to make them get run first
+* `aux-build`s for proc macros require an additional `:proc-macro` after the file name, but then the aux file itself needs no `#![proc_macro]` or other flags.
+* `aux-build`s require specifying nested aux builds explicitly and will not allow you to reference sibling `aux-build`s' artifacts.
diff --git a/vendor/ui_test/src/cmd.rs b/vendor/ui_test/src/cmd.rs
new file mode 100644
index 000000000..63d055e28
--- /dev/null
+++ b/vendor/ui_test/src/cmd.rs
@@ -0,0 +1,120 @@
+use std::{
+    ffi::OsString,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+#[derive(Debug, Clone)]
+/// A command, its args and its environment. Used for
+/// the main command, the dependency builder and the cfg-reader.
+pub struct CommandBuilder {
+    /// Path to the binary.
+    pub program: PathBuf,
+    /// Arguments to the binary.
+    pub args: Vec<OsString>,
+    /// A flag to prefix before the path to where output files should be written.
+    pub out_dir_flag: Option<OsString>,
+    /// A flag to set as the last flag in the command, so the `build` caller can
+    /// append the filename themselves.
+    pub input_file_flag: Option<OsString>,
+    /// Environment variables passed to the binary that is executed.
+    /// The environment variable is removed if the second tuple field is `None`
+    pub envs: Vec<(OsString, Option<OsString>)>,
+}
+
+impl CommandBuilder {
+    /// Uses the `CARGO` env var or just a program named `cargo` and the argument `build`.
+    pub fn cargo() -> Self {
+        Self {
+            program: PathBuf::from(std::env::var_os("CARGO").unwrap_or_else(|| "cargo".into())),
+            args: vec!["build".into()],
+            out_dir_flag: Some("--target-dir".into()),
+            input_file_flag: Some("--manifest-path".into()),
+            envs: vec![],
+        }
+    }
+
+    /// Uses the `RUSTC` env var or just a program named `rustc` and the argument `--error-format=json`.
+    ///
+    /// Take care to only append unless you actually meant to overwrite the defaults.
+    /// Overwriting the defaults may make `//~ ERROR` style comments stop working.
+    pub fn rustc() -> Self {
+        Self {
+            program: PathBuf::from(std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into())),
+            args: vec!["--error-format=json".into()],
+            out_dir_flag: Some("--out-dir".into()),
+            input_file_flag: None,
+            envs: vec![],
+        }
+    }
+
+    /// Same as [`rustc`], but with arguments for obtaining the cfgs.
+    pub fn cfgs() -> Self {
+        Self {
+            args: vec!["--print".into(), "cfg".into()],
+            ..Self::rustc()
+        }
+    }
+
+    /// Build a `CommandBuilder` for a command without any argumemnts.
+    /// You can still add arguments later.
+    pub fn cmd(cmd: impl Into<PathBuf>) -> Self {
+        Self {
+            program: cmd.into(),
+            args: vec![],
+            out_dir_flag: None,
+            input_file_flag: None,
+            envs: vec![],
+        }
+    }
+
+    /// Render the command like you'd use it on a command line.
+    pub fn display(&self) -> impl std::fmt::Display + '_ {
+        struct Display<'a>(&'a CommandBuilder);
+        impl std::fmt::Display for Display<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                for (var, val) in &self.0.envs {
+                    if let Some(val) = val {
+                        write!(f, "{var:?}={val:?} ")?;
+                    }
+                }
+                self.0.program.display().fmt(f)?;
+                for arg in &self.0.args {
+                    write!(f, " {arg:?}")?;
+                }
+                if let Some(flag) = &self.0.out_dir_flag {
+                    write!(f, " {flag:?} OUT_DIR")?;
+                }
+                if let Some(flag) = &self.0.input_file_flag {
+                    write!(f, " {flag:?}")?;
+                }
+                Ok(())
+            }
+        }
+        Display(self)
+    }
+
+    /// Create a command with the given settings.
+    pub fn build(&self, out_dir: &Path) -> Command {
+        let mut cmd = Command::new(&self.program);
+        cmd.args(self.args.iter());
+        if let Some(flag) = &self.out_dir_flag {
+            cmd.arg(flag).arg(out_dir);
+        }
+        if let Some(flag) = &self.input_file_flag {
+            cmd.arg(flag);
+        }
+        self.apply_env(&mut cmd);
+        cmd
+    }
+
+    pub(crate) fn apply_env(&self, cmd: &mut Command) {
+        for (var, val) in self.envs.iter() {
+            if let Some(val) = val {
+                cmd.env(var, val);
+            } else {
+                cmd.env_remove(var);
+            }
+        }
+    }
+}
diff --git a/vendor/ui_test/src/config.rs b/vendor/ui_test/src/config.rs
new file mode 100644
index 000000000..6f24cce90
--- /dev/null
+++ b/vendor/ui_test/src/config.rs
@@ -0,0 +1,196 @@
+use regex::bytes::Regex;
+
+use crate::{dependencies::build_dependencies, CommandBuilder, Filter, Match, Mode};
+pub use color_eyre;
+use color_eyre::eyre::Result;
+use std::{
+    ffi::OsString,
+    num::NonZeroUsize,
+    path::{Path, PathBuf},
+};
+
+#[derive(Debug, Clone)]
+/// Central datastructure containing all information to run the tests.
+pub struct Config {
+    /// Arguments passed to the binary that is executed.
+    /// These arguments are passed *after* the args inserted via `//@compile-flags:`.
+    pub trailing_args: Vec<OsString>,
+    /// Host triple; usually will be auto-detected.
+    pub host: Option<String>,
+    /// `None` to run on the host, otherwise a target triple
+    pub target: Option<String>,
+    /// Filters applied to stderr output before processing it.
+    /// By default contains a filter for replacing backslashes with regular slashes.
+    /// On windows, contains a filter to replace `\n` with `\r\n`.
+    pub stderr_filters: Filter,
+    /// Filters applied to stdout output before processing it.
+    /// On windows, contains a filter to replace `\n` with `\r\n`.
+    pub stdout_filters: Filter,
+    /// The folder in which to start searching for .rs files
+    pub root_dir: PathBuf,
+    /// The mode in which to run the tests.
+    pub mode: Mode,
+    /// The binary to actually execute.
+    pub program: CommandBuilder,
+    /// The command to run to obtain the cfgs that the output is supposed to
+    pub cfgs: CommandBuilder,
+    /// What to do in case the stdout/stderr output differs from the expected one.
+    /// By default, errors in case of conflict, but emits a message informing the user
+    /// that running `cargo test -- -- --bless` will automatically overwrite the
+    /// `.stdout` and `.stderr` files with the latest output.
+    pub output_conflict_handling: OutputConflictHandling,
+    /// Path to a `Cargo.toml` that describes which dependencies the tests can access.
+    pub dependencies_crate_manifest_path: Option<PathBuf>,
+    /// The command to run can be changed from `cargo` to any custom command to build the
+    /// dependencies in `dependencies_crate_manifest_path`
+    pub dependency_builder: CommandBuilder,
+    /// How many threads to use for running tests. Defaults to number of cores
+    pub num_test_threads: NonZeroUsize,
+    /// Where to dump files like the binaries compiled from tests.
+    /// Defaults to `target/ui` in the current directory.
+    pub out_dir: PathBuf,
+    /// The default edition to use on all tests
+    pub edition: Option<String>,
+}
+
+impl Config {
+    /// Create a configuration for testing the output of running
+    /// `rustc` on the test files.
+    pub fn rustc(root_dir: PathBuf) -> Self {
+        Self {
+            trailing_args: vec![],
+            host: None,
+            target: None,
+            stderr_filters: vec![
+                (Match::Exact(vec![b'\\']), b"/"),
+                #[cfg(windows)]
+                (Match::Exact(vec![b'\r']), b""),
+            ],
+            stdout_filters: vec![
+                #[cfg(windows)]
+                (Match::Exact(vec![b'\r']), b""),
+            ],
+            root_dir,
+            mode: Mode::Fail {
+                require_patterns: true,
+            },
+            program: CommandBuilder::rustc(),
+            cfgs: CommandBuilder::cfgs(),
+            output_conflict_handling: OutputConflictHandling::Error(
+                "cargo test -- -- --bless".into(),
+            ),
+            dependencies_crate_manifest_path: None,
+            dependency_builder: CommandBuilder::cargo(),
+            num_test_threads: std::thread::available_parallelism().unwrap(),
+            out_dir: std::env::current_dir().unwrap().join("target/ui"),
+            edition: Some("2021".into()),
+        }
+    }
+
+    /// Create a configuration for testing the output of running
+    /// `cargo` on the test `Cargo.toml` files.
+    pub fn cargo(root_dir: PathBuf) -> Self {
+        Self {
+            program: CommandBuilder::cargo(),
+            edition: None,
+            ..Self::rustc(root_dir)
+        }
+    }
+
+    /// Replace all occurrences of a path in stderr with a byte string.
+    pub fn path_stderr_filter(
+        &mut self,
+        path: &Path,
+        replacement: &'static (impl AsRef<[u8]> + ?Sized),
+    ) {
+        let pattern = path.canonicalize().unwrap();
+        self.stderr_filters
+            .push((pattern.parent().unwrap().into(), replacement.as_ref()));
+    }
+
+    /// Replace all occurrences of a regex pattern in stderr with a byte string.
+    pub fn stderr_filter(
+        &mut self,
+        pattern: &str,
+        replacement: &'static (impl AsRef<[u8]> + ?Sized),
+    ) {
+        self.stderr_filters
+            .push((Regex::new(pattern).unwrap().into(), replacement.as_ref()));
+    }
+
+    /// Replace all occurrences of a regex pattern in stdout with a byte string.
+    pub fn stdout_filter(
+        &mut self,
+        pattern: &str,
+        replacement: &'static (impl AsRef<[u8]> + ?Sized),
+    ) {
+        self.stdout_filters
+            .push((Regex::new(pattern).unwrap().into(), replacement.as_ref()));
+    }
+
+    pub(crate) fn build_dependencies_and_link_them(&mut self) -> Result<()> {
+        let dependencies = build_dependencies(self)?;
+        for (name, artifacts) in dependencies.dependencies {
+            for dependency in artifacts {
+                self.program.args.push("--extern".into());
+                let mut dep = OsString::from(&name);
+                dep.push("=");
+                dep.push(dependency);
+                self.program.args.push(dep);
+            }
+        }
+        for import_path in dependencies.import_paths {
+            self.program.args.push("-L".into());
+            self.program.args.push(import_path.into());
+        }
+        Ok(())
+    }
+
+    /// Make sure we have the host and target triples.
+    pub fn fill_host_and_target(&mut self) -> Result<()> {
+        if self.host.is_none() {
+            self.host = Some(
+                rustc_version::VersionMeta::for_command(std::process::Command::new(
+                    &self.program.program,
+                ))
+                .map_err(|err| {
+                    color_eyre::eyre::Report::new(err).wrap_err(format!(
+                        "failed to parse rustc version info: {}",
+                        self.program.display()
+                    ))
+                })?
+                .host,
+            );
+        }
+        if self.target.is_none() {
+            self.target = Some(self.host.clone().unwrap());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn has_asm_support(&self) -> bool {
+        static ASM_SUPPORTED_ARCHS: &[&str] = &[
+            "x86", "x86_64", "arm", "aarch64", "riscv32",
+            "riscv64",
+            // These targets require an additional asm_experimental_arch feature.
+            // "nvptx64", "hexagon", "mips", "mips64", "spirv", "wasm32",
+        ];
+        ASM_SUPPORTED_ARCHS
+            .iter()
+            .any(|arch| self.target.as_ref().unwrap().contains(arch))
+    }
+}
+
+#[derive(Debug, Clone)]
+/// The different options for what to do when stdout/stderr files differ from the actual output.
+pub enum OutputConflictHandling {
+    /// The default: emit a diff of the expected/actual output.
+    ///
+    /// The string should be a command that can be executed to bless all tests.
+    Error(String),
+    /// Ignore mismatches in the stderr/stdout files.
+    Ignore,
+    /// Instead of erroring if the stderr/stdout differs from the expected
+    /// automatically replace it with the found output (after applying filters).
+    Bless,
+}
diff --git a/vendor/ui_test/src/dependencies.rs b/vendor/ui_test/src/dependencies.rs
new file mode 100644
index 000000000..800a3a447
--- /dev/null
+++ b/vendor/ui_test/src/dependencies.rs
@@ -0,0 +1,183 @@
+use cargo_metadata::{camino::Utf8PathBuf, DependencyKind};
+use cargo_platform::Cfg;
+use color_eyre::eyre::{bail, Result};
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    process::Command,
+    str::FromStr,
+};
+
+use crate::{Config, Mode, OutputConflictHandling};
+
+#[derive(Default, Debug)]
+pub struct Dependencies {
+    /// All paths that must be imported with `-L dependency=`. This is for
+    /// finding proc macros run on the host and dependencies for the target.
+    pub import_paths: Vec<PathBuf>,
+    /// The name as chosen in the `Cargo.toml` and its corresponding rmeta file.
+    pub dependencies: Vec<(String, Vec<Utf8PathBuf>)>,
+}
+
+fn cfgs(config: &Config) -> Result<Vec<Cfg>> {
+    let mut cmd = config.cfgs.build(&config.out_dir);
+    cmd.arg("--target").arg(config.target.as_ref().unwrap());
+    let output = cmd.output()?;
+    let stdout = String::from_utf8(output.stdout)?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8(output.stderr)?;
+        bail!(
+            "failed to obtain `cfg` information from {cmd:?}:\nstderr:\n{stderr}\n\nstdout:{stdout}"
+        );
+    }
+    let mut cfgs = vec![];
+
+    for line in stdout.lines() {
+        cfgs.push(Cfg::from_str(line)?);
+    }
+
+    Ok(cfgs)
+}
+
+/// Compiles dependencies and returns the crate names and corresponding rmeta files.
+pub fn build_dependencies(config: &mut Config) -> Result<Dependencies> {
+    let manifest_path = match &config.dependencies_crate_manifest_path {
+        Some(path) => path.to_owned(),
+        None => return Ok(Default::default()),
+    };
+    let manifest_path = &manifest_path;
+    config.fill_host_and_target()?;
+    eprintln!("   Building test dependencies...");
+    let mut build = config.dependency_builder.build(&config.out_dir);
+    build.arg(manifest_path);
+
+    if let Some(target) = &config.target {
+        build.arg(format!("--target={target}"));
+    }
+
+    // Reusable closure for setting up the environment both for artifact generation and `cargo_metadata`
+    let set_locking = |cmd: &mut Command| match (&config.output_conflict_handling, &config.mode) {
+        (_, Mode::Yolo) => {}
+        (OutputConflictHandling::Error(_), _) => {
+            cmd.arg("--locked");
+        }
+        _ => {}
+    };
+
+    set_locking(&mut build);
+    build.arg("--message-format=json");
+
+    let output = build.output()?;
+
+    if !output.status.success() {
+        let stdout = String::from_utf8(output.stdout)?;
+        let stderr = String::from_utf8(output.stderr)?;
+        bail!("failed to compile dependencies:\ncommand: {build:?}\nstderr:\n{stderr}\n\nstdout:{stdout}");
+    }
+
+    // Collect all artifacts generated
+    let artifact_output = output.stdout;
+    let artifact_output = String::from_utf8(artifact_output)?;
+    let mut import_paths: HashSet<PathBuf> = HashSet::new();
+    let mut artifacts: HashMap<_, _> = artifact_output
+        .lines()
+        .filter_map(|line| {
+            let message = serde_json::from_str::<cargo_metadata::Message>(line).ok()?;
+            if let cargo_metadata::Message::CompilerArtifact(artifact) = message {
+                for filename in &artifact.filenames {
+                    import_paths.insert(filename.parent().unwrap().into());
+                }
+                Some((artifact.package_id, artifact.filenames))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    // Check which crates are mentioned in the crate itself
+    let mut metadata = cargo_metadata::MetadataCommand::new().cargo_command();
+    metadata.arg("--manifest-path").arg(manifest_path);
+    config.dependency_builder.apply_env(&mut metadata);
+    set_locking(&mut metadata);
+    let output = metadata.output()?;
+
+    if !output.status.success() {
+        let stdout = String::from_utf8(output.stdout)?;
+        let stderr = String::from_utf8(output.stderr)?;
+        bail!("failed to run cargo-metadata:\nstderr:\n{stderr}\n\nstdout:{stdout}");
+    }
+
+    let output = output.stdout;
+    let output = String::from_utf8(output)?;
+
+    let cfg = cfgs(config)?;
+
+    for line in output.lines() {
+        if !line.starts_with('{') {
+            continue;
+        }
+        let metadata: cargo_metadata::Metadata = serde_json::from_str(line)?;
+        // Only take artifacts that are defined in the Cargo.toml
+
+        // First, find the root artifact
+        let root = metadata
+            .packages
+            .iter()
+            .find(|package| {
+                package.manifest_path.as_std_path().canonicalize().unwrap()
+                    == manifest_path.canonicalize().unwrap()
+            })
+            .unwrap();
+
+        // Then go over all of its dependencies
+        let dependencies = root
+            .dependencies
+            .iter()
+            .filter(|dep| matches!(dep.kind, DependencyKind::Normal))
+            // Only consider dependencies that are enabled on the current target
+            .filter(|dep| match &dep.target {
+                Some(platform) => platform.matches(config.target.as_ref().unwrap(), &cfg),
+                None => true,
+            })
+            .map(|dep| {
+                let package = metadata
+                    .packages
+                    .iter()
+                    .find(|&p| p.name == dep.name && dep.req.matches(&p.version))
+                    .expect("dependency does not exist");
+                (
+                    package,
+                    dep.rename.clone().unwrap_or_else(|| package.name.clone()),
+                )
+            })
+            // Also expose the root crate
+            .chain(std::iter::once((root, root.name.clone())))
+            .filter_map(|(package, name)| {
+                // Get the id for the package matching the version requirement of the dep
+                let id = &package.id;
+                // Return the name chosen in `Cargo.toml` and the path to the corresponding artifact
+                match artifacts.remove(id) {
+                    Some(artifacts) => Some((name.replace('-', "_"), artifacts)),
+                    None => {
+                        if name == root.name {
+                            // If there are no artifacts, this is the root crate and it is being built as a binary/test
+                            // instead of a library. We simply add no artifacts, meaning you can't depend on functions
+                            // and types declared in the root crate.
+                            None
+                        } else {
+                            panic!("no artifact found for `{name}`(`{id}`):`\n{artifact_output}")
+                        }
+                    }
+                }
+            })
+            .collect();
+        let import_paths = import_paths.into_iter().collect();
+        return Ok(Dependencies {
+            dependencies,
+            import_paths,
+        });
+    }
+
+    bail!("no json found in cargo-metadata output")
+}
diff --git a/vendor/ui_test/src/diff.rs b/vendor/ui_test/src/diff.rs
new file mode 100644
index 000000000..916645dd1
--- /dev/null
+++ b/vendor/ui_test/src/diff.rs
@@ -0,0 +1,175 @@
+use colored::*;
+use diff::{chars, lines, Result, Result::*};
+
+#[derive(Default)]
+struct DiffState<'a> {
+    /// Whether we've already printed something, so we should print starting context, too.
+    print_start_context: bool,
+    /// When we skip lines, remember the last `CONTEXT` ones to
+    /// display after the "skipped N lines" message
+    skipped_lines: Vec<&'a str>,
+    /// When we see a removed line, we don't print it, we
+    /// keep it around to compare it with the next added line.
+    prev_left: Option<&'a str>,
+}
+
+/// How many lines of context are displayed around the actual diffs
+const CONTEXT: usize = 2;
+
+impl<'a> DiffState<'a> {
+    /// Print `... n lines skipped ...` followed by the last `CONTEXT` lines.
+    fn print_end_skip(&self, skipped: usize) {
+        self.print_skipped_msg(skipped);
+        for line in self.skipped_lines.iter().rev().take(CONTEXT).rev() {
+            eprintln!(" {line}");
+        }
+    }
+
+    fn print_skipped_msg(&self, skipped: usize) {
+        match skipped {
+            // When the amount of skipped lines is exactly `CONTEXT * 2`, we already
+            // print all the context and don't actually skip anything.
+            0 => {}
+            // Instead of writing a line saying we skipped one line, print that one line
+            1 => eprintln!(" {}", self.skipped_lines[CONTEXT]),
+            _ => eprintln!("... {skipped} lines skipped ..."),
+        }
+    }
+
+    /// Print an initial `CONTEXT` amount of lines.
+    fn print_start_skip(&self) {
+        for line in self.skipped_lines.iter().take(CONTEXT) {
+            eprintln!(" {line}");
+        }
+    }
+
+    fn print_skip(&mut self) {
+        let half = self.skipped_lines.len() / 2;
+        if !self.print_start_context {
+            self.print_start_context = true;
+            self.print_end_skip(self.skipped_lines.len().saturating_sub(CONTEXT));
+        } else if half < CONTEXT {
+            // Print all the skipped lines if the amount of context desired is less than the amount of lines
+            for line in self.skipped_lines.drain(..) {
+                eprintln!(" {line}");
+            }
+        } else {
+            self.print_start_skip();
+            let skipped = self.skipped_lines.len() - CONTEXT * 2;
+            self.print_end_skip(skipped);
+        }
+        self.skipped_lines.clear();
+    }
+
+    fn skip(&mut self, line: &'a str) {
+        self.skipped_lines.push(line);
+    }
+
+    fn print_prev(&mut self) {
+        if let Some(l) = self.prev_left.take() {
+            self.print_left(l);
+        }
+    }
+
+    fn print_left(&self, l: &str) {
+        eprintln!("{}{}", "-".red(), l.red());
+    }
+
+    fn print_right(&self, r: &str) {
+        eprintln!("{}{}", "+".green(), r.green());
+    }
+
+    fn row(&mut self, row: Result<&'a str>) {
+        match row {
+            Left(l) => {
+                self.print_skip();
+                self.print_prev();
+                self.prev_left = Some(l);
+            }
+            Both(l, _) => {
+                self.print_prev();
+                self.skip(l);
+            }
+            Right(r) => {
+                // When there's an added line after a removed line, we'll want to special case some print cases.
+                // FIXME(oli-obk): also do special printing modes when there are multiple lines that only have minor changes.
+                if let Some(l) = self.prev_left.take() {
+                    let diff = chars(l, r);
+                    let mut seen_l = false;
+                    let mut seen_r = false;
+                    for char in &diff {
+                        match char {
+                            Left(l) if !l.is_whitespace() => seen_l = true,
+                            Right(r) if !r.is_whitespace() => seen_r = true,
+                            _ => {}
+                        }
+                    }
+                    if seen_l && seen_r {
+                        // The line both adds and removes chars, print both lines, but highlight their differences instead of
+                        // drawing the entire line in red/green.
+                        eprint!("{}", "-".red());
+                        for char in &diff {
+                            match *char {
+                                Left(l) => eprint!("{}", l.to_string().red()),
+                                Right(_) => {}
+                                Both(l, _) => eprint!("{l}"),
+                            }
+                        }
+                        eprintln!();
+                        eprint!("{}", "+".green());
+                        for char in diff {
+                            match char {
+                                Left(_) => {}
+                                Right(r) => eprint!("{}", r.to_string().green()),
+                                Both(l, _) => eprint!("{l}"),
+                            }
+                        }
+                        eprintln!();
+                    } else {
+                        // The line only adds or only removes chars, print a single line highlighting their differences.
+                        eprint!("{}", "~".yellow());
+                        for char in diff {
+                            match char {
+                                Left(l) => eprint!("{}", l.to_string().red()),
+                                Both(l, _) => eprint!("{l}"),
+                                Right(r) => eprint!("{}", r.to_string().green()),
+                            }
+                        }
+                        eprintln!();
+                    }
+                } else {
+                    self.print_skip();
+                    self.print_right(r);
+                }
+            }
+        }
+    }
+
+    fn finish(self) {
+        self.print_start_skip();
+        self.print_skipped_msg(self.skipped_lines.len().saturating_sub(CONTEXT));
+        eprintln!()
+    }
+}
+
+pub fn print_diff(expected: &[u8], actual: &[u8]) {
+    let expected_str = String::from_utf8_lossy(expected);
+    let actual_str = String::from_utf8_lossy(actual);
+
+    if expected_str.as_bytes() != expected || actual_str.as_bytes() != actual {
+        eprintln!(
+            "{}",
+            "Non-UTF8 characters in output, diff may be imprecise.".red()
+        );
+    }
+
+    let pat = |c: char| c.is_whitespace() && c != ' ' && c != '\n' && c != '\r';
+    let expected_str = expected_str.replace(pat, "░");
+    let actual_str = actual_str.replace(pat, "░");
+
+    let mut state = DiffState::default();
+    for row in lines(&expected_str, &actual_str) {
+        state.row(row);
+    }
+    state.finish();
+}
diff --git a/vendor/ui_test/src/error.rs b/vendor/ui_test/src/error.rs
new file mode 100644
index 000000000..18ce52ecc
--- /dev/null
+++ b/vendor/ui_test/src/error.rs
@@ -0,0 +1,72 @@
+use crate::{parser::Pattern, rustc_stderr::Message, Mode};
+use std::{path::PathBuf, process::ExitStatus};
+
+/// All the ways in which a test can fail.
+#[derive(Debug)]
+pub enum Error {
+    /// Got an invalid exit status for the given mode.
+    ExitStatus {
+        /// The expected mode.
+        mode: Mode,
+        /// The exit status of the command.
+        status: ExitStatus,
+        /// The expected exit status as set in the file or derived from the mode.
+        expected: i32,
+    },
+    /// A pattern was declared but had no matching error.
+    PatternNotFound {
+        /// The pattern that was missing an error
+        pattern: Pattern,
+        /// The line in which the pattern was defined.
+        definition_line: usize,
+    },
+    /// A ui test checking for failure does not have any failure patterns
+    NoPatternsFound,
+    /// A ui test checking for success has failure patterns
+    PatternFoundInPassTest,
+    /// Stderr/Stdout differed from the `.stderr`/`.stdout` file present.
+    OutputDiffers {
+        /// The file containing the expected output that differs from the actual output.
+        path: PathBuf,
+        /// The output from the command.
+        actual: Vec<u8>,
+        /// The contents of the file.
+        expected: Vec<u8>,
+        /// A command, that when run, causes the output to get blessed instead of erroring.
+        bless_command: String,
+    },
+    /// There were errors that don't have a pattern.
+    ErrorsWithoutPattern {
+        /// The main message of the error.
+        msgs: Vec<Message>,
+        /// File and line information of the error.
+        path: Option<(PathBuf, usize)>,
+    },
+    /// A comment failed to parse.
+    InvalidComment {
+        /// The comment
+        msg: String,
+        /// THe line in which it was defined.
+        line: usize,
+    },
+    /// A subcommand (e.g. rustfix) of a test failed.
+    Command {
+        /// The name of the subcommand (e.g. "rustfix").
+        kind: String,
+        /// The exit status of the command.
+        status: ExitStatus,
+    },
+    /// This catches crashes of ui tests and reports them along the failed test.
+    Bug(String),
+    /// An auxiliary build failed with its own set of errors.
+    Aux {
+        /// Path to the aux file.
+        path: PathBuf,
+        /// The errors that occurred during the build of the aux file.
+        errors: Vec<Error>,
+        /// The line in which the aux file was requested to be built.
+        line: usize,
+    },
+}
+
+pub(crate) type Errors = Vec<Error>;
diff --git a/vendor/ui_test/src/github_actions.rs b/vendor/ui_test/src/github_actions.rs
new file mode 100644
index 000000000..cad9bf569
--- /dev/null
+++ b/vendor/ui_test/src/github_actions.rs
@@ -0,0 +1,94 @@
+//! An interface to github actions workflow commands.
+
+use std::fmt::{Debug, Write};
+
+/// Shows an error message directly in a github diff view on drop.
+pub struct Error {
+    file: String,
+    line: usize,
+    title: String,
+    message: String,
+}
+impl Error {
+    /// Set a line for this error. By default the message is shown at the top of the file.
+    pub fn line(mut self, line: usize) -> Self {
+        self.line = line;
+        self
+    }
+}
+
+/// Create an error to be shown for the given file and with the given title.
+pub fn error(file: impl std::fmt::Display, title: impl Into<String>) -> Error {
+    Error {
+        file: file.to_string(),
+        line: 0,
+        title: title.into(),
+        message: String::new(),
+    }
+}
+
+impl Write for Error {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.message.write_str(s)
+    }
+}
+
+impl Drop for Error {
+    fn drop(&mut self) {
+        if std::env::var_os("GITHUB_ACTION").is_some() {
+            let Error {
+                file,
+                line,
+                title,
+                message,
+            } = self;
+            let message = message.trim();
+            let message = if message.is_empty() {
+                "::no message".into()
+            } else {
+                format!("::{}", github_action_multiline_escape(message))
+            };
+            eprintln!("::error file={file},line={line},title={title}{message}");
+            eprintln!("error file={file},line={line},title={title}{message}");
+        }
+    }
+}
+
+/// Append to the summary file that will be shown for the entire CI run.
+pub fn summary() -> Option<impl std::io::Write> {
+    let path = std::env::var_os("GITHUB_STEP_SUMMARY")?;
+    Some(std::fs::OpenOptions::new().append(true).open(path).unwrap())
+}
+
+fn github_action_multiline_escape(s: &str) -> String {
+    s.replace('%', "%25")
+        .replace('\n', "%0A")
+        .replace('\r', "%0D")
+}
+
+/// All github actions log messages from this call to the Drop of the return value
+/// will be grouped and hidden by default in logs. Note that nesting these does
+/// not really work.
+pub fn group(name: impl std::fmt::Display) -> Group {
+    if std::env::var_os("GITHUB_ACTION").is_some() {
+        eprintln!("::group::{name}");
+    }
+    Group(())
+}
+
+/// A guard that closes the current github actions log group on drop.
+pub struct Group(());
+
+impl Debug for Group {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("a handle that will close the github action group on drop")
+    }
+}
+
+impl Drop for Group {
+    fn drop(&mut self) {
+        if std::env::var_os("GITHUB_ACTION").is_some() {
+            eprintln!("::endgroup::");
+        }
+    }
+}
diff --git a/vendor/ui_test/src/lib.rs b/vendor/ui_test/src/lib.rs
new file mode 100644
index 000000000..7837d0e62
--- /dev/null
+++ b/vendor/ui_test/src/lib.rs
@@ -0,0 +1,1054 @@
+#![allow(
+    clippy::enum_variant_names,
+    clippy::useless_format,
+    clippy::too_many_arguments,
+    rustc::internal
+)]
+#![deny(missing_docs)]
+
+//! A crate to run the Rust compiler (or other binaries) and test their command line output.
+
+use bstr::ByteSlice;
+pub use color_eyre;
+use color_eyre::eyre::{eyre, Result};
+use crossbeam_channel::unbounded;
+use parser::{ErrorMatch, Revisioned};
+use regex::bytes::Regex;
+use rustc_stderr::{Diagnostics, Level, Message};
+use status_emitter::StatusEmitter;
+use std::borrow::Cow;
+use std::collections::{HashSet, VecDeque};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::thread;
+
+use crate::parser::{Comments, Condition};
+
+mod cmd;
+mod config;
+mod dependencies;
+mod diff;
+mod error;
+pub mod github_actions;
+mod mode;
+mod parser;
+mod rustc_stderr;
+pub mod status_emitter;
+#[cfg(test)]
+mod tests;
+
+pub use cmd::*;
+pub use config::*;
+pub use error::*;
+pub use mode::*;
+
+/// A filter's match rule.
+#[derive(Clone, Debug)]
+pub enum Match {
+    /// If the regex matches, the filter applies
+    Regex(Regex),
+    /// If the exact byte sequence is found, the filter applies
+    Exact(Vec<u8>),
+}
+impl Match {
+    fn replace_all<'a>(&self, text: &'a [u8], replacement: &[u8]) -> Cow<'a, [u8]> {
+        match self {
+            Match::Regex(regex) => regex.replace_all(text, replacement),
+            Match::Exact(needle) => text.replace(needle, replacement).into(),
+        }
+    }
+}
+
+impl From<&'_ Path> for Match {
+    fn from(v: &Path) -> Self {
+        let mut v = v.display().to_string();
+        // Normalize away windows canonicalized paths.
+        if v.starts_with(r#"\\?\"#) {
+            v.drain(0..4);
+        }
+        let mut v = v.into_bytes();
+        // Normalize paths on windows to use slashes instead of backslashes,
+        // So that paths are rendered the same on all systems.
+        for c in &mut v {
+            if *c == b'\\' {
+                *c = b'/';
+            }
+        }
+        Self::Exact(v)
+    }
+}
+
+impl From<Regex> for Match {
+    fn from(v: Regex) -> Self {
+        Self::Regex(v)
+    }
+}
+
+/// Replacements to apply to output files.
+pub type Filter = Vec<(Match, &'static [u8])>;
+
+/// Run all tests as described in the config argument.
+pub fn run_tests(config: Config) -> Result<()> {
+    eprintln!("   Compiler: {}", config.program.display());
+
+    let name = config.root_dir.display().to_string();
+
+    run_tests_generic(
+        config,
+        default_file_filter,
+        default_per_file_config,
+        (status_emitter::Text, status_emitter::Gha::<true> { name }),
+    )
+}
+
+/// The filter used by `run_tests` to only run on `.rs` files.
+pub fn default_file_filter(path: &Path) -> bool {
+    path.extension().map(|ext| ext == "rs").unwrap_or(false)
+}
+
+/// The default per-file config used by `run_tests`.
+pub fn default_per_file_config(config: &Config, path: &Path) -> Option<Config> {
+    let mut config = config.clone();
+    // Heuristic:
+    // * if the file contains `#[test]`, automatically pass `--cfg test`.
+    // * if the file does not contain `fn main()` or `#[start]`, automatically pass `--crate-type=lib`.
+    // This avoids having to spam `fn main() {}` in almost every test.
+    let file_contents = std::fs::read(path).unwrap();
+    if file_contents.find(b"#[proc_macro]").is_some()
+        || file_contents.find(b"#[proc_macro_attribute]").is_some()
+        || file_contents.find(b"#[proc_macro_derive]").is_some()
+    {
+        config.program.args.push("--crate-type=proc-macro".into())
+    } else if file_contents.find(b"#[test]").is_some() {
+        config.program.args.push("--test".into());
+    } else if file_contents.find(b"fn main()").is_none()
+        && file_contents.find(b"#[start]").is_none()
+    {
+        config.program.args.push("--crate-type=lib".into());
+    }
+    Some(config)
+}
+
+/// Create a command for running a single file, with the settings from the `config` argument.
+/// Ignores various settings from `Config` that relate to finding test files.
+pub fn test_command(mut config: Config, path: &Path) -> Result<Command> {
+    config.build_dependencies_and_link_them()?;
+
+    let comments =
+        Comments::parse_file(path)?.map_err(|errors| color_eyre::eyre::eyre!("{errors:#?}"))?;
+    let mut errors = vec![];
+    let result = build_command(path, &config, "", &comments, &mut errors);
+    assert!(errors.is_empty(), "{errors:#?}");
+    Ok(result)
+}
+
+#[allow(clippy::large_enum_variant)]
+/// The possible results a single test can have.
+pub enum TestResult {
+    /// The test passed
+    Ok,
+    /// The test was ignored due to a rule (`//@only-*` or `//@ignore-*`)
+    Ignored,
+    /// The test was filtered with the `file_filter` argument.
+    Filtered,
+    /// The test failed.
+    Errored {
+        /// Command that failed
+        command: Command,
+        /// The errors that were encountered.
+        errors: Vec<Error>,
+        /// The full stderr of the test run.
+        stderr: Vec<u8>,
+    },
+}
+
+struct TestRun {
+    result: TestResult,
+    path: PathBuf,
+    revision: String,
+}
+
+/// A version of `run_tests` that allows more fine-grained control over running tests.
+pub fn run_tests_generic(
+    mut config: Config,
+    file_filter: impl Fn(&Path) -> bool + Sync,
+    per_file_config: impl Fn(&Config, &Path) -> Option<Config> + Sync,
+    mut status_emitter: impl StatusEmitter + Send,
+) -> Result<()> {
+    config.fill_host_and_target()?;
+
+    config.build_dependencies_and_link_them()?;
+
+    // A channel for files to process
+    let (submit, receive) = unbounded();
+
+    let mut results = vec![];
+
+    thread::scope(|s| -> Result<()> {
+        // Create a thread that is in charge of walking the directory and submitting jobs.
+        // It closes the channel when it is done.
+        s.spawn(|| {
+            let mut todo = VecDeque::new();
+            todo.push_back(config.root_dir.clone());
+            while let Some(path) = todo.pop_front() {
+                if path.is_dir() {
+                    if path.file_name().unwrap() == "auxiliary" {
+                        continue;
+                    }
+                    // Enqueue everything inside this directory.
+                    // We want it sorted, to have some control over scheduling of slow tests.
+                    let mut entries = std::fs::read_dir(path)
+                        .unwrap()
+                        .collect::<Result<Vec<_>, _>>()
+                        .unwrap();
+                    entries.sort_by_key(|e| e.file_name());
+                    for entry in entries {
+                        todo.push_back(entry.path());
+                    }
+                } else if file_filter(&path) {
+                    // Forward .rs files to the test workers.
+                    submit.send(path).unwrap();
+                }
+            }
+            // There will be no more jobs. This signals the workers to quit.
+            // (This also ensures `submit` is moved into this closure.)
+            drop(submit);
+        });
+
+        // A channel for the messages emitted by the individual test threads.
+        // Used to produce live updates while running the tests.
+        let (finished_files_sender, finished_files_recv) = unbounded::<TestRun>();
+
+        s.spawn(|| {
+            for run in finished_files_recv {
+                status_emitter.test_result(&run.path, &run.revision, &run.result);
+
+                results.push(run);
+            }
+        });
+
+        let mut threads = vec![];
+
+        // Create N worker threads that receive files to test.
+        for _ in 0..config.num_test_threads.get() {
+            let finished_files_sender = finished_files_sender.clone();
+            threads.push(s.spawn(|| -> Result<()> {
+                let finished_files_sender = finished_files_sender;
+                for path in &receive {
+                    let maybe_config;
+                    let config = match per_file_config(&config, &path) {
+                        None => &config,
+                        Some(config) => {
+                            maybe_config = config;
+                            &maybe_config
+                        }
+                    };
+                    let result =
+                        match std::panic::catch_unwind(|| parse_and_test_file(&path, config)) {
+                            Ok(res) => res,
+                            Err(err) => {
+                                finished_files_sender.send(TestRun {
+                                    result: TestResult::Errored {
+                                        command: Command::new("<unknown>"),
+                                        errors: vec![Error::Bug(
+                                            *Box::<dyn std::any::Any + Send + 'static>::downcast::<
+                                                String,
+                                            >(err)
+                                            .unwrap(),
+                                        )],
+                                        stderr: vec![],
+                                    },
+                                    path,
+                                    revision: String::new(),
+                                })?;
+                                continue;
+                            }
+                        };
+                    for result in result {
+                        finished_files_sender.send(result)?;
+                    }
+                }
+                Ok(())
+            }));
+        }
+
+        for thread in threads {
+            thread.join().unwrap()?;
+        }
+        Ok(())
+    })?;
+
+    let mut failures = vec![];
+    let mut succeeded = 0;
+    let mut ignored = 0;
+    let mut filtered = 0;
+
+    for run in results {
+        match run.result {
+            TestResult::Ok => succeeded += 1,
+            TestResult::Ignored => ignored += 1,
+            TestResult::Filtered => filtered += 1,
+            TestResult::Errored {
+                command,
+                errors,
+                stderr,
+            } => failures.push((run.path, command, run.revision, errors, stderr)),
+        }
+    }
+
+    let mut failure_emitter = status_emitter.finalize(failures.len(), succeeded, ignored, filtered);
+    for (path, command, revision, errors, stderr) in &failures {
+        let _guard = status_emitter.failed_test(revision, path, command, stderr);
+        failure_emitter.test_failure(path, revision, errors);
+    }
+
+    if failures.is_empty() {
+        Ok(())
+    } else {
+        Err(eyre!("tests failed"))
+    }
+}
+
+fn parse_and_test_file(path: &Path, config: &Config) -> Vec<TestRun> {
+    let comments = match parse_comments_in_file(path) {
+        Ok(comments) => comments,
+        Err((stderr, errors)) => {
+            return vec![TestRun {
+                result: TestResult::Errored {
+                    command: Command::new("parse comments"),
+                    errors,
+                    stderr,
+                },
+                path: path.into(),
+                revision: "".into(),
+            }]
+        }
+    };
+    // Run the test for all revisions
+    comments
+        .revisions
+        .clone()
+        .unwrap_or_else(|| vec![String::new()])
+        .into_iter()
+        .map(|revision| {
+            // Ignore file if only/ignore rules do (not) apply
+            if !test_file_conditions(&comments, config, &revision) {
+                return TestRun {
+                    result: TestResult::Ignored,
+                    path: path.into(),
+                    revision,
+                };
+            }
+            let (command, errors, stderr) = run_test(path, config, &revision, &comments);
+            let result = if errors.is_empty() {
+                TestResult::Ok
+            } else {
+                TestResult::Errored {
+                    command,
+                    errors,
+                    stderr,
+                }
+            };
+            TestRun {
+                result,
+                revision,
+                path: path.into(),
+            }
+        })
+        .collect()
+}
+
+fn parse_comments_in_file(path: &Path) -> Result<Comments, (Vec<u8>, Vec<Error>)> {
+    match Comments::parse_file(path) {
+        Ok(Ok(comments)) => Ok(comments),
+        Ok(Err(errors)) => Err((vec![], errors)),
+        Err(err) => Err((format!("{err:?}").into(), vec![])),
+    }
+}
+
+fn build_command(
+    path: &Path,
+    config: &Config,
+    revision: &str,
+    comments: &Comments,
+    errors: &mut Vec<Error>,
+) -> Command {
+    let mut cmd = config.program.build(&config.out_dir);
+    cmd.arg(path);
+    if !revision.is_empty() {
+        cmd.arg(format!("--cfg={revision}"));
+    }
+    for arg in comments
+        .for_revision(revision)
+        .flat_map(|r| r.compile_flags.iter())
+    {
+        cmd.arg(arg);
+    }
+    let edition = comments.edition(errors, revision, config);
+    if let Some((edition, _)) = edition {
+        cmd.arg("--edition").arg(edition);
+    }
+    cmd.args(config.trailing_args.iter());
+    cmd.envs(
+        comments
+            .for_revision(revision)
+            .flat_map(|r| r.env_vars.iter())
+            .map(|(k, v)| (k, v)),
+    );
+
+    cmd
+}
+
+fn build_aux(
+    aux_file: &Path,
+    path: &Path,
+    config: &Config,
+    revision: &str,
+    comments: &Comments,
+    kind: &str,
+    aux: &Path,
+    extra_args: &mut Vec<String>,
+) -> std::result::Result<(), (Command, Vec<Error>, Vec<u8>)> {
+    let comments = match parse_comments_in_file(aux_file) {
+        Ok(comments) => comments,
+        Err((msg, mut errors)) => {
+            return Err((
+                build_command(path, config, revision, comments, &mut errors),
+                errors,
+                msg,
+            ))
+        }
+    };
+    assert_eq!(comments.revisions, None);
+
+    let mut config = config.clone();
+
+    // Strip any `crate-type` flags from the args, as we need to set our own,
+    // and they may conflict (e.g. `lib` vs `proc-macro`);
+    let mut prev_was_crate_type = false;
+    config.program.args.retain(|arg| {
+        if prev_was_crate_type {
+            prev_was_crate_type = false;
+            return false;
+        }
+        if arg == "--test" {
+            false
+        } else if arg == "--crate-type" {
+            prev_was_crate_type = true;
+            false
+        } else if let Some(arg) = arg.to_str() {
+            !arg.starts_with("--crate-type=")
+        } else {
+            true
+        }
+    });
+
+    // Put aux builds into a separate directory per test so that
+    // tests running in parallel but building the same aux build don't conflict.
+    // FIXME: put aux builds into the regular build queue.
+    config.out_dir = config.out_dir.join(path.with_extension(""));
+
+    let mut errors = vec![];
+
+    let mut aux_cmd = build_command(aux_file, &config, revision, &comments, &mut errors);
+
+    if !errors.is_empty() {
+        return Err((aux_cmd, errors, vec![]));
+    }
+
+    let current_extra_args =
+        build_aux_files(aux_file, aux_file.parent().unwrap(), &comments, "", &config)?;
+    // Make sure we see our dependencies
+    aux_cmd.args(current_extra_args.iter());
+    // Make sure our dependents also see our dependencies.
+    extra_args.extend(current_extra_args);
+
+    aux_cmd.arg("--crate-type").arg(kind);
+    aux_cmd.arg("--emit=link");
+    let filename = aux.file_stem().unwrap().to_str().unwrap();
+    let output = aux_cmd.output().unwrap();
+    if !output.status.success() {
+        let error = Error::Command {
+            kind: "compilation of aux build failed".to_string(),
+            status: output.status,
+        };
+        return Err((
+            aux_cmd,
+            vec![error],
+            rustc_stderr::process(path, &output.stderr).rendered,
+        ));
+    }
+
+    // Now run the command again to fetch the output filenames
+    aux_cmd.arg("--print").arg("file-names");
+    let output = aux_cmd.output().unwrap();
+    assert!(output.status.success());
+
+    for file in output.stdout.lines() {
+        let file = std::str::from_utf8(file).unwrap();
+        let crate_name = filename.replace('-', "_");
+        let path = config.out_dir.join(file);
+        extra_args.push("--extern".into());
+        extra_args.push(format!("{crate_name}={}", path.display()));
+        // Help cargo find the crates added with `--extern`.
+        extra_args.push("-L".into());
+        extra_args.push(config.out_dir.display().to_string());
+    }
+    Ok(())
+}
+
+fn run_test(
+    path: &Path,
+    config: &Config,
+    revision: &str,
+    comments: &Comments,
+) -> (Command, Errors, Vec<u8>) {
+    let extra_args = match build_aux_files(
+        path,
+        &path.parent().unwrap().join("auxiliary"),
+        comments,
+        revision,
+        config,
+    ) {
+        Ok(value) => value,
+        Err(value) => return value,
+    };
+
+    let mut errors = vec![];
+
+    let mut cmd = build_command(path, config, revision, comments, &mut errors);
+    cmd.args(&extra_args);
+
+    let output = cmd
+        .output()
+        .unwrap_or_else(|err| panic!("could not execute {cmd:?}: {err}"));
+    let mode = config.mode.maybe_override(comments, revision, &mut errors);
+    let status_check = mode.ok(output.status);
+    if status_check.is_empty() && matches!(mode, Mode::Run { .. }) {
+        let cmd = run_test_binary(mode, path, revision, comments, cmd, config, &mut errors);
+        return (cmd, errors, vec![]);
+    }
+    errors.extend(status_check);
+    if output.status.code() == Some(101) && !matches!(config.mode, Mode::Panic | Mode::Yolo) {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        errors.push(Error::Bug(format!(
+            "test panicked: stderr:\n{stderr}\nstdout:\n{stdout}",
+        )));
+        return (cmd, errors, vec![]);
+    }
+    // Always remove annotation comments from stderr.
+    let diagnostics = rustc_stderr::process(path, &output.stderr);
+    let rustfixed = matches!(mode, Mode::Fix).then(|| {
+        run_rustfix(
+            &output.stderr,
+            path,
+            comments,
+            revision,
+            config,
+            extra_args,
+            &mut errors,
+        )
+    });
+    let stderr = check_test_result(
+        path,
+        config,
+        revision,
+        comments,
+        &mut errors,
+        &output.stdout,
+        diagnostics,
+    );
+    if let Some((mut rustfix, rustfix_path)) = rustfixed {
+        // picking the crate name from the file name is problematic when `.revision_name` is inserted
+        rustfix.arg("--crate-name").arg(
+            path.file_stem()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .replace('-', "_"),
+        );
+        let output = rustfix.output().unwrap();
+        if !output.status.success() {
+            errors.push(Error::Command {
+                kind: "rustfix".into(),
+                status: output.status,
+            });
+            return (
+                rustfix,
+                errors,
+                rustc_stderr::process(&rustfix_path, &output.stderr).rendered,
+            );
+        }
+    }
+    (cmd, errors, stderr)
+}
+
+fn build_aux_files(
+    path: &Path,
+    aux_dir: &Path,
+    comments: &Comments,
+    revision: &str,
+    config: &Config,
+) -> Result<Vec<String>, (Command, Vec<Error>, Vec<u8>)> {
+    let mut extra_args = vec![];
+    for rev in comments.for_revision(revision) {
+        for (aux, kind, line) in &rev.aux_builds {
+            let aux_file = if aux.starts_with("..") {
+                aux_dir.parent().unwrap().join(aux)
+            } else {
+                aux_dir.join(aux)
+            };
+            if let Err((command, errors, msg)) = build_aux(
+                &aux_file,
+                path,
+                config,
+                revision,
+                comments,
+                kind,
+                aux,
+                &mut extra_args,
+            ) {
+                return Err((
+                    command,
+                    vec![Error::Aux {
+                        path: aux_file,
+                        errors,
+                        line: *line,
+                    }],
+                    msg,
+                ));
+            }
+        }
+    }
+    Ok(extra_args)
+}
+
+fn run_test_binary(
+    mode: Mode,
+    path: &Path,
+    revision: &str,
+    comments: &Comments,
+    mut cmd: Command,
+    config: &Config,
+    errors: &mut Vec<Error>,
+) -> Command {
+    cmd.arg("--print").arg("file-names");
+    let output = cmd.output().unwrap();
+    assert!(output.status.success());
+
+    let mut files = output.stdout.lines();
+    let file = files.next().unwrap();
+    assert_eq!(files.next(), None);
+    let file = std::str::from_utf8(file).unwrap();
+    let exe = config.out_dir.join(file);
+    let mut exe = Command::new(exe);
+    let output = exe.output().unwrap();
+
+    check_test_output(
+        path,
+        errors,
+        revision,
+        config,
+        comments,
+        &output.stdout,
+        &output.stderr,
+    );
+
+    errors.extend(mode.ok(output.status));
+
+    exe
+}
+
+fn run_rustfix(
+    stderr: &[u8],
+    path: &Path,
+    comments: &Comments,
+    revision: &str,
+    config: &Config,
+    extra_args: Vec<String>,
+    errors: &mut Vec<Error>,
+) -> (Command, PathBuf) {
+    let input = std::str::from_utf8(stderr).unwrap();
+    let suggestions = rustfix::get_suggestions_from_json(
+        input,
+        &HashSet::new(),
+        if let Mode::Yolo = config.mode {
+            rustfix::Filter::Everything
+        } else {
+            rustfix::Filter::MachineApplicableOnly
+        },
+    )
+    .unwrap_or_else(|err| {
+        panic!("could not deserialize diagnostics json for rustfix {err}:{input}")
+    });
+    let fixed_code =
+        rustfix::apply_suggestions(&std::fs::read_to_string(path).unwrap(), &suggestions)
+            .unwrap_or_else(|e| {
+                panic!(
+                    "failed to apply suggestions for {:?} with rustfix: {e}",
+                    path.display()
+                )
+            });
+    let edition = comments.edition(errors, revision, config);
+    let rustfix_comments = Comments {
+        revisions: None,
+        revisioned: std::iter::once((
+            vec![],
+            Revisioned {
+                ignore: vec![],
+                only: vec![],
+                stderr_per_bitwidth: false,
+                compile_flags: comments
+                    .for_revision(revision)
+                    .flat_map(|r| r.compile_flags.iter().cloned())
+                    .collect(),
+                env_vars: comments
+                    .for_revision(revision)
+                    .flat_map(|r| r.env_vars.iter().cloned())
+                    .collect(),
+                normalize_stderr: vec![],
+                error_in_other_files: vec![],
+                error_matches: vec![],
+                require_annotations_for_level: None,
+                aux_builds: comments
+                    .for_revision(revision)
+                    .flat_map(|r| r.aux_builds.iter().cloned())
+                    .collect(),
+                edition,
+                mode: Some((Mode::Pass, 0)),
+                needs_asm_support: false,
+            },
+        ))
+        .collect(),
+    };
+    let path = check_output(
+        fixed_code.as_bytes(),
+        path,
+        errors,
+        revised(revision, "fixed"),
+        &Filter::default(),
+        config,
+        &rustfix_comments,
+        revision,
+    );
+
+    let mut cmd = build_command(&path, config, revision, &rustfix_comments, errors);
+    cmd.args(extra_args);
+    (cmd, path)
+}
+
+fn revised(revision: &str, extension: &str) -> String {
+    if revision.is_empty() {
+        extension.to_string()
+    } else {
+        format!("{revision}.{extension}")
+    }
+}
+
+fn check_test_result(
+    path: &Path,
+    config: &Config,
+    revision: &str,
+    comments: &Comments,
+    errors: &mut Errors,
+    stdout: &[u8],
+    diagnostics: Diagnostics,
+) -> Vec<u8> {
+    check_test_output(
+        path,
+        errors,
+        revision,
+        config,
+        comments,
+        stdout,
+        &diagnostics.rendered,
+    );
+    // Check error annotations in the source against output
+    check_annotations(
+        diagnostics.messages,
+        diagnostics.messages_from_unknown_file_or_line,
+        path,
+        errors,
+        config,
+        revision,
+        comments,
+    );
+    diagnostics.rendered
+}
+
+fn check_test_output(
+    path: &Path,
+    errors: &mut Vec<Error>,
+    revision: &str,
+    config: &Config,
+    comments: &Comments,
+    stdout: &[u8],
+    stderr: &[u8],
+) {
+    // Check output files (if any)
+    // Check output files against actual output
+    check_output(
+        stderr,
+        path,
+        errors,
+        revised(revision, "stderr"),
+        &config.stderr_filters,
+        config,
+        comments,
+        revision,
+    );
+    check_output(
+        stdout,
+        path,
+        errors,
+        revised(revision, "stdout"),
+        &config.stdout_filters,
+        config,
+        comments,
+        revision,
+    );
+}
+
+fn check_annotations(
+    mut messages: Vec<Vec<Message>>,
+    mut messages_from_unknown_file_or_line: Vec<Message>,
+    path: &Path,
+    errors: &mut Errors,
+    config: &Config,
+    revision: &str,
+    comments: &Comments,
+) {
+    let error_patterns = comments
+        .for_revision(revision)
+        .flat_map(|r| r.error_in_other_files.iter());
+
+    let mut seen_error_match = false;
+    for (error_pattern, definition_line) in error_patterns {
+        seen_error_match = true;
+        // first check the diagnostics messages outside of our file. We check this first, so that
+        // you can mix in-file annotations with //@error-in-other-file annotations, even if there is overlap
+        // in the messages.
+        if let Some(i) = messages_from_unknown_file_or_line
+            .iter()
+            .position(|msg| error_pattern.matches(&msg.message))
+        {
+            messages_from_unknown_file_or_line.remove(i);
+        } else {
+            errors.push(Error::PatternNotFound {
+                pattern: error_pattern.clone(),
+                definition_line: *definition_line,
+            });
+        }
+    }
+
+    // The order on `Level` is such that `Error` is the highest level.
+    // We will ensure that *all* diagnostics of level at least `lowest_annotation_level`
+    // are matched.
+    let mut lowest_annotation_level = Level::Error;
+    for &ErrorMatch {
+        ref pattern,
+        definition_line,
+        line,
+        level,
+    } in comments
+        .for_revision(revision)
+        .flat_map(|r| r.error_matches.iter())
+    {
+        seen_error_match = true;
+        // If we found a diagnostic with a level annotation, make sure that all
+        // diagnostics of that level have annotations, even if we don't end up finding a matching diagnostic
+        // for this pattern.
+        lowest_annotation_level = std::cmp::min(lowest_annotation_level, level);
+
+        if let Some(msgs) = messages.get_mut(line) {
+            let found = msgs
+                .iter()
+                .position(|msg| pattern.matches(&msg.message) && msg.level == level);
+            if let Some(found) = found {
+                msgs.remove(found);
+                continue;
+            }
+        }
+
+        errors.push(Error::PatternNotFound {
+            pattern: pattern.clone(),
+            definition_line,
+        });
+    }
+
+    let required_annotation_level = comments
+        .find_one_for_revision(
+            revision,
+            |r| r.require_annotations_for_level,
+            |_| {
+                errors.push(Error::InvalidComment {
+                    msg: "`require_annotations_for_level` specified twice for same revision".into(),
+                    line: 0,
+                })
+            },
+        )
+        .unwrap_or(lowest_annotation_level);
+    let filter = |mut msgs: Vec<Message>| -> Vec<_> {
+        msgs.retain(|msg| msg.level >= required_annotation_level);
+        msgs
+    };
+
+    let mode = config.mode.maybe_override(comments, revision, errors);
+
+    if !matches!(config.mode, Mode::Yolo) {
+        let messages_from_unknown_file_or_line = filter(messages_from_unknown_file_or_line);
+        if !messages_from_unknown_file_or_line.is_empty() {
+            errors.push(Error::ErrorsWithoutPattern {
+                path: None,
+                msgs: messages_from_unknown_file_or_line,
+            });
+        }
+
+        for (line, msgs) in messages.into_iter().enumerate() {
+            let msgs = filter(msgs);
+            if !msgs.is_empty() {
+                errors.push(Error::ErrorsWithoutPattern {
+                    path: Some((path.to_path_buf(), line)),
+                    msgs,
+                });
+            }
+        }
+    }
+
+    match (mode, seen_error_match) {
+        (Mode::Pass, true) | (Mode::Panic, true) => errors.push(Error::PatternFoundInPassTest),
+        (
+            Mode::Fail {
+                require_patterns: true,
+            },
+            false,
+        ) => errors.push(Error::NoPatternsFound),
+        _ => {}
+    }
+}
+
+fn check_output(
+    output: &[u8],
+    path: &Path,
+    errors: &mut Errors,
+    kind: String,
+    filters: &Filter,
+    config: &Config,
+    comments: &Comments,
+    revision: &str,
+) -> PathBuf {
+    let target = config.target.as_ref().unwrap();
+    let output = normalize(path, output, filters, comments, revision);
+    let path = output_path(path, comments, kind, target, revision);
+    match &config.output_conflict_handling {
+        OutputConflictHandling::Bless => {
+            if output.is_empty() {
+                let _ = std::fs::remove_file(&path);
+            } else {
+                std::fs::write(&path, &output).unwrap();
+            }
+        }
+        OutputConflictHandling::Error(bless_command) => {
+            let expected_output = std::fs::read(&path).unwrap_or_default();
+            if output != expected_output {
+                errors.push(Error::OutputDiffers {
+                    path: path.clone(),
+                    actual: output,
+                    expected: expected_output,
+                    bless_command: bless_command.clone(),
+                });
+            }
+        }
+        OutputConflictHandling::Ignore => {}
+    }
+    path
+}
+
+fn output_path(
+    path: &Path,
+    comments: &Comments,
+    kind: String,
+    target: &str,
+    revision: &str,
+) -> PathBuf {
+    if comments
+        .for_revision(revision)
+        .any(|r| r.stderr_per_bitwidth)
+    {
+        return path.with_extension(format!("{}bit.{kind}", get_pointer_width(target)));
+    }
+    path.with_extension(kind)
+}
+
+fn test_condition(condition: &Condition, config: &Config) -> bool {
+    let target = config.target.as_ref().unwrap();
+    match condition {
+        Condition::Bitwidth(bits) => get_pointer_width(target) == *bits,
+        Condition::Target(t) => target.contains(t),
+        Condition::Host(t) => config.host.as_ref().unwrap().contains(t),
+        Condition::OnHost => target == config.host.as_ref().unwrap(),
+    }
+}
+
+/// Returns whether according to the in-file conditions, this file should be run.
+fn test_file_conditions(comments: &Comments, config: &Config, revision: &str) -> bool {
+    if comments
+        .for_revision(revision)
+        .flat_map(|r| r.ignore.iter())
+        .any(|c| test_condition(c, config))
+    {
+        return false;
+    }
+    if comments
+        .for_revision(revision)
+        .any(|r| r.needs_asm_support && !config.has_asm_support())
+    {
+        return false;
+    }
+    comments
+        .for_revision(revision)
+        .flat_map(|r| r.only.iter())
+        .all(|c| test_condition(c, config))
+}
+
+// Taken 1:1 from compiletest-rs
+fn get_pointer_width(triple: &str) -> u8 {
+    if (triple.contains("64") && !triple.ends_with("gnux32") && !triple.ends_with("gnu_ilp32"))
+        || triple.starts_with("s390x")
+    {
+        64
+    } else if triple.starts_with("avr") {
+        16
+    } else {
+        32
+    }
+}
+
+fn normalize(
+    path: &Path,
+    text: &[u8],
+    filters: &Filter,
+    comments: &Comments,
+    revision: &str,
+) -> Vec<u8> {
+    // Useless paths
+    let path_filter = (Match::from(path.parent().unwrap()), b"$DIR" as &[u8]);
+    let filters = filters.iter().chain(std::iter::once(&path_filter));
+    let mut text = text.to_owned();
+    if let Some(lib_path) = option_env!("RUSTC_LIB_PATH") {
+        text = text.replace(lib_path, "RUSTLIB");
+    }
+
+    for (regex, replacement) in filters {
+        text = regex.replace_all(&text, replacement).into_owned();
+    }
+
+    for (from, to) in comments
+        .for_revision(revision)
+        .flat_map(|r| r.normalize_stderr.iter())
+    {
+        text = from.replace_all(&text, to).into_owned();
+    }
+    text
+}
diff --git a/vendor/ui_test/src/mode.rs b/vendor/ui_test/src/mode.rs
new file mode 100644
index 000000000..9c4ce8c60
--- /dev/null
+++ b/vendor/ui_test/src/mode.rs
@@ -0,0 +1,84 @@
+use super::Error;
+use super::Errors;
+use crate::parser::Comments;
+use std::fmt::Display;
+use std::process::ExitStatus;
+
+#[derive(Copy, Clone, Debug)]
+/// Decides what is expected of each test's exit status.
+pub enum Mode {
+    /// The test fails with an error, but passes after running rustfix
+    Fix,
+    /// The test passes a full execution of the rustc driver
+    Pass,
+    /// The test produces an executable binary that can get executed on the host
+    Run {
+        /// The expected exit code
+        exit_code: i32,
+    },
+    /// The rustc driver panicked
+    Panic,
+    /// The rustc driver emitted an error
+    Fail {
+        /// Whether failing tests must have error patterns. Set to false if you just care about .stderr output.
+        require_patterns: bool,
+    },
+    /// Run the tests, but always pass them as long as all annotations are satisfied and stderr files match.
+    Yolo,
+}
+
+impl Mode {
+    pub(crate) fn ok(self, status: ExitStatus) -> Errors {
+        let expected = match self {
+            Mode::Run { exit_code } => exit_code,
+            Mode::Pass => 0,
+            Mode::Panic => 101,
+            Mode::Fail { .. } => 1,
+            Mode::Fix | Mode::Yolo => return vec![],
+        };
+        if status.code() == Some(expected) {
+            vec![]
+        } else {
+            vec![Error::ExitStatus {
+                mode: self,
+                status,
+                expected,
+            }]
+        }
+    }
+    pub(crate) fn maybe_override(
+        self,
+        comments: &Comments,
+        revision: &str,
+        errors: &mut Vec<Error>,
+    ) -> Self {
+        comments
+            .find_one_for_revision(
+                revision,
+                |r| r.mode.as_ref(),
+                |&(_, line)| {
+                    errors.push(Error::InvalidComment {
+                        msg: "multiple mode changes found".into(),
+                        line,
+                    })
+                },
+            )
+            .map(|&(mode, _)| mode)
+            .unwrap_or(self)
+    }
+}
+
+impl Display for Mode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Mode::Run { exit_code } => write!(f, "run({exit_code})"),
+            Mode::Pass => write!(f, "pass"),
+            Mode::Panic => write!(f, "panic"),
+            Mode::Fail {
+                require_patterns: _,
+            } => write!(f, "fail"),
+            Mode::Yolo => write!(f, "yolo"),
+            Mode::Fix => write!(f, "fix"),
+        }
+    }
+}
diff --git a/vendor/ui_test/src/parser.rs b/vendor/ui_test/src/parser.rs
new file mode 100644
index 000000000..d2b510e1b
--- /dev/null
+++ b/vendor/ui_test/src/parser.rs
@@ -0,0 +1,648 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use bstr::{ByteSlice, Utf8Error};
+use regex::bytes::Regex;
+
+use crate::{rustc_stderr::Level, Error, Mode};
+
+use color_eyre::eyre::{Context, Result};
+
+#[cfg(test)]
+mod tests;
+
+/// This crate supports various magic comments that get parsed as file-specific
+/// configuration values. This struct parses them all in one go and then they
+/// get processed by their respective use sites.
+#[derive(Default, Debug)]
+pub(crate) struct Comments {
+    /// List of revision names to execute. Can only be speicified once
+    pub revisions: Option<Vec<String>>,
+    /// Comments that are only available under specific revisions.
+    /// The defaults are in key `vec![]`
+    pub revisioned: HashMap<Vec<String>, Revisioned>,
+}
+
+impl Comments {
+    /// Check that a comment isn't specified twice across multiple differently revisioned statements.
+    /// e.g. `//@[foo, bar] error-in-other-file: bop` and `//@[foo, baz] error-in-other-file boop` would end up
+    /// specifying two error patterns that are available in revision `foo`.
+    pub fn find_one_for_revision<'a, T: 'a>(
+        &'a self,
+        revision: &'a str,
+        f: impl Fn(&'a Revisioned) -> Option<T>,
+        error: impl FnOnce(T),
+    ) -> Option<T> {
+        let mut rev = self.for_revision(revision).filter_map(f);
+        let result = rev.next();
+        if let Some(next) = rev.next() {
+            error(next);
+        }
+        result
+    }
+
+    /// Returns an iterator over all revisioned comments that match the revision.
+    pub fn for_revision<'a>(&'a self, revision: &'a str) -> impl Iterator<Item = &'a Revisioned> {
+        self.revisioned.iter().filter_map(move |(k, v)| {
+            if k.is_empty() || k.iter().any(|rev| rev == revision) {
+                Some(v)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub(crate) fn edition(
+        &self,
+        errors: &mut Vec<Error>,
+        revision: &str,
+        config: &crate::Config,
+    ) -> Option<(String, usize)> {
+        self.find_one_for_revision(
+            revision,
+            |r| r.edition.as_ref(),
+            |&(_, line)| {
+                errors.push(Error::InvalidComment {
+                    msg: "`edition` specified twice".into(),
+                    line,
+                })
+            },
+        )
+        .cloned()
+        .or(config.edition.clone().map(|e| (e, 0)))
+    }
+}
+
+#[derive(Default, Debug)]
+/// Comments that can be filtered for specific revisions.
+pub(crate) struct Revisioned {
+    /// Don't run this test if any of these filters apply
+    pub ignore: Vec<Condition>,
+    /// Only run this test if all of these filters apply
+    pub only: Vec<Condition>,
+    /// Generate one .stderr file per bit width, by prepending with `.64bit` and similar
+    pub stderr_per_bitwidth: bool,
+    /// Additional flags to pass to the executable
+    pub compile_flags: Vec<String>,
+    /// Additional env vars to set for the executable
+    pub env_vars: Vec<(String, String)>,
+    /// Normalizations to apply to the stderr output before emitting it to disk
+    pub normalize_stderr: Vec<(Regex, Vec<u8>)>,
+    /// Arbitrary patterns to look for in the stderr.
+    /// The error must be from another file, as errors from the current file must be
+    /// checked via `error_matches`.
+    pub error_in_other_files: Vec<(Pattern, usize)>,
+    pub error_matches: Vec<ErrorMatch>,
+    /// Ignore diagnostics below this level.
+    /// `None` means pick the lowest level from the `error_pattern`s.
+    pub require_annotations_for_level: Option<Level>,
+    pub aux_builds: Vec<(PathBuf, String, usize)>,
+    pub edition: Option<(String, usize)>,
+    /// Overwrites the mode from `Config`.
+    pub mode: Option<(Mode, usize)>,
+    pub needs_asm_support: bool,
+}
+
+#[derive(Debug)]
+struct CommentParser<T> {
+    /// The comments being built.
+    comments: T,
+    /// Any errors that ocurred during comment parsing.
+    errors: Vec<Error>,
+    /// The line currently being parsed.
+    line: usize,
+}
+
+impl<T> std::ops::Deref for CommentParser<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.comments
+    }
+}
+
+impl<T> std::ops::DerefMut for CommentParser<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.comments
+    }
+}
+
+/// The conditions used for "ignore" and "only" filters.
+#[derive(Debug)]
+pub(crate) enum Condition {
+    /// The given string must appear in the host triple.
+    Host(String),
+    /// The given string must appear in the target triple.
+    Target(String),
+    /// Tests that the bitwidth is the given one.
+    Bitwidth(u8),
+    /// Tests that the target is the host.
+    OnHost,
+}
+
+#[derive(Debug, Clone)]
+/// An error pattern parsed from a `//~` comment.
+pub enum Pattern {
+    SubString(String),
+    Regex(Regex),
+}
+
+#[derive(Debug)]
+pub(crate) struct ErrorMatch {
+    pub pattern: Pattern,
+    pub level: Level,
+    /// The line where the message was defined, for reporting issues with it (e.g. in case it wasn't found).
+    pub definition_line: usize,
+    /// The line this pattern is expecting to find a message in.
+    pub line: usize,
+}
+
+impl Condition {
+    fn parse(c: &str) -> std::result::Result<Self, String> {
+        if c == "on-host" {
+            Ok(Condition::OnHost)
+        } else if let Some(bits) = c.strip_suffix("bit") {
+            let bits: u8 = bits.parse().map_err(|_err| {
+                format!("invalid ignore/only filter ending in 'bit': {c:?} is not a valid bitwdith")
+            })?;
+            Ok(Condition::Bitwidth(bits))
+        } else if let Some(triple_substr) = c.strip_prefix("target-") {
+            Ok(Condition::Target(triple_substr.to_owned()))
+        } else if let Some(triple_substr) = c.strip_prefix("host-") {
+            Ok(Condition::Host(triple_substr.to_owned()))
+        } else {
+            Err(format!(
+                "`{c}` is not a valid condition, expected `on-host`, /[0-9]+bit/, /host-.*/, or /target-.*/"
+            ))
+        }
+    }
+}
+
+impl Comments {
+    pub(crate) fn parse_file(path: &Path) -> Result<std::result::Result<Self, Vec<Error>>> {
+        let content =
+            std::fs::read(path).wrap_err_with(|| format!("failed to read {}", path.display()))?;
+        Ok(Self::parse(&content))
+    }
+
+    /// Parse comments in `content`.
+    /// `path` is only used to emit diagnostics if parsing fails.
+    pub(crate) fn parse(
+        content: &(impl AsRef<[u8]> + ?Sized),
+    ) -> std::result::Result<Self, Vec<Error>> {
+        let mut parser = CommentParser {
+            comments: Comments::default(),
+            errors: vec![],
+            line: 0,
+        };
+
+        let mut fallthrough_to = None; // The line that a `|` will refer to.
+        for (l, line) in content.as_ref().lines().enumerate() {
+            let l = l + 1; // enumerate starts at 0, but line numbers start at 1
+            parser.line = l;
+            match parser.parse_checked_line(&mut fallthrough_to, line) {
+                Ok(()) => {}
+                Err(e) => parser.errors.push(Error::InvalidComment {
+                    msg: format!("Comment is not utf8: {e:?}"),
+                    line: l,
+                }),
+            }
+        }
+        if parser.errors.is_empty() {
+            Ok(parser.comments)
+        } else {
+            Err(parser.errors)
+        }
+    }
+}
+
+impl CommentParser<Comments> {
+    fn parse_checked_line(
+        &mut self,
+        fallthrough_to: &mut Option<usize>,
+        line: &[u8],
+    ) -> std::result::Result<(), Utf8Error> {
+        if let Some(command) = line.strip_prefix(b"//@") {
+            self.parse_command(command.trim().to_str()?)
+        } else if let Some((_, pattern)) = line.split_once_str("//~") {
+            let (revisions, pattern) = self.parse_revisions(pattern.to_str()?);
+            self.revisioned(revisions, |this| {
+                this.parse_pattern(pattern, fallthrough_to)
+            })
+        } else {
+            *fallthrough_to = None;
+            for pos in line.find_iter("//") {
+                let rest = &line[pos + 2..];
+                for rest in std::iter::once(rest).chain(rest.strip_prefix(b" ")) {
+                    if let Some('@' | '~' | '[' | ']' | '^' | '|') = rest.chars().next() {
+                        self.errors.push(Error::InvalidComment {
+                            msg: format!(
+                                "comment looks suspiciously like a test suite command: `{}`\n\
+                             All `//@` test suite commands must be at the start of the line.\n\
+                             The `//` must be directly followed by `@` or `~`.",
+                                rest.to_str()?,
+                            ),
+                            line: self.line,
+                        })
+                    } else {
+                        let mut parser = Self {
+                            line: 0,
+                            errors: vec![],
+                            comments: Comments::default(),
+                        };
+                        parser.parse_command(rest.to_str()?);
+                        if parser.errors.is_empty() {
+                            self.errors.push(Error::InvalidComment {
+                                msg: "a compiletest-rs style comment was detected.\n\
+                                Please use text that could not also be interpreted as a command,\n\
+                                and prefix all actual commands with `//@`"
+                                    .into(),
+                                line: self.line,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl<CommentsType> CommentParser<CommentsType> {
+    fn error(&mut self, s: impl Into<String>) {
+        self.errors.push(Error::InvalidComment {
+            msg: s.into(),
+            line: self.line,
+        });
+    }
+
+    fn check(&mut self, cond: bool, s: impl Into<String>) {
+        if !cond {
+            self.error(s);
+        }
+    }
+
+    fn check_some<T>(&mut self, opt: Option<T>, s: impl Into<String>) -> Option<T> {
+        self.check(opt.is_some(), s);
+        opt
+    }
+}
+
+impl CommentParser<Comments> {
+    fn parse_command(&mut self, command: &str) {
+        let (revisions, command) = self.parse_revisions(command);
+
+        // Commands are letters or dashes, grab everything until the first character that is neither of those.
+        let (command, args) = match command
+            .char_indices()
+            .find_map(|(i, c)| (!c.is_alphanumeric() && c != '-' && c != '_').then_some(i))
+        {
+            None => (command, ""),
+            Some(i) => {
+                let (command, args) = command.split_at(i);
+                let mut args = args.chars();
+                // Commands are separated from their arguments by ':' or ' '
+                let next = args
+                    .next()
+                    .expect("the `position` above guarantees that there is at least one char");
+                self.check(
+                    next == ':',
+                    "test command must be followed by `:` (or end the line)",
+                );
+                (command, args.as_str().trim())
+            }
+        };
+
+        if command == "revisions" {
+            self.check(
+                revisions.is_empty(),
+                "revisions cannot be declared under a revision",
+            );
+            self.check(self.revisions.is_none(), "cannot specify `revisions` twice");
+            self.revisions = Some(args.split_whitespace().map(|s| s.to_string()).collect());
+            return;
+        }
+        self.revisioned(revisions, |this| this.parse_command(command, args));
+    }
+
+    fn revisioned(
+        &mut self,
+        revisions: Vec<String>,
+        f: impl FnOnce(&mut CommentParser<&mut Revisioned>),
+    ) {
+        let mut this = CommentParser {
+            errors: std::mem::take(&mut self.errors),
+            line: self.line,
+            comments: self.revisioned.entry(revisions).or_default(),
+        };
+        f(&mut this);
+        self.errors = this.errors;
+    }
+}
+
+impl CommentParser<&mut Revisioned> {
+    fn parse_command(&mut self, command: &str, args: &str) {
+        match command {
+            "compile-flags" => {
+                self.compile_flags
+                    .extend(args.split_whitespace().map(|s| s.to_string()));
+            }
+            "rustc-env" => {
+                for env in args.split_whitespace() {
+                    if let Some((k, v)) = self.check_some(
+                        env.split_once('='),
+                        "environment variables must be key/value pairs separated by a `=`",
+                    ) {
+                        self.env_vars.push((k.to_string(), v.to_string()));
+                    }
+                }
+            }
+            "normalize-stderr-test" => {
+                let (from, rest) = self.parse_str(args);
+
+                let to = match rest.strip_prefix("->") {
+                    Some(v) => v,
+                    None => {
+                        self.error("normalize-stderr-test needs a pattern and replacement separated by `->`");
+                        return;
+                    },
+                }.trim_start();
+                let (to, rest) = self.parse_str(to);
+
+                self.check(
+                    rest.is_empty(),
+                    format!("trailing text after pattern replacement: {rest}"),
+                );
+
+                if let Some(regex) = self.parse_regex(from) {
+                    self.normalize_stderr
+                        .push((regex, to.as_bytes().to_owned()))
+                }
+            }
+            "error-pattern" => {
+                self.error("`error-pattern` has been renamed to `error-in-other-file`");
+            }
+            "error-in-other-file" => {
+                let pat = self.parse_error_pattern(args.trim());
+                let line = self.line;
+                self.error_in_other_files.push((pat, line));
+            }
+            "stderr-per-bitwidth" => {
+                // args are ignored (can be used as comment)
+                self.check(
+                    !self.stderr_per_bitwidth,
+                    "cannot specify `stderr-per-bitwidth` twice",
+                );
+                self.stderr_per_bitwidth = true;
+            }
+            "run-rustfix" => {
+                // args are ignored (can be used as comment)
+                self.check(
+                    self.mode.is_none(),
+                    "cannot specify test mode changes twice",
+                );
+                self.mode = Some((Mode::Fix, self.line))
+            }
+            "needs-asm-support" => {
+                // args are ignored (can be used as comment)
+                self.check(
+                    !self.needs_asm_support,
+                    "cannot specify `needs-asm-support` twice",
+                );
+                self.needs_asm_support = true;
+            }
+            "aux-build" => {
+                let (name, kind) = args.split_once(':').unwrap_or((args, "lib"));
+                let line = self.line;
+                self.aux_builds.push((name.into(), kind.into(), line));
+            }
+            "edition" => {
+                self.check(self.edition.is_none(), "cannot specify `edition` twice");
+                self.edition = Some((args.into(), self.line))
+            }
+            "check-pass" => {
+                // args are ignored (can be used as comment)
+                self.check(
+                    self.mode.is_none(),
+                    "cannot specify test mode changes twice",
+                );
+                self.mode = Some((Mode::Pass, self.line))
+            }
+            "run" => {
+                self.check(
+                    self.mode.is_none(),
+                    "cannot specify test mode changes twice",
+                );
+                let mut set = |exit_code| self.mode = Some((Mode::Run { exit_code }, self.line));
+                if args.is_empty() {
+                    set(0);
+                } else {
+                    match args.parse() {
+                        Ok(exit_code) => set(exit_code),
+                        Err(err) => self.error(err.to_string()),
+                    }
+                }
+            }
+            "require-annotations-for-level" => {
+                self.check(
+                    self.require_annotations_for_level.is_none(),
+                    "cannot specify `require-annotations-for-level` twice",
+                );
+                match args.trim().parse() {
+                    Ok(it) => self.require_annotations_for_level = Some(it),
+                    Err(msg) => self.error(msg),
+                }
+            }
+            command => {
+                if let Some(s) = command.strip_prefix("ignore-") {
+                    // args are ignored (can be used as comment)
+                    match Condition::parse(s) {
+                        Ok(cond) => self.ignore.push(cond),
+                        Err(msg) => self.error(msg),
+                    }
+                    return;
+                }
+
+                if let Some(s) = command.strip_prefix("only-") {
+                    // args are ignored (can be used as comment)
+                    match Condition::parse(s) {
+                        Ok(cond) => self.only.push(cond),
+                        Err(msg) => self.error(msg),
+                    }
+                    return;
+                }
+                self.error(format!("unknown command `{command}`"));
+            }
+        }
+    }
+}
+
+impl<CommentsType> CommentParser<CommentsType> {
+    fn parse_regex(&mut self, regex: &str) -> Option<Regex> {
+        match Regex::new(regex) {
+            Ok(regex) => Some(regex),
+            Err(err) => {
+                self.error(format!("invalid regex: {err:?}"));
+                None
+            }
+        }
+    }
+
+    /// Parses a string literal. `s` has to start with `"`; everything until the next `"` is
+    /// returned in the first component. `\` can be used to escape arbitrary character.
+    /// Second return component is the rest of the string with leading whitespace removed.
+    fn parse_str<'a>(&mut self, s: &'a str) -> (&'a str, &'a str) {
+        let mut chars = s.char_indices();
+        match chars.next() {
+            Some((_, '"')) => {
+                let s = chars.as_str();
+                let mut escaped = false;
+                for (i, c) in chars {
+                    if escaped {
+                        // Accept any character as literal after a `\`.
+                        escaped = false;
+                    } else if c == '"' {
+                        return (&s[..(i - 1)], s[i..].trim_start());
+                    } else {
+                        escaped = c == '\\';
+                    }
+                }
+                self.error(format!("no closing quotes found for {s}"));
+                (s, "")
+            }
+            Some((_, c)) => {
+                self.error(format!("expected `\"`, got `{c}`"));
+                (s, "")
+            }
+            None => {
+                self.error("expected quoted string, but found end of line");
+                (s, "")
+            }
+        }
+    }
+
+    // parse something like \[[a-z]+(,[a-z]+)*\]
+    fn parse_revisions<'a>(&mut self, pattern: &'a str) -> (Vec<String>, &'a str) {
+        match pattern.chars().next() {
+            Some('[') => {
+                // revisions
+                let s = &pattern[1..];
+                let end = s.char_indices().find_map(|(i, c)| match c {
+                    ']' => Some(i),
+                    _ => None,
+                });
+                let Some(end) = end else {
+                    self.error("`[` without corresponding `]`");
+                    return (vec![], pattern);
+                };
+                let (revision, pattern) = s.split_at(end);
+                (
+                    revision.split(',').map(|s| s.trim().to_string()).collect(),
+                    // 1.. because `split_at` includes the separator
+                    pattern[1..].trim_start(),
+                )
+            }
+            _ => (vec![], pattern),
+        }
+    }
+}
+
+impl CommentParser<&mut Revisioned> {
+    // parse something like (\[[a-z]+(,[a-z]+)*\])?(?P<offset>\||[\^]+)? *(?P<level>ERROR|HELP|WARN|NOTE): (?P<text>.*)
+    fn parse_pattern(&mut self, pattern: &str, fallthrough_to: &mut Option<usize>) {
+        let (match_line, pattern) = match pattern.chars().next() {
+            Some('|') => (
+                match fallthrough_to {
+                    Some(fallthrough) => *fallthrough,
+                    None => {
+                        self.error("`//~|` pattern without preceding line");
+                        return;
+                    }
+                },
+                &pattern[1..],
+            ),
+            Some('^') => {
+                let offset = pattern.chars().take_while(|&c| c == '^').count();
+                (self.line - offset, &pattern[offset..])
+            }
+            Some(_) => (self.line, pattern),
+            None => {
+                self.error("no pattern specified");
+                return;
+            }
+        };
+
+        let pattern = pattern.trim_start();
+        let offset = match pattern.chars().position(|c| !c.is_ascii_alphabetic()) {
+            Some(offset) => offset,
+            None => {
+                self.error("pattern without level");
+                return;
+            }
+        };
+
+        let level = match pattern[..offset].parse() {
+            Ok(level) => level,
+            Err(msg) => {
+                self.error(msg);
+                return;
+            }
+        };
+        let pattern = &pattern[offset..];
+        let pattern = match pattern.strip_prefix(':') {
+            Some(offset) => offset,
+            None => {
+                self.error("no `:` after level found");
+                return;
+            }
+        };
+
+        let pattern = pattern.trim();
+
+        self.check(!pattern.is_empty(), "no pattern specified");
+
+        let pattern = self.parse_error_pattern(pattern);
+
+        *fallthrough_to = Some(match_line);
+
+        let definition_line = self.line;
+        self.error_matches.push(ErrorMatch {
+            pattern,
+            level,
+            definition_line,
+            line: match_line,
+        });
+    }
+}
+
+impl Pattern {
+    pub(crate) fn matches(&self, message: &str) -> bool {
+        match self {
+            Pattern::SubString(s) => message.contains(s),
+            Pattern::Regex(r) => r.is_match(message.as_bytes()),
+        }
+    }
+}
+
+impl<CommentsType> CommentParser<CommentsType> {
+    fn parse_error_pattern(&mut self, pattern: &str) -> Pattern {
+        if let Some(regex) = pattern.strip_prefix('/') {
+            match regex.strip_suffix('/') {
+                Some(regex) => match self.parse_regex(regex) {
+                    Some(regex) => Pattern::Regex(regex),
+                    None => Pattern::SubString(pattern.to_string()),
+                },
+                None => {
+                    self.error(
+                        "expected regex pattern due to leading `/`, but found no closing `/`",
+                    );
+                    Pattern::SubString(pattern.to_string())
+                }
+            }
+        } else {
+            Pattern::SubString(pattern.to_string())
+        }
+    }
+}
diff --git a/vendor/ui_test/src/parser/tests.rs b/vendor/ui_test/src/parser/tests.rs
new file mode 100644
index 000000000..1263d28ce
--- /dev/null
+++ b/vendor/ui_test/src/parser/tests.rs
@@ -0,0 +1,137 @@
+use crate::{
+    parser::{Condition, Pattern},
+    Error,
+};
+
+use super::Comments;
+
+#[test]
+fn parse_simple_comment() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address $HEX is unallocated)
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    println!("parsed comments: {:#?}", comments);
+    assert_eq!(comments.revisioned.len(), 1);
+    let revisioned = &comments.revisioned[&vec![]];
+    assert_eq!(revisioned.error_matches[0].definition_line, 5);
+    match &revisioned.error_matches[0].pattern {
+        Pattern::SubString(s) => {
+            assert_eq!(
+                s,
+                "encountered a dangling reference (address $HEX is unallocated)"
+            )
+        }
+        other => panic!("expected substring, got {other:?}"),
+    }
+}
+
+#[test]
+fn parse_missing_level() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ encountered a dangling reference (address $HEX is unallocated)
+}
+    ";
+    let errors = Comments::parse(s).unwrap_err();
+    println!("parsed comments: {:#?}", errors);
+    assert_eq!(errors.len(), 1);
+    match &errors[0] {
+        Error::InvalidComment { msg, line: 5 } => assert_eq!(msg, "unknown level `encountered`"),
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn parse_slash_slash_at() {
+    let s = r"
+//@  error-in-other-file:  foomp
+use std::mem;
+
+    ";
+    let comments = Comments::parse(s).unwrap();
+    println!("parsed comments: {:#?}", comments);
+    assert_eq!(comments.revisioned.len(), 1);
+    let revisioned = &comments.revisioned[&vec![]];
+    let pat = &revisioned.error_in_other_files[0];
+    assert_eq!(format!("{:?}", pat.0), r#"SubString("foomp")"#);
+    assert_eq!(pat.1, 2);
+}
+
+#[test]
+fn parse_regex_error_pattern() {
+    let s = r"
+//@  error-in-other-file:  /foomp/
+use std::mem;
+
+    ";
+    let comments = Comments::parse(s).unwrap();
+    println!("parsed comments: {:#?}", comments);
+    assert_eq!(comments.revisioned.len(), 1);
+    let revisioned = &comments.revisioned[&vec![]];
+    let pat = &revisioned.error_in_other_files[0];
+    assert_eq!(format!("{:?}", pat.0), r#"Regex(foomp)"#);
+    assert_eq!(pat.1, 2);
+}
+
+#[test]
+fn parse_slash_slash_at_fail() {
+    let s = r"
+//@  error-patttern  foomp
+use std::mem;
+
+    ";
+    let errors = Comments::parse(s).unwrap_err();
+    println!("parsed comments: {:#?}", errors);
+    assert_eq!(errors.len(), 2);
+    match &errors[0] {
+        Error::InvalidComment { msg, line: 2 } => {
+            assert!(msg.contains("must be followed by `:`"))
+        }
+        _ => unreachable!(),
+    }
+    match &errors[1] {
+        Error::InvalidComment { msg, line: 2 } => {
+            assert_eq!(msg, "unknown command `error-patttern`");
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn missing_colon_fail() {
+    let s = r"
+//@stderr-per-bitwidth hello
+use std::mem;
+
+    ";
+    let errors = Comments::parse(s).unwrap_err();
+    println!("parsed comments: {:#?}", errors);
+    assert_eq!(errors.len(), 1);
+    match &errors[0] {
+        Error::InvalidComment { msg, line: 2 } => {
+            assert!(msg.contains("must be followed by `:`"))
+        }
+        _ => unreachable!(),
+    }
+}
+
+#[test]
+fn parse_x86_64() {
+    let s = r"//@ only-target-x86_64-unknown-linux";
+    let comments = Comments::parse(s).unwrap();
+    println!("parsed comments: {:#?}", comments);
+    assert_eq!(comments.revisioned.len(), 1);
+    let revisioned = &comments.revisioned[&vec![]];
+    assert_eq!(revisioned.only.len(), 1);
+    match &revisioned.only[0] {
+        Condition::Target(t) => assert_eq!(t, "x86_64-unknown-linux"),
+        _ => unreachable!(),
+    }
+}
diff --git a/vendor/ui_test/src/rustc_stderr.rs b/vendor/ui_test/src/rustc_stderr.rs
new file mode 100644
index 000000000..64e5928c5
--- /dev/null
+++ b/vendor/ui_test/src/rustc_stderr.rs
@@ -0,0 +1,160 @@
+use std::path::{Path, PathBuf};
+
+use bstr::ByteSlice;
+use regex::Regex;
+
+#[derive(serde::Deserialize, Debug)]
+struct RustcMessage {
+    rendered: Option<String>,
+    spans: Vec<Span>,
+    level: String,
+    message: String,
+    children: Vec<RustcMessage>,
+}
+
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub(crate) enum Level {
+    Ice = 5,
+    Error = 4,
+    Warn = 3,
+    Help = 2,
+    Note = 1,
+    /// Only used for "For more information about this error, try `rustc --explain EXXXX`".
+    FailureNote = 0,
+}
+
+#[derive(Debug)]
+/// A diagnostic message.
+pub struct Message {
+    pub(crate) level: Level,
+    pub(crate) message: String,
+}
+
+/// Information about macro expansion.
+#[derive(serde::Deserialize, Debug)]
+struct Expansion {
+    span: Span,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct Span {
+    line_start: usize,
+    file_name: PathBuf,
+    is_primary: bool,
+    expansion: Option<Box<Expansion>>,
+}
+
+impl std::str::FromStr for Level {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "ERROR" | "error" => Ok(Self::Error),
+            "WARN" | "warning" => Ok(Self::Warn),
+            "HELP" | "help" => Ok(Self::Help),
+            "NOTE" | "note" => Ok(Self::Note),
+            "failure-note" => Ok(Self::FailureNote),
+            "error: internal compiler error" => Ok(Self::Ice),
+            _ => Err(format!("unknown level `{s}`")),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Diagnostics {
+    /// Rendered and concatenated version of all diagnostics.
+    /// This is equivalent to non-json diagnostics.
+    pub rendered: Vec<u8>,
+    /// Per line, a list of messages for that line.
+    pub messages: Vec<Vec<Message>>,
+    /// Messages not on any line (usually because they are from libstd)
+    pub messages_from_unknown_file_or_line: Vec<Message>,
+}
+
+impl RustcMessage {
+    fn line(&self, file: &Path) -> Option<usize> {
+        let span = |primary| self.spans.iter().find_map(|span| span.line(file, primary));
+        span(true).or_else(|| span(false))
+    }
+
+    /// Put the message and its children into the line-indexed list.
+    fn insert_recursive(
+        self,
+        file: &Path,
+        messages: &mut Vec<Vec<Message>>,
+        messages_from_unknown_file_or_line: &mut Vec<Message>,
+        line: Option<usize>,
+    ) {
+        let line = self.line(file).or(line);
+        let msg = Message {
+            level: self.level.parse().unwrap(),
+            message: self.message,
+        };
+        if let Some(line) = line {
+            if messages.len() <= line {
+                messages.resize_with(line + 1, Vec::new);
+            }
+            messages[line].push(msg);
+        // All other messages go into the general bin, unless they are specifically of the
+        // "aborting due to X previous errors" variety, as we never want to match those. They
+        // only count the number of errors and provide no useful information about the tests.
+        } else if !(msg.message.starts_with("aborting due to")
+            && msg.message.contains("previous error"))
+        {
+            messages_from_unknown_file_or_line.push(msg);
+        }
+        for child in self.children {
+            child.insert_recursive(file, messages, messages_from_unknown_file_or_line, line)
+        }
+    }
+}
+
+impl Span {
+    /// Returns the most expanded line number *in the given file*, if possible.
+    fn line(&self, file: &Path, primary: bool) -> Option<usize> {
+        if let Some(exp) = &self.expansion {
+            if let Some(line) = exp.span.line(file, primary && !self.is_primary) {
+                return Some(line);
+            }
+        }
+        ((!primary || self.is_primary) && self.file_name == file).then_some(self.line_start)
+    }
+}
+
+pub(crate) fn filter_annotations_from_rendered(rendered: &str) -> std::borrow::Cow<'_, str> {
+    let annotations = Regex::new(r" *//(\[[a-z,]+\])?~.*").unwrap();
+    annotations.replace_all(rendered, "")
+}
+
+pub(crate) fn process(file: &Path, stderr: &[u8]) -> Diagnostics {
+    let mut rendered = Vec::new();
+    let mut messages = vec![];
+    let mut messages_from_unknown_file_or_line = vec![];
+    for (line_number, line) in stderr.lines_with_terminator().enumerate() {
+        if line.starts_with_str(b"{") {
+            match serde_json::from_slice::<RustcMessage>(line) {
+                Ok(msg) => {
+                    rendered.extend(
+                        filter_annotations_from_rendered(msg.rendered.as_ref().unwrap()).as_bytes(),
+                    );
+                    msg.insert_recursive(
+                        file,
+                        &mut messages,
+                        &mut messages_from_unknown_file_or_line,
+                        None,
+                    );
+                }
+                Err(err) => {
+                    panic!("failed to parse rustc JSON output at line {line_number}: {err}")
+                }
+            }
+        } else {
+            // FIXME: do we want to throw interpreter stderr into a separate file?
+            rendered.extend(line);
+        }
+    }
+    Diagnostics {
+        rendered,
+        messages,
+        messages_from_unknown_file_or_line,
+    }
+}
diff --git a/vendor/ui_test/src/status_emitter.rs b/vendor/ui_test/src/status_emitter.rs
new file mode 100644
index 000000000..a277a9808
--- /dev/null
+++ b/vendor/ui_test/src/status_emitter.rs
@@ -0,0 +1,577 @@
+//! Variaous schemes for reporting messages during testing or after testing is done.
+
+use bstr::ByteSlice;
+use colored::Colorize;
+
+use crate::{github_actions, parser::Pattern, rustc_stderr::Message, Error, Errors, TestResult};
+use std::{
+    fmt::{Debug, Write as _},
+    io::Write as _,
+    path::Path,
+    process::Command,
+};
+
+/// A generic way to handle the output of this crate.
+pub trait StatusEmitter: Sync {
+    /// Invoked before each failed test prints its errors along with a drop guard that can
+    /// gets invoked afterwards.
+    fn failed_test<'a>(
+        &'a self,
+        revision: &'a str,
+        path: &'a Path,
+        cmd: &'a Command,
+        stderr: &'a [u8],
+    ) -> Box<dyn Debug + 'a>;
+
+    /// A test has finished, handle the result immediately.
+    fn test_result(&mut self, _path: &Path, _revision: &str, _result: &TestResult) {}
+
+    /// Create a report about the entire test run at the end.
+    #[allow(clippy::type_complexity)]
+    fn finalize(
+        &self,
+        failed: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary>;
+}
+
+/// Report a summary at the end of a test run.
+pub trait Summary {
+    /// A test has finished, handle the result.
+    fn test_failure(&mut self, _path: &Path, _revision: &str, _errors: &Errors) {}
+}
+
+impl Summary for () {}
+
+/// A human readable output emitter.
+pub struct Text;
+impl StatusEmitter for Text {
+    fn failed_test<'a>(
+        &self,
+        revision: &str,
+        path: &Path,
+        cmd: &Command,
+        stderr: &'a [u8],
+    ) -> Box<dyn Debug + 'a> {
+        eprintln!();
+        let path = path.display().to_string();
+        eprint!("{}", path.underline().bold());
+        let revision = if revision.is_empty() {
+            String::new()
+        } else {
+            format!(" (revision `{revision}`)")
+        };
+        eprint!("{revision}");
+        eprint!(" {}", "FAILED:".red().bold());
+        eprintln!();
+        eprintln!("command: {cmd:?}");
+        eprintln!();
+
+        #[derive(Debug)]
+        struct Guard<'a>(&'a [u8]);
+        impl<'a> Drop for Guard<'a> {
+            fn drop(&mut self) {
+                eprintln!("full stderr:");
+                std::io::stderr().write_all(self.0).unwrap();
+                eprintln!();
+                eprintln!();
+            }
+        }
+        Box::new(Guard(stderr))
+    }
+
+    fn test_result(&mut self, path: &Path, revision: &str, result: &TestResult) {
+        let result = match result {
+            TestResult::Ok => "ok".green(),
+            TestResult::Errored { .. } => "FAILED".red().bold(),
+            TestResult::Ignored => "ignored (in-test comment)".yellow(),
+            TestResult::Filtered => return,
+        };
+        eprint!(
+            "{}{} ... ",
+            path.display(),
+            if revision.is_empty() {
+                "".into()
+            } else {
+                format!(" ({revision})")
+            }
+        );
+        eprintln!("{result}");
+    }
+
+    fn finalize(
+        &self,
+        failures: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary> {
+        // Print all errors in a single thread to show reliable output
+        if failures == 0 {
+            eprintln!();
+            eprintln!(
+                "test result: {}. {} tests passed, {} ignored, {} filtered out",
+                "ok".green(),
+                succeeded.to_string().green(),
+                ignored.to_string().yellow(),
+                filtered.to_string().yellow(),
+            );
+            eprintln!();
+            Box::new(())
+        } else {
+            struct Summarizer {
+                failures: Vec<String>,
+                succeeded: usize,
+                ignored: usize,
+                filtered: usize,
+            }
+
+            impl Summary for Summarizer {
+                fn test_failure(&mut self, path: &Path, revision: &str, errors: &Errors) {
+                    for error in errors {
+                        print_error(error, &path.display().to_string());
+                    }
+
+                    self.failures.push(if revision.is_empty() {
+                        format!("    {}", path.display())
+                    } else {
+                        format!("    {} (revision {revision})", path.display())
+                    });
+                }
+            }
+
+            impl Drop for Summarizer {
+                fn drop(&mut self) {
+                    eprintln!("{}", "FAILURES:".red().underline().bold());
+                    for line in &self.failures {
+                        eprintln!("{line}");
+                    }
+                    eprintln!();
+                    eprintln!(
+                        "test result: {}. {} tests failed, {} tests passed, {} ignored, {} filtered out",
+                        "FAIL".red(),
+                        self.failures.len().to_string().red().bold(),
+                        self.succeeded.to_string().green(),
+                        self.ignored.to_string().yellow(),
+                        self.filtered.to_string().yellow(),
+                    );
+                }
+            }
+            Box::new(Summarizer {
+                failures: vec![],
+                succeeded,
+                ignored,
+                filtered,
+            })
+        }
+    }
+}
+
+fn print_error(error: &Error, path: &str) {
+    match error {
+        Error::ExitStatus {
+            mode,
+            status,
+            expected,
+        } => {
+            eprintln!("{mode} test got {status}, but expected {expected}")
+        }
+        Error::Command { kind, status } => {
+            eprintln!("{kind} failed with {status}");
+        }
+        Error::PatternNotFound {
+            pattern,
+            definition_line,
+        } => {
+            match pattern {
+                Pattern::SubString(s) => {
+                    eprintln!("substring `{s}` {} in stderr output", "not found".red())
+                }
+                Pattern::Regex(r) => {
+                    eprintln!("`/{r}/` does {} stderr output", "not match".red())
+                }
+            }
+            eprintln!(
+                "expected because of pattern here: {}",
+                format!("{path}:{definition_line}").bold()
+            );
+        }
+        Error::NoPatternsFound => {
+            eprintln!("{}", "no error patterns found in fail test".red());
+        }
+        Error::PatternFoundInPassTest => {
+            eprintln!("{}", "error pattern found in pass test".red())
+        }
+        Error::OutputDiffers {
+            path: output_path,
+            actual,
+            expected,
+            bless_command,
+        } => {
+            eprintln!("{}", "actual output differed from expected".underline());
+            eprintln!(
+                "Execute `{}` to update `{}` to the actual output",
+                bless_command,
+                output_path.display()
+            );
+            eprintln!("{}", format!("--- {}", output_path.display()).red());
+            eprintln!("{}", "+++ <stderr output>".green());
+            crate::diff::print_diff(expected, actual);
+        }
+        Error::ErrorsWithoutPattern { path: None, msgs } => {
+            eprintln!(
+                "There were {} unmatched diagnostics that occurred outside the testfile and had no pattern",
+                msgs.len(),
+            );
+            for Message { level, message } in msgs {
+                eprintln!("    {level:?}: {message}")
+            }
+        }
+        Error::ErrorsWithoutPattern {
+            path: Some((path, line)),
+            msgs,
+        } => {
+            let path = path.display();
+            eprintln!(
+                "There were {} unmatched diagnostics at {path}:{line}",
+                msgs.len(),
+            );
+            for Message { level, message } in msgs {
+                eprintln!("    {level:?}: {message}")
+            }
+        }
+        Error::InvalidComment { msg, line } => {
+            eprintln!("Could not parse comment in {path}:{line} because\n{msg}",)
+        }
+        Error::Bug(msg) => {
+            eprintln!("A bug in `ui_test` occurred: {msg}");
+        }
+        Error::Aux {
+            path: aux_path,
+            errors,
+            line,
+        } => {
+            eprintln!("Aux build from {path}:{line} failed");
+            for error in errors {
+                print_error(error, &aux_path.display().to_string());
+            }
+        }
+    }
+    eprintln!();
+}
+
+fn gha_error(error: &Error, path: &str, revision: &str) {
+    match error {
+        Error::ExitStatus {
+            mode,
+            status,
+            expected,
+        } => {
+            github_actions::error(
+                path,
+                format!("{mode} test{revision} got {status}, but expected {expected}"),
+            );
+        }
+        Error::Command { kind, status } => {
+            github_actions::error(path, format!("{kind}{revision} failed with {status}"));
+        }
+        Error::PatternNotFound {
+            pattern: _,
+            definition_line,
+        } => {
+            github_actions::error(path, format!("Pattern not found{revision}"))
+                .line(*definition_line);
+        }
+        Error::NoPatternsFound => {
+            github_actions::error(
+                path,
+                format!("no error patterns found in fail test{revision}"),
+            );
+        }
+        Error::PatternFoundInPassTest => {
+            github_actions::error(path, format!("error pattern found in pass test{revision}"));
+        }
+        Error::OutputDiffers {
+            path: output_path,
+            actual,
+            expected,
+            bless_command: _,
+        } => {
+            let mut err = github_actions::error(
+                if expected.is_empty() {
+                    path.to_owned()
+                } else {
+                    output_path.display().to_string()
+                },
+                "actual output differs from expected",
+            );
+            writeln!(err, "```diff").unwrap();
+            let mut seen_diff_line = Some(0);
+            for r in ::diff::lines(expected.to_str().unwrap(), actual.to_str().unwrap()) {
+                if let Some(line) = &mut seen_diff_line {
+                    *line += 1;
+                }
+                let mut seen_diff = || {
+                    if let Some(line) = seen_diff_line.take() {
+                        writeln!(err, "{line} unchanged lines skipped").unwrap();
+                    }
+                };
+                match r {
+                    ::diff::Result::Both(l, r) => {
+                        if l != r {
+                            seen_diff();
+                            writeln!(err, "-{l}").unwrap();
+                            writeln!(err, "+{r}").unwrap();
+                        } else if seen_diff_line.is_none() {
+                            writeln!(err, " {l}").unwrap()
+                        }
+                    }
+                    ::diff::Result::Left(l) => {
+                        seen_diff();
+                        writeln!(err, "-{l}").unwrap();
+                    }
+                    ::diff::Result::Right(r) => {
+                        seen_diff();
+                        writeln!(err, "+{r}").unwrap();
+                    }
+                }
+            }
+            writeln!(err, "```").unwrap();
+        }
+        Error::ErrorsWithoutPattern { path: None, msgs } => {
+            let mut err = github_actions::error(
+                path,
+                format!("Unmatched diagnostics outside the testfile{revision}"),
+            );
+            for Message { level, message } in msgs {
+                writeln!(err, "{level:?}: {message}").unwrap();
+            }
+        }
+        Error::ErrorsWithoutPattern {
+            path: Some((path, line)),
+            msgs,
+        } => {
+            let path = path.display();
+            let mut err = github_actions::error(&path, format!("Unmatched diagnostics{revision}"))
+                .line(*line);
+            for Message { level, message } in msgs {
+                writeln!(err, "{level:?}: {message}").unwrap();
+            }
+        }
+        Error::InvalidComment { msg, line } => {
+            let mut err =
+                github_actions::error(path, format!("Could not parse comment")).line(*line);
+            writeln!(err, "{msg}").unwrap();
+        }
+        Error::Bug(_) => {}
+        Error::Aux {
+            path: aux_path,
+            errors,
+            line,
+        } => {
+            github_actions::error(path, format!("Aux build failed")).line(*line);
+            for error in errors {
+                gha_error(error, &aux_path.display().to_string(), "")
+            }
+        }
+    }
+    eprintln!();
+}
+
+/// Just print some dots instead of a whole line per run test.
+#[derive(Default)]
+pub struct Quiet {
+    n: usize,
+}
+
+impl StatusEmitter for Quiet {
+    fn test_result(&mut self, _path: &Path, _revision: &str, result: &TestResult) {
+        // Humans start counting at 1
+        self.n += 1;
+        match result {
+            TestResult::Ok => eprint!("{}", ".".green()),
+            TestResult::Errored { .. } => eprint!("{}", "F".red().bold()),
+            TestResult::Ignored => eprint!("{}", "i".yellow()),
+            TestResult::Filtered => {}
+        }
+        if self.n % 100 == 0 {
+            eprintln!(" {}", self.n);
+        }
+    }
+
+    fn failed_test<'a>(
+        &'a self,
+        revision: &'a str,
+        path: &'a Path,
+        cmd: &'a Command,
+        stderr: &'a [u8],
+    ) -> Box<dyn Debug + 'a> {
+        Text.failed_test(revision, path, cmd, stderr)
+    }
+
+    fn finalize(
+        &self,
+        failed: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary> {
+        Text.finalize(failed, succeeded, ignored, filtered)
+    }
+}
+
+/// Emits Github Actions Workspace commands to show the failures directly in the github diff view.
+/// If the const generic `GROUP` boolean is `true`, also emit `::group` commands.
+pub struct Gha<const GROUP: bool> {
+    /// Show a specific name for the final summary.
+    pub name: String,
+}
+
+impl<const GROUP: bool> StatusEmitter for Gha<GROUP> {
+    fn failed_test(
+        &self,
+        revision: &str,
+        path: &Path,
+        _cmd: &Command,
+        _stderr: &[u8],
+    ) -> Box<dyn Debug> {
+        if GROUP {
+            Box::new(github_actions::group(format_args!(
+                "{}:{revision}",
+                path.display()
+            )))
+        } else {
+            Box::new(())
+        }
+    }
+
+    fn test_result(&mut self, _path: &Path, _revision: &str, _result: &TestResult) {}
+
+    fn finalize(
+        &self,
+        _failures: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary> {
+        struct Summarizer<const GROUP: bool> {
+            failures: Vec<String>,
+            succeeded: usize,
+            ignored: usize,
+            filtered: usize,
+            name: String,
+        }
+
+        impl<const GROUP: bool> Summary for Summarizer<GROUP> {
+            fn test_failure(&mut self, path: &Path, revision: &str, errors: &Errors) {
+                let revision = if revision.is_empty() {
+                    "".to_string()
+                } else {
+                    format!(" (revision: {revision})")
+                };
+                for error in errors {
+                    gha_error(error, &path.display().to_string(), &revision);
+                }
+                self.failures.push(format!("{}{revision}", path.display()));
+            }
+        }
+        impl<const GROUP: bool> Drop for Summarizer<GROUP> {
+            fn drop(&mut self) {
+                if let Some(mut file) = github_actions::summary() {
+                    writeln!(file, "### {}", self.name).unwrap();
+                    for line in &self.failures {
+                        writeln!(file, "* {line}").unwrap();
+                    }
+                    writeln!(file).unwrap();
+                    writeln!(file, "| failed | passed | ignored | filtered out |").unwrap();
+                    writeln!(file, "| --- | --- | --- | --- |").unwrap();
+                    writeln!(
+                        file,
+                        "| {} | {} | {} | {} |",
+                        self.failures.len(),
+                        self.succeeded,
+                        self.ignored,
+                        self.filtered,
+                    )
+                    .unwrap();
+                }
+            }
+        }
+
+        Box::new(Summarizer::<GROUP> {
+            failures: vec![],
+            succeeded,
+            ignored,
+            filtered,
+            name: self.name.clone(),
+        })
+    }
+}
+
+impl<T: StatusEmitter, U: StatusEmitter> StatusEmitter for (T, U) {
+    fn failed_test<'a>(
+        &'a self,
+        revision: &'a str,
+        path: &'a Path,
+        cmd: &'a Command,
+        stderr: &'a [u8],
+    ) -> Box<dyn Debug + 'a> {
+        Box::new((
+            self.0.failed_test(revision, path, cmd, stderr),
+            self.1.failed_test(revision, path, cmd, stderr),
+        ))
+    }
+
+    fn test_result(&mut self, path: &Path, revision: &str, result: &TestResult) {
+        self.0.test_result(path, revision, result);
+        self.1.test_result(path, revision, result);
+    }
+
+    fn finalize(
+        &self,
+        failures: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary> {
+        Box::new((
+            self.1.finalize(failures, succeeded, ignored, filtered),
+            self.0.finalize(failures, succeeded, ignored, filtered),
+        ))
+    }
+}
+
+impl<T: StatusEmitter + ?Sized> StatusEmitter for Box<T> {
+    fn failed_test<'a>(
+        &'a self,
+        revision: &'a str,
+        path: &'a Path,
+        cmd: &'a Command,
+        stderr: &'a [u8],
+    ) -> Box<dyn Debug + 'a> {
+        (**self).failed_test(revision, path, cmd, stderr)
+    }
+
+    fn test_result(&mut self, path: &Path, revision: &str, result: &TestResult) {
+        (**self).test_result(path, revision, result);
+    }
+
+    fn finalize(
+        &self,
+        failures: usize,
+        succeeded: usize,
+        ignored: usize,
+        filtered: usize,
+    ) -> Box<dyn Summary> {
+        (**self).finalize(failures, succeeded, ignored, filtered)
+    }
+}
+
+impl Summary for (Box<dyn Summary>, Box<dyn Summary>) {
+    fn test_failure(&mut self, path: &Path, revision: &str, errors: &Errors) {
+        self.0.test_failure(path, revision, errors);
+        self.1.test_failure(path, revision, errors);
+    }
+}
diff --git a/vendor/ui_test/src/tests.rs b/vendor/ui_test/src/tests.rs
new file mode 100644
index 000000000..4aca1d2d0
--- /dev/null
+++ b/vendor/ui_test/src/tests.rs
@@ -0,0 +1,338 @@
+use std::path::{Path, PathBuf};
+
+use crate::rustc_stderr::Level;
+use crate::rustc_stderr::Message;
+
+use super::*;
+
+fn config() -> Config {
+    Config {
+        root_dir: PathBuf::from("$RUSTROOT"),
+        program: CommandBuilder::cmd("cake"),
+        ..Config::rustc(PathBuf::new())
+    }
+}
+
+#[test]
+fn issue_2156() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address $HEX is unallocated)
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let mut errors = vec![];
+    let config = config();
+    let messages = vec![
+        vec![], vec![], vec![], vec![], vec![],
+        vec![
+            Message {
+                message:"Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            }
+        ]
+    ];
+    check_annotations(
+        messages,
+        vec![],
+        Path::new("moobar"),
+        &mut errors,
+        &config,
+        "",
+        &comments,
+    );
+    match &errors[..] {
+        [Error::PatternNotFound {
+            definition_line: 5, ..
+        }, Error::ErrorsWithoutPattern {
+            path: Some((_, 5)), ..
+        }] => {}
+        _ => panic!("{:#?}", errors),
+    }
+}
+
+#[test]
+fn find_pattern() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let config = config();
+    {
+        let messages = vec![vec![], vec![], vec![], vec![], vec![], vec![
+                Message {
+                    message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                    level: Level::Error,
+                }
+            ]
+        ];
+        let mut errors = vec![];
+        check_annotations(
+            messages,
+            vec![],
+            Path::new("moobar"),
+            &mut errors,
+            &config,
+            "",
+            &comments,
+        );
+        match &errors[..] {
+            [] => {}
+            _ => panic!("{:#?}", errors),
+        }
+    }
+
+    // only difference to above is a wrong line number
+    {
+        let messages = vec![vec![], vec![], vec![], vec![], vec![
+                Message {
+                    message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                    level: Level::Error,
+                }
+            ]
+        ];
+        let mut errors = vec![];
+        check_annotations(
+            messages,
+            vec![],
+            Path::new("moobar"),
+            &mut errors,
+            &config,
+            "",
+            &comments,
+        );
+        match &errors[..] {
+            [Error::PatternNotFound {
+                definition_line: 5, ..
+            }, Error::ErrorsWithoutPattern {
+                path: Some((_, 4)), ..
+            }] => {}
+            _ => panic!("not the expected error: {:#?}", errors),
+        }
+    }
+
+    // only difference to first is a wrong level
+    {
+        let messages = vec![
+            vec![], vec![], vec![], vec![], vec![],
+            vec![
+                Message {
+                    message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                    level: Level::Note,
+                }
+            ]
+        ];
+        let mut errors = vec![];
+        check_annotations(
+            messages,
+            vec![],
+            Path::new("moobar"),
+            &mut errors,
+            &config,
+            "",
+            &comments,
+        );
+        match &errors[..] {
+            // Note no `ErrorsWithoutPattern`, because there are no `//~NOTE` in the test file, so we ignore them
+            [Error::PatternNotFound {
+                definition_line: 5, ..
+            }] => {}
+            _ => panic!("not the expected error: {:#?}", errors),
+        }
+    }
+}
+
+#[test]
+fn duplicate_pattern() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+    //~^ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let config = config();
+    let messages = vec![
+        vec![], vec![], vec![], vec![], vec![],
+        vec![
+            Message {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            }
+        ]
+    ];
+    let mut errors = vec![];
+    check_annotations(
+        messages,
+        vec![],
+        Path::new("moobar"),
+        &mut errors,
+        &config,
+        "",
+        &comments,
+    );
+    match &errors[..] {
+        [Error::PatternNotFound {
+            definition_line: 6, ..
+        }] => {}
+        _ => panic!("{:#?}", errors),
+    }
+}
+
+#[test]
+fn missing_pattern() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let config = config();
+    let messages = vec![
+        vec![], vec![], vec![], vec![], vec![],
+        vec![
+            Message {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            },
+            Message {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            }
+        ]
+    ];
+    let mut errors = vec![];
+    check_annotations(
+        messages,
+        vec![],
+        Path::new("moobar"),
+        &mut errors,
+        &config,
+        "",
+        &comments,
+    );
+    match &errors[..] {
+        [Error::ErrorsWithoutPattern {
+            path: Some((_, 5)), ..
+        }] => {}
+        _ => panic!("{:#?}", errors),
+    }
+}
+
+#[test]
+fn missing_warn_pattern() {
+    let s = r"
+use std::mem;
+
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+    //~^ WARN: cake
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let config = config();
+    let messages= vec![
+        vec![],
+        vec![],
+        vec![],
+        vec![],
+        vec![],
+        vec![
+            Message {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            },
+            Message {
+                message: "kaboom".to_string(),
+                level: Level::Warn,
+            },
+            Message {
+                message: "cake".to_string(),
+                level: Level::Warn,
+            },
+        ],
+    ];
+    let mut errors = vec![];
+    check_annotations(
+        messages,
+        vec![],
+        Path::new("moobar"),
+        &mut errors,
+        &config,
+        "",
+        &comments,
+    );
+    match &errors[..] {
+        [Error::ErrorsWithoutPattern {
+            path: Some((_, 5)),
+            msgs,
+            ..
+        }] => match &msgs[..] {
+            [Message {
+                message,
+                level: Level::Warn,
+            }] if message == "kaboom" => {}
+            _ => panic!("{:#?}", msgs),
+        },
+        _ => panic!("{:#?}", errors),
+    }
+}
+
+#[test]
+fn missing_implicit_warn_pattern() {
+    let s = r"
+use std::mem;
+//@require-annotations-for-level: ERROR
+fn main() {
+    let _x: &i32 = unsafe { mem::transmute(16usize) }; //~ ERROR: encountered a dangling reference (address 0x10 is unallocated)
+    //~^ WARN: cake
+}
+    ";
+    let comments = Comments::parse(s).unwrap();
+    let config = config();
+    let messages = vec![
+        vec![],
+        vec![],
+        vec![],
+        vec![],
+        vec![],
+        vec![
+            Message {
+                message: "Undefined Behavior: type validation failed: encountered a dangling reference (address 0x10 is unallocated)".to_string(),
+                level: Level::Error,
+            },
+            Message {
+                message: "kaboom".to_string(),
+                level: Level::Warn,
+            },
+            Message {
+                message: "cake".to_string(),
+                level: Level::Warn,
+            },
+        ],
+    ];
+    let mut errors = vec![];
+    check_annotations(
+        messages,
+        vec![],
+        Path::new("moobar"),
+        &mut errors,
+        &config,
+        "",
+        &comments,
+    );
+    match &errors[..] {
+        [] => {}
+        _ => panic!("{:#?}", errors),
+    }
+}
diff --git a/vendor/ui_test/tests/integration.rs b/vendor/ui_test/tests/integration.rs
new file mode 100644
index 000000000..a9a77b45f
--- /dev/null
+++ b/vendor/ui_test/tests/integration.rs
@@ -0,0 +1,112 @@
+use std::path::Path;
+
+use colored::Colorize;
+use ui_test::color_eyre::Result;
+use ui_test::*;
+
+fn main() -> Result<()> {
+    run("integrations", Mode::Pass)?;
+    run("integrations", Mode::Panic)?;
+
+    eprintln!("integration tests done");
+
+    Ok(())
+}
+
+fn run(name: &str, mode: Mode) -> Result<()> {
+    eprintln!("\n{} `{name}` tests in mode {mode}", "Running".green());
+    let path = Path::new(file!()).parent().unwrap();
+    let root_dir = path.join(name);
+    let bless = std::env::args().all(|arg| arg != "--check");
+    let mut config = Config {
+        trailing_args: vec!["--".into(), "--test-threads".into(), "1".into()],
+        mode,
+        ..Config::cargo(root_dir.clone())
+    };
+
+    if bless {
+        config.output_conflict_handling = OutputConflictHandling::Bless;
+    }
+
+    config.program.args = vec![
+        "test".into(),
+        "--color".into(),
+        "never".into(),
+        "--quiet".into(),
+        "--jobs".into(),
+        "1".into(),
+        "--no-fail-fast".into(),
+    ];
+
+    config
+        .program
+        .envs
+        .push(("BLESS".into(), bless.then(|| String::new().into())));
+
+    config.stdout_filter("in ([0-9]m )?[0-9\\.]+s", "");
+    config.stderr_filter(r#""--out-dir"(,)? "[^"]+""#, r#""--out-dir"$1 "$$TMP"#);
+    config.stderr_filter(
+        "( *process didn't exit successfully: `[^-]+)-[0-9a-f]+",
+        "$1-HASH",
+    );
+    // Windows io::Error uses "exit code".
+    config.stderr_filter("exit code", "exit status");
+    // The order of the `/deps` directory flag is flaky
+    config.stderr_filter("/deps", "");
+    config.path_stderr_filter(&std::path::Path::new(path), "$DIR");
+    config.stderr_filter("[0-9a-f]+\\.rmeta", "$$HASH.rmeta");
+    // Windows backslashes are sometimes escaped.
+    // Insert the replacement filter at the start to make sure the filter for single backslashes
+    // runs afterwards.
+    config
+        .stderr_filters
+        .insert(0, (Match::Exact(b"\\\\".iter().copied().collect()), b"\\"));
+    config.stderr_filter("\\.exe", b"");
+    config.stderr_filter(r#"(panic.*)\.rs:[0-9]+:[0-9]+"#, "$1.rs");
+    config.stderr_filter("   [0-9]: .*", "");
+    config.stderr_filter("/target/[^/]+/[^/]+/debug", "/target/$$TMP/$$TRIPLE/debug");
+    config.stderr_filter("/target/[^/]+/tests", "/target/$$TMP/tests");
+    // Normalize proc macro filenames on windows to their linux repr
+    config.stderr_filter("/([^/\\.]+)\\.dll", "/lib$1.so");
+    // Normalize proc macro filenames on mac to their linux repr
+    config.stderr_filter("/([^/\\.]+)\\.dylib", "/$1.so");
+    config.stderr_filter("(command: )\"[^<rp][^\"]+", "$1\"$$CMD");
+    config.stderr_filter("(src/.*?\\.rs):[0-9]+:[0-9]+", "$1:LL:CC");
+    config.stderr_filter("program not found", "No such file or directory");
+    config.stderr_filter(" \\(os error [0-9]+\\)", "");
+
+    run_tests_generic(
+        config,
+        |path| {
+            let fail = path
+                .parent()
+                .unwrap()
+                .file_name()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .ends_with("-fail");
+            if cfg!(windows) && path.components().any(|c| c.as_os_str() == "basic-bin") {
+                // on windows there's also a .pdb file, so we get additional errors that aren't there on other platforms
+                return false;
+            }
+            path.ends_with("Cargo.toml")
+                && path.parent().unwrap().parent().unwrap() == root_dir
+                && match mode {
+                    Mode::Pass => !fail,
+                    // This is weird, but `cargo test` returns 101 instead of 1 when
+                    // multiple [[test]]s exist. If there's only one test, it returns
+                    // 1 on failure.
+                    Mode::Panic => fail,
+                    Mode::Fix | Mode::Run { .. } | Mode::Yolo | Mode::Fail { .. } => unreachable!(),
+                }
+        },
+        |_, _| None,
+        (
+            ui_test::status_emitter::Text,
+            ui_test::status_emitter::Gha::<true> {
+                name: format!("{mode:?}"),
+            },
+        ),
+    )
+}