Merge branch 'infallibility-2' into infallibility

Author: Ericson2314

src/alloc/abort.rs

@@ -1,41 +1,38 @@
-//! 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.
+#![allow(clippy::use_self)]
 
-use core::{ptr::NonNull, usize};
+use crate::alloc::{handle_alloc_error, AllocRef, BuildAllocRef, DeallocRef, NonZeroUsize, NonZeroLayout, ReallocRef};
+use core::ptr::NonNull;
 
-use crate::alloc::*;
-
-/// An allocator adapter that blows up by calling `handle_alloc_error` on all errors.
+/// An allocator adapter that blows up by calling `handle_alloc_error` on OOM.
+///
+/// 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.
 ///
-/// See the [module-level documentation](../../std/abort_adapter/index.html) for more.
+/// This adapter bridges the gap, effectively allowing `Alloc<Err=!>` to be
+/// implemented by any allocator.
 #[derive(Copy, Clone, Debug, Default)]
 pub struct AbortAlloc<Alloc>(pub Alloc);
 
-impl<B: BuildAllocRef> BuildAllocRef for AbortAlloc<B> {
-    type Ref = AbortAlloc<B::Ref>;
+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 {
-        AbortAlloc(self.0.build_alloc_ref(ptr, layout))
+        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 {
-        AbortAlloc(self.0.get_build_alloc())
+        Self(self.0.get_build_alloc())
     }
 
     unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: NonZeroLayout) {
@@ -49,13 +46,13 @@ impl<A: AllocRef> AllocRef for AbortAlloc<A> {
     fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         self.0
             .alloc(layout)
-            .or_else(|_| handle_alloc_error(layout.into()))
+            .map_err(|_| handle_alloc_error(layout.into()))
     }
 
     fn alloc_zeroed(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
         self.0
             .alloc_zeroed(layout)
-            .or_else(|_| handle_alloc_error(layout.into()))
+            .map_err(|_| handle_alloc_error(layout.into()))
     }
 
     fn usable_size(&self, layout: NonZeroLayout) -> (usize, usize) {
@@ -90,6 +87,6 @@ impl<A: ReallocRef> ReallocRef for AbortAlloc<A> {
     ) -> Result<NonNull<u8>, Self::Error> {
         self.0
             .realloc(ptr, old_layout, new_layout)
-            .or_else(|_| handle_alloc_error(new_layout.into()))
+            .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,
@@ -13,9 +17,6 @@ pub use liballoc::alloc::{handle_alloc_error, Layout};
 #[cfg(feature = "std")]
 use std::alloc::System;
 
-mod abort;
-pub use self::abort::AbortAlloc;
-
 /// Allocate memory with the global allocator.
 ///
 /// This function forwards calls to the [`GlobalAlloc::alloc`] method

src/boxed.rs

@@ -176,10 +176,13 @@ 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)]
@@ -222,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:
@@ -280,7 +286,7 @@ impl<T, A: AllocRef> Box<T, A> {
     #[inline(always)]
     pub fn pin_in(x: T, a: A) -> Pin<Self>
     where
-        A: AllocRef<Error = !>,
+        A: AllocRef<Error = !>
     {
         let Ok(b) = Self::try_pin_in(x, a);
         b
@@ -331,9 +337,12 @@ impl<T, A: AllocRef<Error = !>> 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:
@@ -777,7 +786,7 @@ where
 #[allow(clippy::use_self)]
 impl<T, A: AllocRef<Error = !>> Default for Box<[T], A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     #[must_use]
     fn default() -> Self {
@@ -794,7 +803,7 @@ unsafe fn from_boxed_utf8_unchecked<A: DeallocRef>(v: Box<[u8], A>) -> Box<str,
 #[allow(clippy::use_self)]
 impl<A: AllocRef<Error = !>> Default for Box<str, A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     #[must_use]
     fn default() -> Self {
@@ -804,7 +813,7 @@ where
 
 impl<T: Clone, A: AllocRef<Error = !>> 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.
@@ -971,7 +980,7 @@ impl<T: ?Sized + Hasher, A: DeallocRef> Hasher for Box<T, A> {
 
 impl<T, A: AllocRef<Error = !>> From<T> for Box<T, A>
 where
-    A: Default + AllocRef,
+    A: Default + AllocRef<Error = !>,
 {
     /// Converts a generic type `T` into a `Box<T>`
     ///
@@ -1288,8 +1297,11 @@ 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>

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>;
 }

src/raw_vec.rs

@@ -1,12 +1,12 @@
 use crate::{
     alloc::{
+        AbortAlloc,
         AllocRef,
         BuildAllocRef,
         CapacityOverflow,
         DeallocRef,
         Global,
         NonZeroLayout,
-        AbortAlloc,
         ReallocRef,
     },
     boxed::Box,
@@ -634,7 +634,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// * on 32-bit platforms if the requested capacity exceeds `isize::MAX` bytes.
     pub fn reserve_exact(&mut self, used_capacity: usize, needed_extra_capacity: usize)
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         match self.try_reserve_exact(used_capacity, needed_extra_capacity) {
             Ok(_) => (),
@@ -736,7 +736,7 @@ impl<T, A: DeallocRef> RawVec<T, A> {
     /// Panics if the given amount is *larger* than the current capacity.
     pub fn shrink_to_fit(&mut self, amount: usize)
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         match self.try_shrink_to_fit(amount) {
             Ok(_) => (),

src/string.rs

@@ -52,7 +52,7 @@
 //! ```
 
 use crate::{
-    alloc::{AllocRef, DeallocRef, Global, AbortAlloc, ReallocRef},
+    alloc::{AbortAlloc, AllocRef, DeallocRef, Global, ReallocRef},
     boxed::Box,
     collections::CollectionAllocErr,
     iter::TryExtend,
@@ -1069,7 +1069,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn reserve_exact(&mut self, additional: usize)
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         self.vec.reserve_exact(additional)
     }
@@ -1088,9 +1088,13 @@ impl<A: DeallocRef> String<A> {
     /// # Examples
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, collections::CollectionAllocErr, string::String};
+    /// use alloc_wg::{
+    ///     alloc::{AbortAlloc, Global},
+    ///     collections::CollectionAllocErr,
+    ///     string::String,
+    /// };
     ///
-    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr<Global>> {
+    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr<AbortAlloc<Global>>> {
     ///     let mut output = String::new();
     ///
     ///     // Pre-reserve the memory, exiting if we can't
@@ -1127,9 +1131,13 @@ impl<A: DeallocRef> String<A> {
     /// # Examples
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, collections::CollectionAllocErr, string::String};
+    /// use alloc_wg::{
+    ///     alloc::{AbortAlloc, Global},
+    ///     collections::CollectionAllocErr,
+    ///     string::String,
+    /// };
     ///
-    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr<Global>> {
+    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr<AbortAlloc<Global>>> {
     ///     let mut output = String::new();
     ///
     ///     // Pre-reserve the memory, exiting if we can't
@@ -1172,7 +1180,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn shrink_to_fit(&mut self)
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         self.vec.shrink_to_fit()
     }
@@ -1216,7 +1224,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn shrink_to(&mut self, min_capacity: usize)
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         self.vec.shrink_to(min_capacity)
     }
@@ -1598,7 +1606,7 @@ impl<A: DeallocRef> String<A> {
     #[inline]
     pub fn try_insert_str(&mut self, idx: usize, string: &str) -> Result<(), CollectionAllocErr<A>>
     where
-        A: ReallocRef,
+        A: ReallocRef<Error = !>,
     {
         assert!(self.is_char_boundary(idx));