alloc: stabilise Allocator

Author: nia-e

library/alloc/src/alloc.rs

@@ -440,7 +440,7 @@ impl Global {
     }
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 unsafe impl const Allocator for Global {
     #[inline]

library/alloc/src/boxed.rs

@@ -507,14 +507,12 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api)]
-    ///
     /// use std::alloc::System;
     ///
     /// let five = Box::new_in(5, System);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "allocator_api", issue = "32838")]
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     #[inline]
     pub fn new_in(x: T, alloc: A) -> Self
@@ -801,7 +799,6 @@ impl<T: ?Sized + CloneToUninit> Box<T> {
     ///
     /// ```
     /// #![feature(clone_from_ref)]
-    /// #![feature(allocator_api)]
     ///
     /// let hello: Box<str> = Box::try_clone_from_ref("hello")?;
     /// # Ok::<(), std::alloc::AllocError>(())
@@ -2432,7 +2429,7 @@ impl<E: Error> Error for Box<E> {
     }
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Box<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {

library/alloc/src/boxed/thin.rs

@@ -78,7 +78,6 @@ impl<T> ThinBox<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api)]
     /// #![feature(thin_box)]
     /// use std::boxed::ThinBox;
     ///

library/alloc/src/collections/binary_heap/mod.rs

@@ -553,6 +553,7 @@ impl<T, A: Allocator> BinaryHeap<T, A> {
     /// let heap : BinaryHeap<i32, System> = BinaryHeap::new_in(System);
     /// ```
     #[unstable(feature = "allocator_api", issue = "32838")]
+    #[rustc_const_unstable(feature = "allocator_api", issue = "32838")]
     #[must_use]
     pub const fn new_in(alloc: A) -> BinaryHeap<T, A> {
         BinaryHeap { data: Vec::new_in(alloc) }

library/alloc/src/rc.rs

@@ -1332,7 +1332,6 @@ impl<T: ?Sized + CloneToUninit> Rc<T> {
     ///
     /// ```
     /// #![feature(clone_from_ref)]
-    /// #![feature(allocator_api)]
     /// use std::rc::Rc;
     ///
     /// let hello: Rc<str> = Rc::try_clone_from_ref("hello")?;
@@ -2973,7 +2972,7 @@ impl From<String> for Rc<str> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "shared_from_slice", since = "1.21.0")]
-impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A> {
+impl<T: ?Sized> From<Box<T>> for Rc<T> {
     /// Move a boxed object to a new, reference counted, allocation.
     ///
     /// # Example
@@ -2985,7 +2984,7 @@ impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Rc<T, A> {
     /// assert_eq!(1, *shared);
     /// ```
     #[inline]
-    fn from(v: Box<T, A>) -> Rc<T, A> {
+    fn from(v: Box<T>) -> Rc<T> {
         Rc::from_box_in(v)
     }
 }
@@ -4549,7 +4548,7 @@ impl<T: ?Sized, A: Allocator> Drop for UniqueRcUninit<T, A> {
     }
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Rc<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {

library/alloc/src/sync.rs

@@ -1480,7 +1480,6 @@ impl<T: ?Sized + CloneToUninit> Arc<T> {
     ///
     /// ```
     /// #![feature(clone_from_ref)]
-    /// #![feature(allocator_api)]
     /// use std::sync::Arc;
     ///
     /// let hello: Arc<str> = Arc::try_clone_from_ref("hello")?;
@@ -4011,7 +4010,7 @@ impl From<String> for Arc<str> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "shared_from_slice", since = "1.21.0")]
-impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A> {
+impl<T: ?Sized> From<Box<T>> for Arc<T> {
     /// Move a boxed object to a new, reference-counted allocation.
     ///
     /// # Example
@@ -4023,7 +4022,7 @@ impl<T: ?Sized, A: Allocator> From<Box<T, A>> for Arc<T, A> {
     /// assert_eq!("eggplant", &shared[..]);
     /// ```
     #[inline]
-    fn from(v: Box<T, A>) -> Arc<T, A> {
+    fn from(v: Box<T>) -> Arc<T> {
         Arc::from_box_in(v)
     }
 }
@@ -4918,7 +4917,7 @@ unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for UniqueArc<T, A> {
     }
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Arc<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {

library/alloc/src/vec/mod.rs

@@ -1065,7 +1065,8 @@ impl<T, A: Allocator> Vec<T, A> {
     /// let vec: Vec<i32, System> = Vec::new_in(System);
     /// ```
     #[inline]
-    #[unstable(feature = "allocator_api", issue = "32838")]
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_unstable(feature = "allocator_api", issue = "32838")]
     pub const fn new_in(alloc: A) -> Self {
         Vec { buf: RawVec::new_in(alloc), len: 0 }
     }

library/core/src/alloc/global.rs

@@ -301,3 +301,33 @@ pub unsafe trait GlobalAlloc {
         new_ptr
     }
 }
+
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
+unsafe impl<A: super::Allocator + ?Sized> GlobalAlloc for A {
+    default unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        self.allocate(layout).map_or(ptr::null_mut(), |p| p.as_mut_ptr())
+    }
+
+    default unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        // SAFETY: Guaranteed by caller.
+        unsafe { self.deallocate(ptr::NonNull::new_unchecked(ptr), layout) }
+    }
+
+    default unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        self.allocate_zeroed(layout).map_or(ptr::null_mut(), |p| p.as_mut_ptr())
+    }
+
+    default unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        // SAFETY: Guaranteed by caller.
+        unsafe {
+            let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
+            let ptr = ptr::NonNull::new_unchecked(ptr);
+            if layout.size() > new_size {
+                self.shrink(ptr, layout, new_layout)
+            } else {
+                self.grow(ptr, layout, new_layout)
+            }
+        }
+        .map_or(ptr::null_mut(), |p| p.as_mut_ptr())
+    }
+}

library/core/src/alloc/mod.rs

@@ -27,19 +27,15 @@ use crate::ptr::{self, NonNull};
 /// that may be due to resource exhaustion or to
 /// something wrong when combining the given input arguments with this
 /// allocator.
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct AllocError;
 
-#[unstable(
-    feature = "allocator_api",
-    reason = "the precise API and guarantees it provides may be tweaked.",
-    issue = "32838"
-)]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 impl Error for AllocError {}
 
 // (we need this for downstream impl of trait Error)
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 impl fmt::Display for AllocError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("memory allocation failed")
@@ -100,15 +96,29 @@ impl fmt::Display for AllocError {
 /// A memory block which is [*currently allocated*] may be passed to
 /// any method of the allocator that accepts such an argument.
 ///
+/// No [*currently allocated*] memory may be accessed by the allocator except
+/// through the pointer passed back in within `grow`, `shrink`, and `deallocate`
+/// until that memory has been deallocated.
+///
+/// Implementors of `Allocator` which are also [`PartialEq`] must ensure equality
+/// guarantees that memory allocated with one can be freed with the other.
+///
+/// Behaviour when unwinding out of any of the allocating or deallocating
+/// functions is undefined.
+///
 /// Additionally, any memory block returned by the allocator must
 /// satisfy the allocation invariants described in `core::ptr`.
 /// In particular, if a block has base address `p` and size `n`,
 /// then `p as usize + n <= usize::MAX` must hold.
 ///
 /// This ensures that pointer arithmetic within the allocation
 /// (for example, `ptr.add(len)`) cannot overflow the address space.
+///
+/// Note that some of the stated safety requirements are still experimental and
+/// may be relaxed in the future.
+///
 /// [*currently allocated*]: #currently-allocated-memory
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 pub const unsafe trait Allocator {
     /// Attempts to allocate a block of memory.
@@ -129,14 +139,15 @@ pub const unsafe trait Allocator {
     /// Returning `Err` indicates that either memory is exhausted or `layout` does not meet
     /// allocator's size or alignment constraints.
     ///
-    /// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or
+    /// Implementations are encouraged to return `Err` on memory exhaustion rather than
     /// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement
     /// this trait atop an underlying native allocation library that aborts on memory exhaustion.)
     ///
     /// Clients wishing to abort computation in response to an allocation error are encouraged to
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
 
     /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized.
@@ -146,14 +157,15 @@ pub const unsafe trait Allocator {
     /// Returning `Err` indicates that either memory is exhausted or `layout` does not meet
     /// allocator's size or alignment constraints.
     ///
-    /// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or
+    /// Implementations are encouraged to return `Err` on memory exhaustion rather than
     /// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement
     /// this trait atop an underlying native allocation library that aborts on memory exhaustion.)
     ///
     /// Clients wishing to abort computation in response to an allocation error are encouraged to
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         let ptr = self.allocate(layout)?;
         // SAFETY: `alloc` returns a valid memory block
@@ -165,11 +177,12 @@ pub const unsafe trait Allocator {
     ///
     /// # Safety
     ///
-    /// * `ptr` must denote a block of memory [*currently allocated*] via this allocator, and
-    /// * `layout` must [*fit*] that block of memory.
+    /// * `ptr` must denote a block of memory [*currently allocated*] via this allocator,
+    /// * `layout` must [*fit*] that block of memory, and
     ///
     /// [*currently allocated*]: #currently-allocated-memory
     /// [*fit*]: #memory-fitting
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
 
     /// Attempts to extend the memory block.
@@ -190,7 +203,7 @@ pub const unsafe trait Allocator {
     ///
     /// * `ptr` must denote a block of memory [*currently allocated*] via this allocator.
     /// * `old_layout` must [*fit*] that block of memory (The `new_layout` argument need not fit it.).
-    /// * `new_layout.size()` must be greater than or equal to `old_layout.size()`.
+    /// * `new_layout.size()` must be greater than or equal to `old_layout.size()`
     ///
     /// Note that `new_layout.align()` need not be the same as `old_layout.align()`.
     ///
@@ -202,14 +215,15 @@ pub const unsafe trait Allocator {
     /// Returns `Err` if the new layout does not meet the allocator's size and alignment
     /// constraints of the allocator, or if growing otherwise fails.
     ///
-    /// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or
+    /// Implementations are encouraged to return `Err` on memory exhaustion rather than
     /// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement
     /// this trait atop an underlying native allocation library that aborts on memory exhaustion.)
     ///
     /// Clients wishing to abort computation in response to an allocation error are encouraged to
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     unsafe fn grow(
         &self,
         ptr: NonNull<u8>,
@@ -265,14 +279,15 @@ pub const unsafe trait Allocator {
     /// Returns `Err` if the new layout does not meet the allocator's size and alignment
     /// constraints of the allocator, or if growing otherwise fails.
     ///
-    /// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or
+    /// Implementations are encouraged to return `Err` on memory exhaustion rather than
     /// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement
     /// this trait atop an underlying native allocation library that aborts on memory exhaustion.)
     ///
     /// Clients wishing to abort computation in response to an allocation error are encouraged to
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     unsafe fn grow_zeroed(
         &self,
         ptr: NonNull<u8>,
@@ -329,14 +344,15 @@ pub const unsafe trait Allocator {
     /// Returns `Err` if the new layout does not meet the allocator's size and alignment
     /// constraints of the allocator, or if shrinking otherwise fails.
     ///
-    /// Implementations are encouraged to return `Err` on memory exhaustion rather than panicking or
+    /// Implementations are encouraged to return `Err` on memory exhaustion rather than
     /// aborting, but this is not a strict requirement. (Specifically: it is *legal* to implement
     /// this trait atop an underlying native allocation library that aborts on memory exhaustion.)
     ///
     /// Clients wishing to abort computation in response to an allocation error are encouraged to
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
+    #[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
     unsafe fn shrink(
         &self,
         ptr: NonNull<u8>,
@@ -366,16 +382,22 @@ pub const unsafe trait Allocator {
     /// Creates a "by reference" adapter for this instance of `Allocator`.
     ///
     /// The returned adapter also implements `Allocator` and will simply borrow this.
+    #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline(always)]
     fn by_ref(&self) -> &Self
     where
         Self: Sized,
     {
         self
     }
+
+    /// Dummy function. Used to make `Allocator` non-`dyn` compatible for now.
+    #[doc(hidden)]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    fn dummy_no_dyn() {}
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 unsafe impl<A> const Allocator for &A
 where
@@ -431,7 +453,7 @@ where
     }
 }
 
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 unsafe impl<A> Allocator for &mut A
 where
     A: Allocator + ?Sized,

library/std/src/alloc.rs

@@ -207,7 +207,7 @@ impl System {
 
 // The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,
 // which is in `std::sys::*::alloc`.
-#[unstable(feature = "allocator_api", issue = "32838")]
+#[stable(feature = "min_allocator", since = "CURRENT_RUSTC_VERSION")]
 unsafe impl Allocator for System {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {