Change error handling style for consistency

Author: pvdrz

src/helpers.rs

@@ -1,8 +1,11 @@
 use std::mem;
 
-use rustc::ty::{self, layout::{self, Size, Align}};
 use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc::mir;
+use rustc::ty::{
+    self,
+    layout::{self, Align, Size},
+};
 
 use rand::RngCore;
 
@@ -48,7 +51,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     /// Write a 0 of the appropriate size to `dest`.
     fn write_null(&mut self, dest: PlaceTy<'tcx, Tag>) -> InterpResult<'tcx> {
-        self.eval_context_mut().write_scalar(Scalar::from_int(0, dest.layout.size), dest)
+        self.eval_context_mut()
+            .write_scalar(Scalar::from_int(0, dest.layout.size), dest)
     }
 
     /// Test if this immediate equals 0.
@@ -61,26 +65,21 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     /// Turn a Scalar into an Option<NonNullScalar>
     fn test_null(&self, val: Scalar<Tag>) -> InterpResult<'tcx, Option<Scalar<Tag>>> {
         let this = self.eval_context_ref();
-        Ok(if this.is_null(val)? {
-            None
-        } else {
-            Some(val)
-        })
+        Ok(if this.is_null(val)? { None } else { Some(val) })
     }
 
     /// Get the `Place` for a local
     fn local_place(&mut self, local: mir::Local) -> InterpResult<'tcx, PlaceTy<'tcx, Tag>> {
         let this = self.eval_context_mut();
-        let place = mir::Place { base: mir::PlaceBase::Local(local), projection: Box::new([]) };
+        let place = mir::Place {
+            base: mir::PlaceBase::Local(local),
+            projection: Box::new([]),
+        };
         this.eval_place(&place)
     }
 
     /// Generate some random bytes, and write them to `dest`.
-    fn gen_random(
-        &mut self,
-        ptr: Scalar<Tag>,
-        len: usize,
-    ) -> InterpResult<'tcx>  {
+    fn gen_random(&mut self, ptr: Scalar<Tag>, len: usize) -> InterpResult<'tcx> {
         // Some programs pass in a null pointer and a length of 0
         // to their platform's random-generation function (e.g. getrandom())
         // on Linux. For compatibility with these programs, we don't perform
@@ -91,26 +90,30 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         }
         let this = self.eval_context_mut();
 
-        let ptr = this.memory().check_ptr_access(
-            ptr,
-            Size::from_bytes(len as u64),
-            Align::from_bytes(1).unwrap()
-        )?.expect("we already checked for size 0");
+        let ptr = this
+            .memory()
+            .check_ptr_access(
+                ptr,
+                Size::from_bytes(len as u64),
+                Align::from_bytes(1).unwrap(),
+            )?
+            .expect("we already checked for size 0");
 
         let mut data = vec![0; len];
 
         if this.machine.communicate {
             // Fill the buffer using the host's rng.
             getrandom::getrandom(&mut data)
                 .map_err(|err| err_unsup_format!("getrandom failed: {}", err))?;
-        }
-        else {
+        } else {
             let rng = this.memory_mut().extra.rng.get_mut();
             rng.fill_bytes(&mut data);
         }
 
-        let tcx = &{this.tcx.tcx};
-        this.memory_mut().get_mut(ptr.alloc_id)?.write_bytes(tcx, ptr, &data)
+        let tcx = &{ this.tcx.tcx };
+        this.memory_mut()
+            .get_mut(ptr.alloc_id)?
+            .write_bytes(tcx, ptr, &data)
     }
 
     /// Visits the memory covered by `place`, sensitive to freezing: the 3rd parameter
@@ -123,10 +126,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_ref();
         trace!("visit_frozen(place={:?}, size={:?})", *place, size);
-        debug_assert_eq!(size,
+        debug_assert_eq!(
+            size,
             this.size_and_align_of_mplace(place)?
-            .map(|(size, _)| size)
-            .unwrap_or_else(|| place.layout.size)
+                .map(|(size, _)| size)
+                .unwrap_or_else(|| place.layout.size)
         );
         // Store how far we proceeded into the place so far. Everything to the left of
         // this offset has already been handled, in the sense that the frozen parts
@@ -146,11 +150,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             let frozen_size = unsafe_cell_offset - end_offset;
             // Everything between the end_ptr and this `UnsafeCell` is frozen.
             if frozen_size != Size::ZERO {
-                action(end_ptr, frozen_size, /*frozen*/true)?;
+                action(end_ptr, frozen_size, /*frozen*/ true)?;
             }
             // This `UnsafeCell` is NOT frozen.
             if unsafe_cell_size != Size::ZERO {
-                action(unsafe_cell_ptr, unsafe_cell_size, /*frozen*/false)?;
+                action(unsafe_cell_ptr, unsafe_cell_size, /*frozen*/ false)?;
             }
             // Update end end_ptr.
             end_ptr = unsafe_cell_ptr.wrapping_offset(unsafe_cell_size, this);
@@ -164,7 +168,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 unsafe_cell_action: |place| {
                     trace!("unsafe_cell_action on {:?}", place.ptr);
                     // We need a size to go on.
-                    let unsafe_cell_size = this.size_and_align_of_mplace(place)?
+                    let unsafe_cell_size = this
+                        .size_and_align_of_mplace(place)?
                         .map(|(size, _)| size)
                         // for extern types, just cover what we can
                         .unwrap_or_else(|| place.layout.size);
@@ -187,18 +192,17 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         /// Visiting the memory covered by a `MemPlace`, being aware of
         /// whether we are inside an `UnsafeCell` or not.
         struct UnsafeCellVisitor<'ecx, 'mir, 'tcx, F>
-            where F: FnMut(MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
+        where
+            F: FnMut(MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>,
         {
             ecx: &'ecx MiriEvalContext<'mir, 'tcx>,
             unsafe_cell_action: F,
         }
 
-        impl<'ecx, 'mir, 'tcx, F>
-            ValueVisitor<'mir, 'tcx, Evaluator<'tcx>>
-        for
-            UnsafeCellVisitor<'ecx, 'mir, 'tcx, F>
+        impl<'ecx, 'mir, 'tcx, F> ValueVisitor<'mir, 'tcx, Evaluator<'tcx>>
+            for UnsafeCellVisitor<'ecx, 'mir, 'tcx, F>
         where
-            F: FnMut(MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
+            F: FnMut(MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>,
         {
             type V = MPlaceTy<'tcx, Tag>;
 
@@ -208,11 +212,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
 
             // Hook to detect `UnsafeCell`.
-            fn visit_value(&mut self, v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
-            {
+            fn visit_value(&mut self, v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx> {
                 trace!("UnsafeCellVisitor: {:?} {:?}", *v, v.layout.ty);
                 let is_unsafe_cell = match v.layout.ty.kind {
-                    ty::Adt(adt, _) => Some(adt.did) == self.ecx.tcx.lang_items().unsafe_cell_type(),
+                    ty::Adt(adt, _) => {
+                        Some(adt.did) == self.ecx.tcx.lang_items().unsafe_cell_type()
+                    }
                     _ => false,
                 };
                 if is_unsafe_cell {
@@ -249,7 +254,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             fn visit_aggregate(
                 &mut self,
                 place: MPlaceTy<'tcx, Tag>,
-                fields: impl Iterator<Item=InterpResult<'tcx, MPlaceTy<'tcx, Tag>>>,
+                fields: impl Iterator<Item = InterpResult<'tcx, MPlaceTy<'tcx, Tag>>>,
             ) -> InterpResult<'tcx> {
                 match place.layout.fields {
                     layout::FieldPlacement::Array { .. } => {
@@ -259,7 +264,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     }
                     layout::FieldPlacement::Arbitrary { .. } => {
                         // Gather the subplaces and sort them before visiting.
-                        let mut places = fields.collect::<InterpResult<'tcx, Vec<MPlaceTy<'tcx, Tag>>>>()?;
+                        let mut places =
+                            fields.collect::<InterpResult<'tcx, Vec<MPlaceTy<'tcx, Tag>>>>()?;
                         places.sort_by_key(|place| place.ptr.assert_ptr().offset);
                         self.walk_aggregate(place, places.into_iter().map(Ok))
                     }
@@ -271,8 +277,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
 
             // We have to do *something* for unions.
-            fn visit_union(&mut self, v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
-            {
+            fn visit_union(&mut self, v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx> {
                 // With unions, we fall back to whatever the type says, to hopefully be consistent
                 // with LLVM IR.
                 // FIXME: are we consistent, and is this really the behavior we want?
@@ -285,8 +290,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             }
 
             // We should never get to a primitive, but always short-circuit somewhere above.
-            fn visit_primitive(&mut self, _v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx>
-            {
+            fn visit_primitive(&mut self, _v: MPlaceTy<'tcx, Tag>) -> InterpResult<'tcx> {
                 bug!("we should always short-circuit before coming to a primitive")
             }
         }
@@ -296,12 +300,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
     fn eval_libc(&mut self, name: &str) -> InterpResult<'tcx, Scalar<Tag>> {
         self.eval_context_mut()
             .eval_path_scalar(&["libc", name])?
-            .ok_or_else(|| err_unsup_format!("Path libc::{} cannot be resolved.", name).into())
-            .and_then(|scalar| scalar.not_undef())
+            .ok_or_else(|| err_unsup_format!("Path libc::{} cannot be resolved.", name))?
+            .not_undef()
     }
 
     /// Helper function to get a `libc` constant as an `i32`.
     fn eval_libc_i32(&mut self, name: &str) -> InterpResult<'tcx, i32> {
-        self.eval_libc(name).and_then(|scalar| scalar.to_i32())
+        self.eval_libc(name)?.to_i32()
     }
 }

src/shims/env.rs

@@ -135,7 +135,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let mut bytes = cwd.display().to_string().into_bytes();
                 // If `size` is smaller or equal than the `bytes.len()`, writing `bytes` plus the
                 // required null terminator to memory using the `buf` pointer would cause an
-                // overflow, the desired behavior in this case is to return null.
+                // overflow. The desired behavior in this case is to return null.
                 if (bytes.len() as u64) < size {
                     // We add a `/0` terminator
                     bytes.push(0);