compiletest/
common.rs

1use std::collections::{BTreeSet, HashMap, HashSet};
2use std::iter;
3use std::process::Command;
4use std::sync::OnceLock;
5
6use build_helper::git::GitConfig;
7use camino::{Utf8Path, Utf8PathBuf};
8use semver::Version;
9use serde::de::{Deserialize, Deserializer, Error as _};
10
11use crate::executor::{ColorConfig, OutputFormat};
12use crate::fatal;
13use crate::util::{Utf8PathBufExt, add_dylib_path, string_enum};
14
15string_enum! {
16    #[derive(Clone, Copy, PartialEq, Debug)]
17    pub enum TestMode {
18        Pretty => "pretty",
19        DebugInfo => "debuginfo",
20        Codegen => "codegen",
21        Rustdoc => "rustdoc",
22        RustdocJson => "rustdoc-json",
23        CodegenUnits => "codegen-units",
24        Incremental => "incremental",
25        RunMake => "run-make",
26        Ui => "ui",
27        RustdocJs => "rustdoc-js",
28        MirOpt => "mir-opt",
29        Assembly => "assembly",
30        CoverageMap => "coverage-map",
31        CoverageRun => "coverage-run",
32        Crashes => "crashes",
33    }
34}
35
36impl TestMode {
37    pub fn aux_dir_disambiguator(self) -> &'static str {
38        // Pretty-printing tests could run concurrently, and if they do,
39        // they need to keep their output segregated.
40        match self {
41            TestMode::Pretty => ".pretty",
42            _ => "",
43        }
44    }
45
46    pub fn output_dir_disambiguator(self) -> &'static str {
47        // Coverage tests use the same test files for multiple test modes,
48        // so each mode should have a separate output directory.
49        match self {
50            TestMode::CoverageMap | TestMode::CoverageRun => self.to_str(),
51            _ => "",
52        }
53    }
54}
55
56// Note that coverage tests use the same test files for multiple test modes.
57string_enum! {
58    #[derive(Clone, Copy, PartialEq, Debug)]
59    pub enum TestSuite {
60        AssemblyLlvm => "assembly-llvm",
61        CodegenLlvm => "codegen-llvm",
62        CodegenUnits => "codegen-units",
63        Coverage => "coverage",
64        CoverageRunRustdoc => "coverage-run-rustdoc",
65        Crashes => "crashes",
66        Debuginfo => "debuginfo",
67        Incremental => "incremental",
68        MirOpt => "mir-opt",
69        Pretty => "pretty",
70        RunMake => "run-make",
71        Rustdoc => "rustdoc",
72        RustdocGui => "rustdoc-gui",
73        RustdocJs => "rustdoc-js",
74        RustdocJsStd=> "rustdoc-js-std",
75        RustdocJson => "rustdoc-json",
76        RustdocUi => "rustdoc-ui",
77        Ui => "ui",
78        UiFullDeps => "ui-fulldeps",
79    }
80}
81
82string_enum! {
83    #[derive(Clone, Copy, PartialEq, Debug, Hash)]
84    pub enum PassMode {
85        Check => "check",
86        Build => "build",
87        Run => "run",
88    }
89}
90
91string_enum! {
92    #[derive(Clone, Copy, PartialEq, Debug, Hash)]
93    pub enum RunResult {
94        Pass => "run-pass",
95        Fail => "run-fail",
96        Crash => "run-crash",
97    }
98}
99
100#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
101pub enum RunFailMode {
102    /// Running the program must make it exit with a regular failure exit code
103    /// in the range `1..=127`. If the program is terminated by e.g. a signal
104    /// the test will fail.
105    Fail,
106    /// Running the program must result in a crash, e.g. by `SIGABRT` or
107    /// `SIGSEGV` on Unix or on Windows by having an appropriate NTSTATUS high
108    /// bit in the exit code.
109    Crash,
110    /// Running the program must either fail or crash. Useful for e.g. sanitizer
111    /// tests since some sanitizer implementations exit the process with code 1
112    /// to in the face of memory errors while others abort (crash) the process
113    /// in the face of memory errors.
114    FailOrCrash,
115}
116
117#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
118pub enum FailMode {
119    Check,
120    Build,
121    Run(RunFailMode),
122}
123
124string_enum! {
125    #[derive(Clone, Debug, PartialEq)]
126    pub enum CompareMode {
127        Polonius => "polonius",
128        NextSolver => "next-solver",
129        NextSolverCoherence => "next-solver-coherence",
130        SplitDwarf => "split-dwarf",
131        SplitDwarfSingle => "split-dwarf-single",
132    }
133}
134
135string_enum! {
136    #[derive(Clone, Copy, Debug, PartialEq)]
137    pub enum Debugger {
138        Cdb => "cdb",
139        Gdb => "gdb",
140        Lldb => "lldb",
141    }
142}
143
144#[derive(Clone, Copy, Debug, PartialEq, Default, serde::Deserialize)]
145#[serde(rename_all = "kebab-case")]
146pub enum PanicStrategy {
147    #[default]
148    Unwind,
149    Abort,
150}
151
152impl PanicStrategy {
153    pub(crate) fn for_miropt_test_tools(&self) -> miropt_test_tools::PanicStrategy {
154        match self {
155            PanicStrategy::Unwind => miropt_test_tools::PanicStrategy::Unwind,
156            PanicStrategy::Abort => miropt_test_tools::PanicStrategy::Abort,
157        }
158    }
159}
160
161#[derive(Clone, Debug, PartialEq, serde::Deserialize)]
162#[serde(rename_all = "kebab-case")]
163pub enum Sanitizer {
164    Address,
165    Cfi,
166    Dataflow,
167    Kcfi,
168    KernelAddress,
169    Leak,
170    Memory,
171    Memtag,
172    Safestack,
173    ShadowCallStack,
174    Thread,
175    Hwaddress,
176}
177
178#[derive(Clone, Copy, Debug, PartialEq)]
179pub enum CodegenBackend {
180    Cranelift,
181    Gcc,
182    Llvm,
183}
184
185impl<'a> TryFrom<&'a str> for CodegenBackend {
186    type Error = &'static str;
187
188    fn try_from(value: &'a str) -> Result<Self, Self::Error> {
189        match value.to_lowercase().as_str() {
190            "cranelift" => Ok(Self::Cranelift),
191            "gcc" => Ok(Self::Gcc),
192            "llvm" => Ok(Self::Llvm),
193            _ => Err("unknown backend"),
194        }
195    }
196}
197
198impl CodegenBackend {
199    pub fn as_str(self) -> &'static str {
200        match self {
201            Self::Cranelift => "cranelift",
202            Self::Gcc => "gcc",
203            Self::Llvm => "llvm",
204        }
205    }
206}
207
208/// Configuration for `compiletest` *per invocation*.
209///
210/// In terms of `bootstrap`, this means that `./x test tests/ui tests/run-make` actually correspond
211/// to *two* separate invocations of `compiletest`.
212///
213/// FIXME: this `Config` struct should be broken up into smaller logically contained sub-config
214/// structs, it's too much of a "soup" of everything at the moment.
215///
216/// # Configuration sources
217///
218/// Configuration values for `compiletest` comes from several sources:
219///
220/// - CLI args passed from `bootstrap` while running the `compiletest` binary.
221/// - Env vars.
222/// - Discovery (e.g. trying to identify a suitable debugger based on filesystem discovery).
223/// - Cached output of running the `rustc` under test (e.g. output of `rustc` print requests).
224///
225/// FIXME: make sure we *clearly* account for sources of *all* config options.
226///
227/// FIXME: audit these options to make sure we are not hashing less than necessary for build stamp
228/// (for changed test detection).
229#[derive(Debug, Clone)]
230pub struct Config {
231    /// Some [`TestMode`]s support [snapshot testing], where a *reference snapshot* of outputs (of
232    /// `stdout`, `stderr`, or other form of artifacts) can be compared to the *actual output*.
233    ///
234    /// This option can be set to `true` to update the *reference snapshots* in-place, otherwise
235    /// `compiletest` will only try to compare.
236    ///
237    /// [snapshot testing]: https://jestjs.io/docs/snapshot-testing
238    pub bless: bool,
239
240    /// Attempt to stop as soon as possible after any test fails. We may still run a few more tests
241    /// before stopping when multiple test threads are used.
242    pub fail_fast: bool,
243
244    /// Path to libraries needed to run the *staged* `rustc`-under-test on the **host** platform.
245    ///
246    /// FIXME: maybe rename this to reflect (1) which target platform (host, not target), and (2)
247    /// which `rustc` (the `rustc`-under-test, not the stage 0 `rustc` unless forced).
248    pub compile_lib_path: Utf8PathBuf,
249
250    /// Path to libraries needed to run the compiled executable for the **target** platform. This
251    /// corresponds to the **target** sysroot libraries, including the **target** standard library.
252    ///
253    /// FIXME: maybe rename this to reflect (1) which target platform (target, not host), and (2)
254    /// what "run libraries" are against.
255    ///
256    /// FIXME: this is very under-documented in conjunction with the `remote-test-client` scheme and
257    /// `RUNNER` scheme to actually run the target executable under the target platform environment,
258    /// cf. [`Self::remote_test_client`] and [`Self::runner`].
259    pub run_lib_path: Utf8PathBuf,
260
261    /// Path to the *staged*  `rustc`-under-test. Unless forced, this `rustc` is *staged*, and must
262    /// not be confused with [`Self::stage0_rustc_path`].
263    ///
264    /// FIXME: maybe rename this to reflect that this is the `rustc`-under-test.
265    pub rustc_path: Utf8PathBuf,
266
267    /// Path to a *staged* **host** platform cargo executable (unless stage 0 is forced). This
268    /// staged `cargo` is only used within `run-make` test recipes during recipe run time (and is
269    /// *not* used to compile the test recipes), and so must be staged as there may be differences
270    /// between e.g. beta `cargo` vs in-tree `cargo`.
271    ///
272    /// FIXME: maybe rename this to reflect that this is a *staged* host cargo.
273    ///
274    /// FIXME(#134109): split `run-make` into two test suites, a test suite *with* staged cargo, and
275    /// another test suite *without*.
276    pub cargo_path: Option<Utf8PathBuf>,
277
278    /// Path to the stage 0 `rustc` used to build `run-make` recipes. This must not be confused with
279    /// [`Self::rustc_path`].
280    pub stage0_rustc_path: Option<Utf8PathBuf>,
281
282    /// Path to the `rustdoc`-under-test. Like [`Self::rustc_path`], this `rustdoc` is *staged*.
283    pub rustdoc_path: Option<Utf8PathBuf>,
284
285    /// Path to the `src/tools/coverage-dump/` bootstrap tool executable.
286    pub coverage_dump_path: Option<Utf8PathBuf>,
287
288    /// Path to the Python 3 executable to use for LLDB and htmldocck.
289    ///
290    /// FIXME: the `lldb` setup currently requires I believe Python 3.10 **exactly**, it can't even
291    /// be Python 3.11 or 3.9...
292    pub python: String,
293
294    /// Path to the `src/tools/jsondocck/` bootstrap tool executable.
295    pub jsondocck_path: Option<String>,
296
297    /// Path to the `src/tools/jsondoclint/` bootstrap tool executable.
298    pub jsondoclint_path: Option<String>,
299
300    /// Path to a host LLVM `FileCheck` executable.
301    pub llvm_filecheck: Option<Utf8PathBuf>,
302
303    /// Path to a host LLVM bintools directory.
304    pub llvm_bin_dir: Option<Utf8PathBuf>,
305
306    /// The path to the **target** `clang` executable to run `clang`-based tests with. If `None`,
307    /// then these tests will be ignored.
308    pub run_clang_based_tests_with: Option<String>,
309
310    /// Path to the directory containing the sources. This corresponds to the root folder of a
311    /// `rust-lang/rust` checkout.
312    ///
313    /// FIXME: this name is confusing, because this is actually `$checkout_root`, **not** the
314    /// `$checkout_root/src/` folder.
315    pub src_root: Utf8PathBuf,
316
317    /// Path to the directory containing the test suites sources. This corresponds to the
318    /// `$src_root/tests/` folder.
319    ///
320    /// Must be an immediate subdirectory of [`Self::src_root`].
321    ///
322    /// FIXME: this name is also confusing, maybe just call it `tests_root`.
323    pub src_test_suite_root: Utf8PathBuf,
324
325    /// Path to the build directory (e.g. `build/`).
326    pub build_root: Utf8PathBuf,
327
328    /// Path to the test suite specific build directory (e.g. `build/host/test/ui/`).
329    ///
330    /// Must be a subdirectory of [`Self::build_root`].
331    pub build_test_suite_root: Utf8PathBuf,
332
333    /// Path to the directory containing the sysroot of the `rustc`-under-test.
334    ///
335    /// When stage 0 is forced, this will correspond to the sysroot *of* that specified stage 0
336    /// `rustc`.
337    ///
338    /// FIXME: this name is confusing, because it doesn't specify *which* compiler this sysroot
339    /// corresponds to. It's actually the `rustc`-under-test, and not the bootstrap `rustc`, unless
340    /// stage 0 is forced and no custom stage 0 `rustc` was otherwise specified (so that it
341    /// *happens* to run against the bootstrap `rustc`, but this non-custom bootstrap `rustc` case
342    /// is not really supported).
343    pub sysroot_base: Utf8PathBuf,
344
345    /// The number of the stage under test.
346    pub stage: u32,
347
348    /// The id of the stage under test (stage1-xxx, etc).
349    ///
350    /// FIXME: reconsider this string; this is hashed for test build stamp.
351    pub stage_id: String,
352
353    /// The [`TestMode`]. E.g. [`TestMode::Ui`]. Each test mode can correspond to one or more test
354    /// suites.
355    ///
356    /// FIXME: stop using stringly-typed test suites!
357    pub mode: TestMode,
358
359    /// The test suite.
360    ///
361    /// Example: `tests/ui/` is [`TestSuite::Ui`] test *suite*, which happens to also be of the
362    /// [`TestMode::Ui`] test *mode*.
363    ///
364    /// Note that the same test suite (e.g. `tests/coverage/`) may correspond to multiple test
365    /// modes, e.g. `tests/coverage/` can be run under both [`TestMode::CoverageRun`] and
366    /// [`TestMode::CoverageMap`].
367    pub suite: TestSuite,
368
369    /// When specified, **only** the specified [`Debugger`] will be used to run against the
370    /// `tests/debuginfo` test suite. When unspecified, `compiletest` will attempt to find all three
371    /// of {`lldb`, `cdb`, `gdb`} implicitly, and then try to run the `debuginfo` test suite against
372    /// all three debuggers.
373    ///
374    /// FIXME: this implicit behavior is really nasty, in that it makes it hard for the user to
375    /// control *which* debugger(s) are available and used to run the debuginfo test suite. We
376    /// should have `bootstrap` allow the user to *explicitly* configure the debuggers, and *not*
377    /// try to implicitly discover some random debugger from the user environment. This makes the
378    /// debuginfo test suite particularly hard to work with.
379    pub debugger: Option<Debugger>,
380
381    /// Run ignored tests *unconditionally*, overriding their ignore reason.
382    ///
383    /// FIXME: this is wired up through the test execution logic, but **not** accessible from
384    /// `bootstrap` directly; `compiletest` exposes this as `--ignored`. I.e. you'd have to use `./x
385    /// test $test_suite -- --ignored=true`.
386    pub run_ignored: bool,
387
388    /// Whether *staged* `rustc`-under-test was built with debug assertions.
389    ///
390    /// FIXME: make it clearer that this refers to the staged `rustc`-under-test, not stage 0
391    /// `rustc`.
392    pub with_rustc_debug_assertions: bool,
393
394    /// Whether *staged* `std` was built with debug assertions.
395    ///
396    /// FIXME: make it clearer that this refers to the staged `std`, not stage 0 `std`.
397    pub with_std_debug_assertions: bool,
398
399    /// Only run tests that match these filters (using `libtest` "test name contains" filter logic).
400    ///
401    /// FIXME(#139660): the current hand-rolled test executor intentionally mimics the `libtest`
402    /// "test name contains" filter matching logic to preserve previous `libtest` executor behavior,
403    /// but this is often not intuitive. We should consider changing that behavior with an MCP to do
404    /// test path *prefix* matching which better corresponds to how `compiletest` `tests/` are
405    /// organized, and how users would intuitively expect the filtering logic to work like.
406    pub filters: Vec<String>,
407
408    /// Skip tests matching these substrings. The matching logic exactly corresponds to
409    /// [`Self::filters`] but inverted.
410    ///
411    /// FIXME(#139660): ditto on test matching behavior.
412    pub skip: Vec<String>,
413
414    /// Exactly match the filter, rather than a substring.
415    ///
416    /// FIXME(#139660): ditto on test matching behavior.
417    pub filter_exact: bool,
418
419    /// Force the pass mode of a check/build/run test to instead use this mode instead.
420    ///
421    /// FIXME: make it even more obvious (especially in PR CI where `--pass=check` is used) when a
422    /// pass mode is forced when the test fails, because it can be very non-obvious when e.g. an
423    /// error is emitted only when `//@ build-pass` but not `//@ check-pass`.
424    pub force_pass_mode: Option<PassMode>,
425
426    /// Explicitly enable or disable running of the target test binary.
427    ///
428    /// FIXME: this scheme is a bit confusing, and at times questionable. Re-evaluate this run
429    /// scheme.
430    ///
431    /// FIXME: Currently `--run` is a tri-state, it can be `--run={auto,always,never}`, and when
432    /// `--run=auto` is specified, it's run if the platform doesn't end with `-fuchsia`. See
433    /// [`Config::run_enabled`].
434    pub run: Option<bool>,
435
436    /// A command line to prefix target program execution with, for running under valgrind for
437    /// example, i.e. `$runner target.exe [args..]`. Similar to `CARGO_*_RUNNER` configuration.
438    ///
439    /// Note: this is not to be confused with [`Self::remote_test_client`], which is a different
440    /// scheme.
441    ///
442    /// FIXME: the runner scheme is very under-documented.
443    pub runner: Option<String>,
444
445    /// Compiler flags to pass to the *staged* `rustc`-under-test when building for the **host**
446    /// platform.
447    pub host_rustcflags: Vec<String>,
448
449    /// Compiler flags to pass to the *staged* `rustc`-under-test when building for the **target**
450    /// platform.
451    pub target_rustcflags: Vec<String>,
452
453    /// Whether the *staged* `rustc`-under-test and the associated *staged* `std` has been built
454    /// with randomized struct layouts.
455    pub rust_randomized_layout: bool,
456
457    /// Whether tests should be optimized by default (`-O`). Individual test suites and test files
458    /// may override this setting.
459    ///
460    /// FIXME: this flag / config option is somewhat misleading. For instance, in ui tests, it's
461    /// *only* applied to the [`PassMode::Run`] test crate and not its auxiliaries.
462    pub optimize_tests: bool,
463
464    /// Target platform tuple.
465    pub target: String,
466
467    /// Host platform tuple.
468    pub host: String,
469
470    /// Path to / name of the Microsoft Console Debugger (CDB) executable.
471    ///
472    /// FIXME: this is an *opt-in* "override" option. When this isn't provided, we try to conjure a
473    /// cdb by looking at the user's program files on Windows... See `debuggers::find_cdb`.
474    pub cdb: Option<Utf8PathBuf>,
475
476    /// Version of CDB.
477    ///
478    /// FIXME: `cdb_version` is *derived* from cdb, but it's *not* technically a config!
479    ///
480    /// FIXME: audit cdb version gating.
481    pub cdb_version: Option<[u16; 4]>,
482
483    /// Path to / name of the GDB executable.
484    ///
485    /// FIXME: the fallback path when `gdb` isn't provided tries to find *a* `gdb` or `gdb.exe` from
486    /// `PATH`, which is... arguably questionable.
487    ///
488    /// FIXME: we are propagating a python from `PYTHONPATH`, not from an explicit config for gdb
489    /// debugger script.
490    pub gdb: Option<String>,
491
492    /// Version of GDB, encoded as ((major * 1000) + minor) * 1000 + patch
493    ///
494    /// FIXME: this gdb version gating scheme is possibly questionable -- gdb does not use semver,
495    /// only its major version is likely materially meaningful, cf.
496    /// <https://sourceware.org/gdb/wiki/Internals%20Versions>. Even the major version I'm not sure
497    /// is super meaningful. Maybe min gdb `major.minor` version gating is sufficient for the
498    /// purposes of debuginfo tests?
499    ///
500    /// FIXME: `gdb_version` is *derived* from gdb, but it's *not* technically a config!
501    pub gdb_version: Option<u32>,
502
503    /// Version of LLDB.
504    ///
505    /// FIXME: `lldb_version` is *derived* from lldb, but it's *not* technically a config!
506    pub lldb_version: Option<u32>,
507
508    /// Version of LLVM.
509    ///
510    /// FIXME: Audit the fallback derivation of
511    /// [`crate::directives::extract_llvm_version_from_binary`], that seems very questionable?
512    pub llvm_version: Option<Version>,
513
514    /// Is LLVM a system LLVM.
515    pub system_llvm: bool,
516
517    /// Path to the android tools.
518    ///
519    /// Note: this is only used for android gdb debugger script in the debuginfo test suite.
520    ///
521    /// FIXME: take a look at this; this is piggy-backing off of gdb code paths but only for
522    /// `arm-linux-androideabi` target.
523    pub android_cross_path: Utf8PathBuf,
524
525    /// Extra parameter to run adb on `arm-linux-androideabi`.
526    ///
527    /// FIXME: is this *only* `arm-linux-androideabi`, or is it also for other Tier 2/3 android
528    /// targets?
529    ///
530    /// FIXME: take a look at this; this is piggy-backing off of gdb code paths but only for
531    /// `arm-linux-androideabi` target.
532    pub adb_path: String,
533
534    /// Extra parameter to run test suite on `arm-linux-androideabi`.
535    ///
536    /// FIXME: is this *only* `arm-linux-androideabi`, or is it also for other Tier 2/3 android
537    /// targets?
538    ///
539    /// FIXME: take a look at this; this is piggy-backing off of gdb code paths but only for
540    /// `arm-linux-androideabi` target.
541    pub adb_test_dir: String,
542
543    /// Status whether android device available or not. When unavailable, this will cause tests to
544    /// panic when the test binary is attempted to be run.
545    ///
546    /// FIXME: take a look at this; this also influences adb in gdb code paths in a strange way.
547    pub adb_device_status: bool,
548
549    /// Path containing LLDB's Python module.
550    ///
551    /// FIXME: `PYTHONPATH` takes precedence over this flag...? See `runtest::run_lldb`.
552    pub lldb_python_dir: Option<String>,
553
554    /// Verbose dump a lot of info.
555    ///
556    /// FIXME: this is *way* too coarse; the user can't select *which* info to verbosely dump.
557    pub verbose: bool,
558
559    /// (Useless) Adjust libtest output format.
560    ///
561    /// FIXME: the hand-rolled executor does not support non-JSON output, because `compiletest` need
562    /// to package test outcome as `libtest`-esque JSON that `bootstrap` can intercept *anyway*.
563    /// However, now that we don't use the `libtest` executor, this is useless.
564    pub format: OutputFormat,
565
566    /// Whether to use colors in test output.
567    ///
568    /// Note: the exact control mechanism is delegated to [`colored`].
569    pub color: ColorConfig,
570
571    /// Where to find the remote test client process, if we're using it.
572    ///
573    /// Note: this is *only* used for target platform executables created by `run-make` test
574    /// recipes.
575    ///
576    /// Note: this is not to be confused with [`Self::runner`], which is a different scheme.
577    ///
578    /// FIXME: the `remote_test_client` scheme is very under-documented.
579    pub remote_test_client: Option<Utf8PathBuf>,
580
581    /// [`CompareMode`] describing what file the actual ui output will be compared to.
582    ///
583    /// FIXME: currently, [`CompareMode`] is a mishmash of lot of things (different borrow-checker
584    /// model, different trait solver, different debugger, etc.).
585    pub compare_mode: Option<CompareMode>,
586
587    /// If true, this will generate a coverage file with UI test files that run `MachineApplicable`
588    /// diagnostics but are missing `run-rustfix` annotations. The generated coverage file is
589    /// created in `$test_suite_build_root/rustfix_missing_coverage.txt`
590    pub rustfix_coverage: bool,
591
592    /// Whether to run `tidy` (html-tidy) when a rustdoc test fails.
593    pub has_html_tidy: bool,
594
595    /// Whether to run `enzyme` autodiff tests.
596    pub has_enzyme: bool,
597
598    /// The current Rust channel info.
599    ///
600    /// FIXME: treat this more carefully; "stable", "beta" and "nightly" are definitely valid, but
601    /// channel might also be "dev" or such, which should be treated as "nightly".
602    pub channel: String,
603
604    /// Whether adding git commit information such as the commit hash has been enabled for building.
605    ///
606    /// FIXME: `compiletest` cannot trust `bootstrap` for this information, because `bootstrap` can
607    /// have bugs and had bugs on that logic. We need to figure out how to obtain this e.g. directly
608    /// from CI or via git locally.
609    pub git_hash: bool,
610
611    /// The default Rust edition.
612    ///
613    /// FIXME: perform stronger validation for this. There are editions that *definitely* exists,
614    /// but there might also be "future" edition.
615    pub edition: Option<String>,
616
617    // Configuration for various run-make tests frobbing things like C compilers or querying about
618    // various LLVM component information.
619    //
620    // FIXME: this really should be better packaged together.
621    // FIXME: these need better docs, e.g. for *host*, or for *target*?
622    pub cc: String,
623    pub cxx: String,
624    pub cflags: String,
625    pub cxxflags: String,
626    pub ar: String,
627    pub target_linker: Option<String>,
628    pub host_linker: Option<String>,
629    pub llvm_components: String,
630
631    /// Path to a NodeJS executable. Used for JS doctests, emscripten and WASM tests.
632    pub nodejs: Option<String>,
633    /// Path to a npm executable. Used for rustdoc GUI tests.
634    pub npm: Option<String>,
635
636    /// Whether to rerun tests even if the inputs are unchanged.
637    pub force_rerun: bool,
638
639    /// Only rerun the tests that result has been modified according to `git status`.
640    ///
641    /// FIXME: this is undocumented.
642    ///
643    /// FIXME: how does this interact with [`Self::force_rerun`]?
644    pub only_modified: bool,
645
646    // FIXME: these are really not "config"s, but rather are information derived from
647    // `rustc`-under-test. This poses an interesting conundrum: if we're testing the
648    // `rustc`-under-test, can we trust its print request outputs and target cfgs? In theory, this
649    // itself can break or be unreliable -- ideally, we'd be sharing these kind of information not
650    // through `rustc`-under-test's execution output. In practice, however, print requests are very
651    // unlikely to completely break (we also have snapshot ui tests for them). Furthermore, even if
652    // we share them via some kind of static config, that static config can still be wrong! Who
653    // tests the tester? Therefore, we make a pragmatic compromise here, and use information derived
654    // from print requests produced by the `rustc`-under-test.
655    //
656    // FIXME: move them out from `Config`, because they are *not* configs.
657    pub target_cfgs: OnceLock<TargetCfgs>,
658    pub builtin_cfg_names: OnceLock<HashSet<String>>,
659    pub supported_crate_types: OnceLock<HashSet<String>>,
660
661    /// FIXME: this is why we still need to depend on *staged* `std`, it's because we currently rely
662    /// on `#![feature(internal_output_capture)]` for [`std::io::set_output_capture`] to implement
663    /// `libtest`-esque `--no-capture`.
664    ///
665    /// FIXME: rename this to the more canonical `no_capture`, or better, invert this to `capture`
666    /// to avoid `!nocapture` double-negatives.
667    pub nocapture: bool,
668
669    /// Needed both to construct [`build_helper::git::GitConfig`].
670    pub nightly_branch: String,
671    pub git_merge_commit_email: String,
672
673    /// True if the profiler runtime is enabled for this target. Used by the
674    /// `needs-profiler-runtime` directive in test files.
675    pub profiler_runtime: bool,
676
677    /// Command for visual diff display, e.g. `diff-tool --color=always`.
678    pub diff_command: Option<String>,
679
680    /// Path to minicore aux library (`tests/auxiliary/minicore.rs`), used for `no_core` tests that
681    /// need `core` stubs in cross-compilation scenarios that do not otherwise want/need to
682    /// `-Zbuild-std`. Used in e.g. ABI tests.
683    pub minicore_path: Utf8PathBuf,
684
685    /// Current codegen backend used.
686    pub codegen_backend: CodegenBackend,
687}
688
689impl Config {
690    /// Incomplete config intended for `src/tools/rustdoc-gui-test` **only** as
691    /// `src/tools/rustdoc-gui-test` wants to reuse `compiletest`'s directive -> test property
692    /// handling for `//@ {compile,run}-flags`, do not use for any other purpose.
693    ///
694    /// FIXME(#143827): this setup feels very hacky. It so happens that `tests/rustdoc-gui/`
695    /// **only** uses `//@ {compile,run}-flags` for now and not any directives that actually rely on
696    /// info that is assumed available in a fully populated [`Config`].
697    pub fn incomplete_for_rustdoc_gui_test() -> Config {
698        // FIXME(#143827): spelling this out intentionally, because this is questionable.
699        //
700        // For instance, `//@ ignore-stage1` will not work at all.
701        Config {
702            mode: TestMode::Rustdoc,
703            // E.g. this has no sensible default tbh.
704            suite: TestSuite::Ui,
705
706            // Dummy values.
707            edition: Default::default(),
708            bless: Default::default(),
709            fail_fast: Default::default(),
710            compile_lib_path: Utf8PathBuf::default(),
711            run_lib_path: Utf8PathBuf::default(),
712            rustc_path: Utf8PathBuf::default(),
713            cargo_path: Default::default(),
714            stage0_rustc_path: Default::default(),
715            rustdoc_path: Default::default(),
716            coverage_dump_path: Default::default(),
717            python: Default::default(),
718            jsondocck_path: Default::default(),
719            jsondoclint_path: Default::default(),
720            llvm_filecheck: Default::default(),
721            llvm_bin_dir: Default::default(),
722            run_clang_based_tests_with: Default::default(),
723            src_root: Utf8PathBuf::default(),
724            src_test_suite_root: Utf8PathBuf::default(),
725            build_root: Utf8PathBuf::default(),
726            build_test_suite_root: Utf8PathBuf::default(),
727            sysroot_base: Utf8PathBuf::default(),
728            stage: Default::default(),
729            stage_id: String::default(),
730            debugger: Default::default(),
731            run_ignored: Default::default(),
732            with_rustc_debug_assertions: Default::default(),
733            with_std_debug_assertions: Default::default(),
734            filters: Default::default(),
735            skip: Default::default(),
736            filter_exact: Default::default(),
737            force_pass_mode: Default::default(),
738            run: Default::default(),
739            runner: Default::default(),
740            host_rustcflags: Default::default(),
741            target_rustcflags: Default::default(),
742            rust_randomized_layout: Default::default(),
743            optimize_tests: Default::default(),
744            target: Default::default(),
745            host: Default::default(),
746            cdb: Default::default(),
747            cdb_version: Default::default(),
748            gdb: Default::default(),
749            gdb_version: Default::default(),
750            lldb_version: Default::default(),
751            llvm_version: Default::default(),
752            system_llvm: Default::default(),
753            android_cross_path: Default::default(),
754            adb_path: Default::default(),
755            adb_test_dir: Default::default(),
756            adb_device_status: Default::default(),
757            lldb_python_dir: Default::default(),
758            verbose: Default::default(),
759            format: Default::default(),
760            color: Default::default(),
761            remote_test_client: Default::default(),
762            compare_mode: Default::default(),
763            rustfix_coverage: Default::default(),
764            has_html_tidy: Default::default(),
765            has_enzyme: Default::default(),
766            channel: Default::default(),
767            git_hash: Default::default(),
768            cc: Default::default(),
769            cxx: Default::default(),
770            cflags: Default::default(),
771            cxxflags: Default::default(),
772            ar: Default::default(),
773            target_linker: Default::default(),
774            host_linker: Default::default(),
775            llvm_components: Default::default(),
776            nodejs: Default::default(),
777            npm: Default::default(),
778            force_rerun: Default::default(),
779            only_modified: Default::default(),
780            target_cfgs: Default::default(),
781            builtin_cfg_names: Default::default(),
782            supported_crate_types: Default::default(),
783            nocapture: Default::default(),
784            nightly_branch: Default::default(),
785            git_merge_commit_email: Default::default(),
786            profiler_runtime: Default::default(),
787            diff_command: Default::default(),
788            minicore_path: Default::default(),
789            codegen_backend: CodegenBackend::Llvm,
790        }
791    }
792
793    /// FIXME: this run scheme is... confusing.
794    pub fn run_enabled(&self) -> bool {
795        self.run.unwrap_or_else(|| {
796            // Auto-detect whether to run based on the platform.
797            !self.target.ends_with("-fuchsia")
798        })
799    }
800
801    pub fn target_cfgs(&self) -> &TargetCfgs {
802        self.target_cfgs.get_or_init(|| TargetCfgs::new(self))
803    }
804
805    pub fn target_cfg(&self) -> &TargetCfg {
806        &self.target_cfgs().current
807    }
808
809    pub fn matches_arch(&self, arch: &str) -> bool {
810        self.target_cfg().arch == arch ||
811        // Matching all the thumb variants as one can be convenient.
812        // (thumbv6m, thumbv7em, thumbv7m, etc.)
813        (arch == "thumb" && self.target.starts_with("thumb"))
814    }
815
816    pub fn matches_os(&self, os: &str) -> bool {
817        self.target_cfg().os == os
818    }
819
820    pub fn matches_env(&self, env: &str) -> bool {
821        self.target_cfg().env == env
822    }
823
824    pub fn matches_abi(&self, abi: &str) -> bool {
825        self.target_cfg().abi == abi
826    }
827
828    pub fn matches_family(&self, family: &str) -> bool {
829        self.target_cfg().families.iter().any(|f| f == family)
830    }
831
832    pub fn is_big_endian(&self) -> bool {
833        self.target_cfg().endian == Endian::Big
834    }
835
836    pub fn get_pointer_width(&self) -> u32 {
837        *&self.target_cfg().pointer_width
838    }
839
840    pub fn can_unwind(&self) -> bool {
841        self.target_cfg().panic == PanicStrategy::Unwind
842    }
843
844    /// Get the list of builtin, 'well known' cfg names
845    pub fn builtin_cfg_names(&self) -> &HashSet<String> {
846        self.builtin_cfg_names.get_or_init(|| builtin_cfg_names(self))
847    }
848
849    /// Get the list of crate types that the target platform supports.
850    pub fn supported_crate_types(&self) -> &HashSet<String> {
851        self.supported_crate_types.get_or_init(|| supported_crate_types(self))
852    }
853
854    pub fn has_threads(&self) -> bool {
855        // Wasm targets don't have threads unless `-threads` is in the target
856        // name, such as `wasm32-wasip1-threads`.
857        if self.target.starts_with("wasm") {
858            return self.target.contains("threads");
859        }
860        true
861    }
862
863    pub fn has_asm_support(&self) -> bool {
864        // This should match the stable list in `LoweringContext::lower_inline_asm`.
865        static ASM_SUPPORTED_ARCHS: &[&str] = &[
866            "x86",
867            "x86_64",
868            "arm",
869            "aarch64",
870            "arm64ec",
871            "riscv32",
872            "riscv64",
873            "loongarch32",
874            "loongarch64",
875            "s390x",
876            // These targets require an additional asm_experimental_arch feature.
877            // "nvptx64", "hexagon", "mips", "mips64", "spirv", "wasm32",
878        ];
879        ASM_SUPPORTED_ARCHS.contains(&self.target_cfg().arch.as_str())
880    }
881
882    pub fn git_config(&self) -> GitConfig<'_> {
883        GitConfig {
884            nightly_branch: &self.nightly_branch,
885            git_merge_commit_email: &self.git_merge_commit_email,
886        }
887    }
888
889    pub fn has_subprocess_support(&self) -> bool {
890        // FIXME(#135928): compiletest is always a **host** tool. Building and running an
891        // capability detection executable against the **target** is not trivial. The short term
892        // solution here is to hard-code some targets to allow/deny, unfortunately.
893
894        let unsupported_target = self.target_cfg().env == "sgx"
895            || matches!(self.target_cfg().arch.as_str(), "wasm32" | "wasm64")
896            || self.target_cfg().os == "emscripten";
897        !unsupported_target
898    }
899}
900
901/// Known widths of `target_has_atomic`.
902pub const KNOWN_TARGET_HAS_ATOMIC_WIDTHS: &[&str] = &["8", "16", "32", "64", "128", "ptr"];
903
904#[derive(Debug, Clone)]
905pub struct TargetCfgs {
906    pub current: TargetCfg,
907    pub all_targets: HashSet<String>,
908    pub all_archs: HashSet<String>,
909    pub all_oses: HashSet<String>,
910    pub all_oses_and_envs: HashSet<String>,
911    pub all_envs: HashSet<String>,
912    pub all_abis: HashSet<String>,
913    pub all_families: HashSet<String>,
914    pub all_pointer_widths: HashSet<String>,
915    pub all_rustc_abis: HashSet<String>,
916}
917
918impl TargetCfgs {
919    fn new(config: &Config) -> TargetCfgs {
920        let mut targets: HashMap<String, TargetCfg> = serde_json::from_str(&rustc_output(
921            config,
922            &["--print=all-target-specs-json", "-Zunstable-options"],
923            Default::default(),
924        ))
925        .unwrap();
926
927        let mut all_targets = HashSet::new();
928        let mut all_archs = HashSet::new();
929        let mut all_oses = HashSet::new();
930        let mut all_oses_and_envs = HashSet::new();
931        let mut all_envs = HashSet::new();
932        let mut all_abis = HashSet::new();
933        let mut all_families = HashSet::new();
934        let mut all_pointer_widths = HashSet::new();
935        // NOTE: for distinction between `abi` and `rustc_abi`, see comment on
936        // `TargetCfg::rustc_abi`.
937        let mut all_rustc_abis = HashSet::new();
938
939        // If current target is not included in the `--print=all-target-specs-json` output,
940        // we check whether it is a custom target from the user or a synthetic target from bootstrap.
941        if !targets.contains_key(&config.target) {
942            let mut envs: HashMap<String, String> = HashMap::new();
943
944            if let Ok(t) = std::env::var("RUST_TARGET_PATH") {
945                envs.insert("RUST_TARGET_PATH".into(), t);
946            }
947
948            // This returns false only when the target is neither a synthetic target
949            // nor a custom target from the user, indicating it is most likely invalid.
950            if config.target.ends_with(".json") || !envs.is_empty() {
951                targets.insert(
952                    config.target.clone(),
953                    serde_json::from_str(&rustc_output(
954                        config,
955                        &[
956                            "--print=target-spec-json",
957                            "-Zunstable-options",
958                            "--target",
959                            &config.target,
960                        ],
961                        envs,
962                    ))
963                    .unwrap(),
964                );
965            }
966        }
967
968        for (target, cfg) in targets.iter() {
969            all_archs.insert(cfg.arch.clone());
970            all_oses.insert(cfg.os.clone());
971            all_oses_and_envs.insert(cfg.os_and_env());
972            all_envs.insert(cfg.env.clone());
973            all_abis.insert(cfg.abi.clone());
974            for family in &cfg.families {
975                all_families.insert(family.clone());
976            }
977            all_pointer_widths.insert(format!("{}bit", cfg.pointer_width));
978            if let Some(rustc_abi) = &cfg.rustc_abi {
979                all_rustc_abis.insert(rustc_abi.clone());
980            }
981            all_targets.insert(target.clone());
982        }
983
984        Self {
985            current: Self::get_current_target_config(config, &targets),
986            all_targets,
987            all_archs,
988            all_oses,
989            all_oses_and_envs,
990            all_envs,
991            all_abis,
992            all_families,
993            all_pointer_widths,
994            all_rustc_abis,
995        }
996    }
997
998    fn get_current_target_config(
999        config: &Config,
1000        targets: &HashMap<String, TargetCfg>,
1001    ) -> TargetCfg {
1002        let mut cfg = targets[&config.target].clone();
1003
1004        // To get the target information for the current target, we take the target spec obtained
1005        // from `--print=all-target-specs-json`, and then we enrich it with the information
1006        // gathered from `--print=cfg --target=$target`.
1007        //
1008        // This is done because some parts of the target spec can be overridden with `-C` flags,
1009        // which are respected for `--print=cfg` but not for `--print=all-target-specs-json`. The
1010        // code below extracts them from `--print=cfg`: make sure to only override fields that can
1011        // actually be changed with `-C` flags.
1012        for config in
1013            rustc_output(config, &["--print=cfg", "--target", &config.target], Default::default())
1014                .trim()
1015                .lines()
1016        {
1017            let (name, value) = config
1018                .split_once("=\"")
1019                .map(|(name, value)| {
1020                    (
1021                        name,
1022                        Some(
1023                            value
1024                                .strip_suffix('\"')
1025                                .expect("key-value pair should be properly quoted"),
1026                        ),
1027                    )
1028                })
1029                .unwrap_or_else(|| (config, None));
1030
1031            match (name, value) {
1032                // Can be overridden with `-C panic=$strategy`.
1033                ("panic", Some("abort")) => cfg.panic = PanicStrategy::Abort,
1034                ("panic", Some("unwind")) => cfg.panic = PanicStrategy::Unwind,
1035                ("panic", other) => panic!("unexpected value for panic cfg: {other:?}"),
1036
1037                ("target_has_atomic", Some(width))
1038                    if KNOWN_TARGET_HAS_ATOMIC_WIDTHS.contains(&width) =>
1039                {
1040                    cfg.target_has_atomic.insert(width.to_string());
1041                }
1042                ("target_has_atomic", Some(other)) => {
1043                    panic!("unexpected value for `target_has_atomic` cfg: {other:?}")
1044                }
1045                // Nightly-only std-internal impl detail.
1046                ("target_has_atomic", None) => {}
1047                _ => {}
1048            }
1049        }
1050
1051        cfg
1052    }
1053}
1054
1055#[derive(Clone, Debug, serde::Deserialize)]
1056#[serde(rename_all = "kebab-case")]
1057pub struct TargetCfg {
1058    pub(crate) arch: String,
1059    #[serde(default = "default_os")]
1060    pub(crate) os: String,
1061    #[serde(default)]
1062    pub(crate) env: String,
1063    #[serde(default)]
1064    pub(crate) abi: String,
1065    #[serde(rename = "target-family", default)]
1066    pub(crate) families: Vec<String>,
1067    #[serde(rename = "target-pointer-width", deserialize_with = "serde_parse_u32")]
1068    pub(crate) pointer_width: u32,
1069    #[serde(rename = "target-endian", default)]
1070    endian: Endian,
1071    #[serde(rename = "panic-strategy", default)]
1072    pub(crate) panic: PanicStrategy,
1073    #[serde(default)]
1074    pub(crate) dynamic_linking: bool,
1075    #[serde(rename = "supported-sanitizers", default)]
1076    pub(crate) sanitizers: Vec<Sanitizer>,
1077    #[serde(rename = "supports-xray", default)]
1078    pub(crate) xray: bool,
1079    #[serde(default = "default_reloc_model")]
1080    pub(crate) relocation_model: String,
1081    // NOTE: `rustc_abi` should not be confused with `abi`. `rustc_abi` was introduced in #137037 to
1082    // make SSE2 *required* by the ABI (kind of a hack to make a target feature *required* via the
1083    // target spec).
1084    pub(crate) rustc_abi: Option<String>,
1085
1086    // Not present in target cfg json output, additional derived information.
1087    #[serde(skip)]
1088    /// Supported target atomic widths: e.g. `8` to `128` or `ptr`. This is derived from the builtin
1089    /// `target_has_atomic` `cfg`s e.g. `target_has_atomic="8"`.
1090    pub(crate) target_has_atomic: BTreeSet<String>,
1091}
1092
1093impl TargetCfg {
1094    pub(crate) fn os_and_env(&self) -> String {
1095        format!("{}-{}", self.os, self.env)
1096    }
1097}
1098
1099fn default_os() -> String {
1100    "none".into()
1101}
1102
1103fn default_reloc_model() -> String {
1104    "pic".into()
1105}
1106
1107#[derive(Eq, PartialEq, Clone, Debug, Default, serde::Deserialize)]
1108#[serde(rename_all = "kebab-case")]
1109pub enum Endian {
1110    #[default]
1111    Little,
1112    Big,
1113}
1114
1115fn builtin_cfg_names(config: &Config) -> HashSet<String> {
1116    rustc_output(
1117        config,
1118        &["--print=check-cfg", "-Zunstable-options", "--check-cfg=cfg()"],
1119        Default::default(),
1120    )
1121    .lines()
1122    .map(|l| if let Some((name, _)) = l.split_once('=') { name.to_string() } else { l.to_string() })
1123    .chain(std::iter::once(String::from("test")))
1124    .collect()
1125}
1126
1127pub const KNOWN_CRATE_TYPES: &[&str] =
1128    &["bin", "cdylib", "dylib", "lib", "proc-macro", "rlib", "staticlib"];
1129
1130fn supported_crate_types(config: &Config) -> HashSet<String> {
1131    let crate_types: HashSet<_> = rustc_output(
1132        config,
1133        &["--target", &config.target, "--print=supported-crate-types", "-Zunstable-options"],
1134        Default::default(),
1135    )
1136    .lines()
1137    .map(|l| l.to_string())
1138    .collect();
1139
1140    for crate_type in crate_types.iter() {
1141        assert!(
1142            KNOWN_CRATE_TYPES.contains(&crate_type.as_str()),
1143            "unexpected crate type `{}`: known crate types are {:?}",
1144            crate_type,
1145            KNOWN_CRATE_TYPES
1146        );
1147    }
1148
1149    crate_types
1150}
1151
1152fn rustc_output(config: &Config, args: &[&str], envs: HashMap<String, String>) -> String {
1153    let mut command = Command::new(&config.rustc_path);
1154    add_dylib_path(&mut command, iter::once(&config.compile_lib_path));
1155    command.args(&config.target_rustcflags).args(args);
1156    command.env("RUSTC_BOOTSTRAP", "1");
1157    command.envs(envs);
1158
1159    let output = match command.output() {
1160        Ok(output) => output,
1161        Err(e) => {
1162            fatal!("failed to run {command:?}: {e}");
1163        }
1164    };
1165    if !output.status.success() {
1166        fatal!(
1167            "failed to run {command:?}\n--- stdout\n{}\n--- stderr\n{}",
1168            String::from_utf8(output.stdout).unwrap(),
1169            String::from_utf8(output.stderr).unwrap(),
1170        );
1171    }
1172    String::from_utf8(output.stdout).unwrap()
1173}
1174
1175fn serde_parse_u32<'de, D: Deserializer<'de>>(deserializer: D) -> Result<u32, D::Error> {
1176    let string = String::deserialize(deserializer)?;
1177    string.parse().map_err(D::Error::custom)
1178}
1179
1180#[derive(Debug, Clone)]
1181pub struct TestPaths {
1182    pub file: Utf8PathBuf,         // e.g., compile-test/foo/bar/baz.rs
1183    pub relative_dir: Utf8PathBuf, // e.g., foo/bar
1184}
1185
1186/// Used by `ui` tests to generate things like `foo.stderr` from `foo.rs`.
1187pub fn expected_output_path(
1188    testpaths: &TestPaths,
1189    revision: Option<&str>,
1190    compare_mode: &Option<CompareMode>,
1191    kind: &str,
1192) -> Utf8PathBuf {
1193    assert!(UI_EXTENSIONS.contains(&kind));
1194    let mut parts = Vec::new();
1195
1196    if let Some(x) = revision {
1197        parts.push(x);
1198    }
1199    if let Some(ref x) = *compare_mode {
1200        parts.push(x.to_str());
1201    }
1202    parts.push(kind);
1203
1204    let extension = parts.join(".");
1205    testpaths.file.with_extension(extension)
1206}
1207
1208pub const UI_EXTENSIONS: &[&str] = &[
1209    UI_STDERR,
1210    UI_SVG,
1211    UI_WINDOWS_SVG,
1212    UI_STDOUT,
1213    UI_FIXED,
1214    UI_RUN_STDERR,
1215    UI_RUN_STDOUT,
1216    UI_STDERR_64,
1217    UI_STDERR_32,
1218    UI_STDERR_16,
1219    UI_COVERAGE,
1220    UI_COVERAGE_MAP,
1221];
1222pub const UI_STDERR: &str = "stderr";
1223pub const UI_SVG: &str = "svg";
1224pub const UI_WINDOWS_SVG: &str = "windows.svg";
1225pub const UI_STDOUT: &str = "stdout";
1226pub const UI_FIXED: &str = "fixed";
1227pub const UI_RUN_STDERR: &str = "run.stderr";
1228pub const UI_RUN_STDOUT: &str = "run.stdout";
1229pub const UI_STDERR_64: &str = "64bit.stderr";
1230pub const UI_STDERR_32: &str = "32bit.stderr";
1231pub const UI_STDERR_16: &str = "16bit.stderr";
1232pub const UI_COVERAGE: &str = "coverage";
1233pub const UI_COVERAGE_MAP: &str = "cov-map";
1234
1235/// Absolute path to the directory where all output for all tests in the given `relative_dir` group
1236/// should reside. Example:
1237///
1238/// ```text
1239/// /path/to/build/host-tuple/test/ui/relative/
1240/// ```
1241///
1242/// This is created early when tests are collected to avoid race conditions.
1243pub fn output_relative_path(config: &Config, relative_dir: &Utf8Path) -> Utf8PathBuf {
1244    config.build_test_suite_root.join(relative_dir)
1245}
1246
1247/// Generates a unique name for the test, such as `testname.revision.mode`.
1248pub fn output_testname_unique(
1249    config: &Config,
1250    testpaths: &TestPaths,
1251    revision: Option<&str>,
1252) -> Utf8PathBuf {
1253    let mode = config.compare_mode.as_ref().map_or("", |m| m.to_str());
1254    let debugger = config.debugger.as_ref().map_or("", |m| m.to_str());
1255    Utf8PathBuf::from(&testpaths.file.file_stem().unwrap())
1256        .with_extra_extension(config.mode.output_dir_disambiguator())
1257        .with_extra_extension(revision.unwrap_or(""))
1258        .with_extra_extension(mode)
1259        .with_extra_extension(debugger)
1260}
1261
1262/// Absolute path to the directory where all output for the given
1263/// test/revision should reside. Example:
1264///   /path/to/build/host-tuple/test/ui/relative/testname.revision.mode/
1265pub fn output_base_dir(
1266    config: &Config,
1267    testpaths: &TestPaths,
1268    revision: Option<&str>,
1269) -> Utf8PathBuf {
1270    output_relative_path(config, &testpaths.relative_dir)
1271        .join(output_testname_unique(config, testpaths, revision))
1272}
1273
1274/// Absolute path to the base filename used as output for the given
1275/// test/revision. Example:
1276///   /path/to/build/host-tuple/test/ui/relative/testname.revision.mode/testname
1277pub fn output_base_name(
1278    config: &Config,
1279    testpaths: &TestPaths,
1280    revision: Option<&str>,
1281) -> Utf8PathBuf {
1282    output_base_dir(config, testpaths, revision).join(testpaths.file.file_stem().unwrap())
1283}
1284
1285/// Absolute path to the directory to use for incremental compilation. Example:
1286///   /path/to/build/host-tuple/test/ui/relative/testname.mode/testname.inc
1287pub fn incremental_dir(
1288    config: &Config,
1289    testpaths: &TestPaths,
1290    revision: Option<&str>,
1291) -> Utf8PathBuf {
1292    output_base_name(config, testpaths, revision).with_extension("inc")
1293}