Simplify how we invoke compiletest (rust-lang#784)

* Simplify how we invoke compiletest

I removed stuff that wasn't needed and I have also added default values
for stuff that doesn't really change for Kani. Now only --suite and
--mode are requied.

This will make it easier for us to manually invoke a single test suite.

Author: celinval

scripts/kani-regression.sh

@@ -8,16 +8,6 @@ fi
 set -o pipefail
 set -o nounset
 
-# Test for platform
-PLATFORM=$(uname -sp)
-if [[ $PLATFORM == "Linux x86_64" ]]
-then
-  TARGET="x86_64-unknown-linux-gnu"
-elif [[ $PLATFORM == "Darwin i386" ]]
-then
-  TARGET="x86_64-apple-darwin"
-fi
-
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 export PATH=$SCRIPT_DIR:$PATH
 EXTRA_X_PY_BUILD_ARGS="${EXTRA_X_PY_BUILD_ARGS:-}"
@@ -55,15 +45,10 @@ for testp in "${TESTS[@]}"; do
   testl=($testp)
   suite=${testl[0]}
   mode=${testl[1]}
-  echo "Check compiletest suite=$suite mode=$mode ($TARGET -> $TARGET)"
+  echo "Check compiletest suite=$suite mode=$mode"
   # Note: `cargo-kani` tests fail if we do not add `$(pwd)` to `--build-base`
   # Tracking issue: https://github.com/model-checking/kani/issues/755
-  cargo run -p compiletest --  --kani-dir-path scripts --src-base tests/$suite \
-                               --build-base $(pwd)/build/$TARGET/tests/$suite \
-                               --stage-id stage1-$TARGET \
-                               --suite $suite --mode $mode \
-                               --target $TARGET --host $TARGET \
-                               --quiet --channel dev
+  cargo run -p compiletest --quiet -- --suite $suite --mode $mode --quiet
 done
 
 # Check codegen for the standard library

tools/compiletest/src/common.rs

@@ -88,9 +88,6 @@ pub struct Config {
     /// The directory where programs should be built
     pub build_base: PathBuf,
 
-    /// The name of the stage being built (stage1, etc)
-    pub stage_id: String,
-
     /// The test mode, e.g. ui or debuginfo.
     pub mode: Mode,
 
@@ -135,9 +132,6 @@ pub struct Config {
     /// Whether to use colors in test.
     pub color: ColorConfig,
 
-    /// The current Rust channel
-    pub channel: String,
-
     /// The default Rust edition
     pub edition: Option<String>,
 

tools/compiletest/src/header.rs

@@ -6,7 +6,7 @@
 use std::fs::File;
 use std::io::prelude::*;
 use std::io::BufReader;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 use tracing::*;
 
@@ -176,22 +176,6 @@ impl Config {
         }
     }
 
-    /// This function finds the root source of the repository by starting at the source base for
-    /// compiletest. It will then visit its parent folder and check if we found the root by
-    /// checking if it can find the compiletest `Cargo.toml` file in the path relative to the root.
-    pub fn find_rust_src_root(&self) -> Option<PathBuf> {
-        let mut path = self.src_base.clone();
-        let path_postfix = Path::new("tools/compiletest/Cargo.toml");
-
-        while path.pop() {
-            if path.join(&path_postfix).is_file() {
-                return Some(path);
-            }
-        }
-
-        None
-    }
-
     fn parse_edition(&self, line: &str) -> Option<String> {
         self.parse_name_value_directive(line, "edition")
     }

tools/compiletest/src/main.rs

@@ -12,12 +12,12 @@ extern crate test;
 
 use crate::common::{output_base_dir, output_relative_path, PanicStrategy};
 use crate::common::{Config, Mode, TestPaths};
-use crate::util::logv;
+use crate::util::{logv, top_level};
 use getopts::Options;
 use std::env;
 use std::ffi::OsString;
 use std::fs;
-use std::io::{self, ErrorKind};
+use std::io::{self};
 use std::path::{Path, PathBuf};
 use std::time::SystemTime;
 use test::ColorConfig;
@@ -60,7 +60,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         .optopt("", "llvm-filecheck", "path to LLVM's FileCheck binary", "DIR")
         .optopt("", "src-base", "directory to scan for test files", "PATH")
         .optopt("", "build-base", "directory to deposit test outputs", "PATH")
-        .optopt("", "stage-id", "the target-stage identifier", "stageN-TARGET")
         .optopt(
             "",
             "mode",
@@ -137,7 +136,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         )
         .optflag("", "force-rerun", "rerun tests even if the inputs are unchanged")
         .optflag("h", "help", "show this message")
-        .optopt("", "channel", "current Rust channel", "CHANNEL")
         .optopt("", "edition", "default Rust edition", "EDITION");
 
     let (argv0, args_) = args.split_first().unwrap();
@@ -160,10 +158,16 @@ pub fn parse_config(args: Vec<String>) -> Config {
         panic!()
     }
 
-    fn opt_path(m: &getopts::Matches, nm: &str) -> PathBuf {
+    fn opt_path(m: &getopts::Matches, nm: &str, default: &[&str]) -> PathBuf {
         match m.opt_str(nm) {
             Some(s) => PathBuf::from(&s),
-            None => panic!("no option (=path) found for {}", nm),
+            None => {
+                let mut root_folder = top_level().expect(
+                    format!("Cannot find root directory. Please provide --{} option.", nm).as_str(),
+                );
+                default.into_iter().for_each(|f| root_folder.push(f));
+                root_folder
+            }
         }
     }
 
@@ -175,17 +179,17 @@ pub fn parse_config(args: Vec<String>) -> Config {
         Some(x) => panic!("argument for --color must be auto, always, or never, but found `{}`", x),
     };
 
-    let src_base = opt_path(matches, "src-base");
+    let suite = matches.opt_str("suite").unwrap();
+    let src_base = opt_path(matches, "src-base", &["tests", suite.as_str()]);
     let run_ignored = matches.opt_present("ignored");
     let mode = matches.opt_str("mode").unwrap().parse().expect("invalid mode");
 
     Config {
-        kani_dir_path: opt_path(matches, "kani-dir-path"),
+        kani_dir_path: opt_path(matches, "kani-dir-path", &["scripts"]),
         src_base,
-        build_base: opt_path(matches, "build-base"),
-        stage_id: matches.opt_str("stage-id").unwrap(),
+        build_base: opt_path(matches, "build-base", &["build", "tests", suite.as_str()]),
         mode,
-        suite: matches.opt_str("suite").unwrap(),
+        suite,
         run_ignored,
         filters: matches.free.clone(),
         filter_exact: matches.opt_present("exact"),
@@ -202,7 +206,6 @@ pub fn parse_config(args: Vec<String>) -> Config {
         verbose: matches.opt_present("verbose"),
         quiet: matches.opt_present("quiet"),
         color,
-        channel: matches.opt_str("channel").unwrap(),
         edition: matches.opt_str("edition"),
 
         force_rerun: matches.opt_present("force-rerun"),
@@ -214,7 +217,6 @@ pub fn log_config(config: &Config) {
     logv(c, "configuration:".to_string());
     logv(c, format!("src_base: {:?}", config.src_base.display()));
     logv(c, format!("build_base: {:?}", config.build_base.display()));
-    logv(c, format!("stage_id: {}", config.stage_id));
     logv(c, format!("mode: {}", config.mode));
     logv(c, format!("run_ignored: {}", config.run_ignored));
     logv(c, format!("filters: {:?}", config.filters));
@@ -324,14 +326,14 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
 
 pub fn make_tests(config: &Config, tests: &mut Vec<test::TestDescAndFn>) {
     debug!("making tests from {:?}", config.src_base.display());
-    let inputs = common_inputs_stamp(config);
+    let inputs = common_inputs_stamp();
     collect_tests_from_dir(config, &config.src_base, &PathBuf::new(), &inputs, tests)
         .unwrap_or_else(|_| panic!("Could not read tests from {}", config.src_base.display()));
 }
 
 /// Returns a stamp constructed from input files common to all test cases.
-fn common_inputs_stamp(config: &Config) -> Stamp {
-    let rust_src_dir = config.find_rust_src_root().expect("Could not find Rust source root");
+fn common_inputs_stamp() -> Stamp {
+    let rust_src_dir = top_level().expect("Could not find Rust source root");
     let kani_bin_path = &rust_src_dir.join("target/debug/kani-compiler");
 
     // Create stamp based on the `kani-compiler` binary
@@ -453,16 +455,6 @@ fn is_up_to_date(
     inputs: &Stamp,
 ) -> bool {
     let stamp_name = stamp(config, testpaths, revision);
-    // Check hash.
-    let contents = match fs::read_to_string(&stamp_name) {
-        Ok(f) => f,
-        Err(ref e) if e.kind() == ErrorKind::InvalidData => panic!("Can't read stamp contents"),
-        Err(_) => return false,
-    };
-    let expected_hash = runtest::compute_stamp_hash(config);
-    if contents != expected_hash {
-        return false;
-    }
     // Check timestamps.
     let inputs = inputs.clone();
 

tools/compiletest/src/runtest.rs

@@ -15,10 +15,8 @@ use crate::read2::read2_abbreviated;
 use crate::util::logv;
 use regex::Regex;
 
-use std::collections::hash_map::DefaultHasher;
 use std::env;
 use std::fs::{self, create_dir_all};
-use std::hash::{Hash, Hasher};
 use std::path::PathBuf;
 use std::process::{Command, ExitStatus, Output, Stdio};
 use std::str;
@@ -49,13 +47,6 @@ pub fn run(config: Config, testpaths: &TestPaths, revision: Option<&str>) {
     cx.create_stamp();
 }
 
-pub fn compute_stamp_hash(config: &Config) -> String {
-    let mut hash = DefaultHasher::new();
-    config.stage_id.hash(&mut hash);
-
-    format!("{:x}", hash.finish())
-}
-
 #[derive(Copy, Clone)]
 struct TestCx<'test> {
     config: &'test Config,
@@ -411,7 +402,7 @@ impl<'test> TestCx<'test> {
 
     fn create_stamp(&self) {
         let stamp = crate::stamp(&self.config, self.testpaths, self.revision);
-        fs::write(&stamp, compute_stamp_hash(&self.config)).unwrap();
+        fs::write(&stamp, "we only support one configuration").unwrap();
     }
 }
 

tools/compiletest/src/util.rs

@@ -7,6 +7,7 @@ use crate::common::Config;
 use std::ffi::OsStr;
 use std::path::PathBuf;
 
+use std::process::Command;
 use tracing::*;
 
 pub fn logv(config: &Config, s: String) {
@@ -35,3 +36,12 @@ impl PathBufExt for PathBuf {
         }
     }
 }
+
+pub(crate) fn top_level() -> Option<PathBuf> {
+    match Command::new("git").arg("rev-parse").arg("--show-toplevel").output() {
+        Ok(out) if out.status.success() => {
+            Some(PathBuf::from(String::from_utf8(out.stdout).unwrap().trim()))
+        }
+        _ => None,
+    }
+}