Use ui_tests

Author: celinval

.github/scripts/run_rustc_tests.sh

@@ -23,13 +23,13 @@ fi
 pushd "${RUST_REPO}"
 SUITES=(
   # Match https://github.com/rust-lang/rust/blob/master/src/bootstrap/test.rs for now
-  "tests/ui/cfg ui"
+  "tests/ui/cfg yolo"
 )
 for suite_cfg in "${SUITES[@]}"; do
   # Hack to work on older bash like the ones on MacOS.
   suite_pair=($suite_cfg)
   suite=${suite_pair[0]}
   mode=${suite_pair[1]}
   echo "${suite_cfg} pair: $suite_pair mode: $mode"
-  compiletest --driver-path="${TOOLS_BIN}/test-drive" --mode=${mode} --src-base="${suite}" --output-path "${RUST_REPO}/build"
+  compiletest --driver-path="${TOOLS_BIN}/test-drive" --mode=${mode} --src-base="${suite}" --output-dir="${RUST_REPO}/build"
 done

tools/compiletest/Cargo.toml

@@ -5,7 +5,7 @@ version = "0.0.0"
 edition = "2021"
 
 [dependencies]
-compiletest_rs = { version = "0.10.0", features = [ "rustc" ] }
+ui_test = "0.20.0"
 clap = { version = "4.1.3", features = ["derive"] }
 
 [package.metadata.rust-analyzer]

tools/compiletest/src/args.rs

@@ -1,6 +1,22 @@
-use compiletest_rs::Config;
+/// Create our own parser and build the Config from it.
 use std::fmt::Debug;
 use std::path::PathBuf;
+use ui_test::{CommandBuilder, Config, OutputConflictHandling, RustfixMode};
+
+#[derive(Copy, Clone, Debug, clap::ValueEnum)]
+/// Decides what is expected of each test's exit status.
+pub enum Mode {
+    /// The test passes a full execution of the rustc driver
+    Pass,
+    /// The test produces an executable binary that can get executed on the host
+    Run,
+    /// The rustc driver panicked
+    Panic,
+    /// The rustc driver emitted an error
+    Fail,
+    /// Run the tests, but always pass them as long as all annotations are satisfied and stderr files match.
+    Yolo,
+}
 
 #[derive(Debug, clap::Parser)]
 #[command(version, name = "compiletest")]
@@ -9,32 +25,46 @@ pub struct Args {
     #[arg(long)]
     src_base: PathBuf,
 
-    /// The mode according to compiletest modes.
-    #[arg(long)]
-    mode: String,
+    /// The mode according to ui_test modes.
+    #[arg(long, default_value="yolo")]
+    mode: Mode,
 
     /// Path for the stable-mir driver.
     #[arg(long)]
     driver_path: PathBuf,
 
     /// Path for where the output should be stored.
     #[arg(long)]
-    output_path: PathBuf,
+    output_dir: PathBuf,
 
     #[arg(long)]
-    verbose: bool,
+    pub verbose: bool,
+}
+
+impl From<Mode> for ui_test::Mode {
+    /// Use rustc configuration as default but override arguments to fit our use case.
+    fn from(mode: Mode) -> ui_test::Mode {
+        match mode {
+            Mode::Pass => { ui_test::Mode::Pass }
+            Mode::Run => { ui_test::Mode::Run { exit_code: 0 }}
+            Mode::Panic => { ui_test::Mode::Panic }
+            Mode::Fail => { ui_test::Mode::Fail { require_patterns: false, rustfix: RustfixMode::Disabled }}
+            Mode::Yolo => { ui_test::Mode::Yolo { rustfix: RustfixMode::Disabled }}
+        }
+    }
 }
 
 impl From<Args> for Config {
+    /// Use rustc configuration as default but override arguments to fit our use case.
     fn from(args: Args) -> Config {
-        let mut config = Config::default();
-        config.mode = args.mode.parse().expect("Invalid mode");
-        config.src_base = args.src_base;
-        config.rustc_path = args.driver_path;
-        config.build_base = args.output_path;
-        config.verbose = args.verbose;
-        config.run_lib_path = PathBuf::from(env!("RUSTC_LIB_PATH"));
-        config.link_deps();
+        let mut config = Config::rustc(args.src_base);
+        config.program = CommandBuilder::rustc();
+        config.program.program = args.driver_path;
+        config.program.args.push("--check-smir".into());
+        config.mode = ui_test::Mode::from(args.mode);
+        config.output_conflict_handling = OutputConflictHandling::Error("Should Fail".to_string());
+        config.out_dir = args.output_dir;
+        //config.run_lib_path = PathBuf::from(env!("RUSTC_LIB_PATH"));
         config
     }
 }

tools/compiletest/src/main.rs

@@ -1,12 +1,35 @@
 //! Run compiletest on a given folder.
 
 mod args;
+
+use std::process::ExitCode;
 use clap::Parser;
-use compiletest_rs::Config;
+use ui_test::{status_emitter, Config};
 
-fn main() {
+fn main() -> ExitCode {
     let args = args::Args::parse();
-    println!("args: ${args:?}");
-    let cfg = Config::from(args);
-    compiletest_rs::run_tests(&cfg);
+    let verbose = args.verbose;
+    if verbose {
+        println!("args: ${args:?}");
+    }
+    let config = Config::from(args);
+    if verbose {
+        println!("Compiler: {}", config.program.display());
+    }
+
+    let name = config.root_dir.display().to_string();
+
+    let text = if verbose {
+        status_emitter::Text::verbose()
+    } else {
+        status_emitter::Text::quiet()
+    };
+
+    let result = ui_test::run_tests_generic(
+        vec![config],
+        ui_test::default_file_filter,
+        ui_test::default_per_file_config,
+        (text, status_emitter::Gha::<true> { name }),
+    );
+    if result.is_ok() { ExitCode::SUCCESS } else { ExitCode::FAILURE }
 }

tools/test-drive/src/main.rs

@@ -10,11 +10,17 @@ extern crate rustc_middle;
 extern crate rustc_smir;
 
 use rustc_middle::ty::TyCtxt;
-use rustc_smir::{rustc_internal, stable_mir};
+use rustc_smir::rustc_internal;
+use rustc_smir::stable_mir::CompilerError;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::ops::ControlFlow;
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::process::ExitCode;
 
 const CHECK_ARG: &str = "--check-smir";
+const VERBOSE_ARG: &str = "--verbose";
+// Use a static variable for simplicity.
+static VERBOSE: AtomicBool = AtomicBool::new(false);
 
 type TestResult = Result<(), String>;
 
@@ -32,12 +38,15 @@ fn main() -> ExitCode {
             !is_check_arg
         })
         .collect();
-
-
-    let callback = if check_smir { test_stable_mir } else { |_: TyCtxt| ExitCode::SUCCESS };
-    let result = rustc_internal::StableMir::new(args, callback).continue_compilation().run();
-    if let Ok(test_result) = result {
-        test_result
+    VERBOSE.store(args.iter().any(|arg| &*arg == VERBOSE_ARG), Ordering::Relaxed);
+    let callback = if check_smir {
+        test_stable_mir
+    } else {
+        |_: TyCtxt| ControlFlow::<()>::Continue(())
+    };
+    let result = rustc_internal::StableMir::new(args, callback).run();
+    if result.is_ok() || matches!(result, Err(CompilerError::Skipped)) {
+        ExitCode::SUCCESS
     } else {
         ExitCode::FAILURE
     }
@@ -51,26 +60,32 @@ macro_rules! run_tests {
     };
 }
 
+fn info(msg: String) {
+    if VERBOSE.load(Ordering::Relaxed) {
+        println!("{}", msg);
+    }
+}
+
 /// This function invoke other tests and process their results.
 /// Tests should avoid panic,
-fn test_stable_mir(tcx: TyCtxt<'_>) -> ExitCode {
+fn test_stable_mir(_tcx: TyCtxt<'_>) -> ControlFlow<()> {
     let results = run_tests![
         sanity_checks::test_entry_fn,
         sanity_checks::test_all_fns,
         sanity_checks::test_traits,
         sanity_checks::test_crates
     ];
     let (success, failure): (Vec<_>, Vec<_>) = results.iter().partition(|r| r.is_ok());
-    println!(
+    info(format!(
         "Ran {} tests. {} succeeded. {} failed",
         results.len(),
         success.len(),
         failure.len()
-    );
+    ));
     if failure.is_empty() {
-        ExitCode::SUCCESS
+        ControlFlow::<()>::Continue(())
     } else {
-        ExitCode::FAILURE
+        ControlFlow::<()>::Break(())
     }
 }
 
@@ -79,10 +94,10 @@ fn run_test<F: FnOnce() -> TestResult>(name: &str, f: F) -> TestResult {
         Err(_) => Err("Panic: {}".to_string()),
         Ok(result) => result,
     };
-    println!(
+    info(format!(
         "Test {}: {}",
         name,
         result.as_ref().err().unwrap_or(&"Ok".to_string())
-    );
+    ));
     result
 }

tools/test-drive/src/sanity_checks.rs

@@ -4,9 +4,7 @@
 //! These checks should only depend on StableMIR APIs. See other modules for tests that compare
 //! the result between StableMIR and internal APIs.
 use crate::TestResult;
-use rustc_middle::ty::TyCtxt;
 use rustc_smir::stable_mir;
-use std::collections::HashSet;
 use std::fmt::Debug;
 use std::hint::black_box;
 
@@ -36,6 +34,7 @@ pub fn check(val: bool, msg: String) -> TestResult {
 pub fn test_entry_fn() -> TestResult {
     let entry_fn = stable_mir::entry_fn();
     entry_fn.map_or(Ok(()), |entry_fn| {
+        check_body(entry_fn.body());
         let all_items = stable_mir::all_local_items();
         check(
             all_items.contains(&entry_fn),
@@ -52,6 +51,8 @@ pub fn test_all_fns() -> TestResult {
         "Failed to find any local item".to_string(),
     )?;
 
+    // Not sure which API to use to make sure this is a function that has a body.
+    #[cfg(skip)]
     for item in all_items {
         // Get body and iterate over items
         let body = item.body();