Associate an allocator to boxes

src/liballoc/alloc.rs

@@ -3,6 +3,7 @@
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
 use core::intrinsics::{min_align_of_val, size_of_val};
+use core::marker::PhantomData;
 use core::ptr::{NonNull, Unique};
 use core::usize;
 
@@ -190,14 +191,14 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
 
 #[cfg_attr(not(test), lang = "box_free")]
 #[inline]
-pub(crate) unsafe fn box_free<T: ?Sized>(ptr: Unique<T>) {
+pub(crate) unsafe fn box_free<T: ?Sized, A: Alloc + Default>(ptr: Unique<T>, _a: PhantomData<A>) {
     let ptr = ptr.as_ptr();
     let size = size_of_val(&*ptr);
     let align = min_align_of_val(&*ptr);
     // We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
     if size != 0 {
         let layout = Layout::from_size_align_unchecked(size, align);
-        dealloc(ptr as *mut u8, layout);
+        A::default().dealloc(NonNull::new_unchecked(ptr).cast(), layout);
     }
 }
 

src/liballoc/boxed.rs

@@ -64,7 +64,7 @@ use core::fmt;
 use core::future::Future;
 use core::hash::{Hash, Hasher};
 use core::iter::{Iterator, FromIterator, FusedIterator};
-use core::marker::{Unpin, Unsize};
+use core::marker::{PhantomData, Unpin, Unsize};
 use core::mem;
 use core::pin::Pin;
 use core::ops::{
@@ -73,6 +73,7 @@ use core::ops::{
 use core::ptr::{self, NonNull, Unique};
 use core::task::{LocalWaker, Poll};
 
+use crate::alloc::{Alloc, Global};
 use crate::vec::Vec;
 use crate::raw_vec::RawVec;
 use crate::str::from_boxed_utf8_unchecked;
@@ -83,7 +84,7 @@ use crate::str::from_boxed_utf8_unchecked;
 #[lang = "owned_box"]
 #[fundamental]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Box<T: ?Sized>(Unique<T>);
+pub struct Box<T: ?Sized, A: Alloc + Default = Global>(Unique<T>, PhantomData<A>);
 
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
@@ -136,7 +137,7 @@ impl<T: ?Sized> Box<T> {
     #[stable(feature = "box_raw", since = "1.4.0")]
     #[inline]
     pub unsafe fn from_raw(raw: *mut T) -> Self {
-        Box(Unique::new_unchecked(raw))
+        Box(Unique::new_unchecked(raw), PhantomData)
     }
 
     /// Consumes the `Box`, returning a wrapped raw pointer.
@@ -273,7 +274,7 @@ impl<T: ?Sized> Box<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T: ?Sized> Drop for Box<T> {
+unsafe impl<#[may_dangle] T: ?Sized, A: Alloc + Default> Drop for Box<T, A> {
     fn drop(&mut self) {
         // FIXME: Do nothing, drop is currently performed by compiler.
     }

src/liballoc/rc.rs

@@ -713,7 +713,7 @@ impl<T: ?Sized> Rc<T> {
                 value_size);
 
             // Free the allocation without dropping its contents
-            box_free(box_unique);
+            box_free::<_, Global>(box_unique, PhantomData);
 
             Rc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
         }

src/liballoc/sync.rs

@@ -619,7 +619,7 @@ impl<T: ?Sized> Arc<T> {
                 value_size);
 
             // Free the allocation without dropping its contents
-            box_free(box_unique);
+            box_free::<_, Global>(box_unique, PhantomData);
 
             Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }
         }