Run rustfmt

Author: phil-opp

src/hole.rs

@@ -1,6 +1,6 @@
-use core::ptr::NonNull;
+use core::alloc::{AllocErr, Layout, Opaque};
 use core::mem::size_of;
-use core::alloc::{Layout, Opaque, AllocErr};
+use core::ptr::NonNull;
 
 use super::align_up;
 
@@ -27,7 +27,10 @@ impl HoleList {
         assert!(size_of::<Hole>() == Self::min_size());
 
         let ptr = hole_addr as *mut Hole;
-        ptr.write(Hole { size: hole_size, next: None, });
+        ptr.write(Hole {
+            size: hole_size,
+            next: None,
+        });
 
         HoleList {
             first: Hole {
@@ -75,7 +78,10 @@ impl HoleList {
     /// Returns information about the first hole for test purposes.
     #[cfg(test)]
     pub fn first_hole(&self) -> Option<(usize, usize)> {
-        self.first.next.as_ref().map(|hole| ((*hole) as *const Hole as usize, hole.size))
+        self.first
+            .next
+            .as_ref()
+            .map(|hole| ((*hole) as *const Hole as usize, hole.size))
     }
 }
 
@@ -185,9 +191,10 @@ fn split_hole(hole: HoleInfo, required_layout: Layout) -> Option<Allocation> {
 /// found (and returns it).
 fn allocate_first_fit(mut previous: &mut Hole, layout: Layout) -> Result<Allocation, AllocErr> {
     loop {
-        let allocation: Option<Allocation> = previous.next.as_mut().and_then(|current| {
-            split_hole(current.info(), layout.clone())
-        });
+        let allocation: Option<Allocation> = previous
+            .next
+            .as_mut()
+            .and_then(|current| split_hole(current.info(), layout.clone()));
         match allocation {
             Some(allocation) => {
                 // hole is big enough, so remove it from the list by updating the previous pointer

src/lib.rs

@@ -10,12 +10,12 @@ extern crate std;
 #[cfg(feature = "use_spin")]
 extern crate spin;
 
-use hole::{Hole, HoleList};
+use core::alloc::{Alloc, AllocErr, GlobalAlloc, Layout, Opaque};
 use core::mem;
-use core::ptr::NonNull;
 #[cfg(feature = "use_spin")]
 use core::ops::Deref;
-use core::alloc::{Alloc, GlobalAlloc, AllocErr, Layout, Opaque};
+use core::ptr::NonNull;
+use hole::{Hole, HoleList};
 #[cfg(feature = "use_spin")]
 use spin::Mutex;
 
@@ -121,7 +121,8 @@ impl Heap {
     pub unsafe fn extend(&mut self, by: usize) {
         let top = self.top();
         let layout = Layout::from_size_align(by, 1).unwrap();
-        self.holes.deallocate(NonNull::new_unchecked(top as *mut Opaque), layout);
+        self.holes
+            .deallocate(NonNull::new_unchecked(top as *mut Opaque), layout);
         self.size += by;
     }
 }
@@ -175,13 +176,17 @@ impl Deref for LockedHeap {
 #[cfg(feature = "use_spin")]
 unsafe impl GlobalAlloc for LockedHeap {
     unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
-        self.0.lock().allocate_first_fit(layout).ok().map_or(0 as *mut Opaque, |allocation| {
-            allocation.as_ptr()
-        })
+        self.0
+            .lock()
+            .allocate_first_fit(layout)
+            .ok()
+            .map_or(0 as *mut Opaque, |allocation| allocation.as_ptr())
     }
 
     unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
-        self.0.lock().deallocate(NonNull::new_unchecked(ptr), layout)
+        self.0
+            .lock()
+            .deallocate(NonNull::new_unchecked(ptr), layout)
     }
 
     fn oom(&self) -> ! {

src/test.rs

@@ -1,7 +1,7 @@
-use std::prelude::v1::*;
-use std::mem::{size_of, align_of};
-use core::alloc::Layout;
 use super::*;
+use core::alloc::Layout;
+use std::mem::{align_of, size_of};
+use std::prelude::v1::*;
 
 fn new_heap() -> Heap {
     const HEAP_SIZE: usize = 1000;