WIP: Allocator- and fallibility-polymorphic collections

src/liballoc/abort_adapter.rs

@@ -0,0 +1,112 @@
+//! An allocator adapter that blows up by calling `handle_alloc_error` on all errors.
+//!
+//! On one hand, concrete allocator implementations should always be written
+//! without panicking on user error and OOM to give users maximum
+//! flexibility. On the other hand, code that depends on allocation succeeding
+//! should depend on `Alloc<Err=!>` to avoid repetitively handling errors from
+//! which it cannot recover.
+//!
+//! This adapter bridges the gap, effectively allowing `Alloc<Err=!>` to be
+//! implemented by any allocator.
+
+#![unstable(feature = "allocator_api",
+            reason = "the precise API and guarantees it provides may be tweaked \
+                      slightly, especially to possibly take into account the \
+                      types being stored to make room for a future \
+                      tracing garbage collector",
+            issue = "32838")]
+
+use core::usize;
+use core::ptr::NonNull;
+
+use crate::alloc::*;
+
+/// An allocator adapter that blows up by calling `handle_alloc_error` on all errors.
+///
+/// See the [module-level documentation](../../std/abort_adapter/index.html) for more.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct AbortAdapter<Alloc>(pub Alloc);
+
+impl<A: AllocHelper> AllocHelper for AbortAdapter<A> {
+    type Err = !;
+}
+
+unsafe impl<A: Alloc> Alloc for AbortAdapter<A> {
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, Self::Err> {
+        self.0.alloc(layout).or_else(|_| handle_alloc_error(layout))
+    }
+
+    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
+        self.0.dealloc(ptr, layout)
+    }
+
+    fn usable_size(&self, layout: &Layout) -> (usize, usize) {
+        self.0.usable_size(layout)
+    }
+
+    unsafe fn realloc(&mut self,
+                      ptr: NonNull<u8>,
+                      layout: Layout,
+                      new_size: usize) -> Result<NonNull<u8>, Self::Err> {
+        self.0.realloc(ptr, layout, new_size).or_else(|_| {
+            let layout = Layout::from_size_align_unchecked(new_size, layout.align());
+            handle_alloc_error(layout)
+        })
+    }
+
+    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<u8>, Self::Err> {
+        self.0.alloc_zeroed(layout).or_else(|_| handle_alloc_error(layout))
+    }
+
+    unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, Self::Err> {
+        self.0.alloc_excess(layout).or_else(|_| handle_alloc_error(layout))
+    }
+
+    unsafe fn grow_in_place(&mut self,
+                            ptr: NonNull<u8>,
+                            layout: Layout,
+                            new_size: usize) -> Result<(), CannotReallocInPlace> {
+        self.0.grow_in_place(ptr, layout, new_size)
+    }
+
+    unsafe fn shrink_in_place(&mut self,
+                              ptr: NonNull<u8>,
+                              layout: Layout,
+                              new_size: usize) -> Result<(), CannotReallocInPlace> {
+        self.0.shrink_in_place(ptr, layout, new_size)
+    }
+
+    fn alloc_one<T>(&mut self) -> Result<NonNull<T>, Self::Err>
+        where Self: Sized
+    {
+        self.0.alloc_one().or_else(|_| handle_alloc_error(Layout::new::<T>()))
+    }
+
+    unsafe fn dealloc_one<T>(&mut self, ptr: NonNull<T>)
+        where Self: Sized
+    {
+        self.0.dealloc_one(ptr)
+    }
+
+    fn alloc_array<T>(&mut self, n: usize) -> Result<NonNull<T>, Self::Err>
+        where Self: Sized
+    {
+        self.0.alloc_array(n).or_else(|_| handle_alloc_error(Layout::new::<T>()))
+    }
+
+    unsafe fn realloc_array<T>(&mut self,
+                               ptr: NonNull<T>,
+                               n_old: usize,
+                               n_new: usize) -> Result<NonNull<T>, Self::Err>
+        where Self: Sized
+    {
+        self.0.realloc_array(ptr, n_old, n_new)
+            .or_else(|_| handle_alloc_error(Layout::new::<T>()))
+    }
+
+    unsafe fn dealloc_array<T>(&mut self, ptr: NonNull<T>, n: usize) -> Result<(), Self::Err>
+        where Self: Sized
+    {
+        self.0.dealloc_array(ptr, n).or_else(|_| handle_alloc_error(Layout::new::<T>()))
+    }
+}

src/liballoc/alloc.rs

@@ -40,10 +40,14 @@ extern "Rust" {
 /// accessed through the [free functions in `alloc`](index.html#functions).
 ///
 /// [`Alloc`]: trait.Alloc.html
+#[cfg(not(test))]
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[derive(Copy, Clone, Default, Debug)]
 pub struct Global;
 
+#[cfg(test)]
+pub use std::alloc::Global;
+
 /// Allocate memory with the global allocator.
 ///
 /// This function forwards calls to the [`GlobalAlloc::alloc`] method
@@ -163,6 +167,13 @@ pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
     __rust_alloc_zeroed(layout.size(), layout.align())
 }
 
+#[cfg(not(test))]
+#[unstable(feature = "allocator_api", issue = "32838")]
+impl AllocHelper for Global {
+    type Err = AllocErr;
+}
+
+#[cfg(not(test))]
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl Alloc for Global {
     #[inline]
@@ -201,25 +212,27 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
         align as *mut u8
     } else {
         let layout = Layout::from_size_align_unchecked(size, align);
-        let ptr = alloc(layout);
-        if !ptr.is_null() {
-            ptr
-        } else {
-            handle_alloc_error(layout)
+        match Global.alloc(layout) {
+            Ok(ptr) => ptr.as_ptr(),
+            Err(_) => handle_alloc_error(layout),
         }
     }
 }
 
 #[cfg_attr(not(test), lang = "box_free")]
 #[inline]
-pub(crate) unsafe fn box_free<T: ?Sized>(ptr: Unique<T>) {
-    let ptr = ptr.as_ptr();
-    let size = size_of_val(&*ptr);
-    let align = min_align_of_val(&*ptr);
+pub(crate) unsafe fn box_free<T: ?Sized, A: Alloc>(ptr: Unique<T>, mut a: A) {
+    box_free_worker(ptr, &mut a)
+}
+
+#[inline]
+pub(crate) unsafe fn box_free_worker<T: ?Sized, A: Alloc>(ptr: Unique<T>, a: &mut A) {
+    let size = size_of_val(&*ptr.as_ptr());
+    let align = min_align_of_val(&*ptr.as_ptr());
     // We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
     if size != 0 {
         let layout = Layout::from_size_align_unchecked(size, align);
-        dealloc(ptr as *mut u8, layout);
+        a.dealloc(NonNull::from(ptr).cast(), layout);
     }
 }