remove interior mutability from proc_macro arena

Author: cyrgani

library/proc_macro/src/bridge/arena.rs

@@ -4,7 +4,6 @@
 //! as it is difficult to depend on crates from within `proc_macro`, due to it
 //! being built at the same time as `std`.
 
-use std::cell::{Cell, RefCell};
 use std::mem::MaybeUninit;
 use std::ops::Range;
 use std::{cmp, ptr, slice};
@@ -26,27 +25,22 @@ const HUGE_PAGE: usize = 2 * 1024 * 1024;
 /// This arena doesn't have support for allocating anything other than byte
 /// slices, as that is all that is necessary.
 pub(crate) struct Arena {
-    start: Cell<*mut MaybeUninit<u8>>,
-    end: Cell<*mut MaybeUninit<u8>>,
-    chunks: RefCell<Vec<Box<[MaybeUninit<u8>]>>>,
+    start: *mut MaybeUninit<u8>,
+    end: *mut MaybeUninit<u8>,
+    chunks: Vec<Box<[MaybeUninit<u8>]>>,
 }
 
 impl Arena {
     pub(crate) fn new() -> Self {
-        Arena {
-            start: Cell::new(ptr::null_mut()),
-            end: Cell::new(ptr::null_mut()),
-            chunks: RefCell::new(Vec::new()),
-        }
+        Arena { start: ptr::null_mut(), end: ptr::null_mut(), chunks: Vec::new() }
     }
 
     /// Add a new chunk with at least `additional` free bytes.
     #[inline(never)]
     #[cold]
-    fn grow(&self, additional: usize) {
-        let mut chunks = self.chunks.borrow_mut();
+    fn grow(&mut self, additional: usize) {
         let mut new_cap;
-        if let Some(last_chunk) = chunks.last_mut() {
+        if let Some(last_chunk) = self.chunks.last_mut() {
             // If the previous chunk's len is less than HUGE_PAGE
             // bytes, then this chunk will be least double the previous
             // chunk's size.
@@ -60,48 +54,46 @@ impl Arena {
 
         let mut chunk = Box::new_uninit_slice(new_cap);
         let Range { start, end } = chunk.as_mut_ptr_range();
-        self.start.set(start);
-        self.end.set(end);
-        chunks.push(chunk);
+        self.start = start;
+        self.end = end;
+        self.chunks.push(chunk);
     }
 
     /// Allocates a byte slice with specified size from the current memory
     /// chunk. Returns `None` if there is no free space left to satisfy the
     /// request.
-    #[allow(clippy::mut_from_ref)]
-    fn alloc_raw_without_grow(&self, bytes: usize) -> Option<&mut [MaybeUninit<u8>]> {
-        let start = self.start.get().addr();
-        let old_end = self.end.get();
+    fn alloc_raw_without_grow(&mut self, bytes: usize) -> Option<&mut [MaybeUninit<u8>]> {
+        let start = self.start.addr();
+        let old_end = self.end;
         let end = old_end.addr();
 
         let new_end = end.checked_sub(bytes)?;
         if start <= new_end {
             let new_end = old_end.with_addr(new_end);
-            self.end.set(new_end);
+            self.end = new_end;
             // SAFETY: `bytes` bytes starting at `new_end` were just reserved.
             Some(unsafe { slice::from_raw_parts_mut(new_end, bytes) })
         } else {
             None
         }
     }
 
-    fn alloc_raw(&self, bytes: usize) -> &mut [MaybeUninit<u8>] {
+    fn alloc_raw(&mut self, bytes: usize) -> &mut [MaybeUninit<u8>] {
         if bytes == 0 {
             return &mut [];
         }
 
-        loop {
-            if let Some(a) = self.alloc_raw_without_grow(bytes) {
-                break a;
-            }
-            // No free space left. Allocate a new chunk to satisfy the request.
-            // On failure the grow will panic or abort.
-            self.grow(bytes);
+        if let Some(a) = self.alloc_raw_without_grow(bytes) {
+            // SAFETY: the lifetime is extended here, but then constrained again in `alloc_str`.
+            return unsafe { &mut *(a as *mut _) };
         }
+        // No free space left. Allocate a new chunk to satisfy the request.
+        // On failure the grow will panic or abort.
+        self.grow(bytes);
+        self.alloc_raw_without_grow(bytes).unwrap()
     }
 
-    #[allow(clippy::mut_from_ref)] // arena allocator
-    pub(crate) fn alloc_str<'a>(&'a self, string: &str) -> &'a mut str {
+    pub(crate) fn alloc_str<'a>(&'a mut self, string: &str) -> &'a mut str {
         let alloc = self.alloc_raw(string.len());
         let bytes = alloc.write_copy_of_slice(string.as_bytes());