move to core to fix tests

Author: pitaj

library/alloc/src/alloc.rs

@@ -10,15 +10,9 @@ use core::ptr::Unique;
 #[cfg(not(test))]
 use core::ptr::{self, NonNull};
 
-#[unstable(feature = "allocator_api", issue = "32838")]
-pub use crate::falloc::{Allocator, Fallible};
-#[unstable(feature = "allocator_api", issue = "32838")]
-#[cfg(not(no_global_oom_handling))]
-pub use crate::falloc::{FallibleAdapter, Fatal, HandleAllocError, InfallibleAdapter};
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
-#[allow(deprecated)]
-pub use core::alloc::{AllocError, GlobalAlloc, Layout, LayoutErr, LayoutError};
+pub use core::alloc::*;
 
 #[cfg(test)]
 mod tests;
@@ -454,3 +448,28 @@ impl<T: Copy> WriteCloneIntoRaw for T {
         unsafe { target.copy_from_nonoverlapping(self, 1) };
     }
 }
+
+#[cfg(not(no_global_oom_handling))]
+use crate::collections::{TryReserveError, TryReserveErrorKind};
+
+// One central function responsible for reporting capacity overflows. This'll
+// ensure that the code generation related to these panics is minimal as there's
+// only one location which panics rather than a bunch throughout the module.
+#[cfg(not(no_global_oom_handling))]
+pub(crate) fn capacity_overflow() -> ! {
+    panic!("capacity overflow");
+}
+
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "allocator_api", issue = "32838")]
+impl HandleAllocError for TryReserveError {
+    fn handle_alloc_error(self) -> ! {
+        match self.kind() {
+            TryReserveErrorKind::CapacityOverflow => capacity_overflow(),
+            TryReserveErrorKind::AllocError { layout, .. } => handle_alloc_error(layout),
+        }
+    }
+}
+
+pub(crate) type AllocResult<A, T, E> =
+    <<A as Allocator>::ErrorHandling as ErrorHandling>::Result<T, E>;

library/alloc/src/boxed.rs

@@ -165,14 +165,14 @@ use core::pin::Pin;
 use core::ptr::{self, Unique};
 use core::task::{Context, Poll};
 
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::Fatal;
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc::{handle_alloc_error, WriteCloneIntoRaw};
+use crate::alloc::{AllocError, AllocResult, Allocator, ErrorHandling, Global, Layout};
 #[cfg(not(no_global_oom_handling))]
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
-#[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;

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

@@ -22,9 +22,9 @@ use core::slice;
 #[allow(unused_imports)]
 use core::mem;
 
+use crate::alloc::{AllocResult, Allocator, ErrorHandling, Fatal, Global};
 use crate::collections::TryReserveError;
 use crate::collections::TryReserveErrorKind;
-use crate::falloc::{AllocResult, Allocator, ErrorHandling, Fatal, Global};
 use crate::raw_vec::RawVec;
 use crate::vec::Vec;
 

library/alloc/src/falloc.rs

@@ -226,10 +226,6 @@ mod raw_vec;
 
 pub mod alloc;
 
-// Fallible allocation experiment
-
-mod falloc;
-
 // Primitive types using the heaps above
 
 // Need to conditionally define the mod from `boxed.rs` to avoid

library/alloc/src/lib.rs

@@ -3,7 +3,7 @@ use std::cell::Cell;
 
 #[test]
 fn allocator_param() -> Result<(), TryReserveError> {
-    use crate::alloc::AllocError;
+    use crate::alloc::{AllocError, Fatal};
 
     // Writing a test of integration between third-party
     // allocators and `RawVec` is a little tricky because the `RawVec`
@@ -37,6 +37,7 @@ fn allocator_param() -> Result<(), TryReserveError> {
         unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
             unsafe { Global.deallocate(ptr, layout) }
         }
+        type ErrorHandling = Fatal;
     }
 
     let a = BoundedAlloc { fuel: Cell::new(500) };

library/alloc/src/raw_vec/tests.rs

@@ -26,12 +26,12 @@ use crate::alloc::Allocator;
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc::{self, Global};
 #[cfg(not(no_global_oom_handling))]
+use crate::alloc::{AllocResult, ErrorHandling};
+#[cfg(not(no_global_oom_handling))]
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
 #[cfg(not(no_global_oom_handling))]
 use crate::collections::TryReserveError;
-#[cfg(not(no_global_oom_handling))]
-use crate::falloc::{AllocResult, ErrorHandling};
 use crate::vec::Vec;
 
 #[cfg(test)]
@@ -837,7 +837,7 @@ impl<T: Clone> ToOwned for [T] {
 
     #[cfg(test)]
     fn to_owned(&self) -> Vec<T> {
-        hack::to_vec(self, Global)
+        <Global as Allocator>::ErrorHandling::map_result(hack::to_vec(self, Global))
     }
 
     fn clone_into(&self, target: &mut Vec<T>) {

library/alloc/src/slice.rs

@@ -1,10 +1,12 @@
 #[cfg(not(no_global_oom_handling))]
 use super::AsVecIntoIter;
+#[cfg(test)]
+use crate::alloc::ErrorHandling;
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::Fatal;
 use crate::alloc::{Allocator, Global};
 #[cfg(not(no_global_oom_handling))]
 use crate::collections::VecDeque;
-#[cfg(not(no_global_oom_handling))]
-use crate::falloc::Fatal;
 use crate::raw_vec::RawVec;
 use core::array;
 use core::fmt;
@@ -395,7 +397,11 @@ where
     }
     #[cfg(test)]
     fn clone(&self) -> Self {
-        crate::slice::to_vec(self.as_slice(), self.alloc.deref().clone()).into_iter()
+        A::ErrorHandling::map_result(crate::slice::to_vec(
+            self.as_slice(),
+            self.alloc.deref().clone(),
+        ))
+        .into_iter()
     }
 }
 

library/alloc/src/vec/into_iter.rs

@@ -64,12 +64,12 @@ use core::ops::{self, Index, IndexMut, Range, RangeBounds};
 use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
 
+#[cfg(not(no_global_oom_handling))]
+use crate::alloc::Fatal;
+use crate::alloc::{AllocResult, Allocator, ErrorHandling, Global};
 use crate::borrow::{Cow, ToOwned};
 use crate::boxed::Box;
 use crate::collections::{TryReserveError, TryReserveErrorKind};
-#[cfg(not(no_global_oom_handling))]
-use crate::falloc::Fatal;
-use crate::falloc::{AllocResult, Allocator, ErrorHandling, Global};
 use crate::raw_vec::RawVec;
 
 #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
@@ -2683,7 +2683,7 @@ where
     #[cfg(test)]
     fn clone(&self) -> Self {
         let alloc = self.allocator().clone();
-        crate::slice::to_vec(&**self, alloc)
+        <Global as Allocator>::ErrorHandling::map_result(crate::slice::to_vec(&**self, alloc))
     }
 
     fn clone_from(&mut self, other: &Self) {
@@ -3127,7 +3127,7 @@ impl<T: Clone> From<&[T]> for Vec<T> {
     }
     #[cfg(test)]
     fn from(s: &[T]) -> Vec<T> {
-        crate::slice::to_vec(s, Global)
+        <Global as Allocator>::ErrorHandling::map_result(crate::slice::to_vec(s, Global))
     }
 }
 
@@ -3147,7 +3147,7 @@ impl<T: Clone> From<&mut [T]> for Vec<T> {
     }
     #[cfg(test)]
     fn from(s: &mut [T]) -> Vec<T> {
-        crate::slice::to_vec(s, Global)
+        <Global as Allocator>::ErrorHandling::map_result(crate::slice::to_vec(s, Global))
     }
 }
 

library/alloc/src/vec/mod.rs

@@ -1,7 +1,7 @@
 use core::ptr;
 
+use crate::alloc::Allocator;
 use crate::collections::TryReserveError;
-use crate::falloc::Allocator;
 
 use super::{IsZero, Vec};
 

library/alloc/src/vec/spec_from_elem.rs

@@ -1,7 +1,7 @@
 use core::mem::ManuallyDrop;
 use core::ptr;
 
-use crate::falloc::{Allocator, ErrorHandling, Global};
+use crate::alloc::{Allocator, ErrorHandling, Global};
 
 use super::{IntoIter, SpecExtend, SpecFromIterNested, Vec};
 

library/alloc/src/vec/spec_from_iter.rs

@@ -2,7 +2,7 @@ use core::cmp;
 use core::iter::TrustedLen;
 use core::ptr;
 
-use crate::falloc::{Allocator, ErrorHandling, Global};
+use crate::alloc::{Allocator, ErrorHandling, Global};
 use crate::raw_vec::RawVec;
 
 use super::{SpecExtend, Vec};

library/alloc/src/vec/spec_from_iter_nested.rs

@@ -1,4 +1,4 @@
-use crate::falloc::{Allocator, ErrorHandling, Fatal, Global};
+use crate::alloc::{Allocator, ErrorHandling, Fatal, Global};
 use core::ptr;
 use core::slice;
 

library/alloc/src/vec/splice.rs

@@ -1,4 +1,4 @@
-use core::alloc::{AllocError, Allocator, Layout};
+use core::alloc::{AllocError, Allocator, Layout, Fatal};
 use core::cell::Cell;
 use core::mem::MaybeUninit;
 use core::ptr::NonNull;
@@ -178,4 +178,6 @@ unsafe impl Allocator for ConstAllocator {
     {
         self
     }
+
+    type ErrorHandling = Fatal;
 }