Switch defaults to PanicHandler<Global>

Author: Ericson2314

src/alloc/mod.rs

@@ -14,6 +14,7 @@ pub use liballoc::alloc::{handle_alloc_error, Layout};
 use std::alloc::System;
 
 mod panic_adaptor;
+pub use self::panic_adaptor::PanicAdapter;
 
 /// Allocate memory with the global allocator.
 ///

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::{AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout, PanicAdapter},
     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 = PanicAdapter<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, PanicAdapter(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(PanicAdapter(Global))
     }
 
     /// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
@@ -309,7 +309,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, PanicAdapter(Global))
     }
 }
 
@@ -503,7 +503,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, PanicAdapter(Global))
     }
 }
 

src/raw_vec.rs

@@ -7,6 +7,7 @@ use crate::{
         DeallocRef,
         Global,
         NonZeroLayout,
+        PanicAdapter,
         ReallocRef,
     },
     boxed::Box,
@@ -51,7 +52,7 @@ use core::{
 /// field. This allows zero-sized types to not be special-cased by consumers of
 /// this type.
 // Using `NonNull` + `PhantomData` instead of `Unique` to stay on stable as long as possible
-pub struct RawVec<T, A: DeallocRef = Global> {
+pub struct RawVec<T, A: DeallocRef = PanicAdapter<Global>> {
     ptr: Unique<T>,
     capacity: usize,
     build_alloc: A::BuildAlloc,
@@ -89,7 +90,7 @@ impl<T> RawVec<T> {
             ptr: Unique::empty(),
             // FIXME(mark-i-m): use `cap` when ifs are allowed in const
             capacity: [0, !0][(mem::size_of::<T>() == 0) as usize],
-            build_alloc: Global,
+            build_alloc: PanicAdapter(Global),
         }
     }
 
@@ -110,7 +111,7 @@ impl<T> RawVec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, Global)
+        Self::with_capacity_in(capacity, PanicAdapter(Global))
     }
 
     /// Like `with_capacity`, but guarantees the buffer is zeroed.
@@ -126,7 +127,7 @@ impl<T> RawVec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity_zeroed(capacity: usize) -> Self {
-        Self::with_capacity_zeroed_in(capacity, Global)
+        Self::with_capacity_zeroed_in(capacity, PanicAdapter(Global))
     }
 
     /// Reconstitutes a `RawVec` from a pointer, and capacity.
@@ -138,7 +139,7 @@ impl<T> RawVec<T> {
     /// If the ptr and capacity come from a `RawVec` created with `Global`, then this is guaranteed.
     #[inline]
     pub unsafe fn from_raw_parts(ptr: *mut T, capacity: usize) -> Self {
-        Self::from_raw_parts_in(ptr, capacity, Global)
+        Self::from_raw_parts_in(ptr, capacity, PanicAdapter(Global))
     }
 }
 

src/string.rs

@@ -52,7 +52,7 @@
 //! ```
 
 use crate::{
-    alloc::{AllocRef, DeallocRef, Global, ReallocRef},
+    alloc::{AllocRef, DeallocRef, Global, PanicAdapter, ReallocRef},
     boxed::Box,
     collections::CollectionAllocErr,
     iter::TryExtend,
@@ -312,7 +312,7 @@ pub use liballoc::string::{ParseError, ToString};
 /// [`Deref`]: ../../std/ops/trait.Deref.html
 /// [`as_str()`]: struct.String.html#method.as_str
 #[derive(PartialOrd, Eq, Ord)]
-pub struct String<A: DeallocRef = Global> {
+pub struct String<A: DeallocRef = PanicAdapter<Global>> {
     vec: Vec<u8, A>,
 }
 
@@ -354,7 +354,7 @@ pub struct String<A: DeallocRef = Global> {
 /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
 /// ```
 #[derive(Debug)]
-pub struct FromUtf8Error<A: DeallocRef = Global> {
+pub struct FromUtf8Error<A: DeallocRef = PanicAdapter<Global>> {
     bytes: Vec<u8, A>,
     error: Utf8Error,
 }
@@ -451,7 +451,7 @@ impl String {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, Global)
+        Self::with_capacity_in(capacity, PanicAdapter(Global))
     }
 
     /// Decode a UTF-16 encoded vector `v` into a `String`, returning [`Err`]
@@ -475,7 +475,7 @@ impl String {
     /// assert!(String::from_utf16(v).is_err());
     /// ```
     pub fn from_utf16(v: &[u16]) -> Result<Self, FromUtf16Error> {
-        Self::from_utf16_in(v, Global)
+        Self::from_utf16_in(v, PanicAdapter(Global))
     }
 
     /// Decode a UTF-16 encoded slice `v` into a `String`, replacing
@@ -560,7 +560,7 @@ impl String {
     /// ```
     #[inline]
     pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> Self {
-        Self::from_raw_parts_in(buf, length, capacity, Global)
+        Self::from_raw_parts_in(buf, length, capacity, PanicAdapter(Global))
     }
 }
 

src/vec.rs

@@ -69,7 +69,15 @@
 //! [`vec!`]: ../macro.vec.html
 
 use crate::{
-    alloc::{handle_alloc_error, AllocRef, BuildAllocRef, DeallocRef, Global, ReallocRef},
+    alloc::{
+        handle_alloc_error,
+        AllocRef,
+        BuildAllocRef,
+        DeallocRef,
+        Global,
+        PanicAdapter,
+        ReallocRef,
+    },
     boxed::Box,
     clone::CloneIn,
     collections::CollectionAllocErr,
@@ -328,7 +336,7 @@ use core::{
 /// [`insert`]: Self::insert()
 /// [`reserve`]: Self::reserve
 /// [owned slice]: crate::boxed::Box
-pub struct Vec<T, A: DeallocRef = Global> {
+pub struct Vec<T, A: DeallocRef = PanicAdapter<Global>> {
     buf: RawVec<T, A>,
     len: usize,
 }
@@ -401,7 +409,7 @@ impl<T> Vec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, Global)
+        Self::with_capacity_in(capacity, PanicAdapter(Global))
     }
 
     /// Creates a `Vec<T>` directly from the raw components of another vector.
@@ -664,7 +672,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// # Examples
     ///
     /// ```
-    /// use alloc_wg::{alloc::Global, collections::CollectionAllocErr, vec::Vec};
+    /// use alloc_wg::{alloc::PanicAdapter<Global>, collections::CollectionAllocErr, vec::Vec};
     ///
     /// fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr<Global>> {
     ///     let mut output = Vec::new();
@@ -2024,7 +2032,7 @@ impl<T: PartialEq, A: DeallocRef> Vec<T, A> {
 
 #[doc(hidden)]
 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
-    from_elem_in(elem, n, Global)
+    from_elem_in(elem, n, PanicAdapter(Global))
 }
 
 #[doc(hidden)]
@@ -2267,7 +2275,10 @@ impl<T> FromIterator<T> for Vec<T> {
     #[inline]
     #[must_use]
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        <Self as SpecExtend<T, I::IntoIter, Global>>::from_iter_in(iter.into_iter(), Global)
+        <Self as SpecExtend<T, I::IntoIter, PanicAdapter<Global>>>::from_iter_in(
+            iter.into_iter(),
+            PanicAdapter(Global),
+        )
     }
 }
 
@@ -2896,7 +2907,7 @@ impl From<&str> for Vec<u8> {
 ///
 /// [`Vec`]: struct.Vec.html
 /// [`IntoIterator`]: ../../std/iter/trait.IntoIterator.html
-pub struct IntoIter<T, A: DeallocRef = Global> {
+pub struct IntoIter<T, A: DeallocRef = PanicAdapter<Global>> {
     buf: RawVec<T, A>,
     ptr: *const T,
     end: *const T,
@@ -3042,7 +3053,7 @@ impl<T, A: DeallocRef> Drop for IntoIter<T, A> {
 ///
 /// [`drain`]: struct.Vec.html#method.drain
 /// [`Vec`]: struct.Vec.html
-pub struct Drain<'a, T, A: DeallocRef = Global> {
+pub struct Drain<'a, T, A: DeallocRef = PanicAdapter<Global>> {
     /// Index of tail to preserve
     tail_start: usize,
     /// Length of tail
@@ -3135,7 +3146,7 @@ impl<T, A: DeallocRef> FusedIterator for Drain<'_, T, A> {}
 /// [`splice()`]: struct.Vec.html#method.splice
 /// [`Vec`]: struct.Vec.html
 #[derive(Debug)]
-pub struct Splice<'a, I: Iterator + 'a, A = Global>
+pub struct Splice<'a, I: Iterator + 'a, A = PanicAdapter<Global>>
 where
     A: ReallocRef,
 {
@@ -3257,7 +3268,7 @@ where
 
 /// An iterator produced by calling `drain_filter` on Vec.
 // #[derive(Debug)]
-pub struct DrainFilter<'a, T, F, A: DeallocRef = Global>
+pub struct DrainFilter<'a, T, F, A: DeallocRef = PanicAdapter<Global>>
 where
     F: FnMut(&mut T) -> bool,
 {
@@ -3320,7 +3331,7 @@ where
     F: FnMut(&mut T) -> bool,
 {
     fn drop(&mut self) {
-        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef = Global>
+        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef = PanicAdapter<Global>>
         where
             F: FnMut(&mut T) -> bool,
         {