diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index ed6a957d2acfa..fee06422fdd1f 100644 --- a/src/libcollections/str.rs +++ b/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 { /// 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 { } } +#[stable] impl StrExt for str {} #[cfg(test)] diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs index 0ac0dc396cc1a..15c20253c8bc7 100644 --- a/src/libcore/atomic.rs +++ b/src/libcore/atomic.rs @@ -86,7 +86,7 @@ pub struct AtomicBool { unsafe impl Sync for AtomicBool {} /// A signed integer type which can be safely shared between threads. -#[stable] +#[unstable = "awaiting int/uint conventions, may be renamed"] pub struct AtomicInt { v: UnsafeCell, } @@ -94,7 +94,7 @@ pub struct AtomicInt { unsafe impl Sync for AtomicInt {} /// An unsigned integer type which can be safely shared between threads. -#[stable] +#[unstable = "awaiting int/uint conventions, may be renamed"] pub struct AtomicUint { v: UnsafeCell, } @@ -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"] +#[unstable = "awaiting int/uint conventions, may be renamed"] 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"] +#[unstable = "awaiting int/uint conventions, may be renamed"] 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; @@ -413,6 +403,7 @@ impl AtomicBool { } } +#[unstable = "awaiting int/uint conventions, types may change"] impl AtomicInt { /// Creates a new `AtomicInt`. /// @@ -424,7 +415,6 @@ impl AtomicInt { /// let atomic_forty_two = AtomicInt::new(42); /// ``` #[inline] - #[stable] pub fn new(v: int) -> AtomicInt { AtomicInt {v: UnsafeCell::new(v)} } @@ -447,7 +437,6 @@ impl AtomicInt { /// let value = some_int.load(Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn load(&self, order: Ordering) -> int { unsafe { atomic_load(self.v.get() as *const int, order) } } @@ -470,7 +459,6 @@ impl AtomicInt { /// /// Panics if `order` is `Acquire` or `AcqRel`. #[inline] - #[stable] pub fn store(&self, val: int, order: Ordering) { unsafe { atomic_store(self.v.get(), val, order); } } @@ -489,7 +477,6 @@ impl AtomicInt { /// let value = some_int.swap(10, Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn swap(&self, val: int, order: Ordering) -> int { unsafe { atomic_swap(self.v.get(), val, order) } } @@ -511,7 +498,6 @@ impl AtomicInt { /// let value = some_int.compare_and_swap(5, 10, Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn compare_and_swap(&self, old: int, new: int, order: Ordering) -> int { unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) } } @@ -528,7 +514,6 @@ impl AtomicInt { /// assert_eq!(10, foo.load(Ordering::SeqCst)); /// ``` #[inline] - #[stable] pub fn fetch_add(&self, val: int, order: Ordering) -> int { unsafe { atomic_add(self.v.get(), val, order) } } @@ -545,7 +530,6 @@ impl AtomicInt { /// assert_eq!(-10, foo.load(Ordering::SeqCst)); /// ``` #[inline] - #[stable] pub fn fetch_sub(&self, val: int, order: Ordering) -> int { unsafe { atomic_sub(self.v.get(), val, order) } } @@ -561,7 +545,6 @@ impl AtomicInt { /// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst)); /// assert_eq!(0b100001, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_and(&self, val: int, order: Ordering) -> int { unsafe { atomic_and(self.v.get(), val, order) } } @@ -577,7 +560,6 @@ impl AtomicInt { /// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst)); /// assert_eq!(0b111111, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_or(&self, val: int, order: Ordering) -> int { unsafe { atomic_or(self.v.get(), val, order) } } @@ -593,12 +575,12 @@ impl AtomicInt { /// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst)); /// assert_eq!(0b011110, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_xor(&self, val: int, order: Ordering) -> int { unsafe { atomic_xor(self.v.get(), val, order) } } } +#[unstable = "awaiting int/uint conventions, types may change"] impl AtomicUint { /// Creates a new `AtomicUint`. /// @@ -610,7 +592,6 @@ impl AtomicUint { /// let atomic_forty_two = AtomicUint::new(42u); /// ``` #[inline] - #[stable] pub fn new(v: uint) -> AtomicUint { AtomicUint { v: UnsafeCell::new(v) } } @@ -633,7 +614,6 @@ impl AtomicUint { /// let value = some_uint.load(Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn load(&self, order: Ordering) -> uint { unsafe { atomic_load(self.v.get() as *const uint, order) } } @@ -656,7 +636,6 @@ impl AtomicUint { /// /// Panics if `order` is `Acquire` or `AcqRel`. #[inline] - #[stable] pub fn store(&self, val: uint, order: Ordering) { unsafe { atomic_store(self.v.get(), val, order); } } @@ -675,7 +654,6 @@ impl AtomicUint { /// let value = some_uint.swap(10, Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn swap(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_swap(self.v.get(), val, order) } } @@ -697,7 +675,6 @@ impl AtomicUint { /// let value = some_uint.compare_and_swap(5, 10, Ordering::Relaxed); /// ``` #[inline] - #[stable] pub fn compare_and_swap(&self, old: uint, new: uint, order: Ordering) -> uint { unsafe { atomic_compare_and_swap(self.v.get(), old, new, order) } } @@ -714,7 +691,6 @@ impl AtomicUint { /// assert_eq!(10, foo.load(Ordering::SeqCst)); /// ``` #[inline] - #[stable] pub fn fetch_add(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_add(self.v.get(), val, order) } } @@ -731,7 +707,6 @@ impl AtomicUint { /// assert_eq!(0, foo.load(Ordering::SeqCst)); /// ``` #[inline] - #[stable] pub fn fetch_sub(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_sub(self.v.get(), val, order) } } @@ -747,7 +722,6 @@ impl AtomicUint { /// assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst)); /// assert_eq!(0b100001, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_and(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_and(self.v.get(), val, order) } } @@ -763,7 +737,6 @@ impl AtomicUint { /// assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst)); /// assert_eq!(0b111111, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_or(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_or(self.v.get(), val, order) } } @@ -779,7 +752,6 @@ impl AtomicUint { /// assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst)); /// assert_eq!(0b011110, foo.load(Ordering::SeqCst)); #[inline] - #[stable] pub fn fetch_xor(&self, val: uint, order: Ordering) -> uint { unsafe { atomic_xor(self.v.get(), val, order) } } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index d069744f8da54..964e0089e44ee 100644 --- a/src/libcore/str/mod.rs +++ b/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; diff --git a/src/libstd/prelude/mod.rs b/src/libstd/prelude/mod.rs index 1fbd17ede08f2..0496944dbaf88 100644 --- a/src/libstd/prelude/mod.rs +++ b/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; diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs index 6ce278726e9de..44671b52ba084 100644 --- a/src/libstd/sync/mod.rs +++ b/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; diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 6bc3f561bb3c7..84284ae6d66e2 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/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 Sender { /// drop(rx); /// assert_eq!(tx.send(1i).err().unwrap().0, 1); /// ``` + #[stable] pub fn send(&self, t: T) -> Result<(), SendError> { let (new_inner, ret) = match *unsafe { self.inner() } { Flavor::Oneshot(ref p) => { diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index 08e323c9cb4c3..aa2d957a3eb5e 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -121,10 +121,6 @@ impl Once { unsafe { self.mutex.destroy() } } } - - /// Deprecated - #[deprecated = "renamed to `call_once`"] - pub fn doit(&'static self, f: F) where F: FnOnce() { self.call_once(f) } } #[cfg(test)]