Rollup merge of #49621 - Nemo157:impl-unpin-for-pin, r=withoutboats

diff --combined src/liballoc/boxed.rs
index 4f9dc61ce196be1306884c2afca4c9b71cdabe31,a319fb797f88bbe0620f19da75e8200b8bf77669..71b53cc88e54dfef3ec2b22ce57a182e265c1067
--- 1/src/liballoc/boxed.rs
--- 2/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@@ -55,6 -55,7 +55,6 @@@
  
  #![stable(feature = "rust1", since = "1.0.0")]
  
 -use heap::Heap;
  use raw_vec::RawVec;
  
  use core::any::Any;
@@@ -62,14 -63,47 +62,14 @@@ use core::borrow
  use core::cmp::Ordering;
  use core::fmt;
  use core::hash::{Hash, Hasher};
 -use core::heap::{Alloc, Layout};
  use core::iter::FusedIterator;
 -use core::marker::{self, Unpin, Unsize};
 +use core::marker::{Unpin, Unsize};
  use core::mem::{self, Pin};
  use core::ops::{CoerceUnsized, Deref, DerefMut, Generator, GeneratorState};
 -use core::ops::{BoxPlace, Boxed, InPlace, Place, Placer};
  use core::ptr::{self, NonNull, Unique};
  use core::convert::From;
  use str::from_boxed_utf8_unchecked;
  
 -/// A value that represents the heap. This is the default place that the `box`
 -/// keyword allocates into when no place is supplied.
 -///
 -/// The following two examples are equivalent:
 -///
 -/// ```
 -/// #![feature(box_heap)]
 -///
 -/// #![feature(box_syntax, placement_in_syntax)]
 -/// use std::boxed::HEAP;
 -///
 -/// fn main() {
 -///     let foo: Box<i32> = in HEAP { 5 };
 -///     let foo = box 5;
 -/// }
 -/// ```
 -#[unstable(feature = "box_heap",
 -           reason = "may be renamed; uncertain about custom allocator design",
 -           issue = "27779")]
 -pub const HEAP: ExchangeHeapSingleton = ExchangeHeapSingleton { _force_singleton: () };
 -
 -/// This the singleton type used solely for `boxed::HEAP`.
 -#[unstable(feature = "box_heap",
 -           reason = "may be renamed; uncertain about custom allocator design",
 -           issue = "27779")]
 -#[allow(missing_debug_implementations)]
 -#[derive(Copy, Clone)]
 -pub struct ExchangeHeapSingleton {
 -    _force_singleton: (),
 -}
 -
  /// A pointer type for heap allocation.
  ///
  /// See the [module-level documentation](../../std/boxed/index.html) for more.
@@@ -78,6 -112,121 +78,6 @@@
  #[stable(feature = "rust1", since = "1.0.0")]
  pub struct Box<T: ?Sized>(Unique<T>);
  
 -/// `IntermediateBox` represents uninitialized backing storage for `Box`.
 -///
 -/// FIXME (pnkfelix): Ideally we would just reuse `Box<T>` instead of
 -/// introducing a separate `IntermediateBox<T>`; but then you hit
 -/// issues when you e.g. attempt to destructure an instance of `Box`,
 -/// since it is a lang item and so it gets special handling by the
 -/// compiler.  Easier just to make this parallel type for now.
 -///
 -/// FIXME (pnkfelix): Currently the `box` protocol only supports
 -/// creating instances of sized types. This IntermediateBox is
 -/// designed to be forward-compatible with a future protocol that
 -/// supports creating instances of unsized types; that is why the type
 -/// parameter has the `?Sized` generalization marker, and is also why
 -/// this carries an explicit size. However, it probably does not need
 -/// to carry the explicit alignment; that is just a work-around for
 -/// the fact that the `align_of` intrinsic currently requires the
 -/// input type to be Sized (which I do not think is strictly
 -/// necessary).
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -#[allow(missing_debug_implementations)]
 -pub struct IntermediateBox<T: ?Sized> {
 -    ptr: *mut u8,
 -    layout: Layout,
 -    marker: marker::PhantomData<*mut T>,
 -}
 -
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -unsafe impl<T> Place<T> for IntermediateBox<T> {
 -    fn pointer(&mut self) -> *mut T {
 -        self.ptr as *mut T
 -    }
 -}
 -
 -unsafe fn finalize<T>(b: IntermediateBox<T>) -> Box<T> {
 -    let p = b.ptr as *mut T;
 -    mem::forget(b);
 -    Box::from_raw(p)
 -}
 -
 -fn make_place<T>() -> IntermediateBox<T> {
 -    let layout = Layout::new::<T>();
 -
 -    let p = if layout.size() == 0 {
 -        mem::align_of::<T>() as *mut u8
 -    } else {
 -        unsafe {
 -            Heap.alloc(layout.clone()).unwrap_or_else(|err| {
 -                Heap.oom(err)
 -            })
 -        }
 -    };
 -
 -    IntermediateBox {
 -        ptr: p,
 -        layout,
 -        marker: marker::PhantomData,
 -    }
 -}
 -
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -impl<T> BoxPlace<T> for IntermediateBox<T> {
 -    fn make_place() -> IntermediateBox<T> {
 -        make_place()
 -    }
 -}
 -
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -impl<T> InPlace<T> for IntermediateBox<T> {
 -    type Owner = Box<T>;
 -    unsafe fn finalize(self) -> Box<T> {
 -        finalize(self)
 -    }
 -}
 -
 -#[unstable(feature = "placement_new_protocol", issue = "27779")]
 -impl<T> Boxed for Box<T> {
 -    type Data = T;
 -    type Place = IntermediateBox<T>;
 -    unsafe fn finalize(b: IntermediateBox<T>) -> Box<T> {
 -        finalize(b)
 -    }
 -}
 -
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -impl<T> Placer<T> for ExchangeHeapSingleton {
 -    type Place = IntermediateBox<T>;
 -
 -    fn make_place(self) -> IntermediateBox<T> {
 -        make_place()
 -    }
 -}
 -
 -#[unstable(feature = "placement_in",
 -           reason = "placement box design is still being worked out.",
 -           issue = "27779")]
 -impl<T: ?Sized> Drop for IntermediateBox<T> {
 -    fn drop(&mut self) {
 -        if self.layout.size() > 0 {
 -            unsafe {
 -                Heap.dealloc(self.ptr, self.layout.clone())
 -            }
 -        }
 -    }
 -}
 -
  impl<T> Box<T> {
      /// Allocates memory on the heap and then places `x` into it.
      ///
@@@ -845,3 -994,6 +845,6 @@@ impl<T: ?Sized> fmt::Pointer for PinBox
  
  #[unstable(feature = "pin", issue = "49150")]
  impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<PinBox<U>> for PinBox<T> {}
+ 
+ #[unstable(feature = "pin", issue = "49150")]
+ unsafe impl<T: ?Sized> Unpin for PinBox<T> {}