Reduce the amount of code in unsafe blocks (2)

src/apply.rs

@@ -47,10 +47,10 @@ type HunkCB<'a> = dyn FnMut(Option<DiffHunk<'_>>) -> bool + 'a;
 type DeltaCB<'a> = dyn FnMut(Option<DiffDelta<'_>>) -> bool + 'a;
 
 extern "C" fn delta_cb_c(delta: *const raw::git_diff_delta, data: *mut c_void) -> c_int {
-    panic::wrap(|| unsafe {
-        let delta = Binding::from_raw_opt(delta as *mut _);
+    panic::wrap(|| {
+        let delta = unsafe { Binding::from_raw_opt(delta as *mut _) };
 
-        let payload = &mut *(data as *mut ApplyOptions<'_>);
+        let payload = unsafe { &mut *(data as *mut ApplyOptions<'_>) };
         let callback = match payload.delta_cb {
             Some(ref mut c) => c,
             None => return -1,
@@ -67,10 +67,10 @@ extern "C" fn delta_cb_c(delta: *const raw::git_diff_delta, data: *mut c_void) -
 }
 
 extern "C" fn hunk_cb_c(hunk: *const raw::git_diff_hunk, data: *mut c_void) -> c_int {
-    panic::wrap(|| unsafe {
-        let hunk = Binding::from_raw_opt(hunk);
+    panic::wrap(|| {
+        let hunk = unsafe { Binding::from_raw_opt(hunk) };
 
-        let payload = &mut *(data as *mut ApplyOptions<'_>);
+        let payload = unsafe { &mut *(data as *mut ApplyOptions<'_>) };
         let callback = match payload.hunk_cb {
             Some(ref mut c) => c,
             None => return -1,

src/blame.rs

@@ -245,15 +245,14 @@ impl Default for BlameOptions {
 impl BlameOptions {
     /// Initialize options
     pub fn new() -> BlameOptions {
-        unsafe {
-            let mut raw: raw::git_blame_options = mem::zeroed();
-            assert_eq!(
-                raw::git_blame_init_options(&mut raw, raw::GIT_BLAME_OPTIONS_VERSION),
-                0
-            );
+        let mut raw: raw::git_blame_options = unsafe { mem::zeroed() };
 
-            Binding::from_raw(&raw as *const _ as *mut _)
-        }
+        assert_eq!(
+            unsafe { raw::git_blame_init_options(&mut raw, raw::GIT_BLAME_OPTIONS_VERSION) },
+            0
+        );
+
+        unsafe { Binding::from_raw(&raw as *const _ as *mut _) }
     }
 
     fn flag(&mut self, opt: u32, val: bool) -> &mut BlameOptions {

src/blob.rs

@@ -122,10 +122,8 @@ impl<'repo> Drop for BlobWriter<'repo> {
     fn drop(&mut self) {
         // We need cleanup in case the stream has not been committed
         if self.need_cleanup {
-            unsafe {
-                if let Some(f) = (*self.raw).free {
-                    f(self.raw)
-                }
+            if let Some(f) = unsafe { (*self.raw).free } {
+                f(self.raw)
             }
         }
     }

src/build.rs

@@ -296,23 +296,21 @@ extern "C" fn remote_create_cb(
     url: *const c_char,
     payload: *mut c_void,
 ) -> c_int {
-    unsafe {
-        let repo = Repository::from_raw(repo);
-        let code = panic::wrap(|| {
-            let name = CStr::from_ptr(name).to_str().unwrap();
-            let url = CStr::from_ptr(url).to_str().unwrap();
-            let f = payload as *mut Box<RemoteCreate<'_>>;
-            match (*f)(&repo, name, url) {
-                Ok(remote) => {
-                    *out = crate::remote::remote_into_raw(remote);
-                    0
-                }
-                Err(e) => e.raw_code(),
+    let repo = unsafe { Repository::from_raw(repo) };
+    let code = panic::wrap(|| {
+        let name = unsafe { CStr::from_ptr(name) }.to_str().unwrap();
+        let url = unsafe { CStr::from_ptr(url) }.to_str().unwrap();
+        let f = payload as *mut Box<RemoteCreate<'_>>;
+        match unsafe { (*f)(&repo, name, url) } {
+            Ok(remote) => {
+                unsafe { *out = crate::remote::remote_into_raw(remote) };
+                0
             }
-        });
-        mem::forget(repo);
-        code.unwrap_or(-1)
-    }
+            Err(e) => e.raw_code(),
+        }
+    });
+    mem::forget(repo);
+    code.unwrap_or(-1)
 }
 
 impl<'cb> Default for CheckoutBuilder<'cb> {
@@ -638,16 +636,16 @@ extern "C" fn progress_cb(
     total: size_t,
     data: *mut c_void,
 ) {
-    panic::wrap(|| unsafe {
-        let payload = &mut *(data as *mut CheckoutBuilder<'_>);
+    panic::wrap(|| {
+        let payload = unsafe { &mut *(data as *mut CheckoutBuilder<'_>) };
         let callback = match payload.progress {
             Some(ref mut c) => c,
             None => return,
         };
         let path = if path.is_null() {
             None
         } else {
-            Some(util::bytes2path(CStr::from_ptr(path).to_bytes()))
+            Some(util::bytes2path(unsafe { CStr::from_ptr(path) }.to_bytes()))
         };
         callback(path, completed as usize, total as usize)
     });
@@ -662,34 +660,34 @@ extern "C" fn notify_cb(
     data: *mut c_void,
 ) -> c_int {
     // pack callback etc
-    panic::wrap(|| unsafe {
-        let payload = &mut *(data as *mut CheckoutBuilder<'_>);
+    panic::wrap(|| {
+        let payload = unsafe { &mut *(data as *mut CheckoutBuilder<'_>) };
         let callback = match payload.notify {
             Some(ref mut c) => c,
             None => return 0,
         };
         let path = if path.is_null() {
             None
         } else {
-            Some(util::bytes2path(CStr::from_ptr(path).to_bytes()))
+            Some(util::bytes2path(unsafe { CStr::from_ptr(path) }.to_bytes()))
         };
 
         let baseline = if baseline.is_null() {
             None
         } else {
-            Some(DiffFile::from_raw(baseline))
+            Some(unsafe { DiffFile::from_raw(baseline) })
         };
 
         let target = if target.is_null() {
             None
         } else {
-            Some(DiffFile::from_raw(target))
+            Some(unsafe { DiffFile::from_raw(target) })
         };
 
         let workdir = if workdir.is_null() {
             None
         } else {
-            Some(DiffFile::from_raw(workdir))
+            Some(unsafe { DiffFile::from_raw(workdir) })
         };
 
         let why = CheckoutNotificationType::from_bits_truncate(why as u32);

src/commit.rs

@@ -288,8 +288,8 @@ impl<'repo> Commit<'repo> {
     ///
     /// Use the `parents` iterator to return an iterator over all parents.
     pub fn parent(&self, i: usize) -> Result<Commit<'repo>, Error> {
+        let mut raw = ptr::null_mut();
         unsafe {
-            let mut raw = ptr::null_mut();
             try_call!(raw::git_commit_parent(
                 &mut raw,
                 &*self.raw,

src/message.rs

@@ -201,8 +201,8 @@ impl DoubleEndedIterator for MessageTrailersStrsIterator<'_> {
 
 fn to_str_tuple(trailers: &MessageTrailers, index: usize) -> (&str, &str) {
     let (rkey, rvalue) = to_raw_tuple(trailers, index);
-    let key = unsafe { CStr::from_ptr(rkey).to_str().unwrap() };
-    let value = unsafe { CStr::from_ptr(rvalue).to_str().unwrap() };
+    let key = unsafe { CStr::from_ptr(rkey) }.to_str().unwrap();
+    let value = unsafe { CStr::from_ptr(rvalue) }.to_str().unwrap();
     (key, value)
 }
 
@@ -243,8 +243,8 @@ impl DoubleEndedIterator for MessageTrailersBytesIterator<'_> {
 
 fn to_bytes_tuple(trailers: &MessageTrailers, index: usize) -> (&[u8], &[u8]) {
     let (rkey, rvalue) = to_raw_tuple(trailers, index);
-    let key = unsafe { CStr::from_ptr(rkey).to_bytes() };
-    let value = unsafe { CStr::from_ptr(rvalue).to_bytes() };
+    let key = unsafe { CStr::from_ptr(rkey) }.to_bytes();
+    let value = unsafe { CStr::from_ptr(rvalue) }.to_bytes();
     (key, value)
 }
 

src/object.rs

@@ -157,11 +157,9 @@ impl<'repo> Object<'repo> {
     fn cast_into<T>(self, kind: ObjectType) -> Result<T, Object<'repo>> {
         assert_eq!(mem::size_of_val(&self), mem::size_of::<T>());
         if self.kind() == Some(kind) {
-            Ok(unsafe {
-                let other = ptr::read(&self as *const _ as *const T);
-                mem::forget(self);
-                other
-            })
+            let other = unsafe { ptr::read(&self as *const _ as *const T) };
+            mem::forget(self);
+            Ok(other)
         } else {
             Err(self)
         }
@@ -177,11 +175,9 @@ impl<'repo> CastOrPanic for Object<'repo> {
     fn cast_or_panic<T>(self, kind: ObjectType) -> T {
         assert_eq!(mem::size_of_val(&self), mem::size_of::<T>());
         if self.kind() == Some(kind) {
-            unsafe {
-                let other = ptr::read(&self as *const _ as *const T);
-                mem::forget(self);
-                other
-            }
+            let other = unsafe { ptr::read(&self as *const _ as *const T) };
+            mem::forget(self);
+            other
         } else {
             let buf;
             let akind = match self.kind() {
@@ -204,11 +200,9 @@ impl<'repo> CastOrPanic for Object<'repo> {
 impl<'repo> Clone for Object<'repo> {
     fn clone(&self) -> Object<'repo> {
         let mut raw = ptr::null_mut();
-        unsafe {
-            let rc = raw::git_object_dup(&mut raw, self.raw);
-            assert_eq!(rc, 0);
-            Binding::from_raw(raw)
-        }
+        let rc = unsafe { raw::git_object_dup(&mut raw, self.raw) };
+        assert_eq!(rc, 0);
+        unsafe { Binding::from_raw(raw) }
     }
 }
 

src/odb.rs

@@ -167,8 +167,8 @@ impl<'repo> Odb<'repo> {
 
     /// Write an object to the database.
     pub fn write(&self, kind: ObjectType, data: &[u8]) -> Result<Oid, Error> {
+        let mut out = crate::util::zeroed_raw_oid();
         unsafe {
-            let mut out = crate::util::zeroed_raw_oid();
             try_call!(raw::git_odb_write(
                 &mut out,
                 self.raw,
@@ -471,14 +471,11 @@ pub struct OdbPackwriter<'repo> {
 impl<'repo> OdbPackwriter<'repo> {
     /// Finish writing the packfile
     pub fn commit(&mut self) -> Result<i32, Error> {
-        let res;
-        unsafe {
-            let writepack = &*self.raw;
-            res = match writepack.commit {
-                Some(commit) => commit(self.raw, &mut self.progress),
-                None => -1,
-            };
-        }
+        let writepack = unsafe { &*self.raw };
+        let res = match writepack.commit {
+            Some(commit) => unsafe { commit(self.raw, &mut self.progress) },
+            None => -1,
+        };
 
         if res < 0 {
             Err(Error::last_error(res))
@@ -505,14 +502,11 @@ impl<'repo> io::Write for OdbPackwriter<'repo> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         let ptr = buf.as_ptr() as *mut c_void;
         let len = buf.len();
-        let res;
-        unsafe {
-            let writepack = &*self.raw;
-            res = match writepack.append {
-                Some(append) => append(self.raw, ptr, len, &mut self.progress),
-                None => -1,
-            };
-        }
+        let writepack = unsafe { &*self.raw };
+        let res = match writepack.append {
+            Some(append) => append(self.raw, ptr, len, &mut self.progress),
+            None => -1,
+        };
         if res < 0 {
             Err(io::Error::other("Write error"))
         } else {
@@ -526,14 +520,12 @@ impl<'repo> io::Write for OdbPackwriter<'repo> {
 
 impl<'repo> Drop for OdbPackwriter<'repo> {
     fn drop(&mut self) {
-        unsafe {
-            let writepack = &*self.raw;
-            if let Some(free) = writepack.free {
-                free(self.raw);
-            };
+        let writepack = unsafe { &*self.raw };
+        if let Some(free) = writepack.free {
+            unsafe { free(self.raw) };
+        };
 
-            drop(Box::from_raw(self.progress_payload_ptr));
-        }
+        drop(unsafe { Box::from_raw(self.progress_payload_ptr) });
     }
 }
 
@@ -544,11 +536,11 @@ struct ForeachCbData<'a> {
 }
 
 extern "C" fn foreach_cb(id: *const raw::git_oid, payload: *mut c_void) -> c_int {
-    panic::wrap(|| unsafe {
-        let data = &mut *(payload as *mut ForeachCbData<'_>);
+    panic::wrap(|| {
+        let data = unsafe { &mut *(payload as *mut ForeachCbData<'_>) };
         let res = {
             let callback = &mut data.callback;
-            callback(&Binding::from_raw(id))
+            callback(unsafe { &Binding::from_raw(id) })
         };
 
         if res {
@@ -564,15 +556,15 @@ pub(crate) extern "C" fn write_pack_progress_cb(
     stats: *const raw::git_indexer_progress,
     payload: *mut c_void,
 ) -> c_int {
-    let ok = panic::wrap(|| unsafe {
-        let payload = &mut *(payload as *mut OdbPackwriterCb<'_>);
+    let ok = panic::wrap(|| {
+        let payload = unsafe { &mut *(payload as *mut OdbPackwriterCb<'_>) };
 
         let callback = match payload.cb {
             Some(ref mut cb) => cb,
             None => return true,
         };
 
-        let progress: Progress<'_> = Binding::from_raw(stats);
+        let progress: Progress<'_> = unsafe { Binding::from_raw(stats) };
         callback(progress)
     });
     if ok == Some(true) {

src/oid_array.rs

@@ -21,11 +21,11 @@ impl Deref for OidArray {
     type Target = [Oid];
 
     fn deref(&self) -> &[Oid] {
-        unsafe {
-            debug_assert_eq!(mem::size_of::<Oid>(), mem::size_of_val(&*self.raw.ids));
-
-            slice::from_raw_parts(self.raw.ids as *const Oid, self.raw.count as usize)
-        }
+        debug_assert_eq!(
+            mem::size_of::<Oid>(),
+            mem::size_of_val(unsafe { &*self.raw.ids })
+        );
+        unsafe { slice::from_raw_parts(self.raw.ids as *const Oid, self.raw.count as usize) }
     }
 }