diff options
105 files changed, 386 insertions, 392 deletions
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 48136bc1d96..290dd21d666 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -126,7 +126,7 @@ unsafe impl<T: Sync + Send> Sync for Arc<T> { } /// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles /// between `Arc` pointers. #[unsafe_no_drop_flag] -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] pub struct Weak<T> { // FIXME #12808: strange name to try to avoid interfering with // field accesses of the contained type via Deref @@ -179,7 +179,7 @@ impl<T> Arc<T> { /// /// let weak_five = five.downgrade(); /// ``` - #[experimental = "Weak pointers may not belong in this module."] + #[unstable = "Weak pointers may not belong in this module."] pub fn downgrade(&self) -> Weak<T> { // See the clone() impl for why this is relaxed self.inner().weak.fetch_add(1, Relaxed); @@ -200,12 +200,12 @@ impl<T> Arc<T> { /// Get the number of weak references to this value. #[inline] -#[experimental] +#[unstable] pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 } /// Get the number of strong references to this value. #[inline] -#[experimental] +#[unstable] pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) } #[stable] @@ -271,7 +271,7 @@ impl<T: Send + Sync + Clone> Arc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[experimental] + #[unstable] pub fn make_unique(&mut self) -> &mut T { // Note that we hold a strong reference, which also counts as a weak reference, so we only // clone if there is an additional reference of either kind. @@ -355,7 +355,7 @@ impl<T: Sync + Send> Drop for Arc<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T: Sync + Send> Weak<T> { /// Upgrades a weak reference to a strong reference. /// @@ -393,7 +393,7 @@ impl<T: Sync + Send> Weak<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T: Sync + Send> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. /// @@ -604,7 +604,7 @@ impl<H: Hasher, T: Hash<H>> Hash<H> for Arc<T> { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod tests { use std::clone::Clone; use std::sync::mpsc::channel; diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 97b198164eb..458eb3dce57 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -44,7 +44,7 @@ use core::ops::{Deref, DerefMut}; /// } /// ``` #[lang = "exchange_heap"] -#[experimental = "may be renamed; uncertain about custom allocator design"] +#[unstable = "may be renamed; uncertain about custom allocator design"] pub static HEAP: () = (); /// A type that represents a uniquely-owned value. diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 0bb8ba669ec..916015539a0 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -57,7 +57,7 @@ //! default global allocator. It is not compatible with the libc allocator API. #![crate_name = "alloc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index 27b3f03002f..f42c6dbdc15 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -221,7 +221,7 @@ impl<T> Rc<T> { /// /// let weak_five = five.downgrade(); /// ``` - #[experimental = "Weak pointers may not belong in this module"] + #[unstable = "Weak pointers may not belong in this module"] pub fn downgrade(&self) -> Weak<T> { self.inc_weak(); Weak { @@ -234,12 +234,12 @@ impl<T> Rc<T> { /// Get the number of weak references to this value. #[inline] -#[experimental] +#[unstable] pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 } /// Get the number of strong references to this value. #[inline] -#[experimental] +#[unstable] pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value. @@ -255,7 +255,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// rc::is_unique(&five); /// ``` #[inline] -#[experimental] +#[unstable] pub fn is_unique<T>(rc: &Rc<T>) -> bool { weak_count(rc) == 0 && strong_count(rc) == 1 } @@ -277,7 +277,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool { /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u))); /// ``` #[inline] -#[experimental] +#[unstable] pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { if is_unique(&rc) { unsafe { @@ -311,7 +311,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { /// assert!(rc::get_mut(&mut x).is_none()); /// ``` #[inline] -#[experimental] +#[unstable] pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> { if is_unique(rc) { let inner = unsafe { &mut **rc._ptr }; @@ -337,7 +337,7 @@ impl<T: Clone> Rc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[experimental] + #[unstable] pub fn make_unique(&mut self) -> &mut T { if !is_unique(self) { *self = Rc::new((**self).clone()) @@ -615,7 +615,7 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> { } } -#[experimental = "Show is experimental."] +#[unstable = "Show is experimental."] impl<T: fmt::Show> fmt::Show for Rc<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "Rc({:?})", **self) @@ -635,7 +635,7 @@ impl<T: fmt::String> fmt::String for Rc<T> { /// /// See the [module level documentation](../index.html) for more. #[unsafe_no_drop_flag] -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] pub struct Weak<T> { // FIXME #12808: strange names to try to avoid interfering with // field accesses of the contained type via Deref @@ -644,7 +644,7 @@ pub struct Weak<T> { _noshare: marker::NoSync } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T> Weak<T> { /// Upgrades a weak reference to a strong reference. /// @@ -717,7 +717,7 @@ impl<T> Drop for Weak<T> { } } -#[experimental = "Weak pointers may not belong in this module."] +#[unstable = "Weak pointers may not belong in this module."] impl<T> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. /// @@ -739,7 +739,7 @@ impl<T> Clone for Weak<T> { } } -#[experimental = "Show is experimental."] +#[unstable = "Show is experimental."] impl<T: fmt::Show> fmt::Show for Weak<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "(Weak)") @@ -780,7 +780,7 @@ impl<T> RcBoxPtr<T> for Weak<T> { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod tests { use super::{Rc, Weak, weak_count, strong_count}; use std::cell::RefCell; diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index f208ff9dc05..2456d70e65e 100644 --- a/src/libarena/lib.rs +++ b/src/libarena/lib.rs @@ -20,7 +20,7 @@ //! more complex, slower arena which can hold objects of any type. #![crate_name = "arena"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index 7692c1558a7..8d57cfb6a5d 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -14,7 +14,7 @@ #![crate_name = "collections"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index cb3fbd461cd..9a1f22ef7a6 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -166,7 +166,7 @@ pub trait SliceExt { /// assert_eq!(num_moved, 3); /// assert!(a == [6i, 7, 8, 4, 5]); /// ``` - #[experimental = "uncertain about this API approach"] + #[unstable = "uncertain about this API approach"] fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint; /// Returns a subslice spanning the interval [`start`, `end`). @@ -175,7 +175,7 @@ pub trait SliceExt { /// original slice (i.e. when `end > self.len()`) or when `start > end`. /// /// Slicing with `start` equal to `end` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice(&self, start: uint, end: uint) -> &[Self::Item]; /// Returns a subslice from `start` to the end of the slice. @@ -183,7 +183,7 @@ pub trait SliceExt { /// Panics when `start` is strictly greater than the length of the original slice. /// /// Slicing from `self.len()` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_from(&self, start: uint) -> &[Self::Item]; /// Returns a subslice from the start of the slice to `end`. @@ -191,7 +191,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_to(&self, end: uint) -> &[Self::Item]; /// Divides one slice into two at an index. @@ -284,11 +284,11 @@ pub trait SliceExt { fn first(&self) -> Option<&Self::Item>; /// Returns all but the first element of a slice. - #[experimental = "likely to be renamed"] + #[unstable = "likely to be renamed"] fn tail(&self) -> &[Self::Item]; /// Returns all but the last element of a slice. - #[experimental = "likely to be renamed"] + #[unstable = "likely to be renamed"] fn init(&self) -> &[Self::Item]; /// Returns the last element of a slice, or `None` if it is empty. @@ -384,7 +384,7 @@ pub trait SliceExt { /// original slice (i.e. when `end > self.len()`) or when `start > end`. /// /// Slicing with `start` equal to `end` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item]; /// Returns a mutable subslice from `start` to the end of the slice. @@ -392,7 +392,7 @@ pub trait SliceExt { /// Panics when `start` is strictly greater than the length of the original slice. /// /// Slicing from `self.len()` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item]; /// Returns a mutable subslice from the start of the slice to `end`. @@ -400,7 +400,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[experimental = "will be replaced by slice syntax"] + #[unstable = "will be replaced by slice syntax"] fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item]; /// Returns an iterator that allows modifying each value @@ -412,11 +412,11 @@ pub trait SliceExt { fn first_mut(&mut self) -> Option<&mut Self::Item>; /// Returns all but the first element of a mutable slice - #[experimental = "likely to be renamed or removed"] + #[unstable = "likely to be renamed or removed"] fn tail_mut(&mut self) -> &mut [Self::Item]; /// Returns all but the last element of a mutable slice - #[experimental = "likely to be renamed or removed"] + #[unstable = "likely to be renamed or removed"] fn init_mut(&mut self) -> &mut [Self::Item]; /// Returns a mutable pointer to the last item in the slice. @@ -588,7 +588,7 @@ pub trait SliceExt { /// assert!(dst.clone_from_slice(&src2) == 3); /// assert!(dst == [3i, 4, 5]); /// ``` - #[experimental] + #[unstable] fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; /// Sorts the slice, in place. @@ -677,11 +677,11 @@ pub trait SliceExt { fn prev_permutation(&mut self) -> bool where Self::Item: Ord; /// Find the first index containing a matching value. - #[experimental] + #[unstable] fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; /// Find the last index containing a matching value. - #[experimental] + #[unstable] fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; /// Return true if the slice contains an element with the given value. @@ -697,7 +697,7 @@ pub trait SliceExt { fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq; /// Convert `self` into a vector without clones or allocation. - #[experimental] + #[unstable] fn into_vec(self: Box<Self>) -> Vec<Self::Item>; } @@ -1034,7 +1034,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] { /// /// The last generated swap is always (0, 1), and it returns the /// sequence to its initial order. -#[experimental] +#[unstable] #[derive(Clone)] pub struct ElementSwaps { sdir: Vec<SizeDirection>, @@ -1046,7 +1046,7 @@ pub struct ElementSwaps { impl ElementSwaps { /// Creates an `ElementSwaps` iterator for a sequence of `length` elements. - #[experimental] + #[unstable] pub fn new(length: uint) -> ElementSwaps { // Initialize `sdir` with a direction that position should move in // (all negative at the beginning) and the `size` of the diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 1bb0be05b1e..ae99a07c0ab 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -92,7 +92,7 @@ impl String { /// assert_eq!(s.as_slice(), "hello"); /// ``` #[inline] - #[experimental = "needs investigation to see if to_string() can match perf"] + #[unstable = "needs investigation to see if to_string() can match perf"] pub fn from_str(string: &str) -> String { String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) } } @@ -719,7 +719,7 @@ impl<'a> FromIterator<&'a str> for String { } } -#[experimental = "waiting on Extend stabilization"] +#[unstable = "waiting on Extend stabilization"] impl Extend<char> for String { fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) { let (lower_bound, _) = iterator.size_hint(); @@ -730,7 +730,7 @@ impl Extend<char> for String { } } -#[experimental = "waiting on Extend stabilization"] +#[unstable = "waiting on Extend stabilization"] impl<'a> Extend<&'a str> for String { fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) { // A guess that at least one byte per iterator element will be needed. @@ -790,7 +790,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str { fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) } } -#[experimental = "waiting on Str stabilization"] +#[unstable = "waiting on Str stabilization"] impl Str for String { #[inline] #[stable] @@ -814,14 +814,14 @@ impl fmt::String for String { } } -#[experimental = "waiting on fmt stabilization"] +#[unstable = "waiting on fmt stabilization"] impl fmt::Show for String { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt(&**self, f) } } -#[experimental = "waiting on Hash stabilization"] +#[unstable = "waiting on Hash stabilization"] #[cfg(stage0)] impl<H: hash::Writer> hash::Hash<H> for String { #[inline] @@ -829,7 +829,7 @@ impl<H: hash::Writer> hash::Hash<H> for String { (**self).hash(hasher) } } -#[experimental = "waiting on Hash stabilization"] +#[unstable = "waiting on Hash stabilization"] #[cfg(not(stage0))] impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { #[inline] @@ -887,7 +887,7 @@ impl ops::Deref for String { } /// Wrapper type providing a `&String` reference via `Deref`. -#[experimental] +#[unstable] pub struct DerefString<'a> { x: DerefVec<'a, u8> } @@ -914,7 +914,7 @@ impl<'a> Deref for DerefString<'a> { /// let string = as_string("foo").clone(); /// string_consumer(string); /// ``` -#[experimental] +#[unstable] pub fn as_string<'a>(x: &'a str) -> DerefString<'a> { DerefString { x: as_vec(x.as_bytes()) } } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 69a3947df2b..47afc78bc12 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -376,7 +376,7 @@ impl<T> Vec<T> { /// Note that this will drop any excess capacity. Calling this and /// converting back to a vector with `into_vec()` is equivalent to calling /// `shrink_to_fit()`. - #[experimental] + #[unstable] pub fn into_boxed_slice(mut self) -> Box<[T]> { self.shrink_to_fit(); unsafe { @@ -777,7 +777,7 @@ impl<T> Vec<T> { /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x)); /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice()); /// ``` - #[experimental = "API may change to provide stronger guarantees"] + #[unstable = "API may change to provide stronger guarantees"] pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U { // FIXME: Assert statically that the types `T` and `U` have the same // size. @@ -995,7 +995,7 @@ impl<T: Clone> Vec<T> { /// assert_eq!(vec, vec![1, 2, 3, 4]); /// ``` #[inline] - #[experimental = "likely to be replaced by a more optimized extend"] + #[unstable = "likely to be replaced by a more optimized extend"] pub fn push_all(&mut self, other: &[T]) { self.reserve(other.len()); @@ -1200,7 +1200,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> { } } -#[experimental = "waiting on Index stability"] +#[unstable = "waiting on Index stability"] impl<T> Index<uint> for Vec<T> { type Output = T; @@ -1304,7 +1304,7 @@ impl<T> FromIterator<T> for Vec<T> { } } -#[experimental = "waiting on Extend stability"] +#[unstable = "waiting on Extend stability"] impl<T> Extend<T> for Vec<T> { #[inline] fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) { @@ -1457,7 +1457,7 @@ impl<T> Default for Vec<T> { } } -#[experimental = "waiting on Show stability"] +#[unstable = "waiting on Show stability"] impl<T: fmt::Show> fmt::Show for Vec<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt(self.as_slice(), f) @@ -1475,7 +1475,7 @@ impl<'a> fmt::Writer for Vec<u8> { // Clone-on-write //////////////////////////////////////////////////////////////////////////////// -#[experimental = "unclear how valuable this alias is"] +#[unstable = "unclear how valuable this alias is"] /// A clone-on-write vector pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>; @@ -1693,13 +1693,13 @@ impl<'a, T> Drop for Drain<'a, T> { //////////////////////////////////////////////////////////////////////////////// /// Wrapper type providing a `&Vec<T>` reference via `Deref`. -#[experimental] +#[unstable] pub struct DerefVec<'a, T> { x: Vec<T>, l: ContravariantLifetime<'a> } -#[experimental] +#[unstable] impl<'a, T> Deref for DerefVec<'a, T> { type Target = Vec<T>; @@ -1719,7 +1719,7 @@ impl<'a, T> Drop for DerefVec<'a, T> { } /// Convert a slice to a wrapper type providing a `&Vec<T>` reference. -#[experimental] +#[unstable] pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { unsafe { DerefVec { diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 25007bfde93..797687a9ad9 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -89,7 +89,7 @@ use intrinsics::TypeId; #[stable] pub trait Any: 'static { /// Get the `TypeId` of `self` - #[experimental = "this method will likely be replaced by an associated static"] + #[unstable = "this method will likely be replaced by an associated static"] fn get_type_id(&self) -> TypeId; } diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 0cea0b3d88e..c07fac108d6 100644 --- a/src/libcore/array.rs +++ b/src/libcore/array.rs @@ -12,7 +12,7 @@ //! up to a certain length. Eventually we should able to generalize //! to all lengths. -#![experimental] // not yet reviewed +#![unstable] // not yet reviewed use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 674364269f1..6db01b7cb7a 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -202,7 +202,7 @@ impl<T:Copy> Cell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[experimental] + #[unstable] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -332,7 +332,7 @@ impl<T> RefCell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[experimental] + #[unstable] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -424,7 +424,7 @@ impl<'b, T> Deref for Ref<'b, T> { /// /// A `Clone` implementation would interfere with the widespread /// use of `r.borrow().clone()` to clone the contents of a `RefCell`. -#[experimental = "likely to be moved to a method, pending language changes"] +#[unstable = "likely to be moved to a method, pending language changes"] pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> { Ref { _value: orig._value, diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 3149247a83a..ffa6d085543 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -81,7 +81,7 @@ clone_impl! { char } macro_rules! extern_fn_clone { ($($A:ident),*) => ( - #[experimental = "this may not be sufficient for fns with region parameters"] + #[unstable = "this may not be sufficient for fns with region parameters"] impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType { /// Return a copy of a function pointer #[inline] diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index c3dfd5f5159..c1f1997df74 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[experimental] +#[unstable] pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) | Some(Equal) => Some(v1), @@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> { /// /// Returns the first argument if the comparison determines them to be equal. #[inline] -#[experimental] +#[unstable] pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> { match v1.partial_cmp(&v2) { Some(Less) => Some(v2), diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs index 2b48b2bf81a..a21ec892dd7 100644 --- a/src/libcore/finally.rs +++ b/src/libcore/finally.rs @@ -32,7 +32,7 @@ //! # } //! ``` -#![experimental] +#![unstable] use ops::{Drop, FnMut, FnOnce}; diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs index 1d3767c9e33..67d5482898e 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -36,7 +36,7 @@ mod num; mod float; pub mod rt; -#[experimental = "core and I/O reconciliation may alter this definition"] +#[unstable = "core and I/O reconciliation may alter this definition"] /// The type returned by formatter methods. pub type Result = result::Result<(), Error>; @@ -45,7 +45,7 @@ pub type Result = result::Result<(), Error>; /// This type does not support transmission of an error other than that an error /// occurred. Any extra information must be arranged to be transmitted through /// some other means. -#[experimental = "core and I/O reconciliation may alter this definition"] +#[unstable = "core and I/O reconciliation may alter this definition"] #[derive(Copy)] pub struct Error; @@ -58,7 +58,7 @@ pub struct Error; /// This trait should generally not be implemented by consumers of the standard /// library. The `write!` macro accepts an instance of `io::Writer`, and the /// `io::Writer` trait is favored over implementing this trait. -#[experimental = "waiting for core and I/O reconciliation"] +#[unstable = "waiting for core and I/O reconciliation"] pub trait Writer { /// Writes a slice of bytes into this writer, returning whether the write /// succeeded. @@ -123,7 +123,7 @@ enum Void {} /// family of functions. It contains a function to format the given value. At /// compile time it is ensured that the function and the value have the correct /// types, and then this struct is used to canonicalize arguments to one type. -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] #[derive(Copy)] pub struct Argument<'a> { value: &'a Void, @@ -162,7 +162,7 @@ impl<'a> Arguments<'a> { /// When using the format_args!() macro, this function is used to generate the /// Arguments structure. #[doc(hidden)] #[inline] - #[experimental = "implementation detail of the `format_args!` macro"] + #[unstable = "implementation detail of the `format_args!` macro"] pub fn new(pieces: &'a [&'a str], args: &'a [Argument<'a>]) -> Arguments<'a> { Arguments { @@ -179,7 +179,7 @@ impl<'a> Arguments<'a> { /// created with `argumentuint`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] - #[experimental = "implementation detail of the `format_args!` macro"] + #[unstable = "implementation detail of the `format_args!` macro"] pub fn with_placeholders(pieces: &'a [&'a str], fmt: &'a [rt::Argument<'a>], args: &'a [Argument<'a>]) -> Arguments<'a> { @@ -301,7 +301,7 @@ pub trait UpperExp { /// /// * output - the buffer to write output to /// * args - the precompiled arguments generated by `format_args!` -#[experimental = "libcore and I/O have yet to be reconciled, and this is an \ +#[unstable = "libcore and I/O have yet to be reconciled, and this is an \ implementation detail which should not otherwise be exported"] pub fn write(output: &mut Writer, args: Arguments) -> Result { let mut formatter = Formatter { @@ -563,7 +563,7 @@ impl<'a> Formatter<'a> { } /// Flags for formatting (packed version of rt::Flag) - #[experimental = "return type may change and method was just created"] + #[unstable = "return type may change and method was just created"] pub fn flags(&self) -> uint { self.flags } /// Character used as 'fill' whenever there is alignment @@ -592,7 +592,7 @@ impl Show for Error { /// This is a function which calls are emitted to by the compiler itself to /// create the Argument structures that are passed into the `format` function. #[doc(hidden)] #[inline] -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, t: &'a T) -> Argument<'a> { Argument::new(t, f) @@ -601,7 +601,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, /// When the compiler determines that the type of an argument *must* be a uint /// (such as for width and precision), then it invokes this method. #[doc(hidden)] #[inline] -#[experimental = "implementation detail of the `format_args!` macro"] +#[unstable = "implementation detail of the `format_args!` macro"] pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { Argument::from_uint(s) } diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 6dbda3d8445..8d8e8c4b703 100644 --- a/src/libcore/fmt/rt.rs +++ b/src/libcore/fmt/rt.rs @@ -14,7 +14,7 @@ //! These definitions are similar to their `ct` equivalents, but differ in that //! these can be statically allocated and are slightly optimized for the runtime -#![experimental = "implementation detail of the `format_args!` macro"] +#![unstable = "implementation detail of the `format_args!` macro"] pub use self::Alignment::*; pub use self::Count::*; diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index c8b3616a404..5924d515dda 100644 --- a/src/libcore/intrinsics.rs +++ b/src/libcore/intrinsics.rs @@ -39,7 +39,7 @@ //! guaranteed to happen in order. This is the standard mode for working //! with atomic types and is equivalent to Java's `volatile`. -#![experimental] +#![unstable] #![allow(missing_docs)] #[cfg(not(stage0))] @@ -333,7 +333,7 @@ extern "rust-intrinsic" { /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` /// bytes of memory starting at `dst` to `c`. - #[experimental = "uncertain about naming and semantics"] + #[unstable = "uncertain about naming and semantics"] pub fn set_memory<T>(dst: *mut T, val: u8, count: uint); /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 273a51665ce..d4aa4c99a76 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -942,7 +942,7 @@ pub trait IteratorExt: Iterator + Sized { } /// Use an iterator to reverse a container in place. - #[experimental = "uncertain about placement or widespread use"] + #[unstable = "uncertain about placement or widespread use"] fn reverse_in_place<'a, T: 'a>(&mut self) where Self: Iterator<Item=&'a mut T> + DoubleEndedIterator { @@ -974,7 +974,7 @@ pub trait DoubleEndedIterator: Iterator { /// Calling `next()` or `next_back()` on a `RandomAccessIterator` /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)` /// after `it.next()` is called. -#[experimental = "not widely used, may be better decomposed into Index and ExactSizeIterator"] +#[unstable = "not widely used, may be better decomposed into Index and ExactSizeIterator"] pub trait RandomAccessIterator: Iterator { /// Return the number of indexable elements. At most `std::uint::MAX` /// elements are indexable, even if the iterator represents a longer range. @@ -1049,7 +1049,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator { fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator { #[inline] fn indexable(&self) -> uint { self.iter.indexable() } @@ -1084,7 +1084,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat } /// A trait for iterators over elements which can be added together -#[experimental = "needs to be re-evaluated as part of numerics reform"] +#[unstable = "needs to be re-evaluated as part of numerics reform"] pub trait AdditiveIterator<A> { /// Iterates over the entire iterator, summing up all the elements /// @@ -1102,7 +1102,7 @@ pub trait AdditiveIterator<A> { macro_rules! impl_additive { ($A:ty, $init:expr) => { - #[experimental = "trait is experimental"] + #[unstable = "trait is experimental"] impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T { #[inline] fn sum(self) -> $A { @@ -1125,7 +1125,7 @@ impl_additive! { f32, 0.0 } impl_additive! { f64, 0.0 } /// A trait for iterators over elements which can be multiplied together. -#[experimental = "needs to be re-evaluated as part of numerics reform"] +#[unstable = "needs to be re-evaluated as part of numerics reform"] pub trait MultiplicativeIterator<A> { /// Iterates over the entire iterator, multiplying all the elements /// @@ -1146,7 +1146,7 @@ pub trait MultiplicativeIterator<A> { macro_rules! impl_multiplicative { ($A:ty, $init:expr) => { - #[experimental = "trait is experimental"] + #[unstable = "trait is experimental"] impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T { #[inline] fn product(self) -> $A { @@ -1287,7 +1287,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Cycle<I> where I: Clone + RandomAccessIterator, { @@ -1372,7 +1372,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T, A, B> RandomAccessIterator for Chain<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=T>, @@ -1464,7 +1464,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=U>, @@ -1546,7 +1546,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(A) -> B, @@ -1735,7 +1735,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -1961,7 +1961,7 @@ impl<I> Iterator for Skip<I> where I: Iterator { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2016,7 +2016,7 @@ impl<I> Iterator for Take<I> where I: Iterator{ } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2229,7 +2229,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator { } // Allow RandomAccessIterators to be fused without affecting random-access behavior -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -2246,7 +2246,7 @@ impl<I> Fuse<I> { /// Resets the fuse such that the next call to .next() or .next_back() will /// call the underlying iterator again even if it previously returned None. #[inline] - #[experimental = "seems marginal"] + #[unstable = "seems marginal"] pub fn reset_fuse(&mut self) { self.done = false } @@ -2315,7 +2315,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(&A), @@ -2364,7 +2364,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where /// println!("{}", i); /// } /// ``` -#[experimental] +#[unstable] pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { f: F, /// Internal state that will be passed to the closure on the next iteration @@ -2385,7 +2385,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where } } -#[experimental] +#[unstable] impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> { /// Creates a new iterator with the specified closure as the "iterator /// function" and an initial state to eventually pass to the closure @@ -2778,7 +2778,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> { fn next_back(&mut self) -> Option<A> { self.idx(0) } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<A: Clone> RandomAccessIterator for Repeat<A> { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2790,12 +2790,12 @@ type IterateState<T, F> = (F, Option<T>, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. -#[experimental] +#[unstable] pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>; /// Create a new iterator that produces an infinite sequence of /// repeated applications of the given function `f`. -#[experimental] +#[unstable] pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where T: Clone, F: FnMut(T) -> T, diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index af5aba53bf4..8c4c8a0e78e 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -48,7 +48,7 @@ // separate crate, libcoretest, to avoid bizarre issues. #![crate_name = "core"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs index 087404da624..abaf2529323 100644 --- a/src/libcore/nonzero.rs +++ b/src/libcore/nonzero.rs @@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {} /// NULL or 0 that might allow certain optimizations. #[lang="non_zero"] #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)] -#[experimental] +#[unstable] pub struct NonZero<T: Zeroable>(T); impl<T: Zeroable> NonZero<T> { diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 91fed8a31bd..57415f4331d 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -726,7 +726,7 @@ impl UnsignedInt for u32 {} impl UnsignedInt for u64 {} /// A generic trait for converting a value to a number. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait ToPrimitive { /// Converts the value of `self` to an `int`. #[inline] @@ -991,7 +991,7 @@ impl_to_primitive_float! { f32 } impl_to_primitive_float! { f64 } /// A generic trait for converting a number to a value. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait FromPrimitive : ::marker::Sized { /// Convert an `int` to return an optional value of this type. If the /// value cannot be represented by this value, the `None` is returned. @@ -1073,73 +1073,73 @@ pub trait FromPrimitive : ::marker::Sized { } /// A utility function that just calls `FromPrimitive::from_int`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> { FromPrimitive::from_int(n) } /// A utility function that just calls `FromPrimitive::from_i8`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> { FromPrimitive::from_i8(n) } /// A utility function that just calls `FromPrimitive::from_i16`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> { FromPrimitive::from_i16(n) } /// A utility function that just calls `FromPrimitive::from_i32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> { FromPrimitive::from_i32(n) } /// A utility function that just calls `FromPrimitive::from_i64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> { FromPrimitive::from_i64(n) } /// A utility function that just calls `FromPrimitive::from_uint`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> { FromPrimitive::from_uint(n) } /// A utility function that just calls `FromPrimitive::from_u8`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> { FromPrimitive::from_u8(n) } /// A utility function that just calls `FromPrimitive::from_u16`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> { FromPrimitive::from_u16(n) } /// A utility function that just calls `FromPrimitive::from_u32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> { FromPrimitive::from_u32(n) } /// A utility function that just calls `FromPrimitive::from_u64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> { FromPrimitive::from_u64(n) } /// A utility function that just calls `FromPrimitive::from_f32`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> { FromPrimitive::from_f32(n) } /// A utility function that just calls `FromPrimitive::from_f64`. -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> { FromPrimitive::from_f64(n) } @@ -1190,13 +1190,13 @@ impl_from_primitive! { f64, to_f64 } /// ``` /// #[inline] -#[experimental = "likely to be removed"] +#[unstable = "likely to be removed"] pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> { NumCast::from(n) } /// An interface for casting between machine scalars. -#[experimental = "trait is likely to be removed"] +#[unstable = "trait is likely to be removed"] pub trait NumCast: ToPrimitive { /// Creates a number from another value that can be converted into a primitive via the /// `ToPrimitive` trait. @@ -1394,20 +1394,20 @@ pub trait Float } /// A generic trait for converting a string with a radix (base) to a value -#[experimental = "might need to return Result"] +#[unstable = "might need to return Result"] pub trait FromStrRadix { fn from_str_radix(str: &str, radix: uint) -> Option<Self>; } /// A utility function that just calls FromStrRadix::from_str_radix. -#[experimental = "might need to return Result"] +#[unstable = "might need to return Result"] pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> { FromStrRadix::from_str_radix(str, radix) } macro_rules! from_str_radix_float_impl { ($T:ty) => { - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStr for $T { /// Convert a string in base 10 to a float. /// Accepts an optional decimal exponent. @@ -1440,7 +1440,7 @@ macro_rules! from_str_radix_float_impl { } } - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStrRadix for $T { /// Convert a string in a given base to a float. /// @@ -1604,7 +1604,7 @@ from_str_radix_float_impl! { f64 } macro_rules! from_str_radix_int_impl { ($T:ty) => { - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStr for $T { #[inline] fn from_str(src: &str) -> Option<$T> { @@ -1612,7 +1612,7 @@ macro_rules! from_str_radix_int_impl { } } - #[experimental = "might need to return Result"] + #[unstable = "might need to return Result"] impl FromStrRadix for $T { fn from_str_radix(src: &str, radix: uint) -> Option<$T> { assert!(radix >= 2 && radix <= 36, diff --git a/src/libcore/option.rs b/src/libcore/option.rs index deee67b6d2f..41eecb4649d 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -477,7 +477,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or(0i), Err(0i)); /// ``` #[inline] - #[experimental] + #[unstable] pub fn ok_or<E>(self, err: E) -> Result<T, E> { match self { Some(v) => Ok(v), @@ -498,7 +498,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or_else(|| 0i), Err(0i)); /// ``` #[inline] - #[experimental] + #[unstable] pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> { match self { Some(v) => Ok(v), diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index a17cd410303..ab1e69f0060 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -106,7 +106,7 @@ pub use intrinsics::copy_nonoverlapping_memory; #[unstable] pub use intrinsics::copy_memory; -#[experimental = "uncertain about naming and semantics"] +#[unstable = "uncertain about naming and semantics"] pub use intrinsics::set_memory; diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 1ad6d43f76f..13a387c7cb0 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(missing_docs)] -#![experimental] +#![unstable] //! Contains struct definitions for the layout of compiler built-in types. //! diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 7868ec67c8a..f7421203336 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -953,7 +953,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> { /// If an `Err` is encountered, it is immediately returned. /// Otherwise, the folded value is returned. #[inline] -#[experimental] +#[unstable] pub fn fold<T, V, E, diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs index 1f9aebb91be..b73910d7c06 100644 --- a/src/libcore/simd.rs +++ b/src/libcore/simd.rs @@ -19,7 +19,7 @@ //! provided beyond this module. //! //! ```rust -//! #[allow(experimental)]; +//! #[allow(unstable)]; //! //! fn main() { //! use std::simd::f32x4; @@ -37,7 +37,7 @@ #![allow(non_camel_case_types)] #![allow(missing_docs)] -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -46,26 +46,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8, pub i8); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i16x8(pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16, pub i16); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i32x4(pub i32, pub i32, pub i32, pub i32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i64x2(pub i64, pub i64); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -74,32 +74,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8, pub u8); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u16x8(pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16, pub u16); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u32x4(pub u32, pub u32, pub u32, pub u32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u64x2(pub u64, pub u64); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct f32x4(pub f32, pub f32, pub f32, pub f32); -#[experimental] +#[unstable] #[simd] #[derive(Copy, Show)] #[repr(C)] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 6c62bfda1fe..7e47c5257a3 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -457,7 +457,7 @@ impl<T> SliceExt for [T] { self.binary_search_by(|p| p.cmp(x)) } - #[experimental] + #[unstable] fn next_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -488,7 +488,7 @@ impl<T> SliceExt for [T] { true } - #[experimental] + #[unstable] fn prev_permutation(&mut self) -> bool where T: Ord { // These cases only have 1 permutation each, so we can't do anything. if self.len() < 2 { return false; } @@ -630,25 +630,25 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] { //////////////////////////////////////////////////////////////////////////////// /// Data that is viewable as a slice. -#[experimental = "will be replaced by slice syntax"] +#[unstable = "will be replaced by slice syntax"] pub trait AsSlice<T> { /// Work with `self` as a slice. fn as_slice<'a>(&'a self) -> &'a [T]; } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<T> AsSlice<T> for [T] { #[inline(always)] fn as_slice<'a>(&'a self) -> &'a [T] { self } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U { #[inline(always)] fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) } @@ -754,7 +754,7 @@ pub struct Iter<'a, T: 'a> { marker: marker::ContravariantLifetime<'a> } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -763,7 +763,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -772,7 +772,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -781,7 +781,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> { type Output = [T]; #[inline] @@ -795,7 +795,7 @@ impl<'a, T> Iter<'a, T> { /// /// This has the same lifetime as the original slice, and so the /// iterator can continue to be used while this exists. - #[experimental] + #[unstable] pub fn as_slice(&self) -> &'a [T] { make_slice!(T => &'a [T]: self.ptr, self.end) } @@ -813,7 +813,7 @@ impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { *self } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -847,7 +847,7 @@ pub struct IterMut<'a, T: 'a> { } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -855,7 +855,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -863,7 +863,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -871,7 +871,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -880,7 +880,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -888,7 +888,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -896,7 +896,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -904,7 +904,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[experimental] +#[unstable] impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -921,7 +921,7 @@ impl<'a, T> IterMut<'a, T> { /// to consume the iterator. Consider using the `Slice` and /// `SliceMut` implementations for obtaining slices with more /// restricted lifetimes that do not consume the iterator. - #[experimental] + #[unstable] pub fn into_slice(self) -> &'a mut [T] { make_slice!(T => &'a mut [T]: self.ptr, self.end) } @@ -1269,7 +1269,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> { } } -#[experimental = "trait is experimental"] +#[unstable = "trait is experimental"] impl<'a, T> RandomAccessIterator for Chunks<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -1417,7 +1417,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { // /// Operations on `[u8]`. -#[experimental = "needs review"] +#[unstable = "needs review"] pub mod bytes { use ptr; use slice::SliceExt; @@ -1430,7 +1430,7 @@ pub mod bytes { impl MutableByteVector for [u8] { #[inline] - #[allow(experimental)] + #[allow(unstable)] fn set_memory(&mut self, value: u8) { unsafe { ptr::set_memory(self.as_mut_ptr(), value, self.len()) }; } @@ -1506,7 +1506,7 @@ impl<T: PartialOrd> PartialOrd for [T] { } /// Extension methods for slices containing integers. -#[experimental] +#[unstable] pub trait IntSliceExt<U, S> { /// Converts the slice to an immutable slice of unsigned integers with the same width. fn as_unsigned<'a>(&'a self) -> &'a [U]; @@ -1521,7 +1521,7 @@ pub trait IntSliceExt<U, S> { macro_rules! impl_int_slice { ($u:ty, $s:ty, $t:ty) => { - #[experimental] + #[unstable] impl IntSliceExt<$u, $s> for [$t] { #[inline] fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } } diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs index 86f34ecd15e..a808593ffbd 100644 --- a/src/libcoretest/cell.rs +++ b/src/libcoretest/cell.rs @@ -114,7 +114,7 @@ fn discard_doesnt_unborrow() { } #[test] -#[allow(experimental)] +#[allow(unstable)] fn clone_ref_updates_flag() { let x = RefCell::new(0i); { diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 1896bdd182a..e7e1ead664c 100644 --- a/src/libflate/lib.rs +++ b/src/libflate/lib.rs @@ -15,7 +15,7 @@ //! [mz]: https://code.google.com/p/miniz/ #![crate_name = "flate"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 02eea5d024c..a16fc88d58a 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -15,7 +15,7 @@ //! generated instead. #![crate_name = "fmt_macros"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 1d6c99542b5..a85c8eed5e2 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -78,7 +78,7 @@ //! ``` #![crate_name = "getopts"] -#![experimental = "use the crates.io `getopts` library instead"] +#![unstable = "use the crates.io `getopts` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 9d2318e253e..d6d76b986e4 100644 --- a/src/libgraphviz/lib.rs +++ b/src/libgraphviz/lib.rs @@ -265,7 +265,7 @@ //! * [DOT language](http://www.graphviz.org/doc/info/lang.html) #![crate_name = "graphviz"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index c39fd074387..be630995e24 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -10,7 +10,7 @@ #![crate_name = "libc"] #![crate_type = "rlib"] -#![cfg_attr(not(feature = "cargo-build"), experimental)] +#![cfg_attr(not(feature = "cargo-build"), unstable)] #![cfg_attr(not(feature = "cargo-build"), staged_api)] #![no_std] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 0d5f6b65827..96d31444eee 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -156,7 +156,7 @@ //! if logging is disabled, none of the components of the log will be executed. #![crate_name = "log"] -#![experimental = "use the crates.io `log` library instead"] +#![unstable = "use the crates.io `log` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 2fdba8a6c4f..e248de10df4 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -17,7 +17,7 @@ //! internally. The `IndependentSample` trait is for generating values //! that do not need to record state. -#![experimental] +#![unstable] use core::prelude::*; use core::num::{Float, Int}; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 497e339b316..a533739ee3b 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -24,7 +24,7 @@ html_playground_url = "http://play.rust-lang.org/")] #![no_std] -#![experimental] +#![unstable] #![staged_api] #[macro_use] diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index da803aa5011..19cbead5489 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -16,7 +16,7 @@ //! http://www.matroska.org/technical/specs/rfc/index.html #![crate_name = "rbml"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index d19ce3b460a..bbc2e315409 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -16,7 +16,7 @@ #![crate_name = "regex"] #![crate_type = "rlib"] #![crate_type = "dylib"] -#![experimental = "use the crates.io `regex` library instead"] +#![unstable = "use the crates.io `regex` library instead"] #![staged_api] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", html_favicon_url = "http://www.rust-lang.org/favicon.ico", diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 16dd32b6be2..abc51d62404 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -255,7 +255,7 @@ impl Regex { } #[doc(hidden)] - #[experimental] + #[unstable] pub fn names_iter<'a>(&'a self) -> NamesIter<'a> { match *self { Native(ref n) => NamesIterNative(n.names.iter()), @@ -410,7 +410,7 @@ pub struct Captures<'t> { } impl<'t> Captures<'t> { - #[allow(experimental)] + #[allow(unstable)] fn new(re: &Regex, search: &'t str, locs: CaptureLocs) -> Option<Captures<'t>> { if !has_match(&locs) { diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index e0143917a7c..138a49d0955 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index 7d893f3a106..7df2de32182 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -1630,36 +1630,29 @@ declare_lint! { Warn, "detects use of #[deprecated] items" } -// FIXME #6875: Change to Warn after std library stabilization is complete -declare_lint! { - EXPERIMENTAL, - Allow, - "detects use of #[experimental] items" -} declare_lint! { UNSTABLE, - Allow, + Warn, "detects use of #[unstable] items (incl. items with no stability attribute)" } -declare_lint!(STAGED_EXPERIMENTAL, Warn, - "detects use of #[experimental] items in staged builds"); - -declare_lint!(STAGED_UNSTABLE, Warn, - "detects use of #[unstable] items (incl. items with no stability attribute) \ - in staged builds"); - -/// Checks for use of items with `#[deprecated]`, `#[experimental]` and +/// Checks for use of items with `#[deprecated]`, `#[unstable]` and /// `#[unstable]` attributes, or no stability attribute. #[derive(Copy)] -pub struct Stability; +pub struct Stability { this_crate_staged: bool } impl Stability { + pub fn new() -> Stability { Stability { this_crate_staged: false } } + fn lint(&self, cx: &Context, id: ast::DefId, span: Span) { let ref stability = stability::lookup(cx.tcx, id); let cross_crate = !ast_util::is_local(id); + let staged = (!cross_crate && self.this_crate_staged) + || (cross_crate && stability::is_staged_api(cx.tcx, id)); + + if !staged { return } // stability attributes are promises made across crates; only // check DEPRECATED for crate-local usage. @@ -1668,21 +1661,12 @@ impl Stability { None if cross_crate => (UNSTABLE, "unmarked"), Some(attr::Stability { level: attr::Unstable, .. }) if cross_crate => (UNSTABLE, "unstable"), - Some(attr::Stability { level: attr::Experimental, .. }) if cross_crate => - (EXPERIMENTAL, "experimental"), Some(attr::Stability { level: attr::Deprecated, .. }) => (DEPRECATED, "deprecated"), _ => return }; output(cx, span, stability, lint, label); - if cross_crate && stability::is_staged_api(cx.tcx, id) { - if lint.name == UNSTABLE.name { - output(cx, span, stability, STAGED_UNSTABLE, label); - } else if lint.name == EXPERIMENTAL.name { - output(cx, span, stability, STAGED_EXPERIMENTAL, label); - } - } fn output(cx: &Context, span: Span, stability: &Option<attr::Stability>, lint: &'static Lint, label: &'static str) { @@ -1706,7 +1690,7 @@ impl Stability { impl LintPass for Stability { fn get_lints(&self) -> LintArray { - lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE, STAGED_EXPERIMENTAL, STAGED_UNSTABLE) + lint_array!(DEPRECATED, UNSTABLE) } fn check_crate(&mut self, _: &Context, c: &ast::Crate) { @@ -1717,6 +1701,7 @@ impl LintPass for Stability { match attr.node.value.node { ast::MetaWord(_) => { attr::mark_used(attr); + self.this_crate_staged = true; } _ => (/*pass*/) } diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs index db4d99fe494..95e1e8d44bf 100644 --- a/src/librustc/lint/context.rs +++ b/src/librustc/lint/context.rs @@ -209,7 +209,6 @@ impl LintStore { UnsafeBlocks, UnusedMut, UnusedAllocation, - Stability, MissingCopyImplementations, UnstableFeatures, ); @@ -218,6 +217,7 @@ impl LintStore { TypeLimits, RawPointerDerive, MissingDoc, + Stability, ); add_lint_group!(sess, "bad_style", @@ -308,18 +308,21 @@ impl LintStore { UnstableFeatures::Cheat => Allow }; match self.by_name.get("unstable_features") { - Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), - Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), - None => unreachable!() - } - match self.by_name.get("staged_unstable") { - Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), - Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + Some(&Id(lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, + Some(&Renamed(_, lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, None => unreachable!() } - match self.by_name.get("staged_experimental") { - Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), - Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)), + match self.by_name.get("unstable") { + Some(&Id(lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, + Some(&Renamed(_, lint_id)) => if self.get_level_source(lint_id).0 != Forbid { + self.set_level(lint_id, (lvl, ReleaseChannel)) + }, None => unreachable!() } } diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs index 8a266a2530b..826a35e3bb5 100644 --- a/src/librustc/lint/mod.rs +++ b/src/librustc/lint/mod.rs @@ -40,7 +40,7 @@ use syntax::ast; pub use lint::context::{Context, LintStore, raw_emit_lint, check_crate, gather_attrs}; /// Specification of a single lint. -#[derive(Copy)] +#[derive(Copy, Show)] pub struct Lint { /// A string identifier for the lint. /// @@ -208,7 +208,7 @@ impl LintId { } /// Setting for how to handle a lint. -#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord)] +#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Show)] pub enum Level { Allow, Warn, Deny, Forbid } diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index fcd20158c0a..7aac6446597 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -22,7 +22,7 @@ //! build speedups. #![crate_name = "rustc_back"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index 452eaaaa52d..162880d1856 100644 --- a/src/librustc_borrowck/lib.rs +++ b/src/librustc_borrowck/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustc_borrowck"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 27e1eaacdfd..26790bfcde0 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc_driver"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 4a281c413d6..61363e5423b 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -14,7 +14,7 @@ #![allow(dead_code)] #![crate_name = "rustc_llvm"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index a1ae96490ca..65075745ee0 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustc_resolve"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index 5da51697d2f..97b3dc12f4c 100644 --- a/src/librustc_trans/lib.rs +++ b/src/librustc_trans/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "rustc_trans"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 76ac4b2e8af..5824fb776bb 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -64,7 +64,7 @@ This API is completely unstable and subject to change. */ #![crate_name = "rustc_typeck"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 56f5c23f6f1..1bbbcfb3838 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustdoc"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 671408acebf..77c2315194b 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -22,7 +22,7 @@ use string::String; use vec::Vec; /// Extension methods for ASCII-subset only operations on owned strings -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] pub trait OwnedAsciiExt { /// Convert the string to ASCII upper case: /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', @@ -36,7 +36,7 @@ pub trait OwnedAsciiExt { } /// Extension methods for ASCII-subset only operations on string slices -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] pub trait AsciiExt<T = Self> { /// Check if within the ASCII range. fn is_ascii(&self) -> bool; @@ -57,7 +57,7 @@ pub trait AsciiExt<T = Self> { fn eq_ignore_ascii_case(&self, other: &Self) -> bool; } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt<String> for str { #[inline] fn is_ascii(&self) -> bool { @@ -82,7 +82,7 @@ impl AsciiExt<String> for str { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl OwnedAsciiExt for String { #[inline] fn into_ascii_uppercase(self) -> String { @@ -97,7 +97,7 @@ impl OwnedAsciiExt for String { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt<Vec<u8>> for [u8] { #[inline] fn is_ascii(&self) -> bool { @@ -123,7 +123,7 @@ impl AsciiExt<Vec<u8>> for [u8] { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl OwnedAsciiExt for Vec<u8> { #[inline] fn into_ascii_uppercase(mut self) -> Vec<u8> { @@ -142,7 +142,7 @@ impl OwnedAsciiExt for Vec<u8> { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt for u8 { #[inline] fn is_ascii(&self) -> bool { @@ -165,7 +165,7 @@ impl AsciiExt for u8 { } } -#[experimental = "would prefer to do this in a more general way"] +#[unstable = "would prefer to do this in a more general way"] impl AsciiExt for char { #[inline] fn is_ascii(&self) -> bool { diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs index 8dc41368e7f..3a059766fef 100644 --- a/src/libstd/bitflags.rs +++ b/src/libstd/bitflags.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] //! A typesafe bitmask flag generator. diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index e43cc053ba0..456f3763b39 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -632,7 +632,7 @@ impl<K, V> RawTable<K, V> { /// Creates a new raw table from a given capacity. All buckets are /// initially empty. - #[allow(experimental)] + #[allow(unstable)] pub fn new(capacity: uint) -> RawTable<K, V> { unsafe { let ret = RawTable::new_uninitialized(capacity); diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 2d013a8a5b8..3eeb09b79da 100644 --- a/src/libstd/dynamic_lib.rs +++ b/src/libstd/dynamic_lib.rs @@ -12,7 +12,7 @@ //! //! A simple wrapper over the platform's dynamic library facilities -#![experimental] +#![unstable] #![allow(missing_docs)] use prelude::v1::*; diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index dbc88ddf0a0..54191cf2404 100644 --- a/src/libstd/failure.rs +++ b/src/libstd/failure.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] use prelude::v1::*; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 96fff64d221..907925e93d3 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -410,7 +410,7 @@ //! them with the same character. For example, the `{` character is escaped with //! `{{` and the `}` character is escaped with `}}`. -#![experimental] +#![unstable] use string; @@ -439,7 +439,7 @@ pub use core::fmt::{argument, argumentuint}; /// let s = fmt::format(format_args!("Hello, {}!", "world")); /// assert_eq!(s, "Hello, world!".to_string()); /// ``` -#[experimental = "this is an implementation detail of format! and should not \ +#[unstable = "this is an implementation detail of format! and should not \ be called directly"] pub fn format(args: Arguments) -> string::String { let mut output = string::String::new(); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 1c48b20c444..3968dda2a82 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -219,7 +219,7 @@ //! concerned with error handling; instead its caller is responsible for //! responding to errors that may occur while attempting to read the numbers. -#![experimental] +#![unstable] #![deny(unused_must_use)] pub use self::SeekStyle::*; diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs index 29295b5751c..42d9fff6d15 100644 --- a/src/libstd/io/net/pipe.rs +++ b/src/libstd/io/net/pipe.rs @@ -68,7 +68,7 @@ impl UnixStream { /// /// If a `timeout` with zero or negative duration is specified then /// the function returns `Err`, with the error kind set to `TimedOut`. - #[experimental = "the timeout argument is likely to change types"] + #[unstable = "the timeout argument is likely to change types"] pub fn connect_timeout<P>(path: P, timeout: Duration) -> IoResult<UnixStream> where P: BytesContainer { @@ -107,7 +107,7 @@ impl UnixStream { /// Sets the read/write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -115,7 +115,7 @@ impl UnixStream { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -123,7 +123,7 @@ impl UnixStream { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -219,7 +219,7 @@ impl UnixAcceptor { /// When using this method, it is likely necessary to reset the timeout as /// appropriate, the timeout specified is specific to this object, not /// specific to the next request. - #[experimental = "the name and arguments to this function are likely \ + #[unstable = "the name and arguments to this function are likely \ to change"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) @@ -229,7 +229,7 @@ impl UnixAcceptor { /// /// This function has the same semantics as `TcpAcceptor::close_accept`, and /// more information can be found in that documentation. - #[experimental] + #[unstable] pub fn close_accept(&mut self) -> IoResult<()> { self.inner.close_accept() } diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs index 7a376b50cd7..6a3f5fcb2c6 100644 --- a/src/libstd/io/net/tcp.rs +++ b/src/libstd/io/net/tcp.rs @@ -85,7 +85,7 @@ impl TcpStream { /// /// If a `timeout` with zero or negative duration is specified then /// the function returns `Err`, with the error kind set to `TimedOut`. - #[experimental = "the timeout argument may eventually change types"] + #[unstable = "the timeout argument may eventually change types"] pub fn connect_timeout<A: ToSocketAddr>(addr: A, timeout: Duration) -> IoResult<TcpStream> { if timeout <= Duration::milliseconds(0) { @@ -109,7 +109,7 @@ impl TcpStream { } /// Sets the nodelay flag on this connection to the boolean specified - #[experimental] + #[unstable] pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> { self.inner.set_nodelay(nodelay) } @@ -119,7 +119,7 @@ impl TcpStream { /// If the value specified is `None`, then the keepalive flag is cleared on /// this connection. Otherwise, the keepalive timeout will be set to the /// specified time, in seconds. - #[experimental] + #[unstable] pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> { self.inner.set_keepalive(delay_in_seconds) } @@ -187,7 +187,7 @@ impl TcpStream { /// /// For clarification on the semantics of interrupting a read and a write, /// take a look at `set_read_timeout` and `set_write_timeout`. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -204,7 +204,7 @@ impl TcpStream { /// action is taken. Otherwise, the read operation will be scheduled to /// promptly return. If a timeout error is returned, then no data was read /// during the timeout period. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -231,7 +231,7 @@ impl TcpStream { /// does not know how many bytes were written as part of the timeout /// operation. It may be the case that bytes continue to be written in an /// asynchronous fashion after the call to write returns. - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -374,7 +374,7 @@ impl TcpAcceptor { /// # Example /// /// ```no_run - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::TcpListener; /// use std::io::{Listener, Acceptor, TimedOut}; /// @@ -397,7 +397,7 @@ impl TcpAcceptor { /// a.set_timeout(None); /// let socket = a.accept(); /// ``` - #[experimental = "the type of the argument and name of this function are \ + #[unstable = "the type of the argument and name of this function are \ subject to change"] pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); } @@ -418,7 +418,7 @@ impl TcpAcceptor { /// # Example /// /// ``` - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::{TcpListener, Listener, Acceptor, EndOfFile}; /// use std::thread::Thread; /// @@ -444,7 +444,7 @@ impl TcpAcceptor { /// // Signal our accept loop to exit /// assert!(a.close_accept().is_ok()); /// ``` - #[experimental] + #[unstable] pub fn close_accept(&mut self) -> IoResult<()> { self.inner.close_accept() } @@ -482,7 +482,7 @@ impl sys_common::AsInner<TcpAcceptorImp> for TcpAcceptor { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod test { use prelude::v1::*; diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index a4db0d4f5de..8cdad3f528a 100644 --- a/src/libstd/io/net/udp.rs +++ b/src/libstd/io/net/udp.rs @@ -92,13 +92,13 @@ impl UdpSocket { } /// Joins a multicast IP address (becomes a member of it) - #[experimental] + #[unstable] pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { self.inner.join_multicast(multi) } /// Leaves a multicast IP address (drops membership from it) - #[experimental] + #[unstable] pub fn leave_multicast(&mut self, multi: IpAddr) -> IoResult<()> { self.inner.leave_multicast(multi) } @@ -106,25 +106,25 @@ impl UdpSocket { /// Set the multicast loop flag to the specified value /// /// This lets multicast packets loop back to local sockets (if enabled) - #[experimental] + #[unstable] pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> { self.inner.set_multicast_loop(on) } /// Sets the multicast TTL - #[experimental] + #[unstable] pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.multicast_time_to_live(ttl) } /// Sets this socket's TTL - #[experimental] + #[unstable] pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.time_to_live(ttl) } /// Sets the broadcast flag on or off - #[experimental] + #[unstable] pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> { self.inner.set_broadcast(broadcast) } @@ -132,7 +132,7 @@ impl UdpSocket { /// Sets the read/write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_timeout(timeout_ms) } @@ -140,7 +140,7 @@ impl UdpSocket { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_read_timeout(timeout_ms) } @@ -148,7 +148,7 @@ impl UdpSocket { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[experimental = "the timeout argument may change in type and value"] + #[unstable = "the timeout argument may change in type and value"] pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) { self.inner.set_write_timeout(timeout_ms) } @@ -176,7 +176,7 @@ impl sys_common::AsInner<UdpSocketImp> for UdpSocket { } #[cfg(test)] -#[allow(experimental)] +#[allow(unstable)] mod test { use prelude::v1::*; diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index f824d821601..a093e748d57 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -10,7 +10,7 @@ //! Bindings for executing child processes -#![allow(experimental)] +#![allow(unstable)] #![allow(non_upper_case_globals)] pub use self::StdioContainer::*; @@ -661,7 +661,7 @@ impl Process { /// # Example /// /// ```no_run - /// # #![allow(experimental)] + /// # #![allow(unstable)] /// use std::io::{Command, IoResult}; /// use std::io::process::ProcessExit; /// @@ -689,7 +689,7 @@ impl Process { /// p.wait() /// } /// ``` - #[experimental = "the type of the timeout is likely to change"] + #[unstable = "the type of the timeout is likely to change"] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0); } diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 0594b711ad6..0f293d789ab 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -14,7 +14,7 @@ //! library. Each macro is available for use when linking against the standard //! library. -#![experimental] +#![unstable] /// The entry point for panic of Rust tasks. /// @@ -324,7 +324,7 @@ macro_rules! try { /// /// For more information about select, see the `std::sync::mpsc::Select` structure. #[macro_export] -#[experimental] +#[unstable] macro_rules! select { ( $($name:pat = $rx:ident.$meth:ident() => $code:expr),+ diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs index 0a1c17fab47..adbce893887 100644 --- a/src/libstd/num/f32.rs +++ b/src/libstd/num/f32.rs @@ -366,7 +366,7 @@ impl Float for f32 { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_string(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigAll, ExpNone, false); @@ -379,7 +379,7 @@ pub fn to_string(num: f32) -> String { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_hex(num: f32) -> String { let (r, _) = strconv::float_to_str_common( num, 16u, true, SignNeg, DigAll, ExpNone, false); @@ -394,7 +394,7 @@ pub fn to_str_hex(num: f32) -> String { /// * num - The float value /// * radix - The base to use #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -407,7 +407,7 @@ pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exact(num: f32, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); @@ -422,7 +422,7 @@ pub fn to_str_exact(num: f32, dig: uint) -> String { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_digits(num: f32, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); @@ -438,7 +438,7 @@ pub fn to_str_digits(num: f32, dig: uint) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); @@ -454,7 +454,7 @@ pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs index 2806154a016..baff14125ee 100644 --- a/src/libstd/num/f64.rs +++ b/src/libstd/num/f64.rs @@ -375,7 +375,7 @@ impl Float for f64 { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_string(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigAll, ExpNone, false); @@ -388,7 +388,7 @@ pub fn to_string(num: f64) -> String { /// /// * num - The float value #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_hex(num: f64) -> String { let (r, _) = strconv::float_to_str_common( num, 16u, true, SignNeg, DigAll, ExpNone, false); @@ -403,7 +403,7 @@ pub fn to_str_hex(num: f64) -> String { /// * num - The float value /// * radix - The base to use #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) { strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false) } @@ -416,7 +416,7 @@ pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exact(num: f64, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpNone, false); @@ -431,7 +431,7 @@ pub fn to_str_exact(num: f64, dig: uint) -> String { /// * num - The float value /// * digits - The number of significant digits #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_digits(num: f64, dig: uint) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpNone, false); @@ -447,7 +447,7 @@ pub fn to_str_digits(num: f64, dig: uint) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper); @@ -463,7 +463,7 @@ pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String { /// * digits - The number of digits after the decimal point /// * upper - Use `E` instead of `e` for the exponent sign #[inline] -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String { let (r, _) = strconv::float_to_str_common( num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper); diff --git a/src/libstd/num/float_macros.rs b/src/libstd/num/float_macros.rs index 4c52f29b12d..ec168eaaa9d 100644 --- a/src/libstd/num/float_macros.rs +++ b/src/libstd/num/float_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] macro_rules! assert_approx_eq { diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index ebcb2086187..5bc54152874 100644 --- a/src/libstd/num/int_macros.rs +++ b/src/libstd/num/int_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] macro_rules! int_module { ($T:ty) => ( diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 9c6911cf4d1..e804408b4d0 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -33,7 +33,7 @@ pub use core::num::{FpCategory}; use option::Option; -#[experimental = "may be removed or relocated"] +#[unstable = "may be removed or relocated"] pub mod strconv; /// Mathematical operations on primitive floating point numbers. diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 4ce15491a0e..f480a3b420f 100644 --- a/src/libstd/num/uint_macros.rs +++ b/src/libstd/num/uint_macros.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![experimental] +#![unstable] #![doc(hidden)] #![allow(unsigned_negation)] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index cef85c260a7..6e3949b9e22 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -22,7 +22,7 @@ //! so we will not _hide_ the facts of which OS the user is on -- they should be given the //! opportunity to write OS-ignorant code by default. -#![experimental] +#![unstable] #![allow(missing_docs)] #![allow(non_snake_case)] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index b474ae4e371..1ec7b6b3edc 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -59,7 +59,7 @@ //! println!("path exists: {}", path.exists()); //! ``` -#![experimental] +#![unstable] use core::marker::Sized; use ffi::CString; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 3fa1efe1ccd..60d490982db 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -219,7 +219,7 @@ //! } //! ``` -#![experimental] +#![unstable] use cell::RefCell; use clone::Clone; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index 5ef55f5b487..e3e4e132b81 100644 --- a/src/libstd/rt/mod.rs +++ b/src/libstd/rt/mod.rs @@ -16,7 +16,7 @@ //! and should be considered as private implementation details for the //! time being. -#![experimental] +#![unstable] // FIXME: this should not be here. #![allow(missing_docs)] diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 03876189da9..4cd0b29688a 100644 --- a/src/libstd/rt/unwind.rs +++ b/src/libstd/rt/unwind.rs @@ -582,7 +582,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> /// Only a limited number of callbacks can be registered, and this function /// returns whether the callback was successfully registered or not. It is not /// currently possible to unregister a callback once it has been registered. -#[experimental] +#[unstable] pub unsafe fn register(f: Callback) -> bool { match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) { // The invocation code has knowledge of this window where the count has diff --git a/src/libstd/rtdeps.rs b/src/libstd/rtdeps.rs index 862808a9e3d..f4fbd378899 100644 --- a/src/libstd/rtdeps.rs +++ b/src/libstd/rtdeps.rs @@ -12,7 +12,7 @@ //! the standard library This varies per-platform, but these libraries are //! necessary for running libstd. -#![experimental] +#![unstable] // All platforms need to link to rustrt #[cfg(not(test))] diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index f8eae1322bf..83de98fdbff 100644 --- a/src/libstd/sync/mpsc/mpsc_queue.rs +++ b/src/libstd/sync/mpsc/mpsc_queue.rs @@ -35,7 +35,7 @@ //! method, and see the method for more information about it. Due to this //! caveat, this queue may not be appropriate for all use-cases. -#![experimental] +#![unstable] // http://www.1024cores.net/home/lock-free-algorithms // /queues/non-intrusive-mpsc-node-based-queue diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index b7bb22b3ef3..0da458a51f1 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -46,7 +46,7 @@ //! ``` #![allow(dead_code)] -#![experimental = "This implementation, while likely sufficient, is unsafe and \ +#![unstable = "This implementation, while likely sufficient, is unsafe and \ likely to be error prone. At some point in the future this \ module will likely be replaced, and it is currently \ unknown how much API breakage that will cause. The ability \ diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index e8d6e380be5..46c69f6f547 100644 --- a/src/libstd/sync/mpsc/spsc_queue.rs +++ b/src/libstd/sync/mpsc/spsc_queue.rs @@ -33,7 +33,7 @@ //! concurrently between two tasks. This data structure is safe to use and //! enforces the semantics that there is one pusher and one popper. -#![experimental] +#![unstable] use core::prelude::*; diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index ae3c939bf78..0e4a9d1b307 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -29,7 +29,7 @@ //! } //! ``` -#![experimental] +#![unstable] use sys_common::AsInner; use libc; diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index 049aca3f590..87ff31ab73c 100644 --- a/src/libstd/sys/windows/ext.rs +++ b/src/libstd/sys/windows/ext.rs @@ -14,7 +14,7 @@ //! descriptors, and sockets, but its functionality will grow over //! time. -#![experimental] +#![unstable] use sys_common::AsInner; use libc; diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index c103365745c..932556fe1a6 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -207,14 +207,14 @@ impl Builder { } /// Redirect thread-local stdout. - #[experimental = "Will likely go away after proc removal"] + #[unstable = "Will likely go away after proc removal"] pub fn stdout(mut self, stdout: Box<Writer + Send>) -> Builder { self.stdout = Some(stdout); self } /// Redirect thread-local stderr. - #[experimental = "Will likely go away after proc removal"] + #[unstable = "Will likely go away after proc removal"] pub fn stderr(mut self, stderr: Box<Writer + Send>) -> Builder { self.stderr = Some(stderr); self @@ -483,7 +483,7 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> { impl<T: Send> JoinGuard<'static, T> { /// Detaches the child thread, allowing it to outlive its parent. - #[experimental = "unsure whether this API imposes limitations elsewhere"] + #[unstable = "unsure whether this API imposes limitations elsewhere"] pub fn detach(mut self) { unsafe { imp::detach(self.native) }; self.joined = true; // avoid joining in the destructor diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index a651d927c14..162c3677168 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -10,7 +10,7 @@ //! Temporal quantification -#![experimental] +#![unstable] use {fmt, i64}; use ops::{Add, Sub, Mul, Div, Neg, FnOnce}; diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 1efd6a87f86..eb6a2a43d43 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -15,7 +15,7 @@ //! This API is completely unstable and subject to change. #![crate_name = "syntax"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index b4f224cb4a7..7a161241ed6 100644 --- a/src/libterm/lib.rs +++ b/src/libterm/lib.rs @@ -39,7 +39,7 @@ //! [ti]: https://en.wikipedia.org/wiki/Terminfo #![crate_name = "term"] -#![experimental = "use the crates.io `term` library instead"] +#![unstable = "use the crates.io `term` library instead"] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index d04308814f8..cb6405be7ee 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -24,7 +24,7 @@ // build off of. #![crate_name = "test"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs index 27255cc33ee..ee508572adb 100644 --- a/src/libunicode/lib.rs +++ b/src/libunicode/lib.rs @@ -21,7 +21,7 @@ //! (yet) aim to provide a full set of Unicode tables. #![crate_name = "unicode"] -#![experimental] +#![unstable] #![staged_api] #![crate_type = "rlib"] #, /// mostly similar to ID_Start but modified for closure under NFKx. - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_start(self) -> bool; /// Returns whether the specified `char` satisfies the 'XID_Continue' @@ -121,7 +121,7 @@ pub trait CharExt { /// 'XID_Continue' is a Unicode Derived Property specified in /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), /// mostly similar to 'ID_Continue' but modified for closure under NFKx. - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_continue(self) -> bool; /// Indicates whether a character is in lowercase. @@ -171,7 +171,7 @@ pub trait CharExt { /// /// Returns the lowercase equivalent of the character, or the character /// itself if no conversion is possible. - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_lowercase(self) -> char; /// Converts a character to its uppercase equivalent. @@ -194,7 +194,7 @@ pub trait CharExt { /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt /// /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992 - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_uppercase(self) -> char; /// Returns this character's displayed width in columns, or `None` if it is a @@ -206,7 +206,7 @@ pub trait CharExt { /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/) /// recommends that these characters be treated as 1 column (i.e., /// `is_cjk` = `false`) if the context cannot be reliably determined. - #[experimental = "needs expert opinion. is_cjk flag stands out as ugly"] + #[unstable = "needs expert opinion. is_cjk flag stands out as ugly"] fn width(self, is_cjk: bool) -> Option<uint>; } @@ -238,10 +238,10 @@ impl CharExt for char { } } - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_start(self) -> bool { derived_property::XID_Start(self) } - #[experimental = "mainly needed for compiler internals"] + #[unstable = "mainly needed for compiler internals"] fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) } #[stable] @@ -288,12 +288,12 @@ impl CharExt for char { } } - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_lowercase(self) -> char { conversions::to_lower(self) } - #[experimental = "pending case transformation decisions"] + #[unstable = "pending case transformation decisions"] fn to_uppercase(self) -> char { conversions::to_upper(self) } - #[experimental = "needs expert opinion. is_cjk flag stands out as ugly"] + #[unstable = "needs expert opinion. is_cjk flag stands out as ugly"] fn width(self, is_cjk: bool) -> Option<uint> { charwidth::width(self, is_cjk) } } diff --git a/src/test/auxiliary/inherited_stability.rs b/src/test/auxiliary/inherited_stability.rs index 5691ce3bfa7..7a01ce3de0b 100644 --- a/src/test/auxiliary/inherited_stability.rs +++ b/src/test/auxiliary/inherited_stability.rs @@ -9,7 +9,8 @@ // except according to those terms. #![crate_name="inherited_stability"] #![crate_type = "lib"] -#![experimental] +#![unstable] +#![staged_api] pub fn experimental() {} @@ -26,7 +27,7 @@ pub mod stable_mod { #[unstable] pub mod unstable_mod { - #[experimental] + #[unstable] pub fn experimental() {} pub fn unstable() {} diff --git a/src/test/auxiliary/lint_output_format.rs b/src/test/auxiliary/lint_output_format.rs index 181b651ef52..adbb90fe6c8 100755 --- a/src/test/auxiliary/lint_output_format.rs +++ b/src/test/auxiliary/lint_output_format.rs @@ -10,13 +10,14 @@ #![crate_name="lint_output_format"] #![crate_type = "lib"] +#![staged_api] #[deprecated] pub fn foo() -> uint { 20 } -#[experimental] +#[unstable] pub fn bar() -> uint { 40 } diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index 708830d0259..73724713b21 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -9,15 +9,16 @@ // except according to those terms. #![crate_name="lint_stability"] #![crate_type = "lib"] +#![staged_api] #[deprecated] pub fn deprecated() {} #[deprecated="text"] pub fn deprecated_text() {} -#[experimental] +#[unstable] pub fn experimental() {} -#[experimental="text"] +#[unstable="text"] pub fn experimental_text() {} #[unstable] @@ -51,9 +52,9 @@ impl MethodTester { #[deprecated="text"] pub fn method_deprecated_text(&self) {} - #[experimental] + #[unstable] pub fn method_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] pub fn method_experimental_text(&self) {} #[unstable] @@ -85,9 +86,9 @@ pub trait Trait { #[deprecated="text"] fn trait_deprecated_text(&self) {} - #[experimental] + #[unstable] fn trait_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] fn trait_experimental_text(&self) {} #[unstable] @@ -115,12 +116,12 @@ pub trait Trait { impl Trait for MethodTester {} -#[experimental] +#[unstable] pub trait ExperimentalTrait {} #[deprecated] pub struct DeprecatedStruct { pub i: int } -#[experimental] +#[unstable] pub struct ExperimentalStruct { pub i: int } #[unstable] pub struct UnstableStruct { pub i: int } @@ -134,7 +135,7 @@ pub struct LockedStruct { pub i: int } #[deprecated] pub struct DeprecatedUnitStruct; -#[experimental] +#[unstable] pub struct ExperimentalUnitStruct; #[unstable] pub struct UnstableUnitStruct; @@ -149,7 +150,7 @@ pub struct LockedUnitStruct; pub enum Enum { #[deprecated] DeprecatedVariant, - #[experimental] + #[unstable] ExperimentalVariant, #[unstable] UnstableVariant, @@ -165,7 +166,7 @@ pub enum Enum { #[deprecated] pub struct DeprecatedTupleStruct(pub int); -#[experimental] +#[unstable] pub struct ExperimentalTupleStruct(pub int); #[unstable] pub struct UnstableTupleStruct(pub int); diff --git a/src/test/auxiliary/stability_cfg1.rs b/src/test/auxiliary/stability_cfg1.rs index 6b2e8e7758f..de806c65beb 100644 --- a/src/test/auxiliary/stability_cfg1.rs +++ b/src/test/auxiliary/stability_cfg1.rs @@ -10,3 +10,4 @@ #![cfg_attr(foo, experimental)] #![cfg_attr(not(foo), stable)] +#![staged_api] diff --git a/src/test/auxiliary/stability_cfg2.rs b/src/test/auxiliary/stability_cfg2.rs index 3387b319abf..842f35b08ae 100644 --- a/src/test/auxiliary/stability_cfg2.rs +++ b/src/test/auxiliary/stability_cfg2.rs @@ -10,6 +10,6 @@ // compile-flags:--cfg foo -#![cfg_attr(foo, experimental)] +#![cfg_attr(foo, unstable)] #![cfg_attr(not(foo), stable)] - +#![staged_api] diff --git a/src/test/bench/shootout-mandelbrot.rs b/src/test/bench/shootout-mandelbrot.rs index f6124c1271f..cf1264ff5d6 100644 --- a/src/test/bench/shootout-mandelbrot.rs +++ b/src/test/bench/shootout-mandelbrot.rs @@ -39,7 +39,7 @@ // OF THE POSSIBILITY OF SUCH DAMAGE. #![feature(simd)] -#![allow(experimental)] +#![allow(unstable)] // ignore-pretty very bad with line comments diff --git a/src/test/compile-fail/issue-17337.rs b/src/test/compile-fail/issue-17337.rs index e0f655084ff..24425e5eeec 100644 --- a/src/test/compile-fail/issue-17337.rs +++ b/src/test/compile-fail/issue-17337.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![staged_api] #![deny(deprecated)] struct Foo; diff --git a/src/test/compile-fail/lint-forbid-attr.rs b/src/test/compile-fail/lint-forbid-attr.rs index 92fabd6050b..d1fcf62115b 100644 --- a/src/test/compile-fail/lint-forbid-attr.rs +++ b/src/test/compile-fail/lint-forbid-attr.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![forbid(experimental)] +#![forbid(unstable)] -#[allow(experimental)] //~ ERROR allow(experimental) overruled by outer forbid(experimental) +#[allow(unstable)] //~ ERROR allow(unstable) overruled by outer forbid(unstable) fn main() { } diff --git a/src/test/compile-fail/lint-forbid-cmdline.rs b/src/test/compile-fail/lint-forbid-cmdline.rs index 4de84825ada..e3be0d06a35 100644 --- a/src/test/compile-fail/lint-forbid-cmdline.rs +++ b/src/test/compile-fail/lint-forbid-cmdline.rs @@ -8,8 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-flags: -F experimental +// compile-flags: -F unstable -#[allow(experimental)] //~ ERROR allow(experimental) overruled by outer forbid(experimental) +#![staged_api] +#[allow(unstable)] //~ ERROR allow(unstable) overruled by outer forbid(unstable) fn main() { } diff --git a/src/test/compile-fail/lint-output-format.rs b/src/test/compile-fail/lint-output-format.rs index 35721ee5b14..10217481bf3 100644 --- a/src/test/compile-fail/lint-output-format.rs +++ b/src/test/compile-fail/lint-output-format.rs @@ -8,14 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// compile-flags:-F experimental -D unstable +// compile-flags:-F unstable // aux-build:lint_output_format.rs extern crate lint_output_format; //~ ERROR: use of unmarked item -use lint_output_format::{foo, bar, baz}; +use lint_output_format::{foo, bar}; fn main() { let _x = foo(); //~ WARNING #[warn(deprecated)] on by default - let _y = bar(); //~ ERROR [-F experimental] - let _z = baz(); //~ ERROR [-D unstable] + let _y = bar(); //~ ERROR [-F unstable] } diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 0e24269ec44..1762285c281 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -15,15 +15,16 @@ #![deny(unstable)] #![deny(deprecated)] -#![deny(experimental)] +#![deny(unstable)] #![allow(dead_code)] +#![staged_api] #[macro_use] extern crate lint_stability; //~ ERROR: use of unmarked item mod cross_crate { extern crate stability_cfg1; - extern crate stability_cfg2; //~ ERROR: use of experimental item + extern crate stability_cfg2; //~ ERROR: use of unstable item use lint_stability::*; @@ -38,13 +39,13 @@ mod cross_crate { foo.method_deprecated_text(); //~ ERROR use of deprecated item: text foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - experimental(); //~ ERROR use of experimental item - foo.method_experimental(); //~ ERROR use of experimental item - foo.trait_experimental(); //~ ERROR use of experimental item + experimental(); //~ ERROR use of unstable item + foo.method_experimental(); //~ ERROR use of unstable item + foo.trait_experimental(); //~ ERROR use of unstable item - experimental_text(); //~ ERROR use of experimental item: text - foo.method_experimental_text(); //~ ERROR use of experimental item: text - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + experimental_text(); //~ ERROR use of unstable item: text + foo.method_experimental_text(); //~ ERROR use of unstable item: text + foo.trait_experimental_text(); //~ ERROR use of unstable item: text unstable(); //~ ERROR use of unstable item foo.method_unstable(); //~ ERROR use of unstable item @@ -83,7 +84,7 @@ mod cross_crate { foo.trait_locked_text(); let _ = DeprecatedStruct { i: 0 }; //~ ERROR use of deprecated item - let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of experimental item + let _ = ExperimentalStruct { i: 0 }; //~ ERROR use of unstable item let _ = UnstableStruct { i: 0 }; //~ ERROR use of unstable item let _ = UnmarkedStruct { i: 0 }; //~ ERROR use of unmarked item let _ = StableStruct { i: 0 }; @@ -91,7 +92,7 @@ mod cross_crate { let _ = LockedStruct { i: 0 }; let _ = DeprecatedUnitStruct; //~ ERROR use of deprecated item - let _ = ExperimentalUnitStruct; //~ ERROR use of experimental item + let _ = ExperimentalUnitStruct; //~ ERROR use of unstable item let _ = UnstableUnitStruct; //~ ERROR use of unstable item let _ = UnmarkedUnitStruct; //~ ERROR use of unmarked item let _ = StableUnitStruct; @@ -99,7 +100,7 @@ mod cross_crate { let _ = LockedUnitStruct; let _ = Enum::DeprecatedVariant; //~ ERROR use of deprecated item - let _ = Enum::ExperimentalVariant; //~ ERROR use of experimental item + let _ = Enum::ExperimentalVariant; //~ ERROR use of unstable item let _ = Enum::UnstableVariant; //~ ERROR use of unstable item let _ = Enum::UnmarkedVariant; //~ ERROR use of unmarked item let _ = Enum::StableVariant; @@ -107,7 +108,7 @@ mod cross_crate { let _ = Enum::LockedVariant; let _ = DeprecatedTupleStruct (1); //~ ERROR use of deprecated item - let _ = ExperimentalTupleStruct (1); //~ ERROR use of experimental item + let _ = ExperimentalTupleStruct (1); //~ ERROR use of unstable item let _ = UnstableTupleStruct (1); //~ ERROR use of unstable item let _ = UnmarkedTupleStruct (1); //~ ERROR use of unmarked item let _ = StableTupleStruct (1); @@ -128,8 +129,8 @@ mod cross_crate { fn test_method_param<F: Trait>(foo: F) { foo.trait_deprecated(); //~ ERROR use of deprecated item foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - foo.trait_experimental(); //~ ERROR use of experimental item - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + foo.trait_experimental(); //~ ERROR use of unstable item + foo.trait_experimental_text(); //~ ERROR use of unstable item: text foo.trait_unstable(); //~ ERROR use of unstable item foo.trait_unstable_text(); //~ ERROR use of unstable item: text foo.trait_unmarked(); //~ ERROR use of unmarked item @@ -139,8 +140,8 @@ mod cross_crate { fn test_method_object(foo: &Trait) { foo.trait_deprecated(); //~ ERROR use of deprecated item foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text - foo.trait_experimental(); //~ ERROR use of experimental item - foo.trait_experimental_text(); //~ ERROR use of experimental item: text + foo.trait_experimental(); //~ ERROR use of unstable item + foo.trait_experimental_text(); //~ ERROR use of unstable item: text foo.trait_unstable(); //~ ERROR use of unstable item foo.trait_unstable_text(); //~ ERROR use of unstable item: text foo.trait_unmarked(); //~ ERROR use of unmarked item @@ -149,33 +150,33 @@ mod cross_crate { struct S; - impl ExperimentalTrait for S { } //~ ERROR use of experimental item + impl ExperimentalTrait for S { } //~ ERROR use of unstable item - trait LocalTrait : ExperimentalTrait { } //~ ERROR use of experimental item + trait LocalTrait : ExperimentalTrait { } //~ ERROR use of unstable item } mod inheritance { - extern crate inherited_stability; //~ ERROR: use of experimental item + extern crate inherited_stability; //~ ERROR: use of unstable item use self::inherited_stability::*; fn test_inheritance() { - experimental(); //~ ERROR use of experimental item + experimental(); //~ ERROR use of unstable item stable(); - stable_mod::experimental(); //~ ERROR use of experimental item + stable_mod::experimental(); //~ ERROR use of unstable item stable_mod::stable(); - unstable_mod::experimental(); //~ ERROR use of experimental item + unstable_mod::experimental(); //~ ERROR use of unstable item unstable_mod::unstable(); //~ ERROR use of unstable item - experimental_mod::experimental(); //~ ERROR use of experimental item + experimental_mod::experimental(); //~ ERROR use of unstable item experimental_mod::stable(); - let _ = Experimental::ExperimentalVariant; //~ ERROR use of experimental item + let _ = Experimental::ExperimentalVariant; //~ ERROR use of unstable item let _ = Experimental::StableVariant; let x: uint = 0; - x.experimental(); //~ ERROR use of experimental item + x.experimental(); //~ ERROR use of unstable item x.stable(); } } @@ -186,9 +187,9 @@ mod this_crate { #[deprecated="text"] pub fn deprecated_text() {} - #[experimental] + #[unstable] pub fn experimental() {} - #[experimental="text"] + #[unstable="text"] pub fn experimental_text() {} #[unstable] @@ -222,9 +223,9 @@ mod this_crate { #[deprecated="text"] pub fn method_deprecated_text(&self) {} - #[experimental] + #[unstable] pub fn method_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] pub fn method_experimental_text(&self) {} #[unstable] @@ -256,9 +257,9 @@ mod this_crate { #[deprecated="text"] fn trait_deprecated_text(&self) {} - #[experimental] + #[unstable] fn trait_experimental(&self) {} - #[experimental="text"] + #[unstable="text"] fn trait_experimental_text(&self) {} #[unstable] @@ -288,7 +289,7 @@ mod this_crate { #[deprecated] pub struct DeprecatedStruct { i: int } - #[experimental] + #[unstable] pub struct ExperimentalStruct { i: int } #[unstable] pub struct UnstableStruct { i: int } @@ -302,7 +303,7 @@ mod this_crate { #[deprecated] pub struct DeprecatedUnitStruct; - #[experimental] + #[unstable] pub struct ExperimentalUnitStruct; #[unstable] pub struct UnstableUnitStruct; @@ -317,7 +318,7 @@ mod this_crate { pub enum Enum { #[deprecated] DeprecatedVariant, - #[experimental] + #[unstable] ExperimentalVariant, #[unstable] UnstableVariant, @@ -333,7 +334,7 @@ mod this_crate { #[deprecated] pub struct DeprecatedTupleStruct(int); - #[experimental] + #[unstable] pub struct ExperimentalTupleStruct(int); #[unstable] pub struct UnstableTupleStruct(int); diff --git a/src/test/compile-fail/simd-binop.rs b/src/test/compile-fail/simd-binop.rs index 9fbb7364054..0c2d8972ce7 100644 --- a/src/test/compile-fail/simd-binop.rs +++ b/src/test/compile-fail/simd-binop.rs @@ -10,7 +10,7 @@ // ignore-tidy-linelength -#![allow(experimental)] +#![allow(unstable)] use std::simd::f32x4; diff --git a/src/test/compile-fail/simd-experimental.rs b/src/test/compile-fail/simd-experimental.rs index 5f9f56bf3c0..aea970f90b2 100644 --- a/src/test/compile-fail/simd-experimental.rs +++ b/src/test/compile-fail/simd-experimental.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![deny(experimental)] +#![deny(unstable)] use std::simd; diff --git a/src/test/debuginfo/simd.rs b/src/test/debuginfo/simd.rs index 288e7461dd5..4aaa3e0b75f 100644 --- a/src/test/debuginfo/simd.rs +++ b/src/test/debuginfo/simd.rs @@ -41,7 +41,7 @@ // gdb-command:continue -#![allow(experimental)] +#![allow(unstable)] #![allow(unused_variables)] #![omit_gdb_pretty_printer_section] diff --git a/src/test/run-pass/simd-binop.rs b/src/test/run-pass/simd-binop.rs index 7f9be78d583..690ad351247 100644 --- a/src/test/run-pass/simd-binop.rs +++ b/src/test/run-pass/simd-binop.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(experimental)] +#![allow(unstable)] use std::simd::{i32x4, f32x4, u32x4}; diff --git a/src/test/run-pass/simd-issue-10604.rs b/src/test/run-pass/simd-issue-10604.rs index 966db25a128..6f0db23e2a6 100644 --- a/src/test/run-pass/simd-issue-10604.rs +++ b/src/test/run-pass/simd-issue-10604.rs @@ -9,7 +9,7 @@ // except according to those terms. -#![allow(experimental)] +#![allow(unstable)] #![feature(simd)] pub fn main() { diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs index 4ab089b6eaa..56044289fba 100644 --- a/src/test/run-pass/tcp-connect-timeouts.rs +++ b/src/test/run-pass/tcp-connect-timeouts.rs @@ -16,7 +16,7 @@ // one test task to ensure that errors are timeouts, not file descriptor // exhaustion. -#![allow(experimental)] +#![allow(unstable)] #![reexport_test_harness_main = "test_main"] #![allow(unused_imports)] |