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}