fix nits

Author: RalfJung

src/fn_call.rs

@@ -150,10 +150,14 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
                 if !align.is_power_of_two() {
                     return err!(HeapAllocNonPowerOfTwoAlignment(align));
                 }
-                let ptr = self.memory_mut().allocate(Size::from_bytes(size),
-                                               Align::from_bytes(align, align).unwrap(),
-                                               MiriMemoryKind::Rust.into())?;
-                self.write_scalar(Scalar::Ptr(ptr.with_default_tag()), dest)?;
+                let ptr = self.memory_mut()
+                    .allocate(
+                        Size::from_bytes(size),
+                        Align::from_bytes(align, align).unwrap(),
+                        MiriMemoryKind::Rust.into()
+                    )?
+                    .with_default_tag();
+                self.write_scalar(Scalar::Ptr(ptr), dest)?;
             }
             "__rust_alloc_zeroed" => {
                 let size = self.read_scalar(args[0])?.to_usize(&self)?;
@@ -164,11 +168,13 @@ impl<'a, 'mir, 'tcx: 'mir + 'a> EvalContextExt<'tcx, 'mir> for super::MiriEvalCo
                 if !align.is_power_of_two() {
                     return err!(HeapAllocNonPowerOfTwoAlignment(align));
                 }
-                let ptr = self.memory_mut().allocate(
+                let ptr = self.memory_mut()
+                    .allocate(
                         Size::from_bytes(size),
                         Align::from_bytes(align, align).unwrap(),
                         MiriMemoryKind::Rust.into()
-                    )?.with_default_tag();
+                    )?
+                    .with_default_tag();
                 self.memory_mut().write_repeat(ptr.into(), 0, Size::from_bytes(size))?;
                 self.write_scalar(Scalar::Ptr(ptr), dest)?;
             }

src/stacked_borrows.rs

@@ -251,7 +251,7 @@ impl<'tcx> Stack {
 impl State {
     fn increment_clock(&self) -> Timestamp {
         let val = self.clock.get();
-        self.clock.set(val+1);
+        self.clock.set(val + 1);
         val
     }
 }
@@ -322,13 +322,13 @@ impl<'tcx> Stacks {
     /// Pushes the first borrow to the stacks, must be a mutable one.
     pub fn first_borrow(
         &mut self,
-        r#mut: Mut,
+        mut_borrow: Mut,
         size: Size
     ) {
         for stack in self.stacks.get_mut().iter_mut(Size::ZERO, size) {
             assert!(stack.borrows.len() == 1 && stack.frozen_since.is_none());
             assert_eq!(stack.borrows.pop().unwrap(), BorStackItem::Mut(Mut::Raw));
-            stack.borrows.push(BorStackItem::Mut(r#mut));
+            stack.borrows.push(BorStackItem::Mut(mut_borrow));
         }
     }
 }
@@ -489,7 +489,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
         id: AllocId,
         kind: MemoryKind<MiriMemoryKind>,
     ) -> Borrow {
-        let r#mut = match kind {
+        let mut_borrow = match kind {
             MemoryKind::Stack => {
                 // New unique borrow
                 let time = self.machine.stacked_borrows.increment_clock();
@@ -503,7 +503,7 @@ impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'a, 'mir, '
         // Make this the active borrow for this allocation
         let alloc = self.memory_mut().get_mut(id).expect("This is a new allocation, it must still exist");
         let size = Size::from_bytes(alloc.bytes.len() as u64);
-        alloc.extra.first_borrow(r#mut, size);
-        Borrow::Mut(r#mut)
+        alloc.extra.first_borrow(mut_borrow, size);
+        Borrow::Mut(mut_borrow)
     }
 }

tests/compile-fail/stacked_borrows/illegal_write4.rs

@@ -11,8 +11,8 @@ fn main() {
     let target = 42;
     // Make sure a cannot use a raw-tagged `&mut` pointing to a frozen location, not
     // even to create a raw.
-    let r#ref = ⌖ // freeze
-    let ptr = r#ref as *const _ as *mut i32; // raw ptr, with raw tag
+    let reference = ⌖ // freeze
+    let ptr = reference as *const _ as *mut i32; // raw ptr, with raw tag
     let mut_ref: &mut i32 = unsafe { mem::transmute(ptr) }; // &mut, with raw tag
     // Now we have an &mut to a frozen location, but that is completely normal:
     // We'd just unfreeze the location if we used it.
@@ -23,9 +23,9 @@ fn main() {
     // turns a raw into a `&mut`.  Next, we create a raw ref to a frozen location
     // from a `Raw` tag, which can happen legitimately when interior mutability
     // is involved.
-    let _val = *r#ref; // Make sure it is still frozen.
+    let _val = *reference; // Make sure it is still frozen.
 
     // We only actually unfreeze once we muteate through the bad pointer.
     unsafe { *bad_ptr = 42 }; //~ ERROR does not exist on the stack
-    let _val = *r#ref;
+    let _val = *reference;
 }