Fix some missing stability tags

src/libcollections/str.rs

@@ -50,6 +50,7 @@
 //! is the same as `&[u8]`.
 
 #![doc(primitive = "str")]
+#![stable]
 
 use self::RecompositionState::*;
 use self::DecompositionType::*;
@@ -401,6 +402,7 @@ Section: Trait implementations
 */
 
 /// Any string that can be represented as a slice.
+#[stable]
 pub trait StrExt for Sized?: ops::Slice<uint, str> {
     /// Escapes each char in `s` with `char::escape_default`.
     #[unstable = "return type may change to be an iterator"]
@@ -1340,6 +1342,7 @@ pub trait StrExt for Sized?: ops::Slice<uint, str> {
     }
 }
 
+#[stable]
 impl StrExt for str {}
 
 #[cfg(test)]

src/libcore/atomic.rs

@@ -146,28 +146,18 @@ pub enum Ordering {
 }
 
 /// An `AtomicBool` initialized to `false`.
-#[unstable = "may be renamed, pending conventions for static initalizers"]
+#[stable]
 pub const ATOMIC_BOOL_INIT: AtomicBool =
         AtomicBool { v: UnsafeCell { value: 0 } };
 /// An `AtomicInt` initialized to `0`.
-#[unstable = "may be renamed, pending conventions for static initalizers"]
+#[stable]
 pub const ATOMIC_INT_INIT: AtomicInt =
         AtomicInt { v: UnsafeCell { value: 0 } };
 /// An `AtomicUint` initialized to `0`.
-#[unstable = "may be renamed, pending conventions for static initalizers"]
+#[stable]
 pub const ATOMIC_UINT_INIT: AtomicUint =
         AtomicUint { v: UnsafeCell { value: 0, } };
 
-/// Deprecated
-#[deprecated = "renamed to ATOMIC_BOOL_INIT"]
-pub const INIT_ATOMIC_BOOL: AtomicBool = ATOMIC_BOOL_INIT;
-/// Deprecated
-#[deprecated = "renamed to ATOMIC_INT_INIT"]
-pub const INIT_ATOMIC_INT: AtomicInt = ATOMIC_INT_INIT;
-/// Deprecated
-#[deprecated = "renamed to ATOMIC_UINT_INIT"]
-pub const INIT_ATOMIC_UINT: AtomicUint = ATOMIC_UINT_INIT;
-
 // NB: Needs to be -1 (0b11111111...) to make fetch_nand work correctly
 const UINT_TRUE: uint = -1;
 

src/libcore/str/mod.rs

@@ -142,6 +142,7 @@ Section: Creating a string
 
 /// Errors which can occur when attempting to interpret a byte slice as a `str`.
 #[derive(Copy, Eq, PartialEq, Clone)]
+#[unstable = "error enumeration recently added and definitions may be refined"]
 pub enum Utf8Error {
     /// An invalid byte was detected at the byte offset given.
     ///
@@ -165,6 +166,7 @@ pub enum Utf8Error {
 ///
 /// Returns `Err` if the slice is not utf-8 with a description as to why the
 /// provided slice is not utf-8.
+#[stable]
 pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
     try!(run_utf8_validation_iterator(&mut v.iter()));
     Ok(unsafe { from_utf8_unchecked(v) })
@@ -247,6 +249,7 @@ Section: Iterators
 ///
 /// Created with the method `.chars()`.
 #[derive(Clone, Copy)]
+#[stable]
 pub struct Chars<'a> {
     iter: slice::Iter<'a, u8>
 }
@@ -356,6 +359,7 @@ impl<'a> DoubleEndedIterator for Chars<'a> {
 /// External iterator for a string's characters and their byte offsets.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[stable]
 pub struct CharIndices<'a> {
     front_offset: uint,
     iter: Chars<'a>,
@@ -848,6 +852,7 @@ impl Searcher {
 /// An iterator over the start and end indices of the matches of a
 /// substring within a larger string
 #[derive(Clone)]
+#[unstable = "type may be removed"]
 pub struct MatchIndices<'a> {
     // constants
     haystack: &'a str,
@@ -858,7 +863,7 @@ pub struct MatchIndices<'a> {
 /// An iterator over the substrings of a string separated by a given
 /// search string
 #[derive(Clone)]
-#[unstable = "Type might get removed"]
+#[unstable = "type may be removed"]
 pub struct SplitStr<'a> {
     it: MatchIndices<'a>,
     last_end: uint,
@@ -1056,8 +1061,7 @@ const TAG_CONT_U8: u8 = 0b1000_0000u8;
 Section: Trait implementations
 */
 
-#[allow(missing_docs)]
-pub mod traits {
+mod traits {
     use cmp::{Ordering, Ord, PartialEq, PartialOrd, Eq};
     use cmp::Ordering::{Less, Equal, Greater};
     use iter::IteratorExt;

src/libstd/prelude/mod.rs

@@ -35,5 +35,7 @@
 //! pervasive that it would be obnoxious to import for every use, particularly
 //! those that define methods on primitive types.
 
+#![stable]
+
 #[stable]
 pub mod v1;

src/libstd/sync/mod.rs

@@ -15,7 +15,7 @@
 //! and/or blocking at all, but rather provide the necessary tools to build
 //! other types of concurrent primitives.
 
-#![experimental]
+#![stable]
 
 pub use alloc::arc::{Arc, Weak};
 pub use core::atomic;

src/libstd/sync/mpsc/mod.rs

@@ -163,6 +163,8 @@
 //! }
 //! ```
 
+#![stable]
+
 // A description of how Rust's channel implementation works
 //
 // Channels are supposed to be the basic building block for all other
@@ -565,6 +567,7 @@ impl<T: Send> Sender<T> {
     /// drop(rx);
     /// assert_eq!(tx.send(1i).err().unwrap().0, 1);
     /// ```
+    #[stable]
     pub fn send(&self, t: T) -> Result<(), SendError<T>> {
         let (new_inner, ret) = match *unsafe { self.inner() } {
             Flavor::Oneshot(ref p) => {

src/libstd/sync/once.rs

@@ -121,10 +121,6 @@ impl Once {
             unsafe { self.mutex.destroy() }
         }
     }
-
-    /// Deprecated
-    #[deprecated = "renamed to `call_once`"]
-    pub fn doit<F>(&'static self, f: F) where F: FnOnce() { self.call_once(f) }
 }
 
 #[cfg(test)]