cargo fmt and warning removal

Author: Speedy37

libmimalloc-sys/src/lib.rs

@@ -3,35 +3,35 @@
 use libc::{c_void, size_t};
 
 extern "C" {
-   pub fn mi_zalloc(size: size_t) -> *const c_void;
-   pub fn mi_malloc(size: size_t) -> *const c_void;
-   pub fn mi_realloc(p: *const c_void, size: size_t) -> *const c_void;
-   pub fn mi_zalloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
-   pub fn mi_malloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
-   pub fn mi_realloc_aligned(p: *const c_void, size: size_t, alignment: size_t) -> *const c_void;
-   pub fn mi_free(p: *const c_void) -> c_void;
+    pub fn mi_zalloc(size: size_t) -> *const c_void;
+    pub fn mi_malloc(size: size_t) -> *const c_void;
+    pub fn mi_realloc(p: *const c_void, size: size_t) -> *const c_void;
+    pub fn mi_zalloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
+    pub fn mi_malloc_aligned(size: size_t, alignment: size_t) -> *const c_void;
+    pub fn mi_realloc_aligned(p: *const c_void, size: size_t, alignment: size_t) -> *const c_void;
+    pub fn mi_free(p: *const c_void) -> c_void;
 }
 
 #[cfg(test)]
 mod tests {
-   use super::*;
+    use super::*;
 
-   #[test]
-   fn it_frees_memory_malloc() {
-      let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
-      unsafe { mi_free(ptr as *const c_void) };
-   }
+    #[test]
+    fn it_frees_memory_malloc() {
+        let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
+        unsafe { mi_free(ptr as *const c_void) };
+    }
 
-   #[test]
-   fn it_frees_memory_zalloc() {
-      let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8;
-      unsafe { mi_free(ptr as *const c_void) };
-   }
+    #[test]
+    fn it_frees_memory_zalloc() {
+        let ptr = unsafe { mi_zalloc_aligned(8, 8) } as *mut u8;
+        unsafe { mi_free(ptr as *const c_void) };
+    }
 
-   #[test]
-   fn it_frees_memory_realloc() {
-      let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
-      let ptr = unsafe { mi_realloc_aligned(ptr as *const c_void, 8, 8) } as *mut u8;
-      unsafe { mi_free(ptr as *const c_void) };
-   }
-}
+    #[test]
+    fn it_frees_memory_realloc() {
+        let ptr = unsafe { mi_malloc_aligned(8, 8) } as *mut u8;
+        let ptr = unsafe { mi_realloc_aligned(ptr as *const c_void, 8, 8) } as *mut u8;
+        unsafe { mi_free(ptr as *const c_void) };
+    }
+}

src/lib.rs

@@ -4,19 +4,19 @@
 
 //! A drop-in global allocator wrapper around the [mimalloc](https://github.com/microsoft/mimalloc) allocator.
 //! Mimalloc is a general purpose, performance oriented allocator built by Microsoft.
-//! 
+//!
 //! ## Usage
 //! ```rust,ignore
 //! use mimalloc::MiMalloc;
 //!
 //! #[global_allocator]
 //! static GLOBAL: MiMalloc = MiMalloc;
 //! ```
-//! 
+//!
 //! ## Usage without secure mode
 //! By default this library builds mimalloc in secure mode. This means that
 //! heap allocations are encrypted, but this results in a 3% increase in overhead.
-//! 
+//!
 //! To disable secure mode, in `Cargo.toml`:
 //! ```rust,ignore
 //! [dependencies]
@@ -26,9 +26,8 @@
 extern crate libmimalloc_sys as ffi;
 
 use core::alloc::{GlobalAlloc, Layout};
-use core::ptr;
-use libc::c_void;
 use ffi::*;
+use libc::c_void;
 
 // Copied from https://github.com/rust-lang/rust/blob/master/src/libstd/sys_common/alloc.rs
 #[cfg(all(any(
@@ -52,7 +51,7 @@ const MIN_ALIGN: usize = 8;
 const MIN_ALIGN: usize = 16;
 
 /// Drop-in mimalloc global allocator.
-/// 
+///
 /// ## Usage
 /// ```rust,ignore
 /// use mimalloc::MiMalloc;
@@ -68,10 +67,9 @@ unsafe impl GlobalAlloc for MiMalloc {
         if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
             mi_malloc(layout.size()) as *mut u8
         } else {
-            #[cfg(target_os = "macos")]
-            {
+            if cfg!(target_os = "macos") {
                 if layout.align() > (1 << 31) {
-                    return ptr::null_mut()
+                    return core::ptr::null_mut();
                 }
             }
 
@@ -84,17 +82,16 @@ unsafe impl GlobalAlloc for MiMalloc {
         if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
             mi_zalloc(layout.size()) as *mut u8
         } else {
-            #[cfg(target_os = "macos")]
-            {
+            if cfg!(target_os = "macos") {
                 if layout.align() > (1 << 31) {
-                    return ptr::null_mut()
+                    return core::ptr::null_mut();
                 }
             }
 
             mi_zalloc_aligned(layout.size(), layout.align()) as *mut u8
         }
     }
-    
+
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
         mi_free(ptr as *const c_void);
@@ -147,4 +144,4 @@ mod tests {
             alloc.dealloc(ptr, layout);
         }
     }
-}
+}