refactor for object safety

uses separate trait so there's no generic associated types

Author: pitaj

compiler/rustc_serialize/src/serialize.rs

@@ -1,9 +1,8 @@
 //! Support code for encoding and decoding types.
 
-use std::alloc::Allocator;
+use std::alloc::{Allocator, Fatal};
 use std::borrow::Cow;
 use std::cell::{Cell, RefCell};
-use std::collections::TryReserveError;
 use std::marker::PhantomData;
 use std::path;
 use std::rc::Rc;
@@ -276,8 +275,7 @@ impl<D: Decoder, T> Decodable<D> for PhantomData<T> {
 
 impl<D: Decoder, A: Default, T: Decodable<D>> Decodable<D> for Box<[T], A>
 where
-    A: Allocator<Result<Vec<T, A>, TryReserveError> = Vec<T, A>>,
-    A: Allocator<Result<Box<[T], A>, TryReserveError> = Box<[T], A>>,
+    A: Allocator<ErrorHandling = Fatal>,
 {
     fn decode(d: &mut D) -> Box<[T], A> {
         let v: Vec<T, A> = Decodable::decode(d);
@@ -315,7 +313,7 @@ impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> {
 
 impl<D: Decoder, T: Decodable<D>, A: Default> Decodable<D> for Vec<T, A>
 where
-    A: Allocator<Result<Vec<T, A>, TryReserveError> = Vec<T, A>>,
+    A: Allocator<ErrorHandling = Fatal>,
 {
     default fn decode(d: &mut D) -> Vec<T, A> {
         let len = d.read_usize();

library/alloc/src/alloc.rs

@@ -2,8 +2,6 @@
 
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
-#[cfg(not(test))]
-use core::error::Error;
 #[cfg(not(test))]
 use core::intrinsics;
 use core::intrinsics::{min_align_of_val, size_of_val};
@@ -13,10 +11,10 @@ use core::ptr::Unique;
 use core::ptr::{self, NonNull};
 
 #[unstable(feature = "allocator_api", issue = "32838")]
-pub use crate::falloc::{Allocator, FallibleAdapter};
+pub use crate::falloc::{Allocator, Fallible};
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[cfg(not(no_global_oom_handling))]
-pub use crate::falloc::{HandleAllocError, InfallibleAdapter};
+pub use crate::falloc::{FallibleAdapter, Fatal, HandleAllocError, InfallibleAdapter};
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
 #[allow(deprecated)]
@@ -331,25 +329,9 @@ unsafe impl Allocator for Global {
     }
 
     #[cfg(not(no_global_oom_handling))]
-    type Result<T, E: Error> = T
-    where
-        E: HandleAllocError;
-
-    #[cfg(not(no_global_oom_handling))]
-    fn map_result<T, E: Error>(result: Result<T, E>) -> Self::Result<T, E>
-    where
-        E: HandleAllocError,
-    {
-        result.unwrap_or_else(|e| e.handle_alloc_error())
-    }
-
-    #[cfg(no_global_oom_handling)]
-    type Result<T, E: Error> = Result<T, E>;
-
+    type ErrorHandling = Fatal;
     #[cfg(no_global_oom_handling)]
-    fn map_result<T, E: Error>(result: Result<T, E>) -> Self::Result<T, E> {
-        result
-    }
+    type ErrorHandling = Fallible;
 }
 
 /// The allocator for unique pointers.

library/alloc/src/boxed.rs

@@ -170,7 +170,9 @@ use crate::alloc::{handle_alloc_error, WriteCloneIntoRaw};
 #[cfg(not(no_global_oom_handling))]
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
-use crate::falloc::{AllocError, Allocator, Global, Layout};
+#[cfg(not(no_global_oom_handling))]
+use crate::falloc::Fatal;
+use crate::falloc::{AllocError, AllocResult, Allocator, ErrorHandling, Global, Layout};
 use crate::raw_vec::RawVec;
 #[cfg(not(no_global_oom_handling))]
 use crate::str::from_boxed_utf8_unchecked;
@@ -626,7 +628,8 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         unsafe {
-            <Global as Allocator>::map_result(RawVec::with_capacity_in(len, Global)).into_box(len)
+            <Global as Allocator>::ErrorHandling::map_result(RawVec::with_capacity_in(len, Global))
+                .into_box(len)
         }
     }
 
@@ -653,8 +656,10 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         unsafe {
-            <Global as Allocator>::map_result(RawVec::with_capacity_zeroed_in(len, Global))
-                .into_box(len)
+            <Global as Allocator>::ErrorHandling::map_result(RawVec::with_capacity_zeroed_in(
+                len, Global,
+            ))
+            .into_box(len)
         }
     }
 
@@ -741,8 +746,12 @@ impl<T, A: Allocator> Box<[T], A> {
     pub fn new_uninit_slice_in(
         len: usize,
         alloc: A,
-    ) -> A::Result<Box<[mem::MaybeUninit<T>], A>, TryReserveError> {
-        unsafe { A::map_result(RawVec::with_capacity_in(len, alloc).map(|r| r.into_box(len))) }
+    ) -> AllocResult<A, Box<[mem::MaybeUninit<T>], A>, TryReserveError> {
+        unsafe {
+            A::ErrorHandling::map_result(
+                RawVec::with_capacity_in(len, alloc).map(|r| r.into_box(len)),
+            )
+        }
     }
 
     /// Constructs a new boxed slice with uninitialized contents in the provided allocator,
@@ -771,9 +780,11 @@ impl<T, A: Allocator> Box<[T], A> {
     pub fn new_zeroed_slice_in(
         len: usize,
         alloc: A,
-    ) -> A::Result<Box<[mem::MaybeUninit<T>], A>, TryReserveError> {
+    ) -> AllocResult<A, Box<[mem::MaybeUninit<T>], A>, TryReserveError> {
         unsafe {
-            A::map_result(RawVec::with_capacity_zeroed_in(len, alloc).map(|r| r.into_box(len)))
+            A::ErrorHandling::map_result(
+                RawVec::with_capacity_zeroed_in(len, alloc).map(|r| r.into_box(len)),
+            )
         }
     }
 }
@@ -1474,7 +1485,8 @@ impl<T: Copy> BoxFromSlice<T> for Box<[T]> {
     #[inline]
     fn from_slice(slice: &[T]) -> Self {
         let len = slice.len();
-        let buf = <Global as Allocator>::map_result(RawVec::with_capacity_in(len, Global));
+        let buf =
+            <Global as Allocator>::ErrorHandling::map_result(RawVec::with_capacity_in(len, Global));
         unsafe {
             ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
             buf.into_box(slice.len()).assume_init()
@@ -2018,12 +2030,7 @@ impl<I> FromIterator<I> for Box<[I]> {
 #[stable(feature = "box_slice_clone", since = "1.3.0")]
 impl<T: Clone, A: Clone> Clone for Box<[T], A>
 where
-    // Would like to see something like this work eventually,
-    // using `feature(non_lifetime_binders)` (#108185), but
-    // for now we'll have to enumerate each case that's needed.
-    // A: for<X, Y> Allocator<Result<X, Y> = X>,
-    A: Allocator<Result<Vec<T, A>, TryReserveError> = Vec<T, A>>,
-    A: Allocator<Result<Self, TryReserveError> = Self>,
+    A: Allocator<ErrorHandling = Fatal>,
 {
     fn clone(&self) -> Self {
         let alloc = Box::allocator(self).clone();

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

@@ -24,7 +24,7 @@ use core::mem;
 
 use crate::collections::TryReserveError;
 use crate::collections::TryReserveErrorKind;
-use crate::falloc::{Allocator, Global};
+use crate::falloc::{AllocResult, Allocator, ErrorHandling, Fatal, Global};
 use crate::raw_vec::RawVec;
 use crate::vec::Vec;
 
@@ -108,7 +108,7 @@ pub struct VecDeque<
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone, A> Clone for VecDeque<T, A>
 where
-    A: Allocator<Result<Self, TryReserveError> = Self> + Clone,
+    A: Allocator<ErrorHandling = Fatal> + Clone,
 {
     fn clone(&self) -> Self {
         let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone());
@@ -597,8 +597,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     pub fn with_capacity_in(
         capacity: usize,
         alloc: A,
-    ) -> A::Result<VecDeque<T, A>, TryReserveError> {
-        A::map_result(Self::try_with_capacity_in(capacity, alloc))
+    ) -> AllocResult<A, VecDeque<T, A>, TryReserveError> {
+        A::ErrorHandling::map_result(Self::try_with_capacity_in(capacity, alloc))
     }
 
     /// Creates a `VecDeque` from a raw allocation, when the initialized
@@ -761,8 +761,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     ///
     /// [`reserve`]: VecDeque::reserve
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: usize) -> A::Result<(), TryReserveError> {
-        A::map_result(self.try_reserve_exact(additional))
+    pub fn reserve_exact(&mut self, additional: usize) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result(self.try_reserve_exact(additional))
     }
 
     /// Reserves capacity for at least `additional` more elements to be inserted in the given
@@ -782,8 +782,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert!(buf.capacity() >= 11);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: usize) -> A::Result<(), TryReserveError> {
-        A::map_result(self.try_reserve(additional))
+    pub fn reserve(&mut self, additional: usize) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result(self.try_reserve(additional))
     }
 
     /// Tries to reserve the minimum capacity for at least `additional` more elements to
@@ -928,8 +928,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert!(buf.capacity() >= 4);
     /// ```
     #[stable(feature = "shrink_to", since = "1.56.0")]
-    pub fn shrink_to(&mut self, min_capacity: usize) -> A::Result<(), TryReserveError> {
-        A::map_result((|| {
+    pub fn shrink_to(&mut self, min_capacity: usize) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result((|| {
             // Substitute for try block
             let target_cap = min_capacity.max(self.len);
 
@@ -1625,8 +1625,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(d.front(), Some(&2));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_front(&mut self, value: T) -> A::Result<(), TryReserveError> {
-        A::map_result((|| {
+    pub fn push_front(&mut self, value: T) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result((|| {
             // Substitute for try block
             if self.is_full() {
                 self.grow()?;
@@ -1656,8 +1656,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(3, *buf.back().unwrap());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_back(&mut self, value: T) -> A::Result<(), TryReserveError> {
-        A::map_result((|| {
+    pub fn push_back(&mut self, value: T) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result((|| {
             // Substsitute for try block
             if self.is_full() {
                 self.grow()?;
@@ -1770,8 +1770,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);
     /// ```
     #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn insert(&mut self, index: usize, value: T) -> A::Result<(), TryReserveError> {
-        A::map_result((|| {
+    pub fn insert(&mut self, index: usize, value: T) -> AllocResult<A, (), TryReserveError> {
+        A::ErrorHandling::map_result((|| {
             // Substitute for try block
             assert!(index <= self.len(), "index out of bounds");
             if self.is_full() {
@@ -1877,11 +1877,11 @@ impl<T, A: Allocator> VecDeque<T, A> {
     #[inline]
     #[must_use = "use `.truncate()` if you don't need the other half"]
     #[stable(feature = "split_off", since = "1.4.0")]
-    pub fn split_off(&mut self, at: usize) -> A::Result<Self, TryReserveError>
+    pub fn split_off(&mut self, at: usize) -> AllocResult<A, Self, TryReserveError>
     where
         A: Clone,
     {
-        A::map_result((|| {
+        A::ErrorHandling::map_result((|| {
             let len = self.len;
             assert!(at <= len, "`at` out of bounds");