From 21bb0dcc120011dbe308c5d8410d07188db61ca4 Mon Sep 17 00:00:00 2001 From: Ahmed Charles Date: Sun, 11 Oct 2015 19:33:51 -0700 Subject: [PATCH] Run rustfmt on libarena. --- src/libarena/lib.rs | 120 ++++++++++++++++++-------------------------- 1 file changed, 50 insertions(+), 70 deletions(-) diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index 62463ecabbf..97621a2ac89 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -105,7 +105,7 @@ pub struct Arena<'longer_than_self> { head: RefCell, copy_head: RefCell, chunks: RefCell>, - _marker: marker::PhantomData<*mut &'longer_than_self()>, + _marker: marker::PhantomData<*mut &'longer_than_self ()>, } impl<'a> Arena<'a> { @@ -197,7 +197,7 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) { struct TyDesc { drop_glue: fn(*const i8), size: usize, - align: usize + align: usize, } trait AllTypes { fn dummy(&self) { } } @@ -224,8 +224,7 @@ impl<'longer_than_self> Arena<'longer_than_self> { let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size()); self.chunks.borrow_mut().push(self.copy_head.borrow().clone()); - *self.copy_head.borrow_mut() = - chunk((new_min_chunk_size + 1).next_power_of_two(), true); + *self.copy_head.borrow_mut() = chunk((new_min_chunk_size + 1).next_power_of_two(), true); self.alloc_copy_inner(n_bytes, align) } @@ -242,16 +241,13 @@ impl<'longer_than_self> Arena<'longer_than_self> { let copy_head = self.copy_head.borrow(); copy_head.fill.set(end); - unsafe { - copy_head.as_ptr().offset(start as isize) - } + unsafe { copy_head.as_ptr().offset(start as isize) } } #[inline] fn alloc_copy(&self, op: F) -> &mut T where F: FnOnce() -> T { unsafe { - let ptr = self.alloc_copy_inner(mem::size_of::(), - mem::align_of::()); + let ptr = self.alloc_copy_inner(mem::size_of::(), mem::align_of::()); let ptr = ptr as *mut T; ptr::write(&mut (*ptr), op()); &mut *ptr @@ -259,21 +255,18 @@ impl<'longer_than_self> Arena<'longer_than_self> { } // Functions for the non-POD part of the arena - fn alloc_noncopy_grow(&self, n_bytes: usize, - align: usize) -> (*const u8, *const u8) { + fn alloc_noncopy_grow(&self, n_bytes: usize, align: usize) -> (*const u8, *const u8) { // Allocate a new chunk. let new_min_chunk_size = cmp::max(n_bytes, self.chunk_size()); self.chunks.borrow_mut().push(self.head.borrow().clone()); - *self.head.borrow_mut() = - chunk((new_min_chunk_size + 1).next_power_of_two(), false); + *self.head.borrow_mut() = chunk((new_min_chunk_size + 1).next_power_of_two(), false); self.alloc_noncopy_inner(n_bytes, align) } #[inline] - fn alloc_noncopy_inner(&self, n_bytes: usize, - align: usize) -> (*const u8, *const u8) { + fn alloc_noncopy_inner(&self, n_bytes: usize, align: usize) -> (*const u8, *const u8) { // Be careful to not maintain any `head` borrows active, because // `alloc_noncopy_grow` borrows it mutably. let (start, end, tydesc_start, head_capacity) = { @@ -297,7 +290,8 @@ impl<'longer_than_self> Arena<'longer_than_self> { unsafe { let buf = head.as_ptr(); - (buf.offset(tydesc_start as isize), buf.offset(start as isize)) + (buf.offset(tydesc_start as isize), + buf.offset(start as isize)) } } @@ -305,16 +299,14 @@ impl<'longer_than_self> Arena<'longer_than_self> { fn alloc_noncopy(&self, op: F) -> &mut T where F: FnOnce() -> T { unsafe { let tydesc = get_tydesc::(); - let (ty_ptr, ptr) = - self.alloc_noncopy_inner(mem::size_of::(), - mem::align_of::()); + let (ty_ptr, ptr) = self.alloc_noncopy_inner(mem::size_of::(), mem::align_of::()); let ty_ptr = ty_ptr as *mut usize; let ptr = ptr as *mut T; // Write in our tydesc along with a bit indicating that it // has *not* been initialized yet. *ty_ptr = bitpack_tydesc_ptr(tydesc, false); // Actually initialize it - ptr::write(&mut(*ptr), op()); + ptr::write(&mut (*ptr), op()); // Now that we are done, update the tydesc to indicate that // the object is there. *ty_ptr = bitpack_tydesc_ptr(tydesc, true); @@ -358,10 +350,10 @@ fn test_arena_destructors_fail() { for i in 0..10 { // Arena allocate something with drop glue to make sure it // doesn't leak. - arena.alloc(|| { Rc::new(i) }); + arena.alloc(|| Rc::new(i)); // Allocate something with funny size and alignment, to keep // things interesting. - arena.alloc(|| { [0u8, 1, 2] }); + arena.alloc(|| [0u8, 1, 2]); } // Now, panic while allocating arena.alloc::, _>(|| { @@ -409,12 +401,13 @@ fn calculate_size(capacity: usize) -> usize { impl TypedArenaChunk { #[inline] - unsafe fn new(next: *mut TypedArenaChunk, capacity: usize) - -> *mut TypedArenaChunk { + unsafe fn new(next: *mut TypedArenaChunk, capacity: usize) -> *mut TypedArenaChunk { let size = calculate_size::(capacity); - let chunk = allocate(size, mem::align_of::>()) - as *mut TypedArenaChunk; - if chunk.is_null() { alloc::oom() } + let chunk = + allocate(size, mem::align_of::>()) as *mut TypedArenaChunk; + if chunk.is_null() { + alloc::oom() + } (*chunk).next = next; (*chunk).capacity = capacity; chunk @@ -437,7 +430,8 @@ impl TypedArenaChunk { let next = self.next; let size = calculate_size::(self.capacity); let self_ptr: *mut TypedArenaChunk = self; - deallocate(self_ptr as *mut u8, size, + deallocate(self_ptr as *mut u8, + size, mem::align_of::>()); if !next.is_null() { let capacity = (*next).capacity; @@ -449,9 +443,7 @@ impl TypedArenaChunk { #[inline] fn start(&self) -> *const u8 { let this: *const TypedArenaChunk = self; - unsafe { - round_up(this.offset(1) as usize, mem::align_of::()) as *const u8 - } + unsafe { round_up(this.offset(1) as usize, mem::align_of::()) as *const u8 } } // Returns a pointer to the end of the allocated space. @@ -545,14 +537,21 @@ mod tests { #[test] fn test_arena_alloc_nested() { - struct Inner { value: u8 } - struct Outer<'a> { inner: &'a Inner } - enum EI<'e> { I(Inner), O(Outer<'e>) } + struct Inner { + value: u8, + } + struct Outer<'a> { + inner: &'a Inner, + } + enum EI<'e> { + I(Inner), + O(Outer<'e>), + } struct Wrap<'a>(TypedArena>); impl<'a> Wrap<'a> { - fn alloc_inner Inner>(&self, f: F) -> &Inner { + fn alloc_inner Inner>(&self, f: F) -> &Inner { let r: &EI = self.0.alloc(EI::I(f())); if let &EI::I(ref i) = r { i @@ -560,7 +559,7 @@ mod tests { panic!("mismatch"); } } - fn alloc_outer Outer<'a>>(&self, f: F) -> &Outer { + fn alloc_outer Outer<'a>>(&self, f: F) -> &Outer { let r: &EI = self.0.alloc(EI::O(f())); if let &EI::O(ref o) = r { o @@ -572,8 +571,9 @@ mod tests { let arena = Wrap(TypedArena::new()); - let result = arena.alloc_outer(|| Outer { - inner: arena.alloc_inner(|| Inner { value: 10 }) }); + let result = arena.alloc_outer(|| { + Outer { inner: arena.alloc_inner(|| Inner { value: 10 }) } + }); assert_eq!(result.inner.value, 10); } @@ -582,49 +582,27 @@ mod tests { pub fn test_copy() { let arena = TypedArena::new(); for _ in 0..100000 { - arena.alloc(Point { - x: 1, - y: 2, - z: 3, - }); + arena.alloc(Point { x: 1, y: 2, z: 3 }); } } #[bench] pub fn bench_copy(b: &mut Bencher) { let arena = TypedArena::new(); - b.iter(|| { - arena.alloc(Point { - x: 1, - y: 2, - z: 3, - }) - }) + b.iter(|| arena.alloc(Point { x: 1, y: 2, z: 3 })) } #[bench] pub fn bench_copy_nonarena(b: &mut Bencher) { b.iter(|| { - let _: Box<_> = box Point { - x: 1, - y: 2, - z: 3, - }; + let _: Box<_> = box Point { x: 1, y: 2, z: 3 }; }) } #[bench] pub fn bench_copy_old_arena(b: &mut Bencher) { let arena = Arena::new(); - b.iter(|| { - arena.alloc(|| { - Point { - x: 1, - y: 2, - z: 3, - } - }) - }) + b.iter(|| arena.alloc(|| Point { x: 1, y: 2, z: 3 })) } #[allow(dead_code)] @@ -639,7 +617,7 @@ mod tests { for _ in 0..100000 { arena.alloc(Noncopy { string: "hello world".to_string(), - array: vec!( 1, 2, 3, 4, 5 ), + array: vec!(1, 2, 3, 4, 5), }); } } @@ -650,7 +628,7 @@ mod tests { b.iter(|| { arena.alloc(Noncopy { string: "hello world".to_string(), - array: vec!( 1, 2, 3, 4, 5 ), + array: vec!(1, 2, 3, 4, 5), }) }) } @@ -660,7 +638,7 @@ mod tests { b.iter(|| { let _: Box<_> = box Noncopy { string: "hello world".to_string(), - array: vec!( 1, 2, 3, 4, 5 ), + array: vec!(1, 2, 3, 4, 5), }; }) } @@ -669,9 +647,11 @@ mod tests { pub fn bench_noncopy_old_arena(b: &mut Bencher) { let arena = Arena::new(); b.iter(|| { - arena.alloc(|| Noncopy { - string: "hello world".to_string(), - array: vec!( 1, 2, 3, 4, 5 ), + arena.alloc(|| { + Noncopy { + string: "hello world".to_string(), + array: vec!(1, 2, 3, 4, 5), + } }) }) }