Fix for rust 1.36.0

Author: hansihe

src/lib.rs

@@ -18,7 +18,8 @@
         dropck_eyepatch,
         min_specialization,
         extend_one,
-        allocator_api
+        allocator_api,
+        slice_ptr_get
     )
 )]
 #![allow(

src/raw/alloc.rs

@@ -2,34 +2,35 @@ pub use self::inner::*;
 
 #[cfg(feature = "nightly")]
 mod inner {
-    pub use crate::alloc::alloc::{AllocError, AllocRef, Global};
+    use crate::alloc::alloc::Layout;
+    pub use crate::alloc::alloc::{AllocRef, Global};
+    use core::ptr::NonNull;
+
+    pub fn do_alloc<A: AllocRef>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
+        alloc
+            .alloc(layout)
+            .map(|ptr| ptr.as_non_null_ptr())
+            .map_err(|_| ())
+    }
 }
 
 #[cfg(not(feature = "nightly"))]
 mod inner {
     use crate::alloc::alloc::{alloc, dealloc, Layout};
-    use core::ptr;
     use core::ptr::NonNull;
 
     pub struct AllocError;
 
     pub unsafe trait AllocRef {
-        fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
+        fn alloc(&self, layout: Layout) -> Result<NonNull<u8>, AllocError>;
         unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout);
     }
 
     #[derive(Copy, Clone)]
     pub struct Global;
     unsafe impl AllocRef for Global {
-        fn alloc(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
-            unsafe {
-                let ptr = alloc(layout);
-                if ptr.is_null() {
-                    return Err(AllocError);
-                }
-                let slice = ptr::slice_from_raw_parts_mut(ptr, layout.size());
-                Ok(NonNull::new_unchecked(slice))
-            }
+        fn alloc(&self, layout: Layout) -> Result<NonNull<u8>, AllocError> {
+            unsafe { NonNull::new(alloc(layout)).ok_or(AllocError) }
         }
         unsafe fn dealloc(&self, ptr: NonNull<u8>, layout: Layout) {
             dealloc(ptr.as_ptr(), layout)
@@ -40,4 +41,8 @@ mod inner {
             Global
         }
     }
+
+    pub fn do_alloc<A: AllocRef>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
+        alloc.alloc(layout).map_err(|_| ())
+    }
 }

src/raw/mod.rs

@@ -32,7 +32,7 @@ cfg_if! {
 }
 
 mod alloc;
-pub use self::alloc::{AllocRef, Global};
+pub use self::alloc::{do_alloc, AllocRef, Global};
 
 mod bitmask;
 
@@ -435,7 +435,7 @@ impl<T, A: AllocRef + Clone> RawTable<T, A> {
             Some(lco) => lco,
             None => return Err(fallability.capacity_overflow()),
         };
-        let ptr: NonNull<u8> = match alloc.alloc(layout) {
+        let ptr: NonNull<u8> = match do_alloc(&alloc, layout) {
             Ok(block) => block.cast(),
             Err(_) => return Err(fallability.alloc_err(layout)),
         };