Make trait functions immutable

This allows the traits to be implemented on immutable references.
Internal mutability can still be achieved through Cell or RefCell

Author: Wodann

src/alloc/mod.rs

@@ -149,7 +149,7 @@ pub trait BuildAllocRef: Sized {
     /// * the alignment of the `layout` must match the alignment used to allocate that block of
     ///   memory
     unsafe fn build_alloc_ref(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         layout: Option<NonZeroLayout>,
     ) -> Self::Ref;
@@ -158,23 +158,23 @@ pub trait BuildAllocRef: Sized {
 pub trait DeallocRef: Sized {
     type BuildAlloc: BuildAllocRef<Ref = Self>;
 
-    fn get_build_alloc(&mut self) -> Self::BuildAlloc;
+    fn get_build_alloc(&self) -> Self::BuildAlloc;
 
     /// # Safety
     ///
     /// * `ptr` must denote a block of memory currently allocated via this allocator
     /// * `layout` must *fit* that block of memory
     /// * the alignment of the `layout` must match the alignment used to allocate that block of
     ///   memory
-    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout);
+    unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: NonZeroLayout);
 }
 
 pub trait AllocRef: DeallocRef {
     type Error;
 
-    fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error>;
+    fn alloc(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error>;
 
-    fn alloc_zeroed(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+    fn alloc_zeroed(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         let size = layout.size();
         let p = self.alloc(layout)?;
         unsafe {
@@ -193,7 +193,7 @@ pub trait AllocRef: DeallocRef {
     /// * `layout` must *fit* the `ptr` (see above); note the `new_size` argument need not fit it
     /// * `new_size` must not be less than `layout.size()`
     unsafe fn grow_in_place(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         layout: NonZeroLayout,
         new_size: NonZeroUsize,
@@ -212,7 +212,7 @@ pub trait AllocRef: DeallocRef {
     /// * `layout` must *fit* the `ptr` (see above); note the `new_size` argument need not fit it
     /// * `new_size` must not be greater than `layout.size()` (and must be greater than zero)
     unsafe fn shrink_in_place(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         layout: NonZeroLayout,
         new_size: NonZeroUsize,
@@ -251,7 +251,7 @@ pub trait ReallocRef: AllocRef {
     /// implement this trait atop an underlying native allocation
     /// library that aborts on memory exhaustion.)
     unsafe fn realloc(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         old_layout: NonZeroLayout,
         new_layout: NonZeroLayout,
@@ -297,7 +297,7 @@ macro_rules! impl_buildalloc_alloc_zst {
             type Ref = Self;
 
             unsafe fn build_alloc_ref(
-                &mut self,
+                &self,
                 _ptr: NonNull<u8>,
                 _layout: Option<NonZeroLayout>,
             ) -> Self::Ref {
@@ -314,11 +314,11 @@ impl_buildalloc_alloc_zst!(System);
 impl DeallocRef for Global {
     type BuildAlloc = Self;
 
-    fn get_build_alloc(&mut self) -> Self::BuildAlloc {
+    fn get_build_alloc(&self) -> Self::BuildAlloc {
         Self
     }
 
-    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout) {
+    unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: NonZeroLayout) {
         #[allow(deprecated)]
         dealloc(ptr.as_ptr(), layout.into())
     }
@@ -327,14 +327,14 @@ impl DeallocRef for Global {
 impl AllocRef for Global {
     type Error = AllocErr;
 
-    fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+    fn alloc(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         #[allow(deprecated)]
         unsafe {
             NonNull::new(alloc(layout.into())).ok_or(AllocErr)
         }
     }
 
-    fn alloc_zeroed(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+    fn alloc_zeroed(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         #[allow(deprecated)]
         unsafe {
             NonNull::new(alloc_zeroed(layout.into())).ok_or(AllocErr)
@@ -345,7 +345,7 @@ impl AllocRef for Global {
 impl ReallocRef for Global {
     // FIXME: Remove `else` branch. This is needed, as std provides old method.
     unsafe fn realloc(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         old_layout: NonZeroLayout,
         new_layout: NonZeroLayout,
@@ -369,11 +369,11 @@ impl ReallocRef for Global {
 impl DeallocRef for System {
     type BuildAlloc = Self;
 
-    fn get_build_alloc(&mut self) -> Self::BuildAlloc {
+    fn get_build_alloc(&self) -> Self::BuildAlloc {
         Self
     }
 
-    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout) {
+    unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: NonZeroLayout) {
         GlobalAlloc::dealloc(self, ptr.as_ptr(), layout.into())
     }
 }
@@ -382,11 +382,11 @@ impl DeallocRef for System {
 impl AllocRef for System {
     type Error = AllocErr;
 
-    fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+    fn alloc(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         unsafe { NonNull::new(GlobalAlloc::alloc(self, layout.into())).ok_or(AllocErr) }
     }
 
-    fn alloc_zeroed(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+    fn alloc_zeroed(&self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         unsafe { NonNull::new(GlobalAlloc::alloc_zeroed(self, layout.into())).ok_or(AllocErr) }
     }
 }
@@ -395,7 +395,7 @@ impl AllocRef for System {
 impl ReallocRef for System {
     // FIXME: Remove `else` branch. This is needed, as std provides old method.
     unsafe fn realloc(
-        &mut self,
+        &self,
         ptr: NonNull<u8>,
         old_layout: NonZeroLayout,
         new_layout: NonZeroLayout,
@@ -417,7 +417,7 @@ impl ReallocRef for System {
 
 #[inline]
 unsafe fn alloc_copy_dealloc<A: ReallocRef>(
-    alloc: &mut A,
+    alloc: &A,
     ptr: NonNull<u8>,
     old_layout: NonZeroLayout,
     new_layout: NonZeroLayout,

src/boxed.rs

@@ -201,7 +201,7 @@ impl<T, A: AllocRef> Box<T, A> {
     /// let five = Box::try_new_in(5, Global)?;
     /// # Ok::<_, alloc_wg::alloc::AllocErr>(())
     /// ```
-    pub fn try_new_in(x: T, mut a: A) -> Result<Self, A::Error> {
+    pub fn try_new_in(x: T, a: A) -> Result<Self, A::Error> {
         let ptr = if let Ok(layout) = NonZeroLayout::new::<T>() {
             let ptr = a.alloc(layout)?.cast::<T>();
             unsafe {
@@ -257,7 +257,7 @@ impl<T, A: AllocRef> Box<T, A> {
     /// assert_eq!(*five, 5);
     /// # Ok::<_, alloc_wg::alloc::AllocErr>(())
     /// ```
-    pub fn try_new_uninit_in(mut a: A) -> Result<Box<mem::MaybeUninit<T>, A>, A::Error> {
+    pub fn try_new_uninit_in(a: A) -> Result<Box<mem::MaybeUninit<T>, A>, A::Error> {
         let ptr = if let Ok(layout) = NonZeroLayout::new::<T>() {
             let ptr: NonNull<mem::MaybeUninit<T>> = a.alloc(layout)?.cast();
             ptr
@@ -365,7 +365,7 @@ impl<T, A: AllocRef> Box<[T], A> {
     /// ```
     pub fn try_new_uninit_slice_in(
         len: usize,
-        mut a: A,
+        a: A,
     ) -> Result<Box<[mem::MaybeUninit<T>], A>, CollectionAllocErr<A>> {
         let ptr = if mem::size_of::<T>() == 0 || len == 0 {
             NonNull::dangling()
@@ -732,7 +732,7 @@ fn drop_box<T: ?Sized, A: DeallocRef>(boxed: &mut Box<T, A>) {
     unsafe {
         let ptr = boxed.ptr;
         ptr::drop_in_place(ptr.as_ptr());
-        if let (mut alloc, Some(layout)) = boxed.alloc_ref() {
+        if let (alloc, Some(layout)) = boxed.alloc_ref() {
             alloc.dealloc(ptr.cast().into(), layout)
         }
     }
@@ -807,7 +807,7 @@ where
     /// ```
     #[inline]
     fn clone(&self) -> Self {
-        let mut b = self.build_alloc().clone();
+        let b = self.build_alloc().clone();
         let old_ptr = self.ptr.cast();
         let old_layout = NonZeroLayout::for_value(self.as_ref());
 
@@ -1276,7 +1276,7 @@ where
     A::BuildAlloc: Clone,
 {
     fn clone(&self) -> Self {
-        let mut b = self.build_alloc().clone();
+        let b = self.build_alloc().clone();
         let old_ptr = self.ptr.cast();
         let old_layout = NonZeroLayout::for_value(self.as_ref());
         let a = unsafe { b.build_alloc_ref(old_ptr.into(), old_layout) };

src/raw_vec.rs

@@ -144,7 +144,7 @@ impl<T> RawVec<T> {
 
 impl<T, A: DeallocRef> RawVec<T, A> {
     /// Like `new` but parameterized over the choice of allocator for the returned `RawVec`.
-    pub fn new_in(mut a: A) -> Self {
+    pub fn new_in(a: A) -> Self {
         let capacity = if mem::size_of::<T>() == 0 { !0 } else { 0 };
         Self {
             ptr: Unique::empty(),
@@ -226,7 +226,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     fn allocate_in(
         capacity: usize,
         zeroed: bool,
-        mut alloc: A,
+        alloc: A,
     ) -> Result<Self, CollectionAllocErr<A>>
     where
         A: AllocRef,
@@ -443,7 +443,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
                 return Err(CollectionAllocErr::CapacityOverflow);
             }
 
-            let (mut alloc, old_layout) = self.alloc_ref();
+            let (alloc, old_layout) = self.alloc_ref();
             let (new_cap, ptr) = if let Some(old_layout) = old_layout {
                 // Since we guarantee that we never allocate more than
                 // `isize::MAX` bytes, `elem_size * self.cap <= isize::MAX` as
@@ -524,7 +524,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
                 return Err(CapacityOverflow);
             }
 
-            let (mut alloc, old_layout) = if let (alloc, Some(layout)) = self.alloc_ref() {
+            let (alloc, old_layout) = if let (alloc, Some(layout)) = self.alloc_ref() {
                 (alloc, layout)
             } else {
                 return Ok(false); // nothing to double
@@ -701,7 +701,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
             return Ok(false);
         }
 
-        let (mut alloc, old_layout) = if let (alloc, Some(layout)) = self.alloc_ref() {
+        let (alloc, old_layout) = if let (alloc, Some(layout)) = self.alloc_ref() {
             (alloc, layout)
         } else {
             return Ok(false); // nothing to double
@@ -846,7 +846,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
 
         let _ = alloc_guard(new_layout.size().get(), new_layout.align().get())?;
 
-        let (mut alloc, old_layout) = self.alloc_ref();
+        let (alloc, old_layout) = self.alloc_ref();
         let result = if let Some(layout) = old_layout {
             unsafe { alloc.realloc(self.ptr.cast().into(), layout, new_layout) }
         } else {
@@ -888,7 +888,7 @@ enum ReserveStrategy {
 impl<T, A: DeallocRef> RawVec<T, A> {
     /// Frees the memory owned by the `RawVec` *without* trying to Drop its contents.
     pub fn dealloc_buffer(&mut self) {
-        if let (mut alloc, Some(layout)) = self.alloc_ref() {
+        if let (alloc, Some(layout)) = self.alloc_ref() {
             unsafe { alloc.dealloc(self.ptr.cast().into(), layout) }
         }
     }

src/vec.rs

@@ -2185,7 +2185,7 @@ where
     #[must_use]
     #[inline]
     fn clone(&self) -> Self {
-        let mut b = self.buf.build_alloc().clone();
+        let b = self.buf.build_alloc().clone();
         let old_layout = self.buf.current_layout();
 
         unsafe {
@@ -2463,7 +2463,7 @@ where
 }
 
 impl<T, A: ReallocRef> SpecExtend<T, IntoIter<T, A>, A> for Vec<T, A> {
-    fn try_from_iter_in(iter: IntoIter<T, A>, mut a: A) -> Result<Self, CollectionAllocErr<A>> {
+    fn try_from_iter_in(iter: IntoIter<T, A>, a: A) -> Result<Self, CollectionAllocErr<A>> {
         // A common case is passing a vector into a function which immediately
         // re-collects into a vector. We can short circuit this if the IntoIter
         // has not been advanced at all.

tests/heap.rs

@@ -13,7 +13,7 @@ fn std_heap_overaligned_request() {
     check_overalign_requests(Global)
 }
 
-fn check_overalign_requests<T: AllocRef>(mut allocator: T)
+fn check_overalign_requests<T: AllocRef>(allocator: T)
 where
     T::Error: Debug,
 {