Split compiler tests and local tests

celinval · celinval · commit bc4c9988cde4 · 2023-09-25T17:36:00.000-07:00
diff --git a/.github/scripts/run_own_tests.sh b/.github/scripts/run_own_tests.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Execute our own set of tests using a local `compiletest` tool based on `ui_test`.
+set -e
+set -u
+
+# Where we will store the SMIR tools (Optional).
+TOOLS_BIN="${TOOLS_BIN:-"/tmp/smir/bin"}"
+# Assume we are inside SMIR repository
+SMIR_PATH=$(git rev-parse --show-toplevel)
+export RUST_BACKTRACE=1
+
+# Build stable_mir tools
+function build_smir_tools() {
+  pushd "${SMIR_PATH}"
+  cargo +nightly build -Z unstable-options --out-dir "${TOOLS_BIN}"
+  export PATH="${TOOLS_BIN}":"${PATH}"
+}
+
+# Run tests
+function run_tests() {
+  SUITES=(
+    "sanity-checks pass"
+    "fixme fail"
+  )
+  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 "#### Running suite: ${suite} mode: ${mode}"
+    compiletest \
+        --driver-path="${TOOLS_BIN}/test-drive" \
+        --mode=${mode} \
+        --src-base="tests/${suite}" \
+        --output-dir="target/tests/" \
+        --no-capture
+  done
+}
+
+build_smir_tools
+run_tests
diff --git a/.github/scripts/run_rustc_tests.sh b/.github/scripts/run_rustc_tests.sh
@@ -1,35 +1,96 @@
 #!/usr/bin/env bash
 
+# Run rustc test suites using our test driver using nightly.
+# This script leverages the rustc's repo compiletest crate.
+#
+# The suites configuration should match:
+# https://github.com/rust-lang/rust/blob/master/src/bootstrap/test.rs
+
 set -e
 set -u
+export RUST_BACKTRACE=1
 
 # Location of a rust repository. Clone one if path doesn't exist.
-RUST_REPO="${RUST_REPO:?Missing path to rust repository. Set RUST_REPO}"
+RUST_REPO="${RUST_REPO:-"/tmp/rustc"}"
+
 # Where we will store the SMIR tools (Optional).
 TOOLS_BIN="${TOOLS_BIN:-"/tmp/smir/bin"}"
+
 # Assume we are inside SMIR repository
 SMIR_PATH=$(git rev-parse --show-toplevel)
-export RUST_BACKTRACE=1
 
-pushd "${SMIR_PATH}"
-cargo build -Z unstable-options --out-dir "${TOOLS_BIN}"
-export PATH="${TOOLS_BIN}":"${PATH}"
-
-if [[ ! -e "${RUST_REPO}" ]]; then
-  mkdir -p "$(dirname ${RUST_REPO})"
-  git clone --depth 1 https://github.com/rust-lang/rust.git "${RUST_REPO}"
-fi
-
-pushd "${RUST_REPO}"
-SUITES=(
-  # Match https://github.com/rust-lang/rust/blob/master/src/bootstrap/test.rs for now
-  "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-dir="${RUST_REPO}/build"
-done
+# Build stable_mir tools
+function build_smir_tools() {
+  pushd "${SMIR_PATH}"
+  cargo +nightly build -Z unstable-options --out-dir "${TOOLS_BIN}"
+  export PATH="${TOOLS_BIN}":"${PATH}"
+}
+
+# Set up rustc repository
+function setup_rustc_repo() {
+  if [[ ! -e "${RUST_REPO}" ]]; then
+    mkdir -p "$(dirname ${RUST_REPO})"
+    git clone -b master https://github.com/rust-lang/rust.git "${RUST_REPO}"
+    pushd "${RUST_REPO}"
+    commit="$(rustc +nightly -vV | awk '/^commit-hash/ { print $2 }')"
+    git checkout ${commit}
+    git submodule init -- "${RUST_REPO}/library/stdarch"
+    git submodule update
+  else
+    pushd "${RUST_REPO}"
+  fi
+}
+
+function run_tests() {
+  # Run the following suite configuration for now (test suite + mode)
+  SUITES=(
+    "codegen codegen"
+    "codegen-units codegen-units"
+    # -- The suites below are failing because of fully qualified paths for standard library
+    # E.g.:
+    # -    _10 = _eprint(move _11) -> [return: bb6, unwind unreachable];
+    # +    _10 = std::io::_eprint(move _11) -> [return: bb6, unwind unreachable];
+    #
+    #"ui ui"
+    #"mir-opt mir-opt"
+    #"pretty pretty" -- 2 failing tests
+  )
+
+  SYSROOT=$(rustc +nightly --print sysroot)
+  PY_PATH=$(type -P python3)
+  HOST=$(rustc +nightly -vV | awk '/^host/ { print $2 }')
+  FILE_CHECK="$(which FileCheck-12 || which FileCheck-13 || which FileCheck-14)"
+
+  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 "#### Running suite: ${suite} mode: ${mode}"
+    cargo +nightly run -p compiletest -- \
+      --compile-lib-path="${SYSROOT}/lib" \
+      --run-lib-path="${SYSROOT}/lib"\
+      --python="${PY_PATH}" \
+      --rustc-path="${TOOLS_BIN}/test-drive" \
+      --mode=${mode} \
+      --suite="${suite}" \
+      --src-base="tests/${suite}" \
+      --build-base="$(pwd)/build/${HOST}/stage1/tests/${suite}" \
+      --sysroot-base="$SYSROOT" \
+      --stage-id=stage1-${HOST} \
+      --cc= \
+      --cxx= \
+      --cflags= \
+      --cxxflags= \
+      --llvm-components= \
+      --android-cross-path= \
+      --target=${HOST} \
+      --llvm-filecheck="${FILE_CHECK}" \
+      --channel=nightly
+  done
+}
+
+build_smir_tools
+setup_rustc_repo
+run_tests
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
@@ -14,6 +14,16 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
 
+      - name: Install latest nightly
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+
+      - name: Test
+        run: ./.github/scripts/run_own_tests.sh
+        env:
+          TOOLS_BIN: "/tmp/smir/bin"
+
       - name: Test
         run: ./.github/scripts/run_rustc_tests.sh
         env:
diff --git a/tests/fixme/associated-items/methods.rs b/tests/fixme/associated-items/methods.rs
@@ -0,0 +1,83 @@
+//! Example derived from <https://doc.rust-lang.org/reference/items/associated-items.html>
+#![feature(box_into_inner)]
+
+use std::pin::Pin;
+use std::rc::Rc;
+use std::sync::Arc;
+
+#[derive(Default, Debug)]
+struct Example {
+    inner: String,
+}
+
+type Alias = Example;
+trait Trait {
+    type Output;
+}
+impl Trait for Example {
+    type Output = Example;
+}
+
+#[allow(unused)]
+impl Example {
+    pub fn by_value(self: Self) {
+        self.by_ref("by_val");
+    }
+
+    pub fn by_ref(self: &Self, source: &str) {
+        println!("{source}: {}", self.inner);
+    }
+
+    pub fn by_ref_mut(self: &mut Self) {
+        self.inner = "by_ref_mut".to_string();
+        self.by_ref("mut");
+    }
+
+    pub fn by_box(self: Box<Self>) {
+        self.by_ref("by_box");
+        Box::into_inner(self).by_value();
+    }
+
+    pub fn by_rc(self: Rc<Self>) {
+        self.by_ref("by_rc");
+    }
+
+    pub fn by_arc(self: Arc<Self>) {
+        self.by_ref("by_arc");
+    }
+
+    pub fn by_pin(self: Pin<&Self>) {
+        self.by_ref("by_pin");
+    }
+
+    pub fn explicit_type(self: Arc<Example>) {
+        self.by_ref("explicit");
+    }
+
+    pub fn with_lifetime<'a>(self: &'a Self) {
+        self.by_ref("lifetime");
+    }
+
+    pub fn nested<'a>(self: &mut &'a Arc<Rc<Box<Alias>>>) {
+        self.by_ref("nested");
+    }
+
+    pub fn via_projection(self: <Example as Trait>::Output) {
+        self.by_ref("via_projection");
+    }
+
+    pub fn from(name: String) -> Self {
+        Example { inner: name }
+    }
+}
+
+fn main() {
+    let example = Example::from("Hello".to_string());
+    example.by_value();
+
+    let boxed = Box::new(Example::default());
+    boxed.by_box();
+
+    Example::default().by_ref_mut();
+    Example::default().with_lifetime();
+}
diff --git a/tests/sanity-checks/simple/simple_lib.rs b/tests/sanity-checks/simple/simple_lib.rs
@@ -0,0 +1,23 @@
+//! Just a simple library
+
+pub struct Point {
+    pub x: i64,
+    pub y: i64,
+}
+
+impl Point {
+    pub fn distance(&self, other: &Point) -> u64 {
+        let (x_dist, x_over) = (self.x - other.x).overflowing_pow(2);
+        let (y_dist, y_over) = (self.y - other.y).overflowing_pow(2);
+        if y_over | x_over {
+            panic!("overflow");
+        }
+
+        let dist = (x_dist as u64 + y_dist as u64) >> 1;
+        dist
+    }
+
+    pub fn distance_root(&self) -> u64 {
+        self.distance(&Point { x: 0, y: 0 })
+    }
+}
diff --git a/tools/compiletest/src/args.rs b/tools/compiletest/src/args.rs
@@ -1,3 +1,4 @@
+use std::ffi::OsString;
 /// Create our own parser and build the Config from it.
 use std::fmt::Debug;
 use std::path::PathBuf;
@@ -16,6 +17,8 @@ pub enum Mode {
     Fail,
     /// Run the tests, but always pass them as long as all annotations are satisfied and stderr files match.
     Yolo,
+    /// The test passes a full execution of `cargo build`
+    CargoPass,
 }
 
 #[derive(Debug, clap::Parser)]
@@ -26,7 +29,7 @@ pub struct Args {
     src_base: PathBuf,
 
     /// The mode according to ui_test modes.
-    #[arg(long, default_value="yolo")]
+    #[arg(long, default_value = "yolo")]
     mode: Mode,
 
     /// Path for the stable-mir driver.
@@ -39,32 +42,74 @@ pub struct Args {
 
     #[arg(long)]
     pub verbose: bool,
+
+    /// Run test-driver on verbose mode to print test outputs.
+    #[arg(long)]
+    pub no_capture: 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 }}
+            Mode::Pass | Mode::CargoPass => 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::rustc(args.src_base);
-        config.program = CommandBuilder::rustc();
-        config.program.program = args.driver_path;
-        config.program.args.push("--check-smir".into());
+        let mut config = if matches!(args.mode, Mode::CargoPass) {
+            cargo_config(&args)
+        } else {
+            driver_config(&args)
+        };
+        config.filter(r"\[T-DRIVE\].*\n", "");
         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
     }
 }
+
+fn rustc_flags(args: &Args) -> Vec<OsString> {
+    let mut flags = vec!["--check-smir".into()];
+    if args.verbose || args.no_capture {
+        flags.push("--verbose".into());
+    }
+    flags
+}
+
+/// Configure cargo tests that will run the test-driver instead of rustc.
+fn cargo_config(args: &Args) -> Config {
+    let mut config = Config::cargo(args.src_base.clone());
+    config.program.envs.push((
+        "RUST".into(),
+        Some(args.driver_path.clone().into_os_string()),
+    ));
+    config.program.envs.push((
+        "CARGO_ENCODED_RUSTFLAGS".into(),
+        Some(rustc_flags(args).join(&OsString::from("\x1f")).into()),
+    ));
+    config
+}
+
+/// Configure tests that will invoke the test-driver directly as rustc.
+fn driver_config(args: &Args) -> Config {
+    let mut config = Config::rustc(args.src_base.clone());
+    config.program = CommandBuilder::rustc();
+    config.program.program = args.driver_path.clone();
+    config.program.args = rustc_flags(args);
+    config
+}
diff --git a/tools/compiletest/src/main.rs b/tools/compiletest/src/main.rs
diff --git a/tools/test-drive/src/main.rs b/tools/test-drive/src/main.rs
diff --git a/tools/test-drive/src/sanity_checks.rs b/tools/test-drive/src/sanity_checks.rs
