Cargo fmt

Author: Folyd

aiscript-arena/src/allocator_api.rs

@@ -68,10 +68,12 @@ unsafe impl<A: Allocator> Allocator for MetricsAlloc<'_, A> {
     }
 
     #[inline]
-    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) { unsafe {
-        self.metrics.mark_external_deallocation(layout.size());
-        self.allocator.deallocate(ptr, layout);
-    }}
+    unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
+        unsafe {
+            self.metrics.mark_external_deallocation(layout.size());
+            self.allocator.deallocate(ptr, layout);
+        }
+    }
 
     #[inline]
     fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
@@ -86,38 +88,44 @@ unsafe impl<A: Allocator> Allocator for MetricsAlloc<'_, A> {
         ptr: NonNull<u8>,
         old_layout: Layout,
         new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
-        let ptr = self.allocator.grow(ptr, old_layout, new_layout)?;
-        self.metrics
-            .mark_external_allocation(new_layout.size() - old_layout.size());
-        Ok(ptr)
-    }}
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        unsafe {
+            let ptr = self.allocator.grow(ptr, old_layout, new_layout)?;
+            self.metrics
+                .mark_external_allocation(new_layout.size() - old_layout.size());
+            Ok(ptr)
+        }
+    }
 
     #[inline]
     unsafe fn grow_zeroed(
         &self,
         ptr: NonNull<u8>,
         old_layout: Layout,
         new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
-        let ptr = self.allocator.grow_zeroed(ptr, old_layout, new_layout)?;
-        self.metrics
-            .mark_external_allocation(new_layout.size() - old_layout.size());
-        Ok(ptr)
-    }}
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        unsafe {
+            let ptr = self.allocator.grow_zeroed(ptr, old_layout, new_layout)?;
+            self.metrics
+                .mark_external_allocation(new_layout.size() - old_layout.size());
+            Ok(ptr)
+        }
+    }
 
     #[inline]
     unsafe fn shrink(
         &self,
         ptr: NonNull<u8>,
         old_layout: Layout,
         new_layout: Layout,
-    ) -> Result<NonNull<[u8]>, AllocError> { unsafe {
-        let ptr = self.allocator.shrink(ptr, old_layout, new_layout)?;
-        self.metrics
-            .mark_external_deallocation(old_layout.size() - new_layout.size());
-        Ok(ptr)
-    }}
+    ) -> Result<NonNull<[u8]>, AllocError> {
+        unsafe {
+            let ptr = self.allocator.shrink(ptr, old_layout, new_layout)?;
+            self.metrics
+                .mark_external_deallocation(old_layout.size() - new_layout.size());
+            Ok(ptr)
+        }
+    }
 }
 
 unsafe impl<A: 'static> Collect for MetricsAlloc<'_, A> {

aiscript-arena/src/arena.rs

@@ -2,9 +2,9 @@ use alloc::boxed::Box;
 use core::{f64, marker::PhantomData};
 
 use crate::{
+    Collect,
     context::{Context, EarlyStop, Finalization, Mutation, Phase},
     metrics::Metrics,
-    Collect,
 };
 
 /// A trait that produces a [`Collect`]-able type for the given lifetime. This is used to produce

aiscript-arena/src/barrier.rs

@@ -45,10 +45,12 @@ impl<T: ?Sized> Write<T> {
     /// by this wrapper, unless [`Gc::write`] is invoked manually on the parent [`Gc`]
     /// pointer during the current arena callback.
     #[inline(always)]
-    pub unsafe fn assume(v: &T) -> &Self { unsafe {
-        // SAFETY: `Self` is `repr(transparent)`.
-        mem::transmute(v)
-    }}
+    pub unsafe fn assume(v: &T) -> &Self {
+        unsafe {
+            // SAFETY: `Self` is `repr(transparent)`.
+            mem::transmute(v)
+        }
+    }
 
     /// Gets a writable reference to non-GC'd data.
     ///
@@ -74,10 +76,12 @@ impl<T: ?Sized> Write<T> {
     /// Implementation detail of `write_field!`; same safety requirements as `assume`.
     #[inline(always)]
     #[doc(hidden)]
-    pub unsafe fn __from_ref_and_ptr(v: &T, _: *const T) -> &Self { unsafe {
-        // SAFETY: `Self` is `repr(transparent)`.
-        mem::transmute(v)
-    }}
+    pub unsafe fn __from_ref_and_ptr(v: &T, _: *const T) -> &Self {
+        unsafe {
+            // SAFETY: `Self` is `repr(transparent)`.
+            mem::transmute(v)
+        }
+    }
 
     /// Unlocks the referenced value, providing full interior mutability.
     #[inline]

aiscript-arena/src/context.rs

@@ -7,10 +7,10 @@ use core::{
 };
 
 use crate::{
+    Gc,
     collect::Collect,
     metrics::Metrics,
     types::{GcBox, GcBoxHeader, GcBoxInner, GcColor, Invariant},
-    Gc,
 };
 
 /// Handle value given by arena callbacks during construction and mutation. Allows allocating new
@@ -216,9 +216,9 @@ impl Context {
     }
 
     #[inline]
-    pub(crate) unsafe fn mutation_context<'gc>(&self) -> &Mutation<'gc> { unsafe {
-        mem::transmute::<&Self, &Mutation>(self)
-    }}
+    pub(crate) unsafe fn mutation_context<'gc>(&self) -> &Mutation<'gc> {
+        unsafe { mem::transmute::<&Self, &Mutation>(self) }
+    }
 
     #[inline]
     fn collection_context(&self) -> &Collection {
@@ -227,9 +227,9 @@ impl Context {
     }
 
     #[inline]
-    pub(crate) unsafe fn finalization_context<'gc>(&self) -> &Finalization<'gc> { unsafe {
-        mem::transmute::<&Self, &Finalization>(self)
-    }}
+    pub(crate) unsafe fn finalization_context<'gc>(&self) -> &Finalization<'gc> {
+        unsafe { mem::transmute::<&Self, &Finalization>(self) }
+    }
 
     #[inline]
     pub(crate) fn metrics(&self) -> &Metrics {
@@ -302,7 +302,9 @@ impl Context {
                     let next_gray = if let Some(gc_box) = self.gray.borrow_mut().pop() {
                         self.metrics.mark_gc_traced(gc_box.header().size_of_box());
                         Some(gc_box)
-                    } else { self.gray_again.borrow_mut().pop() };
+                    } else {
+                        self.gray_again.borrow_mut().pop()
+                    };
 
                     if let Some(gc_box) = next_gray {
                         // If we have an object in the gray queue, take one, trace it, and turn it
@@ -586,13 +588,15 @@ impl Context {
 }
 
 // SAFETY: the gc_box must never be accessed after calling this function.
-unsafe fn free_gc_box<'gc>(mut gc_box: GcBox) { unsafe {
-    if gc_box.header().is_live() {
-        // If the alive flag is set, that means we haven't dropped the inner value of this object,
-        gc_box.drop_in_place();
+unsafe fn free_gc_box<'gc>(mut gc_box: GcBox) {
+    unsafe {
+        if gc_box.header().is_live() {
+            // If the alive flag is set, that means we haven't dropped the inner value of this object,
+            gc_box.drop_in_place();
+        }
+        gc_box.dealloc();
     }
-    gc_box.dealloc();
-}}
+}
 
 /// Helper type for managing phase transitions.
 struct PhaseGuard<'a> {

aiscript-arena/src/dynamic_roots.rs

@@ -5,7 +5,7 @@ use alloc::{
     vec::Vec,
 };
 
-use crate::{arena::Root, metrics::Metrics, Collect, Gc, Mutation, Rootable};
+use crate::{Collect, Gc, Mutation, Rootable, arena::Root, metrics::Metrics};
 
 /// A way of registering GC roots dynamically.
 ///

aiscript-arena/src/gc.rs

@@ -9,13 +9,13 @@ use core::{
 };
 
 use crate::{
+    Finalization,
     barrier::{Unlock, Write},
     collect::Collect,
     context::{Collection, Mutation},
     gc_weak::GcWeak,
     static_collect::Static,
     types::{GcBox, GcBoxHeader, GcBoxInner, GcColor, Invariant},
-    Finalization,
 };
 
 /// A garbage collected pointer to a type T. Implements Copy, and is implemented as a plain machine
@@ -152,16 +152,18 @@ impl<'gc, T: ?Sized + 'gc> Gc<'gc, T> {
     /// The provided pointer must have been obtained from `Gc::as_ptr`, and the pointer must not
     /// have been collected yet.
     #[inline]
-    pub unsafe fn from_ptr(ptr: *const T) -> Gc<'gc, T> { unsafe {
-        let layout = Layout::new::<GcBoxHeader>();
-        let (_, header_offset) = layout.extend(Layout::for_value(&*ptr)).unwrap();
-        let header_offset = -(header_offset as isize);
-        let ptr = (ptr as *mut T).byte_offset(header_offset) as *mut GcBoxInner<T>;
-        Gc {
-            ptr: NonNull::new_unchecked(ptr),
-            _invariant: PhantomData,
+    pub unsafe fn from_ptr(ptr: *const T) -> Gc<'gc, T> {
+        unsafe {
+            let layout = Layout::new::<GcBoxHeader>();
+            let (_, header_offset) = layout.extend(Layout::for_value(&*ptr)).unwrap();
+            let header_offset = -(header_offset as isize);
+            let ptr = (ptr as *mut T).byte_offset(header_offset) as *mut GcBoxInner<T>;
+            Gc {
+                ptr: NonNull::new_unchecked(ptr),
+                _invariant: PhantomData,
+            }
         }
-    }}
+    }
 }
 
 impl<'gc, T: Unlock + ?Sized + 'gc> Gc<'gc, T> {

aiscript-arena/src/gc_weak.rs

@@ -112,11 +112,13 @@ impl<'gc, T: 'gc> GcWeak<'gc, T> {
     /// SAFETY:
     /// It must be valid to dereference a `*mut U` that has come from casting a `*mut T`.
     #[inline]
-    pub unsafe fn cast<U: 'gc>(this: GcWeak<'gc, T>) -> GcWeak<'gc, U> { unsafe {
-        GcWeak {
-            inner: Gc::cast::<U>(this.inner),
+    pub unsafe fn cast<U: 'gc>(this: GcWeak<'gc, T>) -> GcWeak<'gc, U> {
+        unsafe {
+            GcWeak {
+                inner: Gc::cast::<U>(this.inner),
+            }
         }
-    }}
+    }
 
     /// Retrieve a `GcWeak` from a raw pointer obtained from `GcWeak::as_ptr`
     ///
@@ -125,9 +127,11 @@ impl<'gc, T: 'gc> GcWeak<'gc, T> {
     /// the pointer must not have been *fully* collected yet (it may be a dropped but valid weak
     /// pointer).
     #[inline]
-    pub unsafe fn from_ptr(ptr: *const T) -> GcWeak<'gc, T> { unsafe {
-        GcWeak {
-            inner: Gc::from_ptr(ptr),
+    pub unsafe fn from_ptr(ptr: *const T) -> GcWeak<'gc, T> {
+        unsafe {
+            GcWeak {
+                inner: Gc::from_ptr(ptr),
+            }
         }
-    }}
+    }
 }

aiscript-arena/src/lock.rs

@@ -6,7 +6,7 @@ use core::{
     fmt,
 };
 
-use crate::{barrier::Unlock, Collect, Collection, Gc, Mutation};
+use crate::{Collect, Collection, Gc, Mutation, barrier::Unlock};
 
 // Helper macro to factor out the common parts of locks types.
 macro_rules! make_lock_wrapper {

aiscript-arena/src/static_collect.rs

@@ -1,5 +1,5 @@
-use crate::collect::Collect;
 use crate::Rootable;
+use crate::collect::Collect;
 
 use alloc::borrow::{Borrow, BorrowMut};
 use core::convert::{AsMut, AsRef};

aiscript-arena/src/types.rs

@@ -19,11 +19,13 @@ impl GcBox {
     /// **SAFETY:** The pointer must point to a valid `GcBoxInner` allocated
     /// in a `Box`.
     #[inline(always)]
-    pub(crate) unsafe fn erase<T: ?Sized>(ptr: NonNull<GcBoxInner<T>>) -> Self { unsafe {
-        // This cast is sound because `GcBoxInner` is `repr(C)`.
-        let erased = ptr.as_ptr() as *mut GcBoxInner<()>;
-        Self(NonNull::new_unchecked(erased))
-    }}
+    pub(crate) unsafe fn erase<T: ?Sized>(ptr: NonNull<GcBoxInner<T>>) -> Self {
+        unsafe {
+            // This cast is sound because `GcBoxInner` is `repr(C)`.
+            let erased = ptr.as_ptr() as *mut GcBoxInner<()>;
+            Self(NonNull::new_unchecked(erased))
+        }
+    }
 
     /// Gets a pointer to the value stored inside this box.
     /// `T` must be the same type that was used with `erase`, so that
@@ -47,31 +49,33 @@ impl GcBox {
     ///
     /// **SAFETY**: `Self::drop_in_place` must not have been called.
     #[inline(always)]
-    pub(crate) unsafe fn trace_value(&self, cc: &crate::Collection) { unsafe {
-        (self.header().vtable().trace_value)(*self, cc)
-    }}
+    pub(crate) unsafe fn trace_value(&self, cc: &crate::Collection) {
+        unsafe { (self.header().vtable().trace_value)(*self, cc) }
+    }
 
     /// Drops the stored value.
     ///
     /// **SAFETY**: once called, no GC pointers should access the stored value
     /// (but accessing the `GcBox` itself is still safe).
     #[inline(always)]
-    pub(crate) unsafe fn drop_in_place(&mut self) { unsafe {
-        (self.header().vtable().drop_value)(*self)
-    }}
+    pub(crate) unsafe fn drop_in_place(&mut self) {
+        unsafe { (self.header().vtable().drop_value)(*self) }
+    }
 
     /// Deallocates the box. Failing to call `Self::drop_in_place` beforehand
     /// will cause the stored value to be leaked.
     ///
     /// **SAFETY**: once called, this `GcBox` should never be accessed by any GC
     /// pointers again.
     #[inline(always)]
-    pub(crate) unsafe fn dealloc(self) { unsafe {
-        let layout = self.header().vtable().box_layout;
-        let ptr = self.0.as_ptr() as *mut u8;
-        // SAFETY: the pointer was `Box`-allocated with this layout.
-        alloc::alloc::dealloc(ptr, layout);
-    }}
+    pub(crate) unsafe fn dealloc(self) {
+        unsafe {
+            let layout = self.header().vtable().box_layout;
+            let ptr = self.0.as_ptr() as *mut u8;
+            // SAFETY: the pointer was `Box`-allocated with this layout.
+            alloc::alloc::dealloc(ptr, layout);
+        }
+    }
 }
 
 pub(crate) struct GcBoxHeader {