Add associated error type to allocators

We will use this for fallibility polymorphism

Author: Ericson2314

src/liballoc/alloc.rs

@@ -167,6 +167,12 @@ 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 {

src/liballoc/boxed.rs

@@ -88,7 +88,7 @@ use core::ops::{
 use core::ptr::{self, NonNull, Unique};
 use core::task::{Context, Poll};
 
-use crate::alloc::{Alloc, Global, Layout, handle_alloc_error};
+use crate::alloc::{Alloc, AllocErr, Global, Layout, handle_alloc_error};
 use crate::vec::Vec;
 use crate::raw_vec::RawVec;
 use crate::str::from_boxed_utf8_unchecked;
@@ -126,7 +126,7 @@ impl<T> Box<T> {
     }
 }
 
-impl<T, A: Alloc> Box<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> Box<T, A> {
     /// Allocates memory in the given allocator and then places `x` into it.
     ///
     /// This doesn't actually allocate if `T` is zero-sized.
@@ -213,7 +213,7 @@ impl<T: ?Sized> Box<T> {
     }
 }
 
-impl<T: ?Sized, A: Alloc> Box<T, A> {
+impl<T: ?Sized, A> Box<T, A> {
     /// Constructs a box from a raw pointer in the given allocator.
     ///
     /// This is similar to the [`Box::from_raw`] function, but assumes
@@ -420,29 +420,29 @@ unsafe impl<#[may_dangle] T: ?Sized, A> Drop for Box<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Default, A: Alloc + Default> Default for Box<T, A> {
+impl<T: Default, A: Alloc<Err = AllocErr> + Default> Default for Box<T, A> {
     /// Creates a `Box<T, A>`, with the `Default` value for T.
     fn default() -> Box<T, A> {
         Box::new_in(Default::default(), A::default())
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Alloc + Default> Default for Box<[T], A> {
+impl<T, A: Alloc<Err = AllocErr> + Default> Default for Box<[T], A> {
     fn default() -> Box<[T], A> {
         Box::<[T; 0], A>::new_in([], A::default())
     }
 }
 
 #[stable(feature = "default_box_extra", since = "1.17.0")]
-impl<A: Alloc + Default> Default for Box<str, A> {
+impl<A: Alloc<Err = AllocErr> + Default> Default for Box<str, A> {
     fn default() -> Box<str, A> {
         unsafe { from_boxed_utf8_unchecked(Default::default()) }
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone, A: Alloc + Clone> Clone for Box<T, A> {
+impl<T: Clone, A: Alloc<Err = AllocErr> + Clone> Clone for Box<T, A> {
     /// Returns a new box with a `clone()` of this box's contents.
     ///
     /// # Examples
@@ -474,9 +474,8 @@ impl<T: Clone, A: Alloc + Clone> Clone for Box<T, A> {
     }
 }
 
-
 #[stable(feature = "box_slice_clone", since = "1.3.0")]
-impl<A: Alloc + Clone> Clone for Box<str, A> {
+impl<A: Alloc<Err = AllocErr> + Clone> Clone for Box<str, A> {
     fn clone(&self) -> Self {
         // this makes a copy of the data
         let buf = Box::<[u8], A>::from_slice_in(self.as_bytes(), self.1.clone());
@@ -584,7 +583,7 @@ impl<T: ?Sized + Hasher, A> Hasher for Box<T, A> {
 }
 
 #[stable(feature = "from_for_ptrs", since = "1.6.0")]
-impl<T, A: Alloc + Default> From<T> for Box<T, A> {
+impl<T, A: Alloc<Err = AllocErr> + Default> From<T> for Box<T, A> {
     /// Converts a generic type `T` into a `Box<T>`
     ///
     /// The conversion allocates on the heap and moves `t`
@@ -612,7 +611,7 @@ impl<T: ?Sized, A> From<Box<T, A>> for Pin<Box<T, A>> {
     }
 }
 
-impl<T: Copy, A: Alloc> Box<[T], A> {
+impl<T: Copy, A: Alloc<Err = AllocErr>> Box<[T], A> {
     fn from_slice_in(slice: &[T], a: A) -> Box<[T], A> {
         let len = slice.len();
         let buf = RawVec::with_capacity_in(len, a);
@@ -624,7 +623,7 @@ impl<T: Copy, A: Alloc> Box<[T], A> {
 }
 
 #[stable(feature = "box_from_slice", since = "1.17.0")]
-impl<T: Copy, A: Alloc + Default> From<&[T]> for Box<[T], A> {
+impl<T: Copy, A: Alloc<Err = AllocErr> + Default> From<&[T]> for Box<[T], A> {
     /// Converts a `&[T]` into a `Box<[T]>`
     ///
     /// This conversion allocates on the heap
@@ -644,7 +643,7 @@ impl<T: Copy, A: Alloc + Default> From<&[T]> for Box<[T], A> {
 }
 
 #[stable(feature = "box_from_slice", since = "1.17.0")]
-impl<A: Alloc + Default> From<&str> for Box<str, A> {
+impl<A: Alloc<Err = AllocErr> + Default> From<&str> for Box<str, A> {
     /// Converts a `&str` into a `Box<str>`
     ///
     /// This conversion allocates on the heap
@@ -662,7 +661,7 @@ impl<A: Alloc + Default> From<&str> for Box<str, A> {
 }
 
 #[stable(feature = "boxed_str_conv", since = "1.19.0")]
-impl<A: Alloc> From<Box<str, A>> for Box<[u8], A> {
+impl<A> From<Box<str, A>> for Box<[u8], A> {
     /// Converts a `Box<str>>` into a `Box<[u8]>`
     ///
     /// This conversion does not allocate on the heap and happens in place.
@@ -685,7 +684,7 @@ impl<A: Alloc> From<Box<str, A>> for Box<[u8], A> {
     }
 }
 
-impl<A: Alloc> Box<dyn Any, A> {
+impl<A> Box<dyn Any, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     /// Attempt to downcast the box to a concrete type.
@@ -716,7 +715,7 @@ impl<A: Alloc> Box<dyn Any, A> {
     }
 }
 
-impl<A: Alloc> Box<dyn Any + Send, A> {
+impl<A: Alloc<Err=AllocErr>> Box<dyn Any + Send, A> {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     /// Attempt to downcast the box to a concrete type.
@@ -941,7 +940,7 @@ impl<A> FromIterator<A> for Box<[A]> {
 }
 
 #[stable(feature = "box_slice_clone", since = "1.3.0")]
-impl<T: Clone, A: Alloc + Clone> Clone for Box<[T], A> {
+impl<T: Clone, A: Alloc<Err = AllocErr> + Clone> Clone for Box<[T], A> {
     fn clone(&self) -> Self {
         let mut new = BoxBuilder {
             data: RawVec::with_capacity_in(self.len(), self.1.clone()),
@@ -962,20 +961,20 @@ impl<T: Clone, A: Alloc + Clone> Clone for Box<[T], A> {
         return unsafe { new.into_box() };
 
         // Helper type for responding to panics correctly.
-        struct BoxBuilder<T, A: Alloc> {
+        struct BoxBuilder<T, A: Alloc<Err = AllocErr>> {
             data: RawVec<T, A>,
             len: usize,
         }
 
-        impl<T, A: Alloc> BoxBuilder<T, A> {
+        impl<T, A: Alloc<Err = AllocErr>> BoxBuilder<T, A> {
             unsafe fn into_box(self) -> Box<[T], A> {
                 let raw = ptr::read(&self.data);
                 mem::forget(self);
                 raw.into_box()
             }
         }
 
-        impl<T, A: Alloc> Drop for BoxBuilder<T, A> {
+        impl<T, A: Alloc<Err = AllocErr>> Drop for BoxBuilder<T, A> {
             fn drop(&mut self) {
                 let mut data = self.data.ptr();
                 let max = unsafe { data.add(self.len) };

src/liballoc/raw_vec.rs

@@ -7,8 +7,8 @@ use core::ops::Drop;
 use core::ptr::{self, NonNull, Unique};
 use core::slice;
 
-use crate::alloc::{Alloc, Layout, Global, handle_alloc_error};
-use crate::collections::CollectionAllocErr::{self, *};
+use crate::alloc::{Alloc, AllocErr, Layout, Global, handle_alloc_error};
+use crate::collections::CollectionAllocErr;
 use crate::boxed::Box;
 
 /// A low-level utility for more ergonomically allocating, reallocating, and deallocating
@@ -39,13 +39,13 @@ use crate::boxed::Box;
 /// field. This allows zero-sized types to not be special-cased by consumers of
 /// this type.
 #[allow(missing_debug_implementations)]
-pub struct RawVec<T, A: Alloc = Global> {
+pub struct RawVec<T, A: Alloc<Err = AllocErr> = Global> {
     ptr: Unique<T>,
     cap: usize,
     a: A,
 }
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     /// Like `new` but parameterized over the choice of allocator for
     /// the returned RawVec.
     pub const fn new_in(a: A) -> Self {
@@ -146,7 +146,7 @@ impl<T> RawVec<T, Global> {
     }
 }
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     /// Reconstitutes a RawVec from a pointer, capacity, and allocator.
     ///
     /// # Undefined Behavior
@@ -189,7 +189,7 @@ impl<T> RawVec<T, Global> {
     }
 }
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     /// Gets a raw pointer to the start of the allocation. Note that this is
     /// Unique::empty() if `cap = 0` or T is zero-sized. In the former case, you must
     /// be careful.
@@ -409,8 +409,8 @@ impl<T, A: Alloc> RawVec<T, A> {
     /// Aborts on OOM
     pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Exact) {
-            Err(CapacityOverflow) => capacity_overflow(),
-            Err(AllocErr) => unreachable!(),
+            Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
+            Err(CollectionAllocErr::AllocErr) => unreachable!(),
             Ok(()) => { /* yay */ }
          }
      }
@@ -422,7 +422,7 @@ impl<T, A: Alloc> RawVec<T, A> {
         -> Result<usize, CollectionAllocErr> {
 
         // Nothing we can really do about these checks :(
-        let required_cap = used_cap.checked_add(needed_extra_cap).ok_or(CapacityOverflow)?;
+        let required_cap = used_cap.checked_add(needed_extra_cap).ok_or(CollectionAllocErr::CapacityOverflow)?;
         // Cannot overflow, because `cap <= isize::MAX`, and type of `cap` is `usize`.
         let double_cap = self.cap * 2;
         // `double_cap` guarantees exponential growth.
@@ -489,8 +489,8 @@ impl<T, A: Alloc> RawVec<T, A> {
     /// ```
     pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {
         match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Amortized) {
-            Err(CapacityOverflow) => capacity_overflow(),
-            Err(AllocErr) => unreachable!(),
+            Err(CollectionAllocErr::CapacityOverflow) => capacity_overflow(),
+            Err(CollectionAllocErr::AllocErr) => unreachable!(),
             Ok(()) => { /* yay */ }
         }
     }
@@ -629,7 +629,7 @@ enum ReserveStrategy {
 
 use ReserveStrategy::*;
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     fn reserve_internal(
         &mut self,
         used_cap: usize,
@@ -638,8 +638,6 @@ impl<T, A: Alloc> RawVec<T, A> {
         strategy: ReserveStrategy,
     ) -> Result<(), CollectionAllocErr> {
         unsafe {
-            use crate::alloc::AllocErr;
-
             // NOTE: we don't early branch on ZSTs here because we want this
             // to actually catch "asking for more than usize::MAX" in that case.
             // If we make it past the first branch then we are guaranteed to
@@ -653,10 +651,10 @@ impl<T, A: Alloc> RawVec<T, A> {
 
             // Nothing we can really do about these checks :(
             let new_cap = match strategy {
-                Exact => used_cap.checked_add(needed_extra_cap).ok_or(CapacityOverflow)?,
+                Exact => used_cap.checked_add(needed_extra_cap).ok_or(CollectionAllocErr::CapacityOverflow)?,
                 Amortized => self.amortized_new_size(used_cap, needed_extra_cap)?,
             };
-            let new_layout = Layout::array::<T>(new_cap).map_err(|_| CapacityOverflow)?;
+            let new_layout = Layout::array::<T>(new_cap).map_err(|_| CollectionAllocErr::CapacityOverflow)?;
 
             alloc_guard(new_layout.size())?;
 
@@ -682,7 +680,7 @@ impl<T, A: Alloc> RawVec<T, A> {
 
 }
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     /// Converts the entire buffer into `Box<[T], A>`.
     ///
     /// Note that this will correctly reconstitute any `cap` changes
@@ -703,7 +701,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     }
 }
 
-impl<T, A: Alloc> RawVec<T, A> {
+impl<T, A: Alloc<Err = AllocErr>> RawVec<T, A> {
     /// Frees the memory owned by the RawVec *without* trying to Drop its contents.
     pub unsafe fn dealloc_buffer(&mut self) {
         let elem_size = mem::size_of::<T>();
@@ -715,7 +713,7 @@ impl<T, A: Alloc> RawVec<T, A> {
     }
 }
 
-unsafe impl<#[may_dangle] T, A: Alloc> Drop for RawVec<T, A> {
+unsafe impl<#[may_dangle] T, A: Alloc<Err = AllocErr>> Drop for RawVec<T, A> {
     /// Frees the memory owned by the RawVec *without* trying to Drop its contents.
     fn drop(&mut self) {
         unsafe { self.dealloc_buffer(); }
@@ -736,7 +734,7 @@ unsafe impl<#[may_dangle] T, A: Alloc> Drop for RawVec<T, A> {
 #[inline]
 fn alloc_guard(alloc_size: usize) -> Result<(), CollectionAllocErr> {
     if mem::size_of::<usize>() < 8 && alloc_size > core::isize::MAX as usize {
-        Err(CapacityOverflow)
+        Err(CollectionAllocErr::CapacityOverflow)
     } else {
         Ok(())
     }

src/liballoc/str.rs

@@ -35,7 +35,7 @@ use core::ptr;
 use core::iter::FusedIterator;
 use core::unicode::conversions;
 
-use crate::alloc::Alloc;
+use crate::alloc::{Alloc, AllocErr};
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
 use crate::slice::{SliceConcatExt, SliceIndex};
@@ -586,6 +586,6 @@ impl str {
 /// ```
 #[stable(feature = "str_box_extras", since = "1.20.0")]
 #[inline]
-pub unsafe fn from_boxed_utf8_unchecked<A: Alloc>(v: Box<[u8], A>) -> Box<str, A> {
+pub unsafe fn from_boxed_utf8_unchecked<A: Alloc<Err=AllocErr>>(v: Box<[u8], A>) -> Box<str, A> {
     Box::map_raw(v, |p| p as *mut str)
 }

src/liballoc/string.rs

@@ -991,7 +991,7 @@ impl String {
     /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?");
     /// ```
     #[unstable(feature = "try_reserve", reason = "new API", issue="48043")]
-    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr>  {
+    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {
         self.vec.try_reserve_exact(additional)
     }