Revert "Remove AbortAlloc"

This reverts commit 708a298.

Author: Ericson2314

src/alloc/abort.rs

@@ -0,0 +1,62 @@
+#![allow(clippy::use_self)]
+
+use crate::alloc::{AllocRef, BuildAllocRef, DeallocRef, NonZeroLayout, ReallocRef};
+use core::ptr::NonNull;
+use liballoc::alloc::handle_alloc_error;
+
+/// An allocator, which wraps another allocator and aborts on OOM.
+#[derive(Debug, Default, Copy, Clone)]
+pub struct AbortAlloc<A>(pub A);
+
+impl<A: BuildAllocRef> BuildAllocRef for AbortAlloc<A> {
+    type Ref = AbortAlloc<A::Ref>;
+
+    unsafe fn build_alloc_ref(
+        &mut self,
+        ptr: NonNull<u8>,
+        layout: Option<NonZeroLayout>,
+    ) -> Self::Ref {
+        Self(self.0.build_alloc_ref(ptr, layout))
+    }
+}
+
+impl<A: DeallocRef> DeallocRef for AbortAlloc<A> {
+    type BuildAlloc = AbortAlloc<A::BuildAlloc>;
+
+    fn get_build_alloc(&mut self) -> Self::BuildAlloc {
+        Self(self.0.get_build_alloc())
+    }
+
+    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout) {
+        self.0.dealloc(ptr, layout)
+    }
+}
+
+impl<A: AllocRef> AllocRef for AbortAlloc<A> {
+    type Error = !;
+
+    fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+        self.0
+            .alloc(layout)
+            .map_err(|_| handle_alloc_error(layout.into()))
+    }
+
+    fn alloc_zeroed(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
+        self.0
+            .alloc_zeroed(layout)
+            .map_err(|_| handle_alloc_error(layout.into()))
+    }
+}
+
+impl<A: ReallocRef> ReallocRef for AbortAlloc<A> {
+    unsafe fn realloc(
+        &mut self,
+        ptr: NonNull<u8>,
+        old_layout: NonZeroLayout,
+        new_layout: NonZeroLayout,
+    ) -> Result<NonNull<u8>, Self::Error> {
+        self.0
+            .realloc(ptr, old_layout, new_layout)
+            .map_err(|_| handle_alloc_error(new_layout.into()))
+    }
+}

src/alloc/mod.rs

@@ -1,6 +1,10 @@
+mod abort;
 mod layout;
 
-pub use self::layout::{LayoutErr, NonZeroLayout};
+pub use self::{
+    abort::AbortAlloc,
+    layout::{LayoutErr, NonZeroLayout},
+};
 pub use core::alloc::GlobalAlloc;
 use core::{
     cmp,

src/boxed.rs

@@ -79,7 +79,7 @@
 //! [`NonZeroLayout::for_value(&*value)`]: crate::alloc::NonZeroLayout::for_value
 
 use crate::{
-    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout},
+    alloc::{AbortAlloc, AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout},
     clone::CloneIn,
     collections::CollectionAllocErr,
     raw_vec::RawVec,
@@ -105,7 +105,7 @@ use core::{
 /// A pointer type for heap allocation.
 ///
 /// See the [module-level documentation](index.html) for more.
-pub struct Box<T: ?Sized, A: DeallocRef = Global> {
+pub struct Box<T: ?Sized, A: DeallocRef = AbortAlloc<Global>> {
     ptr: Unique<T>,
     build_alloc: A::BuildAlloc,
 }
@@ -131,7 +131,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new(x: T) -> Self {
-        Self::new_in(x, Global)
+        Self::new_in(x, AbortAlloc(Global))
     }
 
     /// Constructs a new box with uninitialized contents.
@@ -156,7 +156,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
-        Self::new_uninit_in(Global)
+        Self::new_uninit_in(AbortAlloc(Global))
     }
 
     /// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
@@ -177,14 +177,20 @@ impl<T, A: AllocRef> Box<T, A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, boxed::Box};
+    /// use alloc_wg::{
+    ///     alloc::{AbortAlloc, Global},
+    ///     boxed::Box,
+    /// };
     ///
     /// # #[allow(unused_variables)]
-    /// let five = Box::new_in(5, Global);
+    /// let five = Box::new_in(5, AbortAlloc(Global));
     /// ```
     #[allow(clippy::inline_always)]
     #[inline(always)]
-    pub fn new_in(x: T, a: A) -> Self {
+    pub fn new_in(x: T, a: A) -> Self
+    where
+        A: AllocRef<Error = !>,
+    {
         unsafe { Self::try_new_in(x, a).unwrap_unchecked() }
     }
 
@@ -219,9 +225,12 @@ impl<T, A: AllocRef> Box<T, A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, boxed::Box};
+    /// use alloc_wg::{
+    ///     alloc::{AbortAlloc, Global},
+    ///     boxed::Box,
+    /// };
     ///
-    /// let mut five = Box::<u32, _>::new_uninit_in(Global);
+    /// let mut five = Box::<u32, _>::new_uninit_in(AbortAlloc(Global));
     ///
     /// let five = unsafe {
     ///     // Deferred initialization:
@@ -234,7 +243,10 @@ impl<T, A: AllocRef> Box<T, A> {
     /// ```
     #[allow(clippy::inline_always)]
     #[inline(always)]
-    pub fn new_uninit_in(a: A) -> Box<mem::MaybeUninit<T>, A> {
+    pub fn new_uninit_in(a: A) -> Box<mem::MaybeUninit<T>, A>
+    where
+        A: AllocRef<Error = !>,
+    {
         unsafe { Self::try_new_uninit_in(a).unwrap_unchecked() }
     }
 
@@ -271,7 +283,10 @@ impl<T, A: AllocRef> Box<T, A> {
     /// `Unpin`, then `x` will be pinned in memory and unable to be moved.
     #[allow(clippy::inline_always)]
     #[inline(always)]
-    pub fn pin_in(x: T, a: A) -> Pin<Self> {
+    pub fn pin_in(x: T, a: A) -> Pin<Self>
+    where
+        A: AllocRef<Error = !>,
+    {
         unsafe { Self::try_pin_in(x, a).unwrap_unchecked() }
     }
 
@@ -309,7 +324,7 @@ impl<T> Box<[T]> {
     #[inline(always)]
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
-        Self::new_uninit_slice_in(len, Global)
+        Self::new_uninit_slice_in(len, AbortAlloc(Global))
     }
 }
 
@@ -320,9 +335,12 @@ impl<T, A: AllocRef> Box<[T], A> {
     /// # Example
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, boxed::Box};
+    /// use alloc_wg::{
+    ///     alloc::{AbortAlloc, Global},
+    ///     boxed::Box,
+    /// };
     ///
-    /// let mut values = Box::<[u32], _>::new_uninit_slice_in(3, Global);
+    /// let mut values = Box::<[u32], AbortAlloc<Global>>::new_uninit_slice_in(3, AbortAlloc(Global));
     ///
     /// let values = unsafe {
     ///     // Deferred initialization:
@@ -337,7 +355,10 @@ impl<T, A: AllocRef> Box<[T], A> {
     /// ```
     #[allow(clippy::inline_always)]
     #[inline(always)]
-    pub fn new_uninit_slice_in(len: usize, a: A) -> Box<[mem::MaybeUninit<T>], A> {
+    pub fn new_uninit_slice_in(len: usize, a: A) -> Box<[mem::MaybeUninit<T>], A>
+    where
+        A: AllocRef<Error = !>,
+    {
         unsafe { Self::try_new_uninit_slice_in(len, a).unwrap_unchecked() }
     }
 
@@ -503,7 +524,7 @@ impl<T: ?Sized> Box<T> {
     #[allow(clippy::inline_always)]
     #[inline(always)]
     pub unsafe fn from_raw(raw: *mut T) -> Self {
-        Self::from_raw_in(raw, Global)
+        Self::from_raw_in(raw, AbortAlloc(Global))
     }
 }
 
@@ -747,7 +768,7 @@ unsafe impl<#[may_dangle] T: ?Sized, A: DeallocRef> Drop for Box<T, A> {
 impl<T, A> Default for Box<T, A>
 where
     T: Default,
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     #[must_use]
     fn default() -> Self {
@@ -758,7 +779,7 @@ where
 #[allow(clippy::use_self)]
 impl<T, A> Default for Box<[T], A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     #[must_use]
     fn default() -> Self {
@@ -775,7 +796,7 @@ unsafe fn from_boxed_utf8_unchecked<A: DeallocRef>(v: Box<[u8], A>) -> Box<str,
 #[allow(clippy::use_self)]
 impl<A> Default for Box<str, A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     #[must_use]
     fn default() -> Self {
@@ -785,7 +806,7 @@ where
 
 impl<T: Clone, A> Clone for Box<T, A>
 where
-    A: AllocRef,
+    A: AllocRef<Error = !>,
     A::BuildAlloc: Clone,
 {
     /// Returns a new box with a `clone()` of this box's contents.
@@ -846,7 +867,10 @@ where
 impl<T: Clone, A: AllocRef, B: AllocRef> CloneIn<B> for Box<T, A> {
     type Cloned = Box<T, B>;
 
-    fn clone_in(&self, a: B) -> Self::Cloned {
+    fn clone_in(&self, a: B) -> Self::Cloned
+    where
+        B: AllocRef<Error = !>,
+    {
         Box::new_in(self.as_ref().clone(), a)
     }
 
@@ -949,7 +973,7 @@ impl<T: ?Sized + Hasher, A: DeallocRef> Hasher for Box<T, A> {
 
 impl<T, A> From<T> for Box<T, A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     /// Converts a generic type `T` into a `Box<T>`
     ///
@@ -983,7 +1007,7 @@ impl<T: ?Sized, A: DeallocRef> From<Box<T, A>> for Pin<Box<T, A>> {
 #[allow(clippy::use_self)]
 impl<T: Copy, A> From<&[T]> for Box<[T], A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     /// Converts a `&[T]` into a `Box<[T], B>`
     ///
@@ -1012,7 +1036,7 @@ where
 #[allow(clippy::use_self)]
 impl<A> From<&str> for Box<str, A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     /// Converts a `&str` into a `Box<str>`
     ///
@@ -1266,13 +1290,16 @@ macro_rules! impl_dispatch_from_dyn {
 }
 
 impl_dispatch_from_dyn!(Global);
+impl_dispatch_from_dyn!(AbortAlloc<Global>);
 #[cfg(feature = "std")]
 impl_dispatch_from_dyn!(std::alloc::System);
+#[cfg(feature = "std")]
+impl_dispatch_from_dyn!(AbortAlloc<std::alloc::System>);
 
 #[allow(clippy::items_after_statements)]
 impl<T: Clone, A: Clone> Clone for Box<[T], A>
 where
-    A: AllocRef,
+    A: AllocRef<Error = !>,
     A::BuildAlloc: Clone,
 {
     fn clone(&self) -> Self {

src/clone.rs

@@ -3,7 +3,9 @@ use crate::alloc::AllocRef;
 pub trait CloneIn<A: AllocRef>: Sized {
     type Cloned;
 
-    fn clone_in(&self, a: A) -> Self::Cloned;
+    fn clone_in(&self, a: A) -> Self::Cloned
+    where
+        A: AllocRef<Error = !>;
 
     fn try_clone_in(&self, a: A) -> Result<Self::Cloned, A::Error>;
 }

src/iter.rs

@@ -19,7 +19,7 @@ pub trait TryExtend<A> {
     /// message.try_extend(['d', 'e', 'f'].iter())?;
     ///
     /// assert_eq!(vec!['a', 'b', 'c', 'd', 'e', 'f'], message);
-    /// # Ok::<(), alloc_wg::collections::CollectionAllocErr<alloc_wg::alloc::Global>>(())
+    /// # Ok::<(), alloc_wg::collections::CollectionAllocErr<alloc_wg::alloc::AbortAlloc<alloc_wg::alloc::Global>>>(())
     /// ```
     fn try_extend<T: IntoIterator<Item = A>>(&mut self, iter: T) -> Result<(), Self::Err>;
 }