some formatting

Author: RalfJung

src/eval.rs

@@ -5,9 +5,9 @@ use std::ffi::OsStr;
 use rand::rngs::StdRng;
 use rand::SeedableRng;
 
-use rustc_hir::def_id::DefId;
 use rustc::ty::layout::{LayoutOf, Size};
 use rustc::ty::{self, TyCtxt};
+use rustc_hir::def_id::DefId;
 
 use crate::*;
 
@@ -50,10 +50,7 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     let mut ecx = InterpCx::new(
         tcx.at(rustc_span::source_map::DUMMY_SP),
         ty::ParamEnv::reveal_all(),
-        Evaluator::new(
-            config.communicate,
-            config.validate,
-        ),
+        Evaluator::new(config.communicate, config.validate),
         MemoryExtra::new(
             StdRng::seed_from_u64(config.seed.unwrap_or(0)),
             config.stacked_borrows,

src/helpers.rs

@@ -1,13 +1,13 @@
 use std::ffi::OsStr;
 use std::{iter, mem};
 
-use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc::mir;
 use rustc::ty::{
     self,
     layout::{self, LayoutOf, Size, TyLayout},
     List, TyCtxt,
 };
+use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc_span::source_map::DUMMY_SP;
 
 use rand::RngCore;
@@ -515,7 +515,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn alloc_os_str_as_c_str(
         &mut self,
         os_str: &OsStr,
-        memkind: MemoryKind<MiriMemoryKind>
+        memkind: MemoryKind<MiriMemoryKind>,
     ) -> Pointer<Tag> {
         let size = os_str.len() as u64 + 1; // Make space for `0` terminator.
         let this = self.eval_context_mut();
@@ -532,17 +532,17 @@ pub fn immty_from_int_checked<'tcx>(
     layout: TyLayout<'tcx>,
 ) -> InterpResult<'tcx, ImmTy<'tcx, Tag>> {
     let int = int.into();
-    Ok(ImmTy::try_from_int(int, layout).ok_or_else(||
+    Ok(ImmTy::try_from_int(int, layout).ok_or_else(|| {
         err_unsup_format!("Signed value {:#x} does not fit in {} bits", int, layout.size.bits())
-    )?)
+    })?)
 }
 
 pub fn immty_from_uint_checked<'tcx>(
     int: impl Into<u128>,
     layout: TyLayout<'tcx>,
 ) -> InterpResult<'tcx, ImmTy<'tcx, Tag>> {
     let int = int.into();
-    Ok(ImmTy::try_from_uint(int, layout).ok_or_else(||
+    Ok(ImmTy::try_from_uint(int, layout).ok_or_else(|| {
         err_unsup_format!("Signed value {:#x} does not fit in {} bits", int, layout.size.bits())
-    )?)
+    })?)
 }

src/lib.rs

@@ -11,10 +11,10 @@ extern crate rustc_apfloat;
 extern crate rustc_ast;
 #[macro_use]
 extern crate rustc;
-extern crate rustc_hir;
-extern crate rustc_span;
 extern crate rustc_data_structures;
+extern crate rustc_hir;
 extern crate rustc_mir;
+extern crate rustc_span;
 extern crate rustc_target;
 
 mod diagnostics;
@@ -44,7 +44,8 @@ pub use crate::shims::tls::{EvalContextExt as TlsEvalContextExt, TlsData};
 pub use crate::shims::EvalContextExt as ShimsEvalContextExt;
 
 pub use crate::diagnostics::{
-    register_diagnostic, report_diagnostic, EvalContextExt as DiagnosticsEvalContextExt, NonHaltingDiagnostic,
+    register_diagnostic, report_diagnostic, EvalContextExt as DiagnosticsEvalContextExt,
+    NonHaltingDiagnostic,
 };
 pub use crate::eval::{create_ecx, eval_main, MiriConfig, TerminationInfo};
 pub use crate::helpers::EvalContextExt as HelpersEvalContextExt;
@@ -56,12 +57,17 @@ pub use crate::mono_hash_map::MonoHashMap;
 pub use crate::operator::EvalContextExt as OperatorEvalContextExt;
 pub use crate::range_map::RangeMap;
 pub use crate::stacked_borrows::{
-    EvalContextExt as StackedBorEvalContextExt, Item, Permission, PtrId, Stack,
-    Stacks, Tag,
+    EvalContextExt as StackedBorEvalContextExt, Item, Permission, PtrId, Stack, Stacks, Tag,
 };
 
 /// Insert rustc arguments at the beginning of the argument list that Miri wants to be
 /// set per default, for maximal validation power.
 pub fn miri_default_args() -> &'static [&'static str] {
-    &["-Zalways-encode-mir", "-Zmir-emit-retag", "-Zmir-opt-level=0", "--cfg=miri", "-Cdebug-assertions=on"]
+    &[
+        "-Zalways-encode-mir",
+        "-Zmir-emit-retag",
+        "-Zmir-opt-level=0",
+        "--cfg=miri",
+        "-Cdebug-assertions=on",
+    ]
 }

src/machine.rs

@@ -3,20 +3,20 @@
 
 use std::borrow::Cow;
 use std::cell::RefCell;
-use std::rc::Rc;
 use std::num::NonZeroU64;
+use std::rc::Rc;
 
 use rand::rngs::StdRng;
 
-use rustc_hir::def_id::DefId;
 use rustc::mir;
 use rustc::ty::{
     self,
     layout::{LayoutOf, Size},
     Ty, TyCtxt,
 };
-use rustc_span::{source_map::Span, symbol::sym};
 use rustc_ast::attr;
+use rustc_hir::def_id::DefId;
+use rustc_span::{source_map::Span, symbol::sym};
 
 use crate::*;
 
@@ -85,11 +85,7 @@ impl MemoryExtra {
         } else {
             None
         };
-        MemoryExtra {
-            stacked_borrows,
-            intptrcast: Default::default(),
-            rng: RefCell::new(rng),
-        }
+        MemoryExtra { stacked_borrows, intptrcast: Default::default(), rng: RefCell::new(rng) }
     }
 }
 
@@ -307,18 +303,15 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     ) -> (Cow<'b, Allocation<Self::PointerTag, Self::AllocExtra>>, Self::PointerTag) {
         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
         let alloc = alloc.into_owned();
-        let (stacks, base_tag) = if let Some(stacked_borrows) = memory_extra.stacked_borrows.as_ref() {
-            let (stacks, base_tag) = Stacks::new_allocation(
-                id,
-                alloc.size,
-                Rc::clone(stacked_borrows),
-                kind,
-            );
-            (Some(stacks), base_tag)
-        } else {
-            // No stacks, no tag.
-            (None, Tag::Untagged)
-        };
+        let (stacks, base_tag) =
+            if let Some(stacked_borrows) = memory_extra.stacked_borrows.as_ref() {
+                let (stacks, base_tag) =
+                    Stacks::new_allocation(id, alloc.size, Rc::clone(stacked_borrows), kind);
+                (Some(stacks), base_tag)
+            } else {
+                // No stacks, no tag.
+                (None, Tag::Untagged)
+            };
         let mut stacked_borrows = memory_extra.stacked_borrows.as_ref().map(|sb| sb.borrow_mut());
         let alloc: Allocation<Tag, Self::AllocExtra> = alloc.with_tags_and_extra(
             |alloc| {
@@ -360,14 +353,11 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
 
     #[inline(always)]
     fn stack_push(ecx: &mut InterpCx<'mir, 'tcx, Self>) -> InterpResult<'tcx, FrameData<'tcx>> {
-        let call_id = ecx.memory.extra.stacked_borrows.as_ref().map_or(
-            NonZeroU64::new(1).unwrap(),
-            |stacked_borrows| stacked_borrows.borrow_mut().new_call(),
-        );
-        Ok(FrameData {
-            call_id,
-            catch_panic: None,
-        })
+        let stacked_borrows = ecx.memory.extra.stacked_borrows.as_ref();
+        let call_id = stacked_borrows.map_or(NonZeroU64::new(1).unwrap(), |stacked_borrows| {
+            stacked_borrows.borrow_mut().new_call()
+        });
+        Ok(FrameData { call_id, catch_panic: None })
     }
 
     #[inline(always)]

src/operator.rs

@@ -103,9 +103,9 @@ impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
         offset: i64,
     ) -> InterpResult<'tcx, Scalar<Tag>> {
         let pointee_size = i64::try_from(self.layout_of(pointee_ty)?.size.bytes()).unwrap();
-        let offset = offset
-            .checked_mul(pointee_size)
-            .ok_or_else(|| err_ub_format!("overflow during offset comutation for inbounds pointer arithmetic"))?;
+        let offset = offset.checked_mul(pointee_size).ok_or_else(|| {
+            err_ub_format!("overflow during offset comutation for inbounds pointer arithmetic")
+        })?;
         // We do this first, to rule out overflows.
         let offset_ptr = ptr.ptr_signed_offset(offset, self)?;
         // What we need to check is that starting at `min(ptr, offset_ptr)`,

src/stacked_borrows.rs

@@ -7,9 +7,9 @@ use std::fmt;
 use std::num::NonZeroU64;
 use std::rc::Rc;
 
-use rustc_hir::Mutability;
 use rustc::mir::RetagKind;
 use rustc::ty::{self, layout::Size};
+use rustc_hir::Mutability;
 
 use crate::*;
 
@@ -293,9 +293,12 @@ impl<'tcx> Stack {
         // Two main steps: Find granting item, remove incompatible items above.
 
         // Step 1: Find granting item.
-        let granting_idx = self.find_granting(access, tag).ok_or_else(|| err_ub!(UbExperimental(
-            format!("no item granting {} to tag {:?} found in borrow stack.", access, tag),
-        )))?;
+        let granting_idx = self.find_granting(access, tag).ok_or_else(|| {
+            err_ub!(UbExperimental(format!(
+                "no item granting {} to tag {:?} found in borrow stack.",
+                access, tag
+            ),))
+        })?;
 
         // Step 2: Remove incompatible items above them.  Make sure we do not remove protected
         // items.  Behavior differs for reads and writes.
@@ -334,10 +337,12 @@ impl<'tcx> Stack {
     /// active protectors at all because we will remove all items.
     fn dealloc(&mut self, tag: Tag, global: &GlobalState) -> InterpResult<'tcx> {
         // Step 1: Find granting item.
-        self.find_granting(AccessKind::Write, tag).ok_or_else(|| err_ub!(UbExperimental(format!(
-            "no item granting write access for deallocation to tag {:?} found in borrow stack",
-            tag,
-        ))))?;
+        self.find_granting(AccessKind::Write, tag).ok_or_else(|| {
+            err_ub!(UbExperimental(format!(
+                "no item granting write access for deallocation to tag {:?} found in borrow stack",
+                tag,
+            )))
+        })?;
 
         // Step 2: Remove all items.  Also checks for protectors.
         for item in self.borrows.drain(..).rev() {
@@ -575,7 +580,9 @@ trait EvalContextPrivExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             // breaking `Rc::from_raw`.
             RefKind::Raw { .. } => Tag::Untagged,
             // All other pointesr are properly tracked.
-            _ => Tag::Tagged(this.memory.extra.stacked_borrows.as_ref().unwrap().borrow_mut().new_ptr()),
+            _ => Tag::Tagged(
+                this.memory.extra.stacked_borrows.as_ref().unwrap().borrow_mut().new_ptr(),
+            ),
         };
 
         // Reborrow.