Run cargo fmt

Author: fitzgen

test/src/lib.rs

@@ -8,8 +8,8 @@ extern crate cfg_if;
 extern crate rand;
 extern crate wee_alloc;
 
-use std::alloc::{Alloc, Layout};
 use quickcheck::{Arbitrary, Gen};
+use std::alloc::{Alloc, Layout};
 use std::f64;
 use std::fs;
 use std::io::Read;
@@ -162,7 +162,8 @@ impl Arbitrary for Operations {
         let prefixes =
             (0..self.0.len()).map(move |i| Operations(ops.iter().cloned().take(i).collect()));
 
-        let free_indices: Vec<_> = self.0
+        let free_indices: Vec<_> = self
+            .0
             .iter()
             .enumerate()
             .filter_map(|(i, op)| if let Free(_) = *op { Some(i) } else { None })
@@ -178,7 +179,8 @@ impl Arbitrary for Operations {
             )
         });
 
-        let alloc_indices: Vec<_> = self.0
+        let alloc_indices: Vec<_> = self
+            .0
             .iter()
             .enumerate()
             .filter_map(|(i, op)| if let Alloc(_) = *op { Some(i) } else { None })
@@ -433,7 +435,8 @@ fn allocate_size_zero() {
             .take(1000)
             .chain((0..1000).map(|i| Free(i)))
             .collect(),
-    ).run_single_threaded();
+    )
+    .run_single_threaded();
 }
 
 #[test]
@@ -447,7 +450,8 @@ fn allocate_many_small() {
             .chain(iter::repeat(Alloc(256 * mem::size_of::<usize>())).take(100))
             .chain((0..100).map(|i| Free(i + 100)))
             .collect(),
-    ).run_single_threaded();
+    )
+    .run_single_threaded();
 }
 
 #[test]
@@ -461,7 +465,8 @@ fn allocate_many_large() {
             .chain(iter::repeat(Alloc(1024 * mem::size_of::<usize>())).take(100))
             .chain((0..100).map(|i| Free(i + 100)))
             .collect(),
-    ).run_single_threaded();
+    )
+    .run_single_threaded();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -475,7 +480,8 @@ fn smoke() {
     let mut a = &wee_alloc::WeeAlloc::INIT;
     unsafe {
         let layout = Layout::new::<u8>();
-        let ptr = a.alloc(layout.clone())
+        let ptr = a
+            .alloc(layout.clone())
             .expect("Should be able to alloc a fresh Layout clone");
         {
             let ptr = ptr.as_ptr() as *mut u8;
@@ -484,7 +490,8 @@ fn smoke() {
         }
         a.dealloc(ptr, layout.clone());
 
-        let ptr = a.alloc(layout.clone())
+        let ptr = a
+            .alloc(layout.clone())
             .expect("Should be able to alloc from a second clone");
         {
             let ptr = ptr.as_ptr() as *mut u8;

trace-malloc-free/src/main.rs

@@ -41,20 +41,21 @@ main!(|cli: Cli| {
 
     let malloc_re = Regex::new(
         r#"^\-\-\d+\-\- (realloc\(0x0,\d+\))?malloc\((?P<size>\d+)\) = 0x(?P<ptr>\w+)$"#,
-    ).unwrap();
+    )
+    .unwrap();
 
-    let calloc_re = Regex::new(
-        r#"^\-\-\d+\-\- calloc\((?P<num>\d+),(?P<size>\d+)\) = 0x(?P<ptr>\w+)$"#,
-    ).unwrap();
+    let calloc_re =
+        Regex::new(r#"^\-\-\d+\-\- calloc\((?P<num>\d+),(?P<size>\d+)\) = 0x(?P<ptr>\w+)$"#)
+            .unwrap();
 
-    let realloc_re = Regex::new(
-        r#"^\-\-\d+\-\- realloc\(0x(?P<orig>\w+),(?P<size>\d+)\) = 0x(?P<new>\w+)$"#,
-    ).unwrap();
+    let realloc_re =
+        Regex::new(r#"^\-\-\d+\-\- realloc\(0x(?P<orig>\w+),(?P<size>\d+)\) = 0x(?P<new>\w+)$"#)
+            .unwrap();
 
     // TODO: record the requested alignment and replay that as well.
-    let memalign_re = Regex::new(
-        r#"r#"^\-\-\d+\-\- memalign\(al \d+, size (?P<size>\d+)\) = 0x(?P<ptr>\w+)$"#,
-    ).unwrap();
+    let memalign_re =
+        Regex::new(r#"r#"^\-\-\d+\-\- memalign\(al \d+, size (?P<size>\d+)\) = 0x(?P<ptr>\w+)$"#)
+            .unwrap();
 
     let free_re = Regex::new(r#"^\-\-\d+\-\- free\(0x(?P<ptr>\w+)\)$"#).unwrap();
 

wee_alloc/build.rs

@@ -38,7 +38,8 @@ fn export_rerun_rules() {
         "./build.rs",
         "./src/lib.rs",
         "./src/imp_static_array.rs",
-    ].iter()
+    ]
+    .iter()
     {
         println!("cargo:rerun-if-changed={}", path);
     }

wee_alloc/src/lib.rs

@@ -777,10 +777,7 @@ impl<'a> AllocPolicy<'a> for LargeAllocPolicy {
         // free list with this new cell, make sure that we allocate enough to
         // fulfill the requested alignment, and still have the minimum cell size
         // left over.
-        let size: Bytes = cmp::max(
-            size.into(),
-            (align + Self::MIN_CELL_SIZE) * Words(2),
-        );
+        let size: Bytes = cmp::max(size.into(), (align + Self::MIN_CELL_SIZE) * Words(2));
 
         let pages: Pages = (size + size_of::<CellHeader>()).round_up_to();
         let new_pages = imp::alloc_pages(pages)?;
@@ -912,9 +909,7 @@ unsafe fn alloc_first_fit<'a>(
 
         if let Some(allocated) = current.try_alloc(previous, size, align, policy) {
             assert_aligned_to(allocated.data(), align);
-            return Some(unchecked_unwrap(
-                NonNull::new(allocated.data() as *mut u8),
-            ));
+            return Some(unchecked_unwrap(NonNull::new(allocated.data() as *mut u8)));
         }
 
         None
@@ -1093,7 +1088,8 @@ impl<'a> WeeAlloc<'a> {
                 // immediately, whereas the consolidating with the next adjacent
                 // cell must be delayed, as explained above.
 
-                if let Some(prev) = free.header
+                if let Some(prev) = free
+                    .header
                     .neighbors
                     .prev()
                     .and_then(|p| (*p).as_free_cell())
@@ -1108,7 +1104,8 @@ impl<'a> WeeAlloc<'a> {
                     return;
                 }
 
-                if let Some(next) = free.header
+                if let Some(next) = free
+                    .header
                     .neighbors
                     .next()
                     .and_then(|n| (*n).as_free_cell())