Update tracking issue.

Author: boats

src/liballoc/boxed.rs

@@ -898,22 +898,22 @@ impl<T> Generator for Box<T>
 }
 
 /// A pinned, heap allocated reference.
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 #[fundamental]
 pub struct PinBox<T: ?Sized> {
     inner: Box<T>,
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T> PinBox<T> {
     /// Allocate memory on the heap, move the data into it and pin it.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub fn new(data: T) -> PinBox<T> {
         PinBox { inner: Box::new(data) }
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: ?Sized> PinBox<T> {
     /// Get a pinned reference to the data in this PinBox.
     pub fn as_pin<'a>(&'a mut self) -> Pin<'a, T> {
@@ -937,21 +937,21 @@ impl<T: ?Sized> PinBox<T> {
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: ?Sized> From<Box<T>> for PinBox<T> {
     fn from(boxed: Box<T>) -> PinBox<T> {
         PinBox { inner: boxed }
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: Unpin + ?Sized> From<PinBox<T>> for Box<T> {
     fn from(pinned: PinBox<T>) -> Box<T> {
         pinned.inner
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: ?Sized> Deref for PinBox<T> {
     type Target = T;
 
@@ -960,28 +960,28 @@ impl<T: ?Sized> Deref for PinBox<T> {
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: Unpin + ?Sized> DerefMut for PinBox<T> {
     fn deref_mut(&mut self) -> &mut T {
         &mut *self.inner
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: fmt::Display + ?Sized> fmt::Display for PinBox<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&*self.inner, f)
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: fmt::Debug + ?Sized> fmt::Debug for PinBox<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&*self.inner, f)
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: ?Sized> fmt::Pointer for PinBox<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // It's not possible to extract the inner Uniq directly from the Box,
@@ -991,5 +991,5 @@ impl<T: ?Sized> fmt::Pointer for PinBox<T> {
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<PinBox<U>> for PinBox<T> {}

src/libcore/marker.rs

@@ -573,5 +573,5 @@ unsafe impl<'a, T: ?Sized> Freeze for &'a mut T {}
 /// `Pin` pointer.
 ///
 /// This trait is automatically implemented for almost every type.
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 pub unsafe auto trait Unpin {}

src/libcore/mem.rs

@@ -1111,38 +1111,38 @@ pub unsafe fn unreachable() -> ! {
 /// A pinned reference is a lot like a mutable reference, except that it is not
 /// safe to move a value out of a pinned reference unless the type of that
 /// value implements the `Unpin` trait.
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 #[fundamental]
 pub struct Pin<'a, T: ?Sized + 'a> {
     inner: &'a mut T,
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized + Unpin> Pin<'a, T> {
     /// Construct a new `Pin` around a reference to some data of a type that
     /// implements `Unpin`.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub fn new(reference: &'a mut T) -> Pin<'a, T> {
         Pin { inner: reference }
     }
 }
 
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized> Pin<'a, T> {
     /// Construct a new `Pin` around a reference to some data of a type that
     /// may or may not implement `Unpin`.
     ///
     /// This constructor is unsafe because we do not know what will happen with
     /// that data after the reference ends. If you cannot guarantee that the
     /// data will never move again, calling this constructor is invalid.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub unsafe fn new_unchecked(reference: &'a mut T) -> Pin<'a, T> {
         Pin { inner: reference }
     }
 
     /// Borrow a Pin for a shorter lifetime than it already has.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub fn borrow<'b>(this: &'b mut Pin<'a, T>) -> Pin<'b, T> {
         Pin { inner: this.inner }
     }
@@ -1152,7 +1152,7 @@ impl<'a, T: ?Sized> Pin<'a, T> {
     /// This function is unsafe. You must guarantee that you will never move
     /// the data out of the mutable reference you receive when you call this
     /// function.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub unsafe fn get_mut<'b>(this: &'b mut Pin<'a, T>) -> &'b mut T {
         this.inner
     }
@@ -1166,15 +1166,15 @@ impl<'a, T: ?Sized> Pin<'a, T> {
     /// will not move so long as the argument value does not move (for example,
     /// because it is one of the fields of that value), and also that you do
     /// not move out of the argument you receive to the interior function.
-    #[unstable(feature = "pin", issue = "0")]
+    #[unstable(feature = "pin", issue = "49150")]
     pub unsafe fn map<'b, U, F>(this: &'b mut Pin<'a, T>, f: F) -> Pin<'b, U> where
         F: FnOnce(&mut T) -> &mut U
     {
         Pin { inner: f(this.inner) }
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized> Deref for Pin<'a, T> {
     type Target = T;
 
@@ -1183,33 +1183,33 @@ impl<'a, T: ?Sized> Deref for Pin<'a, T> {
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized + Unpin> DerefMut for Pin<'a, T> {
     fn deref_mut(&mut self) -> &mut T {
         self.inner
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: fmt::Debug + ?Sized> fmt::Debug for Pin<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: fmt::Display + ?Sized> fmt::Display for Pin<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(&**self, f)
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized> fmt::Pointer for Pin<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&(&*self.inner as *const T), f)
     }
 }
 
-#[unstable(feature = "pin", issue = "0")]
+#[unstable(feature = "pin", issue = "49150")]
 impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Pin<'a, U>> for Pin<'a, T> {}