Merge branch 'master' into rustup

Author: RalfJung

.travis.yml

@@ -12,51 +12,22 @@ os:
 dist: xenial
 
 before_script:
-# install extra stuff for cross-compilation
+# Linux: install extra stuff for cross-compilation
 - if [[ "$TRAVIS_OS_NAME" == linux ]]; then sudo apt update && sudo apt install gcc-multilib; fi
-# macOS weirdness (https://github.com/travis-ci/travis-ci/issues/6307, https://github.com/travis-ci/travis-ci/issues/10165)
-- if [[ "$TRAVIS_OS_NAME" == osx ]]; then rvm get stable; fi
 # Compute the rust version we use. We do not use "language: rust" to have more control here.
 - |
   if [[ "$TRAVIS_EVENT_TYPE" == cron ]]; then
     RUST_TOOLCHAIN=nightly
   else
     RUST_TOOLCHAIN=$(cat rust-version)
   fi
-- |
-  if [ "$TRAVIS_OS_NAME" == osx ]; then
-    export MIRI_SYSROOT_BASE=~/Library/Caches/miri.miri.miri/
-  else
-    export MIRI_SYSROOT_BASE=~/.cache/miri/
-  fi
-- |
-  if [[ "$TRAVIS_OS_NAME" == osx ]]; then
-    FOREIGN_TARGET=i686-apple-darwin
-  else
-    FOREIGN_TARGET=i686-unknown-linux-gnu
-  fi
 # install Rust
 - curl https://build.travis-ci.org/files/rustup-init.sh -sSf | sh -s -- -y --default-toolchain "$RUST_TOOLCHAIN"
 - export PATH=$HOME/.cargo/bin:$PATH
 - rustc --version
 
 script:
-- set -e
-- |
-  # Build and install miri
-  cargo build --release --all-features --all-targets &&
-  cargo install --all-features --force --path .
-- |
-  # Get ourselves a MIR-full libstd for the host and a foreign architecture
-  cargo miri setup &&
-  cargo miri setup --target "$FOREIGN_TARGET"
-- |
-  # Test miri with full MIR, on the host and other architectures
-  MIRI_SYSROOT=$MIRI_SYSROOT_BASE/HOST cargo test --release --all-features &&
-  MIRI_SYSROOT=$MIRI_SYSROOT_BASE MIRI_TARGET=$FOREIGN_TARGET cargo test --release --all-features
-- |
-  # Test cargo integration
-  (cd test-cargo-miri && MIRI_SYSROOT=$MIRI_SYSROOT_BASE/HOST ./run-test.py)
+- ./travis.sh
 
 notifications:
   email:
@@ -67,3 +38,4 @@ branches:
 env:
   global:
   - RUST_TEST_NOCAPTURE=1
+  - RUST_BACKTRACE=1

Cargo.toml

@@ -39,6 +39,10 @@ directories = { version = "1.0", optional = true }
 rustc_version = { version = "0.2.3", optional = true }
 env_logger = "0.5"
 log = "0.4"
+# A noop dependency that changes in the Rust repository, it's a bit of a hack.
+# See the `src/tools/rustc-workspace-hack/README.md` file in `rust-lang/rust`
+# for more information.
+rustc-workspace-hack = "1.0.0"
 
 [build-dependencies]
 vergen = "3"

README.md

@@ -39,17 +39,28 @@ example above), overriding it in your project directory as well, or use `rustup
 default nightly` (or `rustup default nightly-YYYY-MM-DD`) to globally make
 `nightly` the default toolchain.
 
-Now you can run your project in miri:
+Now you can run your project in Miri:
 
 1. Run `cargo clean` to eliminate any cached dependencies.  Miri needs your
    dependencies to be compiled the right way, that would not happen if they have
    previously already been compiled.
 2. To run all tests in your project through Miri, use `cargo +nightly miri test`.
-   **NOTE**: This is currently broken, see the discussion in
-   [#479](https://github.com/solson/miri/issues/479).
 3. If you have a binary project, you can run it through Miri using `cargo
    +nightly miri run`.
 
+When running code via `cargo miri`, the `cargo-miri` feature is set.  You can
+use this to exclude test cases that will fail under Miri because they do things
+Miri does not support:
+
+```rust
+#[cfg(not(feature = "cargo-miri"))]
+#[test]
+fn does_not_work_on_miri() {
+    let x = 0u8;
+    assert!(&x as *const _ as usize % 4 < 4);
+}
+```
+
 ### Common Problems
 
 When using the above instructions, you may encounter a number of confusing compiler

appveyor.yml

@@ -25,15 +25,19 @@ install:
 build: false
 
 test_script:
-    - set RUSTFLAGS=-g
+    - set RUST_TEST_NOCAPTURE=1
     - set RUST_BACKTRACE=1
-    # Build miri
+    # Build and install miri
     - cargo build --release --all-features --all-targets
+    - cargo install --all-features --force --path .
     # Get ourselves a MIR-full libstd, and use it henceforth
-    - cargo run --release --all-features --bin cargo-miri -- miri setup
+    - cargo miri setup
     - set MIRI_SYSROOT=%USERPROFILE%\AppData\Local\miri\miri\cache\HOST
     # Test miri
     - cargo test --release --all-features
+    # Test cargo integration
+    - cd test-cargo-miri
+    - python3 run-test.py
 
 notifications:
     - provider: Email

rust-version

@@ -1 +1 @@
-nightly-2018-12-08
+nightly-2018-12-18

src/bin/cargo-miri.rs

@@ -3,7 +3,7 @@
 extern crate cargo_metadata;
 
 use std::path::{PathBuf, Path};
-use std::io::{self, Write};
+use std::io::{self, Write, BufRead};
 use std::process::Command;
 use std::fs::{self, File};
 
@@ -114,6 +114,42 @@ fn list_targets() -> impl Iterator<Item=cargo_metadata::Target> {
     package.targets.into_iter()
 }
 
+fn xargo_version() -> Option<(u32, u32, u32)> {
+    let out = Command::new("xargo").arg("--version").output().ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    // Parse output. The first line looks like "xargo 0.3.12 (b004f1c 2018-12-13)".
+    let line = out.stderr.lines().nth(0)
+        .expect("malformed `xargo --version` output: not at least one line")
+        .expect("malformed `xargo --version` output: error reading first line");
+    let (name, version) = {
+        let mut split = line.split(' ');
+        (split.next().expect("malformed `xargo --version` output: empty"),
+         split.next().expect("malformed `xargo --version` output: not at least two words"))
+    };
+    if name != "xargo" {
+        panic!("malformed `xargo --version` output: application name is not `xargo`");
+    }
+    let mut version_pieces = version.split('.');
+    let major = version_pieces.next()
+        .expect("malformed `xargo --version` output: not a major version piece")
+        .parse()
+        .expect("malformed `xargo --version` output: major version is not an integer");
+    let minor = version_pieces.next()
+        .expect("malformed `xargo --version` output: not a minor version piece")
+        .parse()
+        .expect("malformed `xargo --version` output: minor version is not an integer");
+    let patch = version_pieces.next()
+        .expect("malformed `xargo --version` output: not a patch version piece")
+        .parse()
+        .expect("malformed `xargo --version` output: patch version is not an integer");
+    if !version_pieces.next().is_none() {
+        panic!("malformed `xargo --version` output: more than three pieces in version");
+    }
+    Some((major, minor, patch))
+}
+
 fn ask(question: &str) {
     let mut buf = String::new();
     print!("{} [Y/n] ", question);
@@ -134,14 +170,14 @@ fn setup(ask_user: bool) {
     }
 
     // First, we need xargo
-    if Command::new("xargo").arg("--version").output().is_err()
-    {
+    let xargo = xargo_version();
+    if xargo.map_or(true, |v| v < (0, 3, 13)) {
         if ask_user {
-            ask("It seems you do not have xargo installed. I will run `cargo install xargo`. Proceed?");
+            ask("It seems you do not have a recent enough xargo installed. I will run `cargo install xargo -f`. Proceed?");
         } else {
-            println!("Installing xargo: `cargo install xargo`");
+            println!("Installing xargo: `cargo install xargo -f`");
         }
-        if !Command::new("cargo").args(&["install", "xargo"]).status().unwrap().success() {
+        if !Command::new("cargo").args(&["install", "xargo", "-f"]).status().unwrap().success() {
             show_error(format!("Failed to install xargo"));
         }
     }
@@ -279,9 +315,8 @@ fn main() {
                 (MiriCommand::Test, "lib") => {
                     // For libraries we call `cargo rustc -- --test <rustc args>`
                     // Notice now that `--test` is a rustc arg rather than a cargo arg. This tells
-                    // rustc to build a test harness which calls all #[test] functions. We don't
-                    // use the harness since we execute each #[test] function's MIR ourselves before
-                    // compilation even completes, but this option is necessary to build the library.
+                    // rustc to build a test harness which calls all #[test] functions.
+                    // We then execute that harness just like any other binary.
                     if let Err(code) = process(
                         vec!["--".to_string(), "--test".to_string()].into_iter().chain(
                             args,
@@ -305,8 +340,8 @@ fn main() {
                 _ => {}
             }
         }
-    } else {
-        // This arm is executed when cargo-miri runs `cargo rustc` with the `RUSTC` env var set to itself:
+    } else if let Some("rustc") = std::env::args().nth(1).as_ref().map(AsRef::as_ref) {
+        // This arm is executed when cargo-miri runs `cargo rustc` with the `RUSTC_WRAPPER` env var set to itself:
         // Dependencies get dispatched to rustc, the final test/binary to miri.
 
         let home = option_env!("RUSTUP_HOME").or(option_env!("MULTIRUST_HOME"));
@@ -332,11 +367,11 @@ fn main() {
 
         // this conditional check for the --sysroot flag is there so users can call `cargo-miri` directly
         // without having to pass --sysroot or anything
+        let rustc_args = std::env::args().skip(2);
         let mut args: Vec<String> = if std::env::args().any(|s| s == "--sysroot") {
-            std::env::args().skip(1).collect()
+            rustc_args.collect()
         } else {
-            std::env::args()
-                .skip(1)
+            rustc_args
                 .chain(Some("--sysroot".to_owned()))
                 .chain(Some(sys_root))
                 .collect()
@@ -365,6 +400,8 @@ fn main() {
             Err(ref e) if miri_enabled => panic!("error during miri run: {:?}", e),
             Err(ref e) => panic!("error during rustc call: {:?}", e),
         }
+    } else {
+        show_error(format!("Must be called with either `miri` or `rustc` as first argument."))
     }
 }
 
@@ -383,13 +420,11 @@ where
         args.push("--".to_owned());
     }
     args.push("--emit=dep-info,metadata".to_owned());
-    args.push("--cfg".to_owned());
-    args.push(r#"feature="cargo-miri""#.to_owned());
 
     let path = std::env::current_exe().expect("current executable path invalid");
     let exit_status = Command::new("cargo")
         .args(&args)
-        .env("RUSTC", path)
+        .env("RUSTC_WRAPPER", path)
         .spawn()
         .expect("could not run cargo")
         .wait()

src/bin/miri.rs

@@ -23,8 +23,6 @@ use rustc_metadata::cstore::CStore;
 use rustc_driver::{Compilation, CompilerCalls, RustcDefaultCalls};
 use rustc_driver::driver::{CompileState, CompileController};
 use rustc::session::config::{self, Input, ErrorOutputType};
-use rustc::hir::{self, itemlikevisit};
-use rustc::ty::TyCtxt;
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
 use syntax::ast;
 
@@ -115,43 +113,12 @@ fn after_analysis<'a, 'tcx>(
 
     let tcx = state.tcx.unwrap();
 
-    if std::env::args().any(|arg| arg == "--test") {
-        struct Visitor<'a, 'tcx: 'a> {
-            tcx: TyCtxt<'a, 'tcx, 'tcx>,
-            state: &'a CompileState<'a, 'tcx>,
-            validate: bool,
-        };
-        impl<'a, 'tcx: 'a, 'hir> itemlikevisit::ItemLikeVisitor<'hir> for Visitor<'a, 'tcx> {
-            fn visit_item(&mut self, i: &'hir hir::Item) {
-                if let hir::ItemKind::Fn(.., body_id) = i.node {
-                    if i.attrs.iter().any(|attr| {
-                        attr.name() == "test"
-                    })
-                    {
-                        let did = self.tcx.hir().body_owner_def_id(body_id);
-                        println!(
-                            "running test: {}",
-                            self.tcx.def_path_debug_str(did),
-                        );
-                        miri::eval_main(self.tcx, did, self.validate);
-                        self.state.session.abort_if_errors();
-                    }
-                }
-            }
-            fn visit_trait_item(&mut self, _trait_item: &'hir hir::TraitItem) {}
-            fn visit_impl_item(&mut self, _impl_item: &'hir hir::ImplItem) {}
-        }
-        state.hir_crate.unwrap().visit_all_item_likes(
-            &mut Visitor { tcx, state, validate }
-        );
-    } else if let Some((entry_node_id, _, _)) = *state.session.entry_fn.borrow() {
-        let entry_def_id = tcx.hir().local_def_id(entry_node_id);
-        miri::eval_main(tcx, entry_def_id, validate);
-
-        state.session.abort_if_errors();
-    } else {
-        println!("no main function found, assuming auxiliary build");
-    }
+    let (entry_node_id, _, _) = state.session.entry_fn.borrow().expect("no main function found!");
+    let entry_def_id = tcx.hir().local_def_id(entry_node_id);
+
+    miri::eval_main(tcx, entry_def_id, validate);
+
+    state.session.abort_if_errors();
 }
 
 fn init_early_loggers() {