Changing the alloc() to accept &self instead of &mut self

library/alloc/src/alloc.rs

@@ -145,7 +145,7 @@ pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
 
 impl Global {
  #[inline]
- fn alloc_impl(&mut self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocErr> {
  match layout.size() {
  0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)),
  // SAFETY: `layout` is non-zero in size,
@@ -208,17 +208,17 @@ impl Global {
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl AllocRef for Global {
  #[inline]
- fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  self.alloc_impl(layout, false)
  }
 
  #[inline]
- fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  self.alloc_impl(layout, true)
  }
 
  #[inline]
- unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+ unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) {
  if layout.size() != 0 {
  // SAFETY: `layout` is non-zero in size,
  // other conditions must be upheld by the caller

library/alloc/src/raw_vec.rs

@@ -169,7 +169,7 @@ impl<T, A: AllocRef> RawVec<T, A> {
  Self::allocate_in(capacity, AllocInit::Zeroed, alloc)
  }
 
- fn allocate_in(capacity: usize, init: AllocInit, mut alloc: A) -> Self {
+ fn allocate_in(capacity: usize, init: AllocInit, alloc: A) -> Self {
  if mem::size_of::<T>() == 0 {
  Self::new_in(alloc)
  } else {

library/alloc/src/raw_vec/tests.rs

@@ -1,4 +1,5 @@
 use super::*;
+use std::cell::Cell;
 
 #[test]
 fn allocator_param() {
@@ -17,32 +18,32 @@ fn allocator_param() {
  // A dumb allocator that consumes a fixed amount of fuel
  // before allocation attempts start failing.
  struct BoundedAlloc {
- fuel: usize,
+ fuel: Cell<usize>,
  }
  unsafe impl AllocRef for BoundedAlloc {
- fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  let size = layout.size();
- if size > self.fuel {
+ if size > self.fuel.get() {
  return Err(AllocErr);
  }
  match Global.alloc(layout) {
  ok @ Ok(_) => {
- self.fuel -= size;
+ self.fuel.set(self.fuel.get() - size);
  ok
  }
  err @ Err(_) => err,
  }
  }
- unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+ unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) {
  unsafe { Global.dealloc(ptr, layout) }
  }
  }
 
- let a = BoundedAlloc { fuel: 500 };
+ let a = BoundedAlloc { fuel: Cell::new(500) };
  let mut v: RawVec<u8, _> = RawVec::with_capacity_in(50, a);
- assert_eq!(v.alloc.fuel, 450);
+ assert_eq!(v.alloc.fuel.get(), 450);
  v.reserve(50, 150); // (causes a realloc, thus using 50 + 150 = 200 units of fuel)
- assert_eq!(v.alloc.fuel, 250);
+ assert_eq!(v.alloc.fuel.get(), 250);
 }
 
 #[test]

library/alloc/tests/heap.rs

@@ -11,7 +11,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) {
  for &align in &[4, 8, 16, 32] {
  // less than and bigger than `MIN_ALIGN`
  for &size in &[align / 2, align - 1] {

library/core/src/alloc/mod.rs

@@ -109,7 +109,7 @@ pub unsafe trait AllocRef {
  /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
  ///
  /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
- fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>;
+ fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr>;
 
  /// Behaves like `alloc`, but also ensures that the returned memory is zero-initialized.
  ///
@@ -126,7 +126,7 @@ pub unsafe trait AllocRef {
  /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
  ///
  /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
- fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  let ptr = self.alloc(layout)?;
  // SAFETY: `alloc` returns a valid memory block
  unsafe { ptr.as_non_null_ptr().as_ptr().write_bytes(0, ptr.len()) }
@@ -142,7 +142,7 @@ pub unsafe trait AllocRef {
  ///
  /// [*currently allocated*]: #currently-allocated-memory
  /// [*fit*]: #memory-fitting
- unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout);
+ unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout);
 
  /// Attempts to extend the memory block.
  ///
@@ -348,17 +348,17 @@ where
  A: AllocRef + ?Sized,
 {
  #[inline]
- fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  (**self).alloc(layout)
  }
 
  #[inline]
- fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  (**self).alloc_zeroed(layout)
  }
 
  #[inline]
- unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+ unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) {
  // SAFETY: the safety contract must be upheld by the caller
  unsafe { (**self).dealloc(ptr, layout) }
  }

library/std/src/alloc.rs

@@ -133,7 +133,7 @@ pub struct System;
 
 impl System {
  #[inline]
- fn alloc_impl(&mut self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result<NonNull<[u8]>, AllocErr> {
  match layout.size() {
  0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)),
  // SAFETY: `layout` is non-zero in size,
@@ -202,17 +202,17 @@ impl System {
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl AllocRef for System {
  #[inline]
- fn alloc(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  self.alloc_impl(layout, false)
  }
 
  #[inline]
- fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
+ fn alloc_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocErr> {
  self.alloc_impl(layout, true)
  }
 
  #[inline]
- unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+ unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) {
  if layout.size() != 0 {
  // SAFETY: `layout` is non-zero in size,
  // other conditions must be upheld by the caller

src/test/ui/allocator/custom.rs

@@ -18,7 +18,7 @@ struct A;
 unsafe impl alloc::GlobalAlloc for A {
  unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
  HITS.fetch_add(1, Ordering::SeqCst);
- System.alloc(layout)
+ AllocRef::alloc(&System, layout).unwrap().as_mut_ptr()
  }
 
  unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {