disable validation code so that it all compiles against current nightly

src/librustc_mir/interpret/bin/miri.rs

@@ -202,7 +202,6 @@ fn main() {
 
     // for auxilary builds in unit tests
     args.push("-Zalways-encode-mir".to_owned());
-    args.push("-Zmir-emit-validate".to_owned());
 
     rustc_driver::run_compiler(&args, &mut MiriCompilerCalls(RustcDefaultCalls), None, None);
 }

src/librustc_mir/interpret/eval_context.rs

@@ -31,6 +31,8 @@ pub struct EvalContext<'a, 'tcx: 'a> {
     /// The virtual memory system.
     pub(crate) memory: Memory<'a, 'tcx>,
 
+    #[allow(dead_code)]
+    // FIXME(@RalfJung): validation branch
     /// Lvalues that were suspended by the validation subsystem, and will be recovered later
     pub(crate) suspended: HashMap<DynamicLifetime, Vec<ValidationQuery<'tcx>>>,
 

src/librustc_mir/interpret/memory.rs

@@ -31,6 +31,8 @@ mod range {
     }
 
     impl MemoryRange {
+        #[allow(dead_code)]
+        // FIXME(@RalfJung): validation branch
         pub fn new(offset: u64, len: u64) -> MemoryRange {
             assert!(len > 0);
             MemoryRange {
@@ -55,6 +57,8 @@ mod range {
             left..right
         }
 
+        #[allow(dead_code)]
+        // FIXME(@RalfJung): validation branch
         pub fn contained_in(&self, offset: u64, len: u64) -> bool {
             assert!(len > 0);
             offset <= self.start && self.end <= (offset + len)
@@ -135,6 +139,8 @@ impl Allocation {
             .filter(move |&(range, _)| range.overlaps(offset, len))
     }
 
+    #[allow(dead_code)]
+    // FIXME(@RalfJung): validation branch
     fn iter_locks_mut<'a>(&'a mut self, offset: u64, len: u64) -> impl Iterator<Item=(&'a MemoryRange, &'a mut LockInfo)> + 'a {
         self.locks.range_mut(MemoryRange::range(offset, len))
             .filter(move |&(range, _)| range.overlaps(offset, len))
@@ -537,6 +543,8 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             .map_err(|lock| EvalError::MemoryLockViolation { ptr, len, frame, access, lock })
     }
 
+    #[allow(dead_code)]
+    // FIXME(@RalfJung): validation branch
     /// Acquire the lock for the given lifetime
     pub(crate) fn acquire_lock(&mut self, ptr: MemoryPointer, len: u64, region: Option<CodeExtent>, kind: AccessKind) -> EvalResult<'tcx> {
         use std::collections::btree_map::Entry::*;
@@ -565,6 +573,8 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
+    #[allow(dead_code)]
+    // FIXME(@RalfJung): validation branch
     /// Release a write lock prematurely. If there's a read lock or someone else's lock, fail.
     pub(crate) fn release_write_lock(&mut self, ptr: MemoryPointer, len: u64) -> EvalResult<'tcx> {
         assert!(len > 0);

src/librustc_mir/interpret/step.rs

@@ -128,15 +128,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 self.deallocate_local(old_val)?;
             }
 
-            // Validity checks.
-            Validate(op, ref lvalues) => {
-                for operand in lvalues {
-                    self.validation_op(op, operand)?;
-                }
-            }
-            EndRegion(ce) => {
-                self.end_region(ce)?;
-            }
+            // NOPs for now.
+            EndRegion(_ce) => {}
 
             // Defined to do nothing. These are added by optimization passes, to avoid changing the
             // size of MIR constantly.

src/librustc_mir/interpret/validation.rs

@@ -1,6 +1,9 @@
+// code for @RalfJung's validation branch is dead for now
+#![allow(dead_code)]
+
 use rustc::hir::Mutability;
 use rustc::hir::Mutability::*;
-use rustc::mir::{self, ValidationOp, ValidationOperand};
+use rustc::mir;
 use rustc::ty::{self, Ty, TypeFoldable};
 use rustc::ty::subst::Subst;
 use rustc::traits::Reveal;
@@ -13,6 +16,23 @@ use memory::{AccessKind, LockInfo};
 use value::{PrimVal, Value};
 use lvalue::{Lvalue, LvalueExtra};
 
+// FIXME remove this once it lands in rustc
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub enum ValidationOp {
+    Acquire,
+    Release,
+    Suspend(CodeExtent),
+}
+
+#[derive(Clone, Debug)]
+pub struct ValidationOperand<'tcx, T> {
+    pub lval: T,
+    pub ty: Ty<'tcx>,
+    pub re: Option<CodeExtent>,
+    pub mutbl: Mutability,
+}
+// FIXME end
+
 pub type ValidationQuery<'tcx> = ValidationOperand<'tcx, Lvalue<'tcx>>;
 
 #[derive(Copy, Clone, Debug)]