Update with a stable GlobalAlloc trait

Author: alexcrichton

.travis.yml

@@ -3,7 +3,6 @@ sudo: false
 
 matrix:
   include:
-    - rust: stable
     - rust: beta
     - rust: nightly
     - rust: nightly

src/global.rs

@@ -1,73 +1,77 @@
-use core::alloc::{Alloc, Layout, GlobalAlloc, AllocErr, Opaque};
+use core::alloc::{Layout, GlobalAlloc};
 use core::ops::{Deref, DerefMut};
+#[cfg(feature = "allocator-api")]
 use core::ptr::NonNull;
+#[cfg(feature = "allocator-api")]
+use core::alloc::{AllocErr, Alloc};
 
 use Dlmalloc;
 
 pub struct GlobalDlmalloc;
 
 unsafe impl GlobalAlloc for GlobalDlmalloc {
     #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
-        <Dlmalloc>::malloc(&mut get(), layout.size(), layout.align()) as *mut Opaque
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        <Dlmalloc>::malloc(&mut get(), layout.size(), layout.align())
     }
 
     #[inline]
-    unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
-        <Dlmalloc>::free(&mut get(), ptr as *mut u8, layout.size(), layout.align())
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        <Dlmalloc>::free(&mut get(), ptr, layout.size(), layout.align())
     }
 
     #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
-        <Dlmalloc>::calloc(&mut get(), layout.size(), layout.align()) as *mut Opaque
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        <Dlmalloc>::calloc(&mut get(), layout.size(), layout.align())
     }
 
     #[inline]
     unsafe fn realloc(
         &self,
-        ptr: *mut Opaque,
+        ptr: *mut u8,
         layout: Layout,
         new_size: usize
-    ) -> *mut Opaque {
+    ) -> *mut u8 {
         <Dlmalloc>::realloc(
             &mut get(),
-            ptr as *mut u8,
+            ptr,
             layout.size(),
             layout.align(),
             new_size,
-        ) as *mut Opaque
+        )
     }
 }
 
+#[cfg(feature = "allocator-api")]
 unsafe impl Alloc for GlobalDlmalloc {
     #[inline]
     unsafe fn alloc(
         &mut self,
         layout: Layout
-    ) -> Result<NonNull<Opaque>, AllocErr> {
+    ) -> Result<NonNull<u8>, AllocErr> {
         get().alloc(layout)
     }
 
     #[inline]
-    unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
+    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {
         get().dealloc(ptr, layout)
     }
 
     #[inline]
     unsafe fn realloc(
         &mut self,
-        ptr: NonNull<Opaque>,
+        ptr: NonNull<u8>,
         layout: Layout,
         new_size: usize
-    ) -> Result<NonNull<Opaque>, AllocErr> {
+    ) -> Result<NonNull<u8>, AllocErr> {
         Alloc::realloc(&mut *get(), ptr, layout, new_size)
     }
 
     #[inline]
     unsafe fn alloc_zeroed(
         &mut self,
         layout: Layout
-    ) -> Result<NonNull<Opaque>, AllocErr> {
+    ) -> Result<NonNull<u8>, AllocErr> {
         get().alloc_zeroed(layout)
     }
 }

src/lib.rs

@@ -4,14 +4,12 @@
 #![no_std]
 
 #[cfg(feature = "allocator-api")]
-use core::alloc::{Alloc, Layout, AllocErr, Opaque};
+use core::alloc::{Alloc, Layout, AllocErr};
 use core::cmp;
 use core::ptr;
 
-#[cfg(feature = "allocator-api")]
 pub use self::global::GlobalDlmalloc;
 
-#[cfg(feature = "allocator-api")]
 mod global;
 mod dlmalloc;
 
@@ -86,39 +84,39 @@ unsafe impl Alloc for Dlmalloc {
     unsafe fn alloc(
         &mut self,
         layout: Layout
-    ) -> Result<ptr::NonNull<Opaque>, AllocErr> {
+    ) -> Result<ptr::NonNull<u8>, AllocErr> {
         let ptr = <Dlmalloc>::malloc(self, layout.size(), layout.align());
-        ptr::NonNull::new(ptr as *mut Opaque).ok_or(AllocErr)
+        ptr::NonNull::new(ptr).ok_or(AllocErr)
     }
 
     #[inline]
-    unsafe fn dealloc(&mut self, ptr: ptr::NonNull<Opaque>, layout: Layout) {
-        <Dlmalloc>::free(self, ptr.as_ptr() as *mut u8, layout.size(), layout.align())
+    unsafe fn dealloc(&mut self, ptr: ptr::NonNull<u8>, layout: Layout) {
+        <Dlmalloc>::free(self, ptr.as_ptr(), layout.size(), layout.align())
     }
 
     #[inline]
     unsafe fn realloc(
         &mut self,
-        ptr: ptr::NonNull<Opaque>,
+        ptr: ptr::NonNull<u8>,
         layout: Layout,
         new_size: usize
-    ) -> Result<ptr::NonNull<Opaque>, AllocErr> {
+    ) -> Result<ptr::NonNull<u8>, AllocErr> {
         let ptr = <Dlmalloc>::realloc(
             self,
-            ptr.as_ptr() as *mut u8,
+            ptr.as_ptr(),
             layout.size(),
             layout.align(),
             new_size,
         );
-        ptr::NonNull::new(ptr as *mut Opaque).ok_or(AllocErr)
+        ptr::NonNull::new(ptr).ok_or(AllocErr)
     }
 
     #[inline]
     unsafe fn alloc_zeroed(
         &mut self,
         layout: Layout
-    ) -> Result<ptr::NonNull<Opaque>, AllocErr> {
+    ) -> Result<ptr::NonNull<u8>, AllocErr> {
         let ptr = <Dlmalloc>::calloc(self, layout.size(), layout.align());
-        ptr::NonNull::new(ptr as *mut Opaque).ok_or(AllocErr)
+        ptr::NonNull::new(ptr).ok_or(AllocErr)
     }
 }