std: Add issues to all unstable features

5 files changed, 40 insertions, 20 deletions

diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs
index 79b3dfa67b1..fc0e08139f4 100644
--- a/src/libstd/sync/condvar.rs
+++ b/src/libstd/sync/condvar.rs
@@ -76,7 +76,8 @@ pub struct Condvar { inner: Box<StaticCondvar> }
 /// static CVAR: StaticCondvar = CONDVAR_INIT;
 /// ```
 #[unstable(feature = "static_condvar",
-           reason = "may be merged with Condvar in the future")]
+           reason = "may be merged with Condvar in the future",
+           issue = "27717")]
 pub struct StaticCondvar {
     inner: sys::Condvar,
     mutex: AtomicUsize,
@@ -84,7 +85,8 @@ pub struct StaticCondvar {
 
 /// Constant initializer for a statically allocated condition variable.
 #[unstable(feature = "static_condvar",
-           reason = "may be merged with Condvar in the future")]
+           reason = "may be merged with Condvar in the future",
+           issue = "27717")]
 pub const CONDVAR_INIT: StaticCondvar = StaticCondvar::new();
 
 impl Condvar {
@@ -173,7 +175,8 @@ impl Condvar {
     ///
     /// Like `wait`, the lock specified will be re-acquired when this function
     /// returns, regardless of whether the timeout elapsed or not.
-    #[unstable(feature = "wait_timeout", reason = "waiting for Duration")]
+    #[unstable(feature = "wait_timeout", reason = "waiting for Duration",
+               issue = "27772")]
     pub fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>,
                                dur: Duration)
                                -> LockResult<(MutexGuard<'a, T>, bool)> {
@@ -190,7 +193,8 @@ impl Condvar {
     /// that the implementation will repeatedly wait while the duration has not
     /// passed and the provided function returns `false`.
     #[unstable(feature = "wait_timeout_with",
-               reason = "unsure if this API is broadly needed or what form it should take")]
+               reason = "unsure if this API is broadly needed or what form it should take",
+               issue = "27748")]
     pub fn wait_timeout_with<'a, T, F>(&self,
                                        guard: MutexGuard<'a, T>,
                                        dur: Duration,
@@ -234,7 +238,8 @@ impl Drop for Condvar {
 impl StaticCondvar {
     /// Creates a new condition variable
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub const fn new() -> StaticCondvar {
         StaticCondvar {
             inner: sys::Condvar::new(),
@@ -247,7 +252,8 @@ impl StaticCondvar {
     ///
     /// See `Condvar::wait`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn wait<'a, T>(&'static self, guard: MutexGuard<'a, T>)
                        -> LockResult<MutexGuard<'a, T>> {
         let poisoned = unsafe {
@@ -268,7 +274,8 @@ impl StaticCondvar {
     ///
     /// See `Condvar::wait_timeout`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn wait_timeout_ms<'a, T>(&'static self, guard: MutexGuard<'a, T>, ms: u32)
                                   -> LockResult<(MutexGuard<'a, T>, bool)> {
         self.wait_timeout(guard, Duration::from_millis(ms as u64))
@@ -279,7 +286,8 @@ impl StaticCondvar {
     ///
     /// See `Condvar::wait_timeout`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn wait_timeout<'a, T>(&'static self,
                                guard: MutexGuard<'a, T>,
                                timeout: Duration)
@@ -305,7 +313,8 @@ impl StaticCondvar {
     ///
     /// See `Condvar::wait_timeout_with`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn wait_timeout_with<'a, T, F>(&'static self,
                                        guard: MutexGuard<'a, T>,
                                        dur: Duration,
@@ -351,14 +360,16 @@ impl StaticCondvar {
     ///
     /// See `Condvar::notify_one`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn notify_one(&'static self) { unsafe { self.inner.notify_one() } }
 
     /// Wakes up all blocked threads on this condvar.
     ///
     /// See `Condvar::notify_all`.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub fn notify_all(&'static self) { unsafe { self.inner.notify_all() } }
 
     /// Deallocates all resources associated with this static condvar.
@@ -368,7 +379,8 @@ impl StaticCondvar {
     /// users of the condvar. This method is required to be called to not leak
     /// memory on all platforms.
     #[unstable(feature = "static_condvar",
-               reason = "may be merged with Condvar in the future")]
+               reason = "may be merged with Condvar in the future",
+               issue = "27717")]
     pub unsafe fn destroy(&'static self) {
         self.inner.destroy()
     }
diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 56d903fed3b..cc068fd1dea 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -54,7 +54,8 @@
                       module will likely be replaced, and it is currently \
                       unknown how much API breakage that will cause. The ability \
                       to select over a number of channels will remain forever, \
-                      but no guarantees beyond this are being made")]
+                      but no guarantees beyond this are being made",
+            issue = "27800")]
 
 
 use core::cell::{Cell, UnsafeCell};
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index 773bd7f5606..e56e5a72c13 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -151,7 +151,8 @@ unsafe impl<T: ?Sized + Send> Sync for Mutex<T> { }
 /// // lock is unlocked here.
 /// ```
 #[unstable(feature = "static_mutex",
-           reason = "may be merged with Mutex in the future")]
+           reason = "may be merged with Mutex in the future",
+           issue = "27717")]
 pub struct StaticMutex {
     lock: sys::Mutex,
     poison: poison::Flag,
@@ -177,7 +178,8 @@ impl<'a, T: ?Sized> !marker::Send for MutexGuard<'a, T> {}
 /// Static initialization of a mutex. This constant can be used to initialize
 /// other mutex constants.
 #[unstable(feature = "static_mutex",
-           reason = "may be merged with Mutex in the future")]
+           reason = "may be merged with Mutex in the future",
+           issue = "27717")]
 pub const MUTEX_INIT: StaticMutex = StaticMutex::new();
 
 impl<T> Mutex<T> {
@@ -271,7 +273,8 @@ unsafe impl Sync for Dummy {}
 static DUMMY: Dummy = Dummy(UnsafeCell::new(()));
 
 #[unstable(feature = "static_mutex",
-           reason = "may be merged with Mutex in the future")]
+           reason = "may be merged with Mutex in the future",
+           issue = "27717")]
 impl StaticMutex {
     /// Creates a new mutex in an unlocked state ready for use.
     pub const fn new() -> StaticMutex {
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index 40d5af49156..7210328fad8 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -98,7 +98,8 @@ unsafe impl<T: ?Sized + Send + Sync> Sync for RwLock<T> {}
 /// unsafe { LOCK.destroy() } // free all resources
 /// ```
 #[unstable(feature = "static_rwlock",
-           reason = "may be merged with RwLock in the future")]
+           reason = "may be merged with RwLock in the future",
+           issue = "27717")]
 pub struct StaticRwLock {
     lock: sys::RWLock,
     poison: poison::Flag,
@@ -106,7 +107,8 @@ pub struct StaticRwLock {
 
 /// Constant initialization for a statically-initialized rwlock.
 #[unstable(feature = "static_rwlock",
-           reason = "may be merged with RwLock in the future")]
+           reason = "may be merged with RwLock in the future",
+           issue = "27717")]
 pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock::new();
 
 /// RAII structure used to release the shared read access of a lock when
@@ -285,7 +287,8 @@ unsafe impl Sync for Dummy {}
 static DUMMY: Dummy = Dummy(UnsafeCell::new(()));
 
 #[unstable(feature = "static_rwlock",
-           reason = "may be merged with RwLock in the future")]
+           reason = "may be merged with RwLock in the future",
+           issue = "27717")]
 impl StaticRwLock {
     /// Creates a new rwlock.
     pub const fn new() -> StaticRwLock {
diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs
index 907df69bfb0..891f8775ff2 100644
--- a/src/libstd/sync/semaphore.rs
+++ b/src/libstd/sync/semaphore.rs
@@ -10,7 +10,8 @@
 
 #![unstable(feature = "semaphore",
             reason = "the interaction between semaphores and the acquisition/release \
-                      of resources is currently unclear")]
+                      of resources is currently unclear",
+            issue = "27798")]
 
 use ops::Drop;
 use sync::{Mutex, Condvar};