Use old name

Author: Ericson2314

src/alloc/mod.rs

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

src/alloc/panic_adaptor.rs

@@ -17,33 +17,33 @@ use crate::alloc::*;
 ///
 /// See the [module-level documentation](../../std/abort_adapter/index.html) for more.
 #[derive(Copy, Clone, Debug, Default)]
-pub struct PanicAdapter<Alloc>(pub Alloc);
+pub struct AbortAlloc<Alloc>(pub Alloc);
 
-impl<B: BuildAllocRef> BuildAllocRef for PanicAdapter<B> {
-    type Ref = PanicAdapter<B::Ref>;
+impl<B: BuildAllocRef> BuildAllocRef for AbortAlloc<B> {
+    type Ref = AbortAlloc<B::Ref>;
 
     unsafe fn build_alloc_ref(
         &mut self,
         ptr: NonNull<u8>,
         layout: Option<NonZeroLayout>,
     ) -> Self::Ref {
-        PanicAdapter(self.0.build_alloc_ref(ptr, layout))
+        AbortAlloc(self.0.build_alloc_ref(ptr, layout))
     }
 }
 
-impl<A: DeallocRef> DeallocRef for PanicAdapter<A> {
-    type BuildAlloc = PanicAdapter<A::BuildAlloc>;
+impl<A: DeallocRef> DeallocRef for AbortAlloc<A> {
+    type BuildAlloc = AbortAlloc<A::BuildAlloc>;
 
     fn get_build_alloc(&mut self) -> Self::BuildAlloc {
-        PanicAdapter(self.0.get_build_alloc())
+        AbortAlloc(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 PanicAdapter<A> {
+impl<A: AllocRef> AllocRef for AbortAlloc<A> {
     type Error = !;
 
     fn alloc(&mut self, layout: NonZeroLayout) -> Result<NonNull<u8>, Self::Error> {
@@ -81,7 +81,7 @@ impl<A: AllocRef> AllocRef for PanicAdapter<A> {
     }
 }
 
-impl<A: ReallocRef> ReallocRef for PanicAdapter<A> {
+impl<A: ReallocRef> ReallocRef for AbortAlloc<A> {
     unsafe fn realloc(
         &mut self,
         ptr: NonNull<u8>,

src/boxed.rs

@@ -79,7 +79,7 @@
 //! [`NonZeroLayout::for_value(&*value)`]: crate::alloc::NonZeroLayout::for_value
 
 use crate::{
-    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout, PanicAdapter},
+    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, NonZeroLayout, AbortAlloc},
     clone::CloneIn,
     collections::CollectionAllocErr,
     raw_vec::RawVec,
@@ -104,7 +104,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 = PanicAdapter<Global>> {
+pub struct Box<T: ?Sized, A: DeallocRef = AbortAlloc<Global>> {
     ptr: Unique<T>,
     build_alloc: A::BuildAlloc,
 }
@@ -130,7 +130,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new(x: T) -> Self {
-        Self::new_in(x, PanicAdapter(Global))
+        Self::new_in(x, AbortAlloc(Global))
     }
 
     /// Constructs a new box with uninitialized contents.
@@ -155,7 +155,7 @@ impl<T> Box<T> {
     #[inline(always)]
     #[must_use]
     pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
-        Self::new_uninit_in(PanicAdapter(Global))
+        Self::new_uninit_in(AbortAlloc(Global))
     }
 
     /// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
@@ -320,7 +320,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, PanicAdapter(Global))
+        Self::new_uninit_slice_in(len, AbortAlloc(Global))
     }
 }
 
@@ -522,7 +522,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, PanicAdapter(Global))
+        Self::from_raw_in(raw, AbortAlloc(Global))
     }
 }
 

src/raw_vec.rs

@@ -6,7 +6,7 @@ use crate::{
         DeallocRef,
         Global,
         NonZeroLayout,
-        PanicAdapter,
+        AbortAlloc,
         ReallocRef,
     },
     boxed::Box,
@@ -50,7 +50,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 = PanicAdapter<Global>> {
+pub struct RawVec<T, A: DeallocRef = AbortAlloc<Global>> {
     ptr: Unique<T>,
     capacity: usize,
     build_alloc: A::BuildAlloc,
@@ -88,7 +88,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: PanicAdapter(Global),
+            build_alloc: AbortAlloc(Global),
         }
     }
 
@@ -109,7 +109,7 @@ impl<T> RawVec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, PanicAdapter(Global))
+        Self::with_capacity_in(capacity, AbortAlloc(Global))
     }
 
     /// Like `with_capacity`, but guarantees the buffer is zeroed.
@@ -125,7 +125,7 @@ impl<T> RawVec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity_zeroed(capacity: usize) -> Self {
-        Self::with_capacity_zeroed_in(capacity, PanicAdapter(Global))
+        Self::with_capacity_zeroed_in(capacity, AbortAlloc(Global))
     }
 
     /// Reconstitutes a `RawVec` from a pointer, and capacity.
@@ -137,7 +137,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, PanicAdapter(Global))
+        Self::from_raw_parts_in(ptr, capacity, AbortAlloc(Global))
     }
 }
 

src/string.rs

@@ -52,7 +52,7 @@
 //! ```
 
 use crate::{
-    alloc::{AllocRef, DeallocRef, Global, PanicAdapter, ReallocRef},
+    alloc::{AllocRef, DeallocRef, Global, AbortAlloc, 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 = PanicAdapter<Global>> {
+pub struct String<A: DeallocRef = AbortAlloc<Global>> {
     vec: Vec<u8, A>,
 }
 
@@ -354,7 +354,7 @@ pub struct String<A: DeallocRef = PanicAdapter<Global>> {
 /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
 /// ```
 #[derive(Debug)]
-pub struct FromUtf8Error<A: DeallocRef = PanicAdapter<Global>> {
+pub struct FromUtf8Error<A: DeallocRef = AbortAlloc<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, PanicAdapter(Global))
+        Self::with_capacity_in(capacity, AbortAlloc(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, PanicAdapter(Global))
+        Self::from_utf16_in(v, AbortAlloc(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, PanicAdapter(Global))
+        Self::from_raw_parts_in(buf, length, capacity, AbortAlloc(Global))
     }
 }
 

src/vec.rs

@@ -69,7 +69,7 @@
 //! [`vec!`]: ../macro.vec.html
 
 use crate::{
-    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, PanicAdapter, ReallocRef},
+    alloc::{AllocRef, BuildAllocRef, DeallocRef, Global, AbortAlloc, ReallocRef},
     boxed::Box,
     clone::CloneIn,
     collections::CollectionAllocErr,
@@ -328,7 +328,7 @@ use core::{
 /// [`insert`]: Self::insert()
 /// [`reserve`]: Self::reserve
 /// [owned slice]: crate::boxed::Box
-pub struct Vec<T, A: DeallocRef = PanicAdapter<Global>> {
+pub struct Vec<T, A: DeallocRef = AbortAlloc<Global>> {
     buf: RawVec<T, A>,
     len: usize,
 }
@@ -401,7 +401,7 @@ impl<T> Vec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, PanicAdapter(Global))
+        Self::with_capacity_in(capacity, AbortAlloc(Global))
     }
 
     /// Creates a `Vec<T>` directly from the raw components of another vector.
@@ -664,7 +664,7 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// # Examples
     ///
     /// ```
-    /// use alloc_wg::{alloc::PanicAdapter<Global>, collections::CollectionAllocErr, vec::Vec};
+    /// use alloc_wg::{alloc::AbortAlloc<Global>, collections::CollectionAllocErr, vec::Vec};
     ///
     /// fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr<Global>> {
     ///     let mut output = Vec::new();
@@ -2037,7 +2037,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, PanicAdapter(Global))
+    from_elem_in(elem, n, AbortAlloc(Global))
 }
 
 #[doc(hidden)]
@@ -2280,9 +2280,9 @@ 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, PanicAdapter<Global>>>::from_iter_in(
+        <Self as SpecExtend<T, I::IntoIter, AbortAlloc<Global>>>::from_iter_in(
             iter.into_iter(),
-            PanicAdapter(Global),
+            AbortAlloc(Global),
         )
     }
 }
@@ -2923,7 +2923,7 @@ impl From<&str> for Vec<u8> {
 ///
 /// [`Vec`]: struct.Vec.html
 /// [`IntoIterator`]: ../../std/iter/trait.IntoIterator.html
-pub struct IntoIter<T, A: DeallocRef = PanicAdapter<Global>> {
+pub struct IntoIter<T, A: DeallocRef = AbortAlloc<Global>> {
     buf: RawVec<T, A>,
     ptr: *const T,
     end: *const T,
@@ -3069,7 +3069,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 = PanicAdapter<Global>> {
+pub struct Drain<'a, T, A: DeallocRef = AbortAlloc<Global>> {
     /// Index of tail to preserve
     tail_start: usize,
     /// Length of tail
@@ -3162,7 +3162,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 = PanicAdapter<Global>>
+pub struct Splice<'a, I: Iterator + 'a, A = AbortAlloc<Global>>
 where
     A: ReallocRef<Error = !>, // Because Drop can allocate
 {
@@ -3284,7 +3284,7 @@ where
 
 /// An iterator produced by calling `drain_filter` on Vec.
 // #[derive(Debug)]
-pub struct DrainFilter<'a, T, F, A: DeallocRef = PanicAdapter<Global>>
+pub struct DrainFilter<'a, T, F, A: DeallocRef = AbortAlloc<Global>>
 where
     F: FnMut(&mut T) -> bool,
 {
@@ -3347,7 +3347,7 @@ where
     F: FnMut(&mut T) -> bool,
 {
     fn drop(&mut self) {
-        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef = PanicAdapter<Global>>
+        struct BackshiftOnDrop<'a, 'b, T, F, A: DeallocRef = AbortAlloc<Global>>
         where
             F: FnMut(&mut T) -> bool,
         {