Issue 3223: reformat via cargo fmt

src/machine/heap.rs

@@ -58,20 +58,20 @@ struct InnerHeap {
 
 impl InnerHeap {
     unsafe fn grow(&mut self) -> bool {
-            let new_cap = if self.byte_cap == 0 {
-                256 * 256 * 8
-            } else {
-                2 * self.byte_cap
-            };
+        let new_cap = if self.byte_cap == 0 {
+            256 * 256 * 8
+        } else {
+            2 * self.byte_cap
+        };
 
-            let new_layout =
-                alloc::Layout::from_size_align(new_cap, size_of::<HeapCellValue>()).unwrap();
+        let new_layout =
+            alloc::Layout::from_size_align(new_cap, size_of::<HeapCellValue>()).unwrap();
 
-            assert!(
-                new_layout.size() <= isize::MAX as usize,
-                "Allocation too large. We should probably GC (TODO)"
-            );
-            unsafe {
+        assert!(
+            new_layout.size() <= isize::MAX as usize,
+            "Allocation too large. We should probably GC (TODO)"
+        );
+        unsafe {
             let new_ptr = if self.byte_cap == 0 {
                 alloc::alloc(new_layout)
             } else {
@@ -104,12 +104,12 @@ pub struct HeapStringScan<'a> {
 
 // The heap_slice should be inside the heap
 unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan<'_> {
-        let string_len = heap_slice
-            .iter()
-            .position(|b| *b == 0u8)
-            .unwrap_or(heap_slice.len());
-        
-        unsafe {
+    let string_len = heap_slice
+        .iter()
+        .position(|b| *b == 0u8)
+        .unwrap_or(heap_slice.len());
+
+    unsafe {
         let zero_byte_addr = heap_slice.as_ptr().add(string_len);
 
         let sentinel_len = pstr_sentinel_length(zero_byte_addr.addr());
@@ -130,19 +130,19 @@ unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan<'_> {
 // Same as scan_slice_to_str but assumes that the slice is from the start of a string.
 // Can be used on strings out of the heap.
 unsafe fn scan_slice_to_str_from_start(heap_slice: &[u8]) -> HeapStringScan<'_> {
-        let string_len = heap_slice
-            .iter()
-            .position(|b| *b == 0u8)
-            .unwrap_or(heap_slice.len());
+    let string_len = heap_slice
+        .iter()
+        .position(|b| *b == 0u8)
+        .unwrap_or(heap_slice.len());
 
-        let sentinel_len = pstr_sentinel_length(string_len);
-        let tail_idx = cell_index!(
-            (string_len + sentinel_len).next_multiple_of(ALIGN)
-                + if sentinel_len <= 1 { heap_index!(1) } else { 0 }
-        );
+    let sentinel_len = pstr_sentinel_length(string_len);
+    let tail_idx = cell_index!(
+        (string_len + sentinel_len).next_multiple_of(ALIGN)
+            + if sentinel_len <= 1 { heap_index!(1) } else { 0 }
+    );
+
+    let str_slice = &heap_slice[..string_len];
 
-        let str_slice = &heap_slice[..string_len];
-        
     unsafe {
         HeapStringScan {
             string: std::str::from_utf8_unchecked(str_slice),

src/machine/stack.rs

@@ -176,8 +176,8 @@ impl Stack {
 
     #[inline(always)]
     unsafe fn alloc(&mut self, frame_size: usize) -> Result<NonNull<u8>, AllocError> {
-            loop {
-                unsafe {
+        loop {
+            unsafe {
                 let ptr = self.buf.alloc(frame_size);
                 if let Some(ptr) = NonNull::new(ptr) {
                     return Ok(ptr);