Run rustfmt

Author: bitwalker

liblumen_alloc/src/erts/message.rs

@@ -3,7 +3,7 @@ use core::mem;
 
 use intrusive_collections::LinkedListLink;
 
-use super::{Term, TypedTerm, InvalidTermError};
+use super::{InvalidTermError, Term, TypedTerm};
 
 #[derive(Debug)]
 pub struct Message {

liblumen_alloc/src/erts/process/flags.rs

@@ -1,4 +1,4 @@
-use core::ops::{Not, BitOr, BitOrAssign, BitAnd, BitAndAssign};
+use core::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not};
 use core::sync::atomic::{AtomicU32, Ordering};
 
 /// This type provides an enum-like type with bitflag semantics,
@@ -16,7 +16,7 @@ impl ProcessFlag {
     pub const GrowHeap: Self = Self(1 << 1);
     /// This flag indicates that the next GC should be a full sweep unconditionally
     pub const NeedFullSweep: Self = Self(1 << 2);
-    /// This flag indicates that the next GC check will always return `true`, 
+    /// This flag indicates that the next GC check will always return `true`,
     /// i.e. a collection will be forced
     pub const ForceGC: Self = Self(1 << 3);
     /// This flag indicates that GC should be disabled temporarily
@@ -151,4 +151,4 @@ mod tests {
         assert!(flags.is_set(ProcessFlag::NeedFullSweep));
         assert!(!flags.is_set(ProcessFlag::ForceGC));
     }
-}
+}

liblumen_alloc/src/erts/process/gc/collector.rs

@@ -1,8 +1,8 @@
 use core::alloc::AllocErr;
 use core::ptr;
 
-use log::trace;
 use intrusive_collections::UnsafeRef;
+use log::trace;
 
 use liblumen_core::util::pointer::{distance_absolute, in_area};
 
@@ -117,7 +117,9 @@ impl<'p> GarbageCollector<'p> {
             return Err(GcError::MaxHeapSizeExceeded);
         }
         // Unset heap_grow and need_fullsweep flags, because we are doing both
-        self.process.flags.clear(ProcessFlag::GrowHeap | ProcessFlag::NeedFullSweep);
+        self.process
+            .flags
+            .clear(ProcessFlag::GrowHeap | ProcessFlag::NeedFullSweep);
         // Allocate new heap
         let new_heap_start = alloc::heap(new_size).map_err(|_| GcError::AllocErr)?;
         let mut new_heap = YoungHeap::new(new_heap_start, new_size);
@@ -185,9 +187,15 @@ impl<'p> GarbageCollector<'p> {
         let heap_used = self.process.young.heap_used();
         let size_after = heap_used + stack_used + self.process.off_heap_size();
         if size_before >= size_after {
-            trace!("Full sweep reclaimed {} words of garbage", size_before - size_after);
+            trace!(
+                "Full sweep reclaimed {} words of garbage",
+                size_before - size_after
+            );
         } else {
-            trace!("Full sweep resulted in heap growth of {} words", size_after - size_before);
+            trace!(
+                "Full sweep resulted in heap growth of {} words",
+                size_after - size_before
+            );
         }
         // Determine if we oversized the heap and should shrink it
         let mut adjusted = false;

liblumen_alloc/src/erts/process/gc/old_heap.rs

@@ -1,5 +1,5 @@
-use core::ptr;
 use core::mem;
+use core::ptr;
 
 use crate::erts::*;
 
@@ -161,7 +161,7 @@ impl OldHeap {
         // Sub-binaries are a little different, in that since we're garbage
         // collecting, we can't guarantee that the original binary will stick
         // around, and we don't necessarily want it to. Instead we create a new
-        // heap binary (if within the size limit) that contains the slice of 
+        // heap binary (if within the size limit) that contains the slice of
         // the original binary that the sub-binary referenced. If the sub-binary
         // is too large to build a heap binary, then the original must be a ProcBin,
         // so we don't need to worry about it being collected out from under us
@@ -180,10 +180,7 @@ impl OldHeap {
                 // Copy referenced part of binary to heap
                 ptr::copy_nonoverlapping(bin_ptr, new_bin_ptr, bin_size);
                 // Write heapbin header
-                ptr::write(
-                    dst,
-                    HeapBin::from_raw_parts(bin_header, bin_flags),
-                );
+                ptr::write(dst, HeapBin::from_raw_parts(bin_header, bin_flags));
                 // Write a move marker to the original location
                 let marker = Term::from_raw(heap_top as usize | Term::FLAG_BOXED);
                 ptr::write(orig, marker);

liblumen_alloc/src/erts/process/gc/virtual_heap.rs

@@ -5,8 +5,8 @@ use core::ptr;
 use intrusive_collections::intrusive_adapter;
 use intrusive_collections::{LinkedList, LinkedListLink, UnsafeRef};
 
+use super::{OldHeap, YoungHeap};
 use crate::erts::*;
-use super::{YoungHeap, OldHeap};
 
 intrusive_adapter!(pub ProcBinAdapter = UnsafeRef<ProcBin>: ProcBin { link: LinkedListLink });
 
@@ -61,7 +61,9 @@ impl VirtualBinaryHeap {
     /// Returns true if the given pointer belongs to a binary on the virtual heap
     #[inline]
     pub fn contains<T>(&self, ptr: *const T) -> bool {
-        self.bins.iter().any(|bin_ref| ptr == bin_ref as *const _ as *const T)
+        self.bins
+            .iter()
+            .any(|bin_ref| ptr == bin_ref as *const _ as *const T)
     }
 
     /// Adds the given `ProcBin` to the virtual binary heap

liblumen_alloc/src/erts/process/gc/young_heap.rs

@@ -254,7 +254,7 @@ impl YoungHeap {
         // Sub-binaries are a little different, in that since we're garbage
         // collecting, we can't guarantee that the original binary will stick
         // around, and we don't necessarily want it to. Instead we create a new
-        // heap binary (if within the size limit) that contains the slice of 
+        // heap binary (if within the size limit) that contains the slice of
         // the original binary that the sub-binary referenced. If the sub-binary
         // is too large to build a heap binary, then the original must be a ProcBin,
         // so we don't need to worry about it being collected out from under us
@@ -273,10 +273,7 @@ impl YoungHeap {
                 // Copy referenced part of binary to heap
                 ptr::copy_nonoverlapping(bin_ptr, new_bin_ptr, bin_size);
                 // Write heapbin header
-                ptr::write(
-                    dst,
-                    HeapBin::from_raw_parts(bin_header, bin_flags),
-                );
+                ptr::write(dst, HeapBin::from_raw_parts(bin_header, bin_flags));
                 // Write a move marker to the original location
                 let marker = Term::from_raw(heap_top as usize | Term::FLAG_BOXED);
                 ptr::write(orig, marker);

liblumen_alloc/src/erts/term.rs

@@ -28,9 +28,9 @@ pub use typed_term::*;
 //pub use map::*;
 pub use boxed::*;
 
+use core::alloc::{AllocErr, Layout};
 use core::fmt;
 use core::ptr;
-use core::alloc::{Layout, AllocErr};
 
 use super::ProcessControlBlock;
 
@@ -105,16 +105,16 @@ impl crate::borrow::CloneToProcess for MapHeader {
 }
 
 /// Constructs a binary from the given string, and associated with the given process
-/// 
+///
 /// For inputs greater than 64 bytes in size, the resulting binary data is allocated
 /// on the global shared heap, and reference counted (a `ProcBin`), the header to that
 /// binary is allocated on the process heap, and the data is placed in the processes'
 /// virtual binary heap, and a boxed term is returned which can then be placed on the stack,
 /// or as part of a larger structure if desired.
-/// 
+///
 /// For inputs less than or equal to 64 bytes, both the header and data are allocated
 /// on the process heap, and a boxed term is returned as described above.
-/// 
+///
 /// NOTE: If allocation fails for some reason, `Err(AllocErr)` is returned, this usually
 /// indicates that a process needs to be garbage collected, but in some cases may indicate
 /// that the global heap is out of space.
@@ -140,7 +140,8 @@ pub fn make_binary_from_str(process: &mut ProcessControlBlock, s: &str) -> Resul
             let header_ptr = process.alloc_layout(HeapBin::layout(s))?.as_ptr() as *mut HeapBin;
             // Pointer to start of binary data
             let bin_ptr = header_ptr.offset(1) as *mut u8;
-            // Construct the right header based on whether input string is only ASCII or includes UTF8
+            // Construct the right header based on whether input string is only ASCII or includes
+            // UTF8
             let header = if s.is_ascii() {
                 HeapBin::new_latin1(len)
             } else {
@@ -158,21 +159,24 @@ pub fn make_binary_from_str(process: &mut ProcessControlBlock, s: &str) -> Resul
 }
 
 /// Constructs a binary from the given byte slice, and associated with the given process
-/// 
+///
 /// For inputs greater than 64 bytes in size, the resulting binary data is allocated
 /// on the global shared heap, and reference counted (a `ProcBin`), the header to that
 /// binary is allocated on the process heap, and the data is placed in the processes'
 /// virtual binary heap, and a boxed term is returned which can then be placed on the stack,
 /// or as part of a larger structure if desired.
-/// 
+///
 /// For inputs less than or equal to 64 bytes, both the header and data are allocated
 /// on the process heap, and a boxed term is returned as described above.
-/// 
+///
 /// NOTE: If allocation fails for some reason, `Err(AllocErr)` is returned, this usually
 /// indicates that a process needs to be garbage collected, but in some cases may indicate
 /// that the global heap is out of space.
 #[inline]
-pub fn make_binary_from_bytes(process: &mut ProcessControlBlock, s: &[u8]) -> Result<Term, AllocErr> {
+pub fn make_binary_from_bytes(
+    process: &mut ProcessControlBlock,
+    s: &[u8],
+) -> Result<Term, AllocErr> {
     let len = s.len();
     // Allocate ProcBins for sizes greater than 64 bytes
     if len > 64 {
@@ -190,10 +194,12 @@ pub fn make_binary_from_bytes(process: &mut ProcessControlBlock, s: &[u8]) -> Re
     } else {
         unsafe {
             // Allocates space on the process heap for the header + data
-            let header_ptr = process.alloc_layout(HeapBin::layout_bytes(s))?.as_ptr() as *mut HeapBin;
+            let header_ptr =
+                process.alloc_layout(HeapBin::layout_bytes(s))?.as_ptr() as *mut HeapBin;
             // Pointer to start of binary data
             let bin_ptr = header_ptr.offset(1) as *mut u8;
-            // Construct the right header based on whether input string is only ASCII or includes UTF8
+            // Construct the right header based on whether input string is only ASCII or includes
+            // UTF8
             let header = HeapBin::new(len);
             // Write header
             ptr::write(header_ptr, header);
@@ -203,19 +209,22 @@ pub fn make_binary_from_bytes(process: &mut ProcessControlBlock, s: &[u8]) -> Re
             let result = Term::from_raw(header_ptr as usize | Term::FLAG_BOXED);
             Ok(result)
         }
-    } 
+    }
 }
 
 /// Constructs a `Tuple` from a slice of `Term`
-/// 
+///
 /// Be aware that this does not allocate non-immediate terms in `elements` on the process heap,
 /// it is expected that the slice provided is constructed from either immediate terms, or
 /// terms which were returned from other constructor functions, e.g. `make_binary_from_str`.
-/// 
+///
 /// The resulting `Term` is a box pointing to the tuple header, and can itself be used in
 /// a slice passed to `make_tuple_from_slice` to produce nested tuples.
 #[inline]
-pub fn make_tuple_from_slice(process: &mut ProcessControlBlock, elements: &[Term]) -> Result<Term, AllocErr> {
+pub fn make_tuple_from_slice(
+    process: &mut ProcessControlBlock,
+    elements: &[Term],
+) -> Result<Term, AllocErr> {
     let len = elements.len();
     let layout = Tuple::layout(len);
     let tuple_ptr = unsafe { process.alloc_layout(layout)?.as_ptr() as *mut Tuple };
@@ -311,4 +320,4 @@ pub(crate) fn to_word_size(bytes: usize) -> usize {
 pub(crate) fn word_size_of<T: Sized>() -> usize {
     use core::mem;
     to_word_size(mem::size_of::<T>())
-}
+}

liblumen_alloc/src/erts/term/binary.rs

@@ -431,10 +431,7 @@ impl HeapBin {
 
     #[inline]
     pub(in crate::erts) fn from_raw_parts(header: Term, flags: usize) -> Self {
-        Self {
-            header,
-            flags,
-        }
+        Self { header, flags }
     }
 
     /// Returns true if this binary is a raw binary
@@ -493,7 +490,8 @@ impl HeapBin {
         unsafe { Layout::from_size_align_unchecked(size, mem::align_of::<Term>()) }
     }
 
-    /// Get a `Layout` describing the necessary layout to allocate a `HeapBin` for the given byte slice
+    /// Get a `Layout` describing the necessary layout to allocate a `HeapBin` for the given byte
+    /// slice
     #[inline]
     pub fn layout_bytes(input: &[u8]) -> Layout {
         let size = mem::size_of::<Self>() + input.len();
@@ -650,11 +648,7 @@ impl SubBinary {
     ///
     /// NOTE: You should not use this for any other purpose
     pub(crate) fn to_heapbin_parts(&self) -> Result<(Term, usize, *mut u8, usize), ()> {
-        if self.bitsize == 0
-            && self.bitoffs == 0
-            && !self.writable
-            && self.size <= 64
-        {
+        if self.bitsize == 0 && self.bitoffs == 0 && !self.writable && self.size <= 64 {
             Ok(unsafe { self.to_raw_parts() })
         } else {
             Err(())
@@ -756,7 +750,7 @@ impl CloneToProcess for SubBinary {
 }
 
 /// Represents a binary being matched
-/// 
+///
 /// See `ErlBinMatchBuffer` in `erl_bits.h`
 #[derive(Debug, Clone, Copy)]
 #[repr(C)]
@@ -772,7 +766,7 @@ pub struct MatchBuffer {
 }
 impl MatchBuffer {
     /// Create a match buffer from a binary
-    /// 
+    ///
     /// See `erts_bs_start_match_2` in `erl_bits.c`
     #[inline]
     pub fn start_match(orig: Term) -> Self {
@@ -814,7 +808,7 @@ pub struct MatchContext {
 }
 impl MatchContext {
     /// Create a new MatchContext from a boxed procbin/heapbin/sub-bin
-    /// 
+    ///
     /// See `erts_bs_start_match_2` in `erl_bits.c`
     #[inline]
     pub fn new(orig: Term) -> Self {