Update to latest rustc changes

.gitignore

@@ -4,3 +4,4 @@ tex/*/out
 *.dot
 *.mir
 *.rs.bk
+Cargo.lock

Cargo.toml

@@ -29,7 +29,7 @@ cargo_metadata = { version = "0.2", optional = true }
 cargo_miri = ["cargo_metadata"]
 
 [dev-dependencies]
-compiletest_rs = { version = "0.3", features = ["tmp"] }
+compiletest_rs = { version = "0.3.3", features = ["tmp"] }
 
 [workspace]
 exclude = ["xargo", "cargo-miri-test", "rustc_tests"]

miri/fn_call.rs

@@ -187,7 +187,7 @@ impl<'a, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'tcx, super::Evaluator>
                             .to_owned(),
                     ),
                 )?;
-                let arg_dest = self.eval_lvalue(&mir::Lvalue::Local(arg_local))?;
+                let arg_dest = self.eval_lvalue(&mir::Place::Local(arg_local))?;
                 self.write_ptr(arg_dest, data, u8_ptr_ty)?;
 
                 assert!(args.next().is_none(), "__rust_maybe_catch_panic argument has more arguments than expected");

miri/lib.rs

@@ -87,7 +87,7 @@ pub fn eval_main<'a, 'tcx: 'a>(
 
             // First argument: pointer to main()
             let main_ptr = ecx.memory_mut().create_fn_alloc(main_instance);
-            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let dest = ecx.eval_lvalue(&mir::Place::Local(args.next().unwrap()))?;
             let main_ty = main_instance.def.def_ty(ecx.tcx);
             let main_ptr_ty = ecx.tcx.mk_fn_ptr(main_ty.fn_sig(ecx.tcx));
             ecx.write_value(
@@ -99,13 +99,13 @@ pub fn eval_main<'a, 'tcx: 'a>(
             )?;
 
             // Second argument (argc): 1
-            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let dest = ecx.eval_lvalue(&mir::Place::Local(args.next().unwrap()))?;
             let ty = ecx.tcx.types.isize;
             ecx.write_primval(dest, PrimVal::Bytes(1), ty)?;
 
             // FIXME: extract main source file path
             // Third argument (argv): &[b"foo"]
-            let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+            let dest = ecx.eval_lvalue(&mir::Place::Local(args.next().unwrap()))?;
             let ty = ecx.tcx.mk_imm_ptr(ecx.tcx.mk_imm_ptr(ecx.tcx.types.u8));
             let foo = ecx.memory.allocate_cached(b"foo\0");
             let ptr_size = ecx.memory.pointer_size();
@@ -261,7 +261,7 @@ impl<'tcx> Machine<'tcx> for Evaluator {
         let usize = ecx.tcx.types.usize;
 
         // First argument: size
-        let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+        let dest = ecx.eval_lvalue(&mir::Place::Local(args.next().unwrap()))?;
         ecx.write_value(
             ValTy {
                 value: Value::ByVal(PrimVal::Bytes(size as u128)),
@@ -271,7 +271,7 @@ impl<'tcx> Machine<'tcx> for Evaluator {
         )?;
 
         // Second argument: align
-        let dest = ecx.eval_lvalue(&mir::Lvalue::Local(args.next().unwrap()))?;
+        let dest = ecx.eval_lvalue(&mir::Place::Local(args.next().unwrap()))?;
         ecx.write_value(
             ValTy {
                 value: Value::ByVal(PrimVal::Bytes(align as u128)),

miri/tls.rs

@@ -125,7 +125,7 @@ impl<'a, 'tcx: 'a> EvalContextExt<'tcx> for EvalContext<'a, 'tcx, Evaluator> {
             let arg_local = self.frame().mir.args_iter().next().ok_or(
                 EvalErrorKind::AbiViolation("TLS dtor does not take enough arguments.".to_owned()),
             )?;
-            let dest = self.eval_lvalue(&mir::Lvalue::Local(arg_local))?;
+            let dest = self.eval_lvalue(&mir::Place::Local(arg_local))?;
             let ty = self.tcx.mk_mut_ptr(self.tcx.types.u8);
             self.write_ptr(dest, ptr, ty)?;
 

tests/compile-fail/invalid_bool.rs

@@ -1,4 +1,4 @@
 fn main() {
-    let b = unsafe { std::mem::transmute::<u8, bool>(2) };
-    if b { unreachable!() } else { unreachable!() } //~ ERROR: invalid boolean value read
+    let b = unsafe { std::mem::transmute::<u8, bool>(2) }; //~ ERROR: invalid boolean value read
+    if b { unreachable!() } else { unreachable!() }
 }

tests/compile-fail/match_char.rs

@@ -1,7 +1,7 @@
 fn main() {
     assert!(std::char::from_u32(-1_i32 as u32).is_none());
-    match unsafe { std::mem::transmute::<i32, char>(-1) } {
-        'a' => {}, //~ERROR tried to interpret an invalid 32-bit value as a char: 4294967295
+    match unsafe { std::mem::transmute::<i32, char>(-1) } { //~ERROR tried to interpret an invalid 32-bit value as a char: 4294967295
+        'a' => {},
         'b' => {},
         _ => {},
     }

tests/compile-fail/never_say_never.rs

@@ -7,7 +7,7 @@
 fn main() {
     let y = &5;
     let x: ! = unsafe {
-        *(y as *const _ as *const !) //~ ERROR tried to access a dead local variable
+        *(y as *const _ as *const !) //~ ERROR entered unreachable code
     };
     f(x)
 }

tests/compile-fail/reference_to_packed.rs

@@ -14,6 +14,6 @@ fn main() {
         x: 42,
         y: 99,
     };
-    let p = &foo.x;
+    let p = unsafe { &foo.x };
     let i = *p; //~ ERROR tried to access memory with alignment 1, but alignment 4 is required
 }

tests/run-pass/issue-36278-prefix-nesting.rs

@@ -22,7 +22,10 @@ fn main() {
     let size_of_sized; let size_of_unsized;
     let x: Box<Ack<[u8; 0]>> = Box::new(P([0; SZ], P([0; SZ], [0; 0])));
     size_of_sized = mem::size_of_val::<Ack<_>>(&x);
+    let align_of_sized = mem::align_of_val::<Ack<_>>(&x);
     let y: Box<Ack<[u8   ]>> = x;
     size_of_unsized = mem::size_of_val::<Ack<_>>(&y);
     assert_eq!(size_of_sized, size_of_unsized);
+    assert_eq!(align_of_sized, 1);
+    assert_eq!(mem::align_of_val::<Ack<_>>(&y), 1);
 }