diff options
| author | Brian Anderson <banderson@mozilla.com> | 2015-01-21 16:15:40 -0800 |
|---|---|---|
| committer | Brian Anderson <banderson@mozilla.com> | 2015-01-21 19:25:55 -0800 |
| commit | 41278c5441f484a68a20ca12d93cab368a2a943f (patch) | |
| tree | af1a988123f3917e1e83206a1d083ff34bfcbbb7 | |
| parent | 0768892abee31e1f8065deb4c61f0a88a682b17a (diff) | |
| download | rust-41278c5441f484a68a20ca12d93cab368a2a943f.tar.gz rust-41278c5441f484a68a20ca12d93cab368a2a943f.zip | |
Remove 'since' from unstable attributes
131 files changed, 695 insertions, 690 deletions
diff --git a/src/etc/featureck.py b/src/etc/featureck.py index 616596aa352..360d6380a29 100644 --- a/src/etc/featureck.py +++ b/src/etc/featureck.py @@ -94,11 +94,15 @@ for (dirpath, dirnames, filenames) in os.walk(src_dir): # the same line, e.g. # `#[unstable(feature = "foo", since = "1.0.0")]` - p = re.compile('feature *= *"(\w*)".*since *= *"([\w\.]*)"') + p = re.compile('(unstable|stable|deprecated).*feature *= *"(\w*)"') m = p.search(line) if not m is None: - feature_name = m.group(1) - since = m.group(2) + feature_name = m.group(2) + since = None + if "stable" in line or "deprecated" in line: + pp = re.compile('since *= *"([\w\.]*)"') + mm = pp.search(line) + since = m.group(1) lib_features[feature_name] = feature_name if lib_features_and_level.get((feature_name, level)) is None: # Add it to the observed features diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index 9245d33047c..821933f3f0a 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] pub struct Weak<T> { // FIXME #12808: strange name to try to avoid interfering with @@ -180,7 +180,7 @@ impl<T> Arc<T> { /// /// let weak_five = five.downgrade(); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] pub fn downgrade(&self) -> Weak<T> { // See the clone() impl for why this is relaxed @@ -202,12 +202,12 @@ impl<T> Arc<T> { /// Get the number of weak references to this value. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) } #[stable(feature = "grandfathered", since = "1.0.0")] @@ -273,7 +273,7 @@ impl<T: Send + Sync + Clone> Arc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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. @@ -357,7 +357,7 @@ impl<T: Sync + Send> Drop for Arc<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] impl<T: Sync + Send> Weak<T> { /// Upgrades a weak reference to a strong reference. @@ -396,7 +396,7 @@ impl<T: Sync + Send> Weak<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] impl<T: Sync + Send> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs index 6f41ccbf415..7351f1f3306 100644 --- a/src/liballoc/boxed.rs +++ b/src/liballoc/boxed.rs @@ -44,7 +44,7 @@ use core::ops::{Deref, DerefMut}; /// } /// ``` #[lang = "exchange_heap"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed; uncertain about custom allocator design")] pub static HEAP: () = (); @@ -126,7 +126,7 @@ impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> { } /// Extension methods for an owning `Any` trait object. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "this trait will likely disappear once compiler bugs blocking \ a direct impl on `Box<Any>` have been fixed ")] // FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 0cb97410562..19496616a5d 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -80,7 +80,7 @@ pub fn usable_size(size: uint, align: uint) -> uint { /// /// These statistics may be inconsistent if other threads use the allocator /// during the call. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn stats_print() { imp::stats_print(); } diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index b8c9c8403c3..db4ef263722 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![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 07eebe600d5..4e3c165361b 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -268,7 +268,7 @@ impl<T> Rc<T> { /// let weak_five = five.downgrade(); /// ``` #[cfg(stage0)] // NOTE remove after next snapshot - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module")] pub fn downgrade(&self) -> Weak<T> { self.inc_weak(); @@ -291,7 +291,7 @@ impl<T> Rc<T> { /// let weak_five = five.downgrade(); /// ``` #[cfg(not(stage0))] // NOTE remove cfg after next snapshot - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module")] pub fn downgrade(&self) -> Weak<T> { self.inc_weak(); @@ -301,12 +301,12 @@ impl<T> Rc<T> { /// Get the number of weak references to this value. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 } /// Get the number of strong references to this value. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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. @@ -322,7 +322,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// rc::is_unique(&five); /// ``` #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn is_unique<T>(rc: &Rc<T>) -> bool { weak_count(rc) == 0 && strong_count(rc) == 1 } @@ -344,7 +344,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool { /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u))); /// ``` #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { if is_unique(&rc) { unsafe { @@ -378,7 +378,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { /// assert!(rc::get_mut(&mut x).is_none()); /// ``` #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 }; @@ -404,7 +404,7 @@ impl<T: Clone> Rc<T> { /// let mut_five = five.make_unique(); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn make_unique(&mut self) -> &mut T { if !is_unique(self) { *self = Rc::new((**self).clone()) @@ -695,7 +695,7 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Show is experimental.")] +#[unstable(feature = "unnamed_feature", reason = "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) @@ -716,7 +716,7 @@ impl<T: fmt::String> fmt::String for Rc<T> { /// See the [module level documentation](../index.html) for more. #[unsafe_no_drop_flag] #[cfg(stage0)] // NOTE remove impl after next snapshot -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] pub struct Weak<T> { // FIXME #12808: strange names to try to avoid interfering with @@ -732,7 +732,7 @@ pub struct Weak<T> { /// /// See the [module level documentation](../index.html) for more. #[unsafe_no_drop_flag] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] #[cfg(not(stage0))] // NOTE remove cfg after next snapshot pub struct Weak<T> { @@ -748,7 +748,7 @@ impl<T> !marker::Send for Weak<T> {} impl<T> !marker::Sync for Weak<T> {} -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] impl<T> Weak<T> { /// Upgrades a weak reference to a strong reference. @@ -850,7 +850,7 @@ impl<T> Drop for Weak<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Weak pointers may not belong in this module.")] impl<T> Clone for Weak<T> { /// Makes a clone of the `Weak<T>`. @@ -894,7 +894,7 @@ impl<T> Clone for Weak<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Show is experimental.")] +#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")] impl<T: fmt::Show> fmt::Show for Weak<T> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "(Weak)") diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs index feb70e48562..c0889bad3a5 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index fb7fa895ae3..003a05f6b04 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -551,7 +551,7 @@ impl<T: Ord> BinaryHeap<T> { /// Clears the binary heap, returning an iterator over the removed elements. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain(&mut self) -> Drain<T> { Drain { iter: self.data.drain() } @@ -623,7 +623,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> { impl<T> ExactSizeIterator for IntoIter<T> {} /// An iterator that drains a `BinaryHeap`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recent addition")] +#[unstable(feature = "unnamed_feature", reason = "recent addition")] pub struct Drain<'a, T: 'a> { iter: vec::Drain<'a, T>, } diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 8911f67a35f..66f2b7c69db 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -156,7 +156,7 @@ static FALSE: bool = false; /// println!("{:?}", bv); /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count()); /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "RFC 509")] pub struct Bitv { /// Internal representation of the bit vector @@ -403,7 +403,7 @@ impl Bitv { /// assert_eq!(bv[3], true); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "panic semantics are likely to change in the future")] pub fn set(&mut self, i: uint, x: bool) { assert!(i < self.nbits); @@ -1109,7 +1109,7 @@ impl<'a> RandomAccessIterator for Iter<'a> { /// assert!(bv[3]); /// ``` #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "RFC 509")] pub struct BitvSet { bitv: Bitv, diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 8ee4a566dbc..fc68b982995 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -136,7 +136,7 @@ pub struct RangeMut<'a, K: 'a, V: 'a> { } /// A view into a single entry in a map, which may either be vacant or occupied. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still under development")] pub enum Entry<'a, K:'a, V:'a> { /// A vacant Entry @@ -146,7 +146,7 @@ pub enum Entry<'a, K:'a, V:'a> { } /// A vacant Entry. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still under development")] pub struct VacantEntry<'a, K:'a, V:'a> { key: K, @@ -154,7 +154,7 @@ pub struct VacantEntry<'a, K:'a, V:'a> { } /// An occupied Entry. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still under development")] pub struct OccupiedEntry<'a, K:'a, V:'a> { stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>, @@ -1099,7 +1099,7 @@ impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> { } impl<'a, K: Ord, V> Entry<'a, K, V> { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> { @@ -1113,7 +1113,7 @@ impl<'a, K: Ord, V> Entry<'a, K, V> { impl<'a, K: Ord, V> VacantEntry<'a, K, V> { /// Sets the value of the entry with the VacantEntry's key, /// and returns a mutable reference to it. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn insert(self, value: V) -> &'a mut V { self.stack.insert(self.key, value) @@ -1122,21 +1122,21 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> { impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { /// Gets a reference to the value in the entry. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn get(&self) -> &V { self.stack.peek() } /// Gets a mutable reference to the value in the entry. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn get_mut(&mut self) -> &mut V { self.stack.peek_mut() } /// Converts the entry into a mutable reference to its value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn into_mut(self) -> &'a mut V { self.stack.into_top() @@ -1144,7 +1144,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { /// Sets the value of the entry with the OccupiedEntry's key, /// and returns the entry's old value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn insert(&mut self, mut value: V) -> V { mem::swap(self.stack.peek_mut(), &mut value); @@ -1152,7 +1152,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { } /// Takes the value of the entry out of the map, and returns it. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] pub fn remove(self) -> V { self.stack.remove() @@ -1480,7 +1480,7 @@ impl<K: Ord, V> BTreeMap<K, V> { /// } /// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next()); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn range<'a>(&'a self, min: Bound<&K>, max: Bound<&K>) -> Range<'a, K, V> { range_impl!(&self.root, min, max, as_slices_internal, iter, Range, edges, []) @@ -1507,7 +1507,7 @@ impl<K: Ord, V> BTreeMap<K, V> { /// println!("{} => {}", name, balance); /// } /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn range_mut<'a>(&'a mut self, min: Bound<&K>, max: Bound<&K>) -> RangeMut<'a, K, V> { range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut, @@ -1540,7 +1540,7 @@ impl<K: Ord, V> BTreeMap<K, V> { /// assert_eq!(count["a"], 3u); /// ``` /// The key must have the same ordering before or after `.to_owned()` is called. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "precise API still under development")] pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> { // same basic logic of `swap` and `pop`, blended together diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index 00d90aefab7..b1672d6184a 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -102,7 +102,7 @@ impl<T: Ord> BTreeSet<T> { /// Makes a new BTreeSet with the given B. /// /// B cannot be less than 2. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "probably want this to be on the type, eventually")] pub fn with_b(b: uint) -> BTreeSet<T> { BTreeSet { map: BTreeMap::with_b(b) } @@ -173,7 +173,7 @@ impl<T: Ord> BTreeSet<T> { /// } /// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next()); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> { fn first<A, B>((a, _): (A, B)) -> A { a } diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index f0f2ef3488c..cb1e2e16f06 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -770,7 +770,7 @@ impl<'a, A> IterMut<'a, A> { /// } /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this is probably better handled by a cursor type -- we'll see")] pub fn insert_next(&mut self, elt: A) { self.insert_next_node(box Node::new(elt)) @@ -792,7 +792,7 @@ impl<'a, A> IterMut<'a, A> { /// assert_eq!(it.next().unwrap(), &2); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this is probably better handled by a cursor type -- we'll see")] pub fn peek_next(&mut self) -> Option<&mut A> { if self.nelem == 0 { diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index ec5d7cbcda9..a18634539a8 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -82,21 +82,21 @@ fn bit<E:CLike>(e: &E) -> uint { impl<E:CLike> EnumSet<E> { /// Returns an empty `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn new() -> EnumSet<E> { EnumSet {bits: 0} } /// Returns the number of elements in the given `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn len(&self) -> uint { self.bits.count_ones() } /// Returns true if the `EnumSet` is empty. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn is_empty(&self) -> bool { self.bits == 0 @@ -107,21 +107,21 @@ impl<E:CLike> EnumSet<E> { } /// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool { (self.bits & other.bits) == 0 } /// Returns `true` if a given `EnumSet` is included in this `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn is_superset(&self, other: &EnumSet<E>) -> bool { (self.bits & other.bits) == other.bits } /// Returns `true` if this `EnumSet` is included in the given `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn is_subset(&self, other: &EnumSet<E>) -> bool { other.is_superset(self) @@ -138,7 +138,7 @@ impl<E:CLike> EnumSet<E> { } /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn insert(&mut self, e: E) -> bool { let result = !self.contains(&e); @@ -147,7 +147,7 @@ impl<E:CLike> EnumSet<E> { } /// Removes an enum from the EnumSet - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn remove(&mut self, e: &E) -> bool { let result = self.contains(e); @@ -156,14 +156,14 @@ impl<E:CLike> EnumSet<E> { } /// Returns `true` if an `EnumSet` contains a given enum. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn contains(&self, e: &E) -> bool { (self.bits & bit(e)) != 0 } /// Returns an iterator over an `EnumSet`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn iter(&self) -> Iter<E> { Iter::new(self.bits) diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs index b99019f921e..3459806e29c 100644 --- a/src/libcollections/lib.rs +++ b/src/libcollections/lib.rs @@ -14,7 +14,7 @@ #![crate_name = "collections"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", @@ -70,13 +70,13 @@ pub mod string; pub mod vec; pub mod vec_map; -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "RFC 509")] pub mod bitv { pub use bit::{Bitv, Iter}; } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "RFC 509")] pub mod bitv_set { pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference}; diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 156ba129bcb..edd3b174edb 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -480,7 +480,7 @@ impl<T> RingBuf<T> { /// assert_eq!(buf.len(), 1); /// assert_eq!(Some(&5), buf.get(0)); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification; waiting on panic semantics")] pub fn truncate(&mut self, len: uint) { for _ in range(len, self.len()) { @@ -550,7 +550,7 @@ impl<T> RingBuf<T> { /// Returns a pair of slices which contain, in order, the contents of the /// `RingBuf`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) { unsafe { @@ -570,7 +570,7 @@ impl<T> RingBuf<T> { /// Returns a pair of slices which contain, in order, the contents of the /// `RingBuf`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) { unsafe { @@ -635,7 +635,7 @@ impl<T> RingBuf<T> { /// assert!(v.is_empty()); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain(&mut self) -> Drain<T> { Drain { @@ -876,7 +876,7 @@ impl<T> RingBuf<T> { /// buf.push_back(10); /// assert_eq!(buf.swap_back_remove(1), Some(99)); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "the naming of this function may be altered")] pub fn swap_back_remove(&mut self, index: uint) -> Option<T> { let length = self.len(); @@ -909,7 +909,7 @@ impl<T> RingBuf<T> { /// buf.push_back(20i); /// assert_eq!(buf.swap_front_remove(3), Some(99)); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "the naming of this function may be altered")] pub fn swap_front_remove(&mut self, index: uint) -> Option<T> { let length = self.len(); @@ -1310,7 +1310,7 @@ impl<T: Clone> RingBuf<T> { /// assert_eq!(a, b); /// } /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification; waiting on panic semantics")] pub fn resize(&mut self, new_len: uint, value: T) { let len = self.len(); @@ -1500,7 +1500,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> { impl<T> ExactSizeIterator for IntoIter<T> {} /// A draining RingBuf iterator -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub struct Drain<'a, T: 'a> { inner: &'a mut RingBuf<T>, diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index 697ed77f06f..45537746baa 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]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "uncertain about this API approach")] fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint; @@ -176,7 +176,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice(&self, start: uint, end: uint) -> &[Self::Item]; @@ -185,7 +185,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice_from(&self, start: uint) -> &[Self::Item]; @@ -194,7 +194,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice_to(&self, end: uint) -> &[Self::Item]; @@ -288,11 +288,11 @@ pub trait SliceExt { fn first(&self) -> Option<&Self::Item>; /// Returns all but the first element of a slice. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be renamed")] + #[unstable(feature = "unnamed_feature", reason = "likely to be renamed")] fn tail(&self) -> &[Self::Item]; /// Returns all but the last element of a slice. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be renamed")] + #[unstable(feature = "unnamed_feature", reason = "likely to be renamed")] fn init(&self) -> &[Self::Item]; /// Returns the last element of a slice, or `None` if it is empty. @@ -388,7 +388,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item]; @@ -397,7 +397,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item]; @@ -406,7 +406,7 @@ pub trait SliceExt { /// Panics when `end` is strictly greater than the length of the original slice. /// /// Slicing to `0` yields an empty slice. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item]; @@ -419,12 +419,12 @@ pub trait SliceExt { fn first_mut(&mut self) -> Option<&mut Self::Item>; /// Returns all but the first element of a mutable slice - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "likely to be renamed or removed")] fn tail_mut(&mut self) -> &mut [Self::Item]; /// Returns all but the last element of a mutable slice - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "likely to be renamed or removed")] fn init_mut(&mut self) -> &mut [Self::Item]; @@ -577,7 +577,7 @@ pub trait SliceExt { /// assert_eq!(Some(vec![1i, 3, 2]), perms.next()); /// assert_eq!(Some(vec![3i, 1, 2]), perms.next()); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone; /// Copies as many elements from `src` as it can into `self` (the @@ -597,7 +597,7 @@ pub trait SliceExt { /// assert!(dst.clone_from_slice(&src2) == 3); /// assert!(dst == [3i, 4, 5]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; /// Sorts the slice, in place. @@ -663,7 +663,7 @@ pub trait SliceExt { /// let b: &mut [_] = &mut [1i, 0, 2]; /// assert!(v == b); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "uncertain if this merits inclusion in std")] fn next_permutation(&mut self) -> bool where Self::Item: Ord; @@ -683,16 +683,16 @@ pub trait SliceExt { /// let b: &mut [_] = &mut [0i, 1, 2]; /// assert!(v == b); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "uncertain if this merits inclusion in std")] fn prev_permutation(&mut self) -> bool where Self::Item: Ord; /// Find the first index containing a matching value. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq; /// Find the last index containing a matching value. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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. @@ -708,7 +708,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn into_vec(self: Box<Self>) -> Vec<Self::Item>; } @@ -1000,7 +1000,7 @@ impl<T> SliceExt for [T] { //////////////////////////////////////////////////////////////////////////////// // Extension traits for slices over specific kinds of data //////////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "U should be an associated type")] +#[unstable(feature = "unnamed_feature", reason = "U should be an associated type")] /// An extension trait for concatenating slices pub trait SliceConcatExt<T: ?Sized, U> { /// Flattens a slice of `T` into a single value `U`. @@ -1045,7 +1045,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. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[derive(Clone)] pub struct ElementSwaps { sdir: Vec<SizeDirection>, @@ -1057,7 +1057,7 @@ pub struct ElementSwaps { impl ElementSwaps { /// Creates an `ElementSwaps` iterator for a sequence of `length` elements. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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 @@ -1074,17 +1074,17 @@ impl ElementSwaps { // Standard trait implementations for slices //////////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl<T> BorrowFrom<Vec<T>> for [T] { fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl<T> BorrowFromMut<Vec<T>> for [T] { fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl<T: Clone> ToOwned<Vec<T>> for [T] { fn to_owned(&self) -> Vec<T> { self.to_vec() } } @@ -1166,13 +1166,13 @@ impl Iterator for ElementSwaps { /// swap applied. /// /// Generates even and odd permutations alternately. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct Permutations<T> { swaps: ElementSwaps, v: Vec<T>, } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl<T: Clone> Iterator for Permutations<T> { type Item = Vec<T>; diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs index e5e612b8128..db5aa166674 100644 --- a/src/libcollections/str.rs +++ b/src/libcollections/str.rs @@ -165,7 +165,7 @@ enum DecompositionType { /// External iterator for a string's decomposition's characters. /// Use with the `std::iter` module. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct Decompositions<'a> { kind: DecompositionType, iter: Chars<'a>, @@ -255,7 +255,7 @@ enum RecompositionState { /// External iterator for a string's recomposition's characters. /// Use with the `std::iter` module. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct Recompositions<'a> { iter: Decompositions<'a>, state: RecompositionState, @@ -352,7 +352,7 @@ impl<'a> Iterator for Recompositions<'a> { /// External iterator for a string's UTF16 codeunits. /// Use with the `std::iter` module. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct Utf16Units<'a> { encoder: Utf16Encoder<Chars<'a>> } @@ -384,12 +384,12 @@ macro_rules! utf8_acc_cont_byte { ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32) } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl BorrowFrom<String> for str { fn borrow_from(owned: &String) -> &str { &owned[] } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl ToOwned<String> for str { fn to_owned(&self) -> String { unsafe { @@ -410,14 +410,14 @@ Section: Trait implementations #[stable(feature = "grandfathered", since = "1.0.0")] pub trait StrExt: Index<FullRange, Output = str> { /// Escapes each char in `s` with `char::escape_default`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return type may change to be an iterator")] fn escape_default(&self) -> String { self.chars().flat_map(|c| c.escape_default()).collect() } /// Escapes each char in `s` with `char::escape_unicode`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return type may change to be an iterator")] fn escape_unicode(&self) -> String { self.chars().flat_map(|c| c.escape_unicode()).collect() @@ -463,7 +463,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// Returns an iterator over the string in Unicode Normalization Form D /// (canonical decomposition). #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may be moved to libunicode")] fn nfd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { @@ -477,7 +477,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// Returns an iterator over the string in Unicode Normalization Form KD /// (compatibility decomposition). #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may be moved to libunicode")] fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> { Decompositions { @@ -491,7 +491,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// An Iterator over the string in Unicode Normalization Form C /// (canonical decomposition followed by canonical composition). #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may be moved to libunicode")] fn nfc_chars<'a>(&'a self) -> Recompositions<'a> { Recompositions { @@ -506,7 +506,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// An Iterator over the string in Unicode Normalization Form KC /// (compatibility decomposition followed by canonical composition). #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may be moved to libunicode")] fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> { Recompositions { @@ -545,7 +545,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// ```rust /// assert!("hello".contains_char('e')); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might get removed in favour of a more generic contains()")] fn contains_char<P: CharEq>(&self, pat: P) -> bool { core_str::StrExt::contains_char(&self[], pat) @@ -658,7 +658,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect(); /// assert_eq!(v, vec!["leopard", "tiger", "", "lion"]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might get removed")] + #[unstable(feature = "unnamed_feature", reason = "might get removed")] fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> { core_str::StrExt::split_terminator(&self[], pat) } @@ -704,7 +704,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect(); /// assert_eq!(v, vec![(0, 3)]); // only the first `aba` /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might have its iterator type changed")] fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> { core_str::StrExt::match_indices(&self[], pat) @@ -721,7 +721,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect(); /// assert_eq!(v, vec!["1", "", "2"]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might get removed in the future in favor of a more generic split()")] fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> { core_str::StrExt::split_str(&self[], pat) @@ -789,7 +789,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// // byte 100 is outside the string /// // s.slice(3, 100); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "use slice notation [a..b] instead")] fn slice(&self, begin: uint, end: uint) -> &str { core_str::StrExt::slice(&self[], begin, end) @@ -803,7 +803,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// out of bounds. /// /// See also `slice`, `slice_to` and `slice_chars`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "use slice notation [a..] instead")] fn slice_from(&self, begin: uint) -> &str { core_str::StrExt::slice_from(&self[], begin) @@ -818,7 +818,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// out of bounds. /// /// See also `slice`, `slice_from` and `slice_chars`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "use slice notation [..a] instead")] fn slice_to(&self, end: uint) -> &str { core_str::StrExt::slice_to(&self[], end) @@ -847,7 +847,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// assert_eq!(s.slice_chars(0, 4), "Löwe"); /// assert_eq!(s.slice_chars(5, 7), "老虎"); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may have yet to prove its worth")] fn slice_chars(&self, begin: uint, end: uint) -> &str { core_str::StrExt::slice_chars(&self[], begin, end) @@ -971,7 +971,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// // third byte of `老` /// assert!(!s.is_char_boundary(8)); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] fn is_char_boundary(&self, index: uint) -> bool { core_str::StrExt::is_char_boundary(&self[], index) @@ -1030,7 +1030,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// /// If `i` is greater than or equal to the length of the string. /// If `i` is not the index of the beginning of a valid UTF-8 character. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] fn char_range_at(&self, start: uint) -> CharRange { core_str::StrExt::char_range_at(&self[], start) @@ -1046,7 +1046,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// /// If `i` is greater than the length of the string. /// If `i` is not an index following a valid UTF-8 character. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] fn char_range_at_reverse(&self, start: uint) -> CharRange { core_str::StrExt::char_range_at_reverse(&self[], start) @@ -1067,7 +1067,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// /// If `i` is greater than or equal to the length of the string. /// If `i` is not the index of the beginning of a valid UTF-8 character. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] fn char_at(&self, i: uint) -> char { core_str::StrExt::char_at(&self[], i) @@ -1079,7 +1079,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// /// If `i` is greater than the length of the string. /// If `i` is not an index following a valid UTF-8 character. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] fn char_at_reverse(&self, i: uint) -> char { core_str::StrExt::char_at_reverse(&self[], i) @@ -1172,7 +1172,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// assert_eq!(s.find_str("老虎 L"), Some(6)); /// assert_eq!(s.find_str("muffin man"), None); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might get removed in favor of a more generic find in the future")] fn find_str(&self, needle: &str) -> Option<uint> { core_str::StrExt::find_str(&self[], needle) @@ -1196,7 +1196,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// assert_eq!(c, 'ö'); /// assert_eq!(s2, "we 老虎 Léopard"); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "awaiting conventions about shifting and slices")] fn slice_shift_char(&self) -> Option<(char, &str)> { core_str::StrExt::slice_shift_char(&self[]) @@ -1216,7 +1216,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// assert!(string.subslice_offset(lines[1]) == 2); // &"b" /// assert!(string.subslice_offset(lines[2]) == 4); // &"c" /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "awaiting convention about comparability of arbitrary slices")] fn subslice_offset(&self, inner: &str) -> uint { core_str::StrExt::subslice_offset(&self[], inner) @@ -1234,7 +1234,7 @@ pub trait StrExt: Index<FullRange, Output = str> { } /// Return an iterator of `u16` over the string encoded as UTF-16. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may only be provided by libunicode")] fn utf16_units(&self) -> Utf16Units { Utf16Units { encoder: Utf16Encoder::new(self[].chars()) } @@ -1276,7 +1276,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// assert_eq!("j".parse::<u32>(), None); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this method was just created")] fn parse<F: FromStr>(&self) -> Option<F> { core_str::StrExt::parse(&self[]) @@ -1301,7 +1301,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"]; /// assert_eq!(gr2.as_slice(), b); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may only be provided by libunicode")] fn graphemes(&self, is_extended: bool) -> Graphemes { UnicodeStr::graphemes(&self[], is_extended) @@ -1317,7 +1317,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")]; /// assert_eq!(gr_inds.as_slice(), b); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may only be provided by libunicode")] fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices { UnicodeStr::grapheme_indices(&self[], is_extended) @@ -1348,7 +1348,7 @@ pub trait StrExt: Index<FullRange, Output = str> { /// [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 locale is unknown. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this functionality may only be provided by libunicode")] fn width(&self, is_cjk: bool) -> uint { UnicodeStr::width(&self[], is_cjk) diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index d23be315481..3fe4d99ee18 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -92,7 +92,7 @@ impl String { /// assert_eq!(s.as_slice(), "hello"); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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()) } @@ -725,7 +725,7 @@ impl<'a> FromIterator<&'a str> for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "waiting on Extend stabilization")] impl Extend<char> for String { fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) { @@ -737,7 +737,7 @@ impl Extend<char> for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "waiting on Extend stabilization")] impl<'a> Extend<&'a str> for String { fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) { @@ -798,7 +798,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str { fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Str stabilization")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Str stabilization")] impl Str for String { #[inline] #[stable(feature = "grandfathered", since = "1.0.0")] @@ -824,7 +824,7 @@ impl fmt::String for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on fmt stabilization")] +#[unstable(feature = "unnamed_feature", reason = "waiting on fmt stabilization")] impl fmt::Show for String { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { @@ -832,7 +832,7 @@ impl fmt::Show for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Hash stabilization")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Hash stabilization")] impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { #[inline] fn hash(&self, hasher: &mut H) { @@ -840,7 +840,7 @@ impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "recent addition, needs more experience")] impl<'a> Add<&'a str> for String { type Output = String; @@ -892,7 +892,7 @@ impl ops::Deref for String { } /// Wrapper type providing a `&String` reference via `Deref`. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct DerefString<'a> { x: DerefVec<'a, u8> } @@ -920,7 +920,7 @@ impl<'a> Deref for DerefString<'a> { /// let string = as_string("foo").clone(); /// string_consumer(string); /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 4a8cd3e1645..32ff3e37c83 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -255,7 +255,7 @@ impl<T> Vec<T> { /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector /// without cloning, as if `ptr::read()` were called on them. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be better expressed via composition")] pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> { let mut dst = Vec::with_capacity(elts); @@ -377,7 +377,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()`. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn into_boxed_slice(mut self) -> Box<[T]> { self.shrink_to_fit(); unsafe { @@ -697,7 +697,7 @@ impl<T> Vec<T> { /// assert_eq!(vec2, vec![]); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "new API, waiting for dust to settle")] pub fn append(&mut self, other: &mut Self) { if mem::size_of::<T>() == 0 { @@ -734,7 +734,7 @@ impl<T> Vec<T> { /// assert!(v.is_empty()); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain<'a>(&'a mut self) -> Drain<'a, T> { unsafe { @@ -817,7 +817,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()); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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 @@ -1012,7 +1012,7 @@ impl<T: Clone> Vec<T> { /// vec.resize(2, 0); /// assert_eq!(vec, vec![1, 2]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification; waiting for dust to settle")] pub fn resize(&mut self, new_len: uint, value: T) { let len = self.len(); @@ -1037,7 +1037,7 @@ impl<T: Clone> Vec<T> { /// assert_eq!(vec, vec![1, 2, 3, 4]); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "likely to be replaced by a more optimized extend")] pub fn push_all(&mut self, other: &[T]) { self.reserve(other.len()); @@ -1206,7 +1206,7 @@ unsafe fn dealloc<T>(ptr: *mut T, len: uint) { // Common trait implementations for Vec //////////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<T:Clone> Clone for Vec<T> { fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) } @@ -1235,7 +1235,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Index stability")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Index stability")] impl<T> Index<uint> for Vec<T> { type Output = T; @@ -1339,7 +1339,7 @@ impl<T> FromIterator<T> for Vec<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Extend stability")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Extend stability")] impl<T> Extend<T> for Vec<T> { #[inline] fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) { @@ -1414,7 +1414,7 @@ macro_rules! impl_eq_for_cowvec { impl_eq_for_cowvec! { &'b [B] } impl_eq_for_cowvec! { &'b mut [B] } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "waiting on PartialOrd stability")] impl<T: PartialOrd> PartialOrd for Vec<T> { #[inline] @@ -1423,10 +1423,10 @@ impl<T: PartialOrd> PartialOrd for Vec<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Eq stability")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Eq stability")] impl<T: Eq> Eq for Vec<T> {} -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Ord stability")] +#[unstable(feature = "unnamed_feature", reason = "waiting on Ord stability")] impl<T: Ord> Ord for Vec<T> { #[inline] fn cmp(&self, other: &Vec<T>) -> Ordering { @@ -1457,7 +1457,7 @@ impl<T> AsSlice<T> for Vec<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "recent addition, needs more experience")] impl<'a, T: Clone> Add<&'a [T]> for Vec<T> { type Output = Vec<T>; @@ -1494,7 +1494,7 @@ impl<T> Default for Vec<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "waiting on Show stability")] +#[unstable(feature = "unnamed_feature", reason = "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) @@ -1512,12 +1512,12 @@ impl<'a> fmt::Writer for Vec<u8> { // Clone-on-write //////////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "unclear how valuable this alias is")] /// A clone-on-write vector pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>; -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone { fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> { Cow::Owned(FromIterator::from_iter(it)) @@ -1555,7 +1555,7 @@ unsafe impl<T: Sync> Sync for IntoIter<T> { } impl<T> IntoIter<T> { #[inline] /// Drops all items that have not yet been moved and returns the empty vector. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn into_inner(mut self) -> Vec<T> { unsafe { for _x in self { } @@ -1646,7 +1646,7 @@ impl<T> Drop for IntoIter<T> { /// An iterator that drains a vector. #[unsafe_no_drop_flag] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "recently added as part of collections reform 2")] pub struct Drain<'a, T> { ptr: *const T, @@ -1735,13 +1735,13 @@ impl<'a, T> Drop for Drain<'a, T> { //////////////////////////////////////////////////////////////////////////////// /// Wrapper type providing a `&Vec<T>` reference via `Deref`. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct DerefVec<'a, T> { x: Vec<T>, l: ContravariantLifetime<'a> } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> Deref for DerefVec<'a, T> { type Target = Vec<T>; @@ -1761,7 +1761,7 @@ impl<'a, T> Drop for DerefVec<'a, T> { } /// Convert a slice to a wrapper type providing a `&Vec<T>` reference. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> { unsafe { DerefVec { diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index b45b86e3b97..ea95d91349e 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -310,7 +310,7 @@ impl<V> VecMap<V> { /// /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain<'a>(&'a mut self) -> Drain<'a, V> { fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> { @@ -700,7 +700,7 @@ pub struct IntoIter<V> { fn((uint, Option<V>)) -> Option<(uint, V)>> } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct Drain<'a, V> { iter: FilterMap< (uint, Option<V>), @@ -709,7 +709,7 @@ pub struct Drain<'a, V> { fn((uint, Option<V>)) -> Option<(uint, V)>> } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, V> Iterator for Drain<'a, V> { type Item = (uint, V); @@ -717,7 +717,7 @@ impl<'a, V> Iterator for Drain<'a, V> { fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, V> DoubleEndedIterator for Drain<'a, V> { fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() } } diff --git a/src/libcore/any.rs b/src/libcore/any.rs index 4ef4db2813e..098e96ef4cb 100644 --- a/src/libcore/any.rs +++ b/src/libcore/any.rs @@ -89,7 +89,7 @@ use intrinsics; #[stable(feature = "grandfathered", since = "1.0.0")] pub trait Any: 'static { /// Get the `TypeId` of `self` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this method will likely be replaced by an associated static")] fn get_type_id(&self) -> TypeId; } @@ -177,7 +177,7 @@ impl TypeId { /// Returns the `TypeId` of the type this generic function has been /// instantiated with #[cfg(not(stage0))] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may grow a `Reflect` bound soon via marker traits")] pub fn of<T: ?Sized + 'static>() -> TypeId { TypeId { diff --git a/src/libcore/array.rs b/src/libcore/array.rs index 86e8c4b4f03..c8a26ff8e9b 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] // not yet reviewed +#![unstable(feature = "unnamed_feature")] // not yet reviewed use clone::Clone; use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering}; @@ -39,7 +39,7 @@ macro_rules! array_impls { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "waiting for Show to stabilize")] impl<T:fmt::Show> fmt::Show for [T; $N] { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs index ef0cf321690..998b2e1b608 100644 --- a/src/libcore/borrow.rs +++ b/src/libcore/borrow.rs @@ -42,7 +42,7 @@ //! is desired, `to_mut` will obtain a mutable references to an owned //! value, cloning if necessary. -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "recently added as part of collections reform")] use clone::Clone; diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs index 2cd793a0847..854a68211e4 100644 --- a/src/libcore/cell.rs +++ b/src/libcore/cell.rs @@ -201,7 +201,7 @@ impl<T:Copy> Cell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -271,7 +271,7 @@ impl<T> RefCell<T> { /// immutable borrows can be taken out at the same time. /// /// Returns `None` if the value is currently mutably borrowed. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed or removed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> { match BorrowRef::new(&self.borrow) { Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }), @@ -301,7 +301,7 @@ impl<T> RefCell<T> { /// cannot be borrowed while this borrow is active. /// /// Returns `None` if the value is currently borrowed. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed or removed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")] pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> { match BorrowRefMut::new(&self.borrow) { Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }), @@ -331,7 +331,7 @@ impl<T> RefCell<T> { /// /// This function is `unsafe` because `UnsafeCell`'s field is public. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> { &self.value } @@ -423,7 +423,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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "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 { @@ -528,7 +528,7 @@ pub struct UnsafeCell<T> { /// /// This field should not be accessed directly, it is made public for static /// initializers. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub value: T, } diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 3af9fdef982..49faefde118 100644 --- a/src/libcore/char.rs +++ b/src/libcore/char.rs @@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> { /// Panics if given an `radix` > 36. /// #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub fn from_digit(num: uint, radix: uint) -> Option<char> { if radix > 36 { panic!("from_digit: radix is too high (maximum 36)"); @@ -126,7 +126,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix > 36. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool; @@ -141,7 +141,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix outside the range [0..36]. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint>; @@ -198,13 +198,13 @@ pub trait CharExt { #[stable(feature = "grandfathered", since = "1.0.0")] impl CharExt for char { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool { self.to_digit(radix).is_some() } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint> { if radix > 36 { @@ -260,7 +260,7 @@ impl CharExt for char { } #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { // Marked #[inline] to allow llvm optimizing it away @@ -289,7 +289,7 @@ impl CharExt for char { } #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { // Marked #[inline] to allow llvm optimizing it away @@ -320,7 +320,7 @@ pub struct EscapeUnicode { } #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] enum EscapeUnicodeState { Backslash, Type, @@ -382,7 +382,7 @@ pub struct EscapeDefault { } #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] enum EscapeDefaultState { Backslash(char), Char(char), diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs index 0fbf9438c23..243a30c6737 100644 --- a/src/libcore/clone.rs +++ b/src/libcore/clone.rs @@ -36,7 +36,7 @@ pub trait Clone : Sized { /// but can be overridden to reuse the resources of `a` to avoid unnecessary /// allocations. #[inline(always)] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "this function is rarely used")] fn clone_from(&mut self, source: &Self) { *self = source.clone() @@ -82,7 +82,7 @@ clone_impl! { char } macro_rules! extern_fn_clone { ($($A:ident),*) => ( - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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 diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 1c8ebb0e7c2..079293aa502 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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/fmt/mod.rs b/src/libcore/fmt/mod.rs index bd45f742b60..532071a8600 100644 --- a/src/libcore/fmt/mod.rs +++ b/src/libcore/fmt/mod.rs @@ -36,7 +36,7 @@ mod num; mod float; pub mod rt; -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "core and I/O reconciliation may alter this definition")] /// The type returned by formatter methods. pub type Result = result::Result<(), Error>; @@ -46,7 +46,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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "core and I/O reconciliation may alter this definition")] #[derive(Copy)] pub struct Error; @@ -60,7 +60,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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "waiting for core and I/O reconciliation")] pub trait Writer { /// Writes a slice of bytes into this writer, returning whether the write @@ -104,7 +104,7 @@ pub trait Writer { /// A struct to represent both where to emit formatting strings to and how they /// should be formatted. A mutable version of this is passed to all formatting /// traits. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "name may change and implemented traits are also unstable")] pub struct Formatter<'a> { flags: uint, @@ -127,7 +127,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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] #[derive(Copy)] pub struct Argument<'a> { @@ -167,7 +167,7 @@ impl<'a> Arguments<'a> { /// When using the format_args!() macro, this function is used to generate the /// Arguments structure. #[doc(hidden)] #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] pub fn new(pieces: &'a [&'a str], args: &'a [Argument<'a>]) -> Arguments<'a> { @@ -185,7 +185,7 @@ impl<'a> Arguments<'a> { /// created with `argumentuint`. However, failing to do so doesn't cause /// unsafety, but will ignore invalid . #[doc(hidden)] #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] pub fn with_placeholders(pieces: &'a [&'a str], fmt: &'a [rt::Argument], @@ -236,7 +236,7 @@ impl<'a> String for Arguments<'a> { /// Format trait for the `:?` format. Useful for debugging, most all types /// should implement this. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait Show { /// Formats the value using the given formatter. @@ -245,7 +245,7 @@ pub trait Show { /// When a value can be semantically expressed as a String, this trait may be /// used. It corresponds to the default format, `{}`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait String { /// Formats the value using the given formatter. @@ -254,7 +254,7 @@ pub trait String { /// Format trait for the `o` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait Octal { /// Formats the value using the given formatter. @@ -262,7 +262,7 @@ pub trait Octal { } /// Format trait for the `b` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait Binary { /// Formats the value using the given formatter. @@ -270,7 +270,7 @@ pub trait Binary { } /// Format trait for the `x` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait LowerHex { /// Formats the value using the given formatter. @@ -278,7 +278,7 @@ pub trait LowerHex { } /// Format trait for the `X` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait UpperHex { /// Formats the value using the given formatter. @@ -286,7 +286,7 @@ pub trait UpperHex { } /// Format trait for the `p` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait Pointer { /// Formats the value using the given formatter. @@ -294,7 +294,7 @@ pub trait Pointer { } /// Format trait for the `e` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait LowerExp { /// Formats the value using the given formatter. @@ -302,7 +302,7 @@ pub trait LowerExp { } /// Format trait for the `E` character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "I/O and core have yet to be reconciled")] pub trait UpperExp { /// Formats the value using the given formatter. @@ -317,7 +317,7 @@ pub trait UpperExp { /// /// * output - the buffer to write output to /// * args - the precompiled arguments generated by `format_args!` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "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 { @@ -415,7 +415,7 @@ impl<'a> Formatter<'a> { /// /// This function will correctly account for the flags provided as well as /// the minimum width. It will not take precision into account. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "definition may change slightly over time")] pub fn pad_integral(&mut self, is_positive: bool, @@ -492,7 +492,7 @@ impl<'a> Formatter<'a> { /// is longer than this length /// /// Notably this function ignored the `flag` parameters - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "definition may change slightly over time")] pub fn pad(&mut self, s: &str) -> Result { // Make sure there's a fast path up front @@ -570,38 +570,38 @@ impl<'a> Formatter<'a> { /// Writes some data to the underlying buffer contained within this /// formatter. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "reconciling core and I/O may alter this definition")] pub fn write_str(&mut self, data: &str) -> Result { self.buf.write_str(data) } /// Writes some formatted information into this instance - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "reconciling core and I/O may alter this definition")] pub fn write_fmt(&mut self, fmt: Arguments) -> Result { write(self.buf, fmt) } /// Flags for formatting (packed version of rt::Flag) - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return type may change and method was just created")] pub fn flags(&self) -> uint { self.flags } /// Character used as 'fill' whenever there is alignment - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")] + #[unstable(feature = "unnamed_feature", reason = "method was just created")] pub fn fill(&self) -> char { self.fill } /// Flag indicating what form of alignment was requested - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")] + #[unstable(feature = "unnamed_feature", reason = "method was just created")] pub fn align(&self) -> rt::Alignment { self.align } /// Optionally specified integer width that the output should be - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")] + #[unstable(feature = "unnamed_feature", reason = "method was just created")] pub fn width(&self) -> Option<uint> { self.width } /// Optionally specified precision for numeric types - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "method was just created")] + #[unstable(feature = "unnamed_feature", reason = "method was just created")] pub fn precision(&self) -> Option<uint> { self.precision } } @@ -614,7 +614,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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result, t: &'a T) -> Argument<'a> { @@ -624,7 +624,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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> { Argument::from_uint(s) @@ -879,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<T: Show> Show for RefCell<T> { fn fmt(&self, f: &mut Formatter) -> Result { match self.try_borrow() { diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs index 630b7489eba..710446e42be 100644 --- a/src/libcore/fmt/num.rs +++ b/src/libcore/fmt/num.rs @@ -111,7 +111,7 @@ radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x, /// A radix with in the range of `2..36`. #[derive(Clone, Copy, PartialEq)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed or move to a different module")] pub struct Radix { base: u8, @@ -136,7 +136,7 @@ impl GenericRadix for Radix { } /// A helper type for formatting radixes. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed or move to a different module")] #[derive(Copy)] pub struct RadixFmt<T, R>(T, R); @@ -149,7 +149,7 @@ pub struct RadixFmt<T, R>(T, R); /// use std::fmt::radix; /// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string()); /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed or move to a different module")] pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> { RadixFmt(x, Radix::new(base)) diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs index 6056a8858b7..483d701c2c3 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 -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "implementation detail of the `format_args!` macro")] pub use self::Alignment::*; diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index 9e436367e6c..f070b4e0610 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -56,7 +56,7 @@ //! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2)); //! ``` -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "module was recently redesigned")] use prelude::*; @@ -96,7 +96,7 @@ pub trait Hasher { /// A common bound on the `Hasher` parameter to `Hash` implementations in order /// to generically hash an aggregate. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "this trait will likely be replaced by io::Writer")] #[allow(missing_docs)] pub trait Writer { diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs index 5835449e946..3957cba5a00 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`. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![allow(missing_docs)] use marker::Sized; @@ -303,7 +303,7 @@ extern "rust-intrinsic" { /// } /// } /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint); /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source @@ -333,12 +333,12 @@ extern "rust-intrinsic" { /// } /// ``` /// - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint); /// Invokes memset on the specified pointer, setting `count * size_of::<T>()` /// bytes of memory starting at `dst` to `c`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "uncertain about naming and semantics")] pub fn set_memory<T>(dst: *mut T, val: u8, count: uint); diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 9dc13a58311..d0e0b737419 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -564,7 +564,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(even, vec![2, 4]); /// assert_eq!(odd, vec![1, 3]); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added as part of collections reform")] fn partition<B, F>(mut self, mut f: F) -> (B, B) where B: Default + Extend<Self::Item>, @@ -760,7 +760,7 @@ pub trait IteratorExt: Iterator + Sized { /// let v = [1i, 1, 1, 1]; /// assert!(v.iter().min_max() == MinMax(&1, &1)); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "return type may change")] + #[unstable(feature = "unnamed_feature", reason = "return type may change")] fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord { let (mut min, mut max) = match self.next() { @@ -817,7 +817,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may want to produce an Ordering directly; see #15311")] fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, @@ -847,7 +847,7 @@ pub trait IteratorExt: Iterator + Sized { /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may want to produce an Ordering directly; see #15311")] fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, @@ -887,7 +887,7 @@ pub trait IteratorExt: Iterator + Sized { /// /// Loops through the entire iterator, collecting the first component of /// each item into one new container, and the second component into another. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recent addition")] + #[unstable(feature = "unnamed_feature", reason = "recent addition")] fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, @@ -920,7 +920,7 @@ pub trait IteratorExt: Iterator + Sized { /// Creates an iterator that clones the elements it yields. Useful for converting an /// Iterator<&T> to an Iterator<T>. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recent addition")] + #[unstable(feature = "unnamed_feature", reason = "recent addition")] fn cloned<T, D>(self) -> Cloned<Self> where Self: Iterator<Item=D>, D: Deref<Target=T>, @@ -948,7 +948,7 @@ pub trait IteratorExt: Iterator + Sized { } /// Use an iterator to reverse a container in place. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "uncertain about placement or widespread use")] fn reverse_in_place<'a, T: 'a>(&mut self) where Self: Iterator<Item=&'a mut T> + DoubleEndedIterator @@ -982,7 +982,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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "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` @@ -1058,7 +1058,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator { fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator { #[inline] fn indexable(&self) -> uint { self.iter.indexable() } @@ -1093,7 +1093,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat } /// A trait for iterators over elements which can be added together -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "needs to be re-evaluated as part of numerics reform")] pub trait AdditiveIterator<A> { /// Iterates over the entire iterator, summing up all the elements @@ -1112,7 +1112,7 @@ pub trait AdditiveIterator<A> { macro_rules! impl_additive { ($A:ty, $init:expr) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] + #[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T { #[inline] fn sum(self) -> $A { @@ -1135,7 +1135,7 @@ impl_additive! { f32, 0.0 } impl_additive! { f64, 0.0 } /// A trait for iterators over elements which can be multiplied together. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "needs to be re-evaluated as part of numerics reform")] pub trait MultiplicativeIterator<A> { /// Iterates over the entire iterator, multiplying all the elements @@ -1157,7 +1157,7 @@ pub trait MultiplicativeIterator<A> { macro_rules! impl_multiplicative { ($A:ty, $init:expr) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] + #[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T { #[inline] fn product(self) -> $A { @@ -1181,7 +1181,7 @@ impl_multiplicative! { f64, 1.0 } /// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail. #[derive(Clone, PartialEq, Show)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "unclear whether such a fine-grained result is widely useful")] pub enum MinMaxResult<T> { /// Empty iterator @@ -1214,7 +1214,7 @@ impl<T: Clone> MinMaxResult<T> { /// let r = MinMax(1i,2i); /// assert_eq!(r.into_option(), Some((1,2))); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "type is unstable")] + #[unstable(feature = "unnamed_feature", reason = "type is unstable")] pub fn into_option(self) -> Option<(T,T)> { match self { NoElements => None, @@ -1225,7 +1225,7 @@ impl<T: Clone> MinMaxResult<T> { } /// An iterator that clones the elements of an underlying iterator -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recent addition")] +#[unstable(feature = "unnamed_feature", reason = "recent addition")] #[must_use = "iterator adaptors are lazy and do nothing unless consumed"] #[derive(Clone)] pub struct Cloned<I> { @@ -1299,7 +1299,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Cycle<I> where I: Clone + RandomAccessIterator, { @@ -1384,7 +1384,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<T, A, B> RandomAccessIterator for Chain<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=T>, @@ -1476,7 +1476,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where A: RandomAccessIterator<Item=T>, B: RandomAccessIterator<Item=U>, @@ -1558,7 +1558,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(A) -> B, @@ -1747,7 +1747,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -1973,7 +1973,7 @@ impl<I> Iterator for Skip<I> where I: Iterator { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2028,7 +2028,7 @@ impl<I> Iterator for Take<I> where I: Iterator{ } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{ #[inline] fn indexable(&self) -> uint { @@ -2241,7 +2241,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator { } // Allow RandomAccessIterators to be fused without affecting random-access behavior -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator { #[inline] fn indexable(&self) -> uint { @@ -2258,7 +2258,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] - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "seems marginal")] + #[unstable(feature = "unnamed_feature", reason = "seems marginal")] pub fn reset_fuse(&mut self) { self.done = false } @@ -2327,7 +2327,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where I: RandomAccessIterator<Item=A>, F: FnMut(&A), @@ -2376,7 +2376,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where /// println!("{}", i); /// } /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 @@ -2397,7 +2397,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 @@ -2429,7 +2429,7 @@ impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A /// An infinite iterator starting at `start` and advancing by `step` with each /// iteration #[derive(Clone, Copy)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed or replaced by range notation adapaters")] pub struct Counter<A> { /// The current state the counter is at (next value to be yielded) @@ -2440,7 +2440,7 @@ pub struct Counter<A> { /// Creates a new counter with the specified start/step #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be renamed or replaced by range notation adapaters")] pub fn count<A>(start: A, step: A) -> Counter<A> { Counter{state: start, step: step} @@ -2465,7 +2465,7 @@ impl<A: Add<Output=A> + Clone> Iterator for Counter<A> { /// An iterator over the range [start, stop) #[derive(Clone, Copy)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be replaced by range notation")] pub struct Range<A> { state: A, @@ -2487,7 +2487,7 @@ pub struct Range<A> { /// } /// ``` #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be replaced by range notation")] pub fn range<A: Int>(start: A, stop: A) -> Range<A> { Range { @@ -2498,7 +2498,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> { } // FIXME: #10414: Unfortunate type bound -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be replaced by range notation")] impl<A: Int + ToPrimitive> Iterator for Range<A> { type Item = A; @@ -2549,7 +2549,7 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> { /// `Int` is required to ensure the range will be the same regardless of /// the direction it is consumed. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be replaced by range notation")] impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> { #[inline] @@ -2565,7 +2565,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> { /// An iterator over the range [start, stop] #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub struct RangeInclusive<A> { range: Range<A>, @@ -2574,7 +2574,7 @@ pub struct RangeInclusive<A> { /// Return an iterator over the range [start, stop] #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { RangeInclusive { @@ -2583,7 +2583,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> { type Item = A; @@ -2619,7 +2619,7 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> { #[inline] @@ -2639,7 +2639,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> { /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub struct RangeStep<A> { state: A, @@ -2650,14 +2650,14 @@ pub struct RangeStep<A> { /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> { let rev = step < Int::zero(); RangeStep{state: start, stop: stop, step: step, rev: rev} } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] impl<A: Int> Iterator for RangeStep<A> { type Item = A; @@ -2679,7 +2679,7 @@ impl<A: Int> Iterator for RangeStep<A> { /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub struct RangeStepInclusive<A> { state: A, @@ -2691,7 +2691,7 @@ pub struct RangeStepInclusive<A> { /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> { let rev = step < Int::zero(); @@ -2704,7 +2704,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to be replaced by range notation and adapters")] impl<A: Int> Iterator for RangeStepInclusive<A> { type Item = A; @@ -2730,7 +2730,7 @@ impl<A: Int> Iterator for RangeStepInclusive<A> { /// directions. The `steps_between` function provides a way to /// compare two Step objects (it could be provided using `step()` and `Ord`, /// but the implementation would be so inefficient as to be useless). -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "design of range notation/iteration is in flux")] pub trait Step: Ord { /// Change self to the next object. @@ -2746,7 +2746,7 @@ pub trait Step: Ord { macro_rules! step_impl { ($($t:ty)*) => ($( - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Trait is unstable.")] + #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] impl Step for $t { #[inline] fn step(&mut self) { *self += 1; } @@ -2763,7 +2763,7 @@ macro_rules! step_impl { macro_rules! step_impl_no_between { ($($t:ty)*) => ($( - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "Trait is unstable.")] + #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")] impl Step for $t { #[inline] fn step(&mut self) { *self += 1; } @@ -2807,7 +2807,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> { fn next_back(&mut self) -> Option<A> { self.idx(0) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<A: Clone> RandomAccessIterator for Repeat<A> { #[inline] fn indexable(&self) -> uint { uint::MAX } @@ -2819,12 +2819,12 @@ type IterateState<T, F> = (F, Option<T>, bool); /// An iterator that repeatedly applies a given function, starting /// from a given seed value. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where T: Clone, F: FnMut(T) -> T, @@ -2867,7 +2867,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> { /// /// If two sequences are equal up until the point where one ends, /// the shorter sequence compares less. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "needs review and revision")] +#[unstable(feature = "unnamed_feature", reason = "needs review and revision")] pub mod order { use cmp; use cmp::{Eq, Ord, PartialOrd, PartialEq}; diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index ecb4af218cd..ff7f8fc2815 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![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/macros.rs b/src/libcore/macros.rs index 65a17c91c87..393f8825f5e 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -235,7 +235,7 @@ macro_rules! writeln { /// } /// ``` #[macro_export] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "relationship with panic is unclear")] macro_rules! unreachable { () => ({ @@ -252,7 +252,7 @@ macro_rules! unreachable { /// A standardised placeholder for marking unfinished code. It panics with the /// message `"not yet implemented"` when executed. #[macro_export] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "relationship with panic is unclear")] macro_rules! unimplemented { () => (panic!("not yet implemented")) diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs index 4c9384b266a..9d8509cd11f 100644 --- a/src/libcore/marker.rs +++ b/src/libcore/marker.rs @@ -28,7 +28,7 @@ use clone::Clone; /// Types able to be transferred across task boundaries. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be overhauled with new lifetime rules; see RFC 458")] #[lang="send"] pub unsafe trait Send: 'static { @@ -192,7 +192,7 @@ pub trait Copy { /// around the value(s) which can be mutated when behind a `&` /// reference; not doing this is undefined behaviour (for example, /// `transmute`-ing from `&T` to `&mut T` is illegal). -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be overhauled with new lifetime rules; see RFC 458")] #[lang="sync"] pub unsafe trait Sync { @@ -237,7 +237,7 @@ pub unsafe trait Sync { /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U` /// (for example, `S<&'static int>` is a subtype of `S<&'a int>` /// for some lifetime `'a`, but not the other way around). -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="covariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] @@ -287,7 +287,7 @@ impl<T: ?Sized> Clone for CovariantType<T> { /// subtype of `S<U>` if `U` is a subtype of `T`; given that the /// function requires arguments of type `T`, it must also accept /// arguments of type `U`, hence such a conversion is safe. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="contravariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] @@ -318,16 +318,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> { /// The type system would infer that `value` is only read here and /// never written, but in fact `Cell` uses unsafe code to achieve /// interior mutability. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="invariant_type"] #[derive(PartialEq, Eq, PartialOrd, Ord)] pub struct InvariantType<T: ?Sized>; -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] impl<T: ?Sized> Copy for InvariantType<T> {} -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] impl<T: ?Sized> Clone for InvariantType<T> { fn clone(&self) -> InvariantType<T> { *self } @@ -349,7 +349,7 @@ impl<T: ?Sized> Clone for InvariantType<T> { /// /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="covariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -367,7 +367,7 @@ pub struct CovariantLifetime<'a>; /// /// For more information about variance, refer to this Wikipedia /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="contravariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -380,7 +380,7 @@ pub struct ContravariantLifetime<'a>; /// pointer that is actually a pointer into memory with lifetime `'a`, /// and this pointer is itself stored in an inherently mutable /// location (such as a `Cell`). -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="invariant_lifetime"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -390,7 +390,7 @@ pub struct InvariantLifetime<'a>; /// be safely sent between tasks, even if it is owned. This is /// typically embedded in other types, such as `Gc`, to ensure that /// their instances remain thread-local. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="no_send_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -400,7 +400,7 @@ pub struct NoSend; /// A type which is considered "not POD", meaning that it is not /// implicitly copyable. This is typically embedded in other types to /// ensure that they are never copied, even if they lack a destructor. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="no_copy_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -410,7 +410,7 @@ pub struct NoCopy; /// A type which is considered "not sync", meaning that /// its contents are not threadsafe, hence they cannot be /// shared between tasks. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="no_sync_bound"] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] @@ -419,7 +419,7 @@ pub struct NoSync; /// A type which is considered managed by the GC. This is typically /// embedded in other types. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "likely to change with new variance strategy")] #[lang="managed_bound"] #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs index b28df93b359..bfaf897b3a4 100644 --- a/src/libcore/mem.rs +++ b/src/libcore/mem.rs @@ -318,7 +318,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U { /// Transforms lifetime of the second pointer to match the first. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "this function may be removed in the future due to its \ questionable utility")] pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, @@ -328,7 +328,7 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S, /// Transforms lifetime of the second mutable pointer to match the first. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "this function may be removed in the future due to its \ questionable utility")] pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S, diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs index 111d2f074b1..601e1b192a9 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)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct NonZero<T: Zeroable>(T); impl<T: Zeroable> NonZero<T> { diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index 9aecd761e2a..4d5a0c1af4d 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -22,12 +22,12 @@ use num::Float; use num::FpCategory as Fp; use option::Option; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const RADIX: uint = 2u; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MANTISSA_DIGITS: uint = 24u; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const DIGITS: uint = 6u; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -43,14 +43,14 @@ pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32; #[stable(feature = "grandfathered", since = "1.0.0")] pub const MAX_VALUE: f32 = 3.40282347e+38_f32; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MIN_EXP: int = -125; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MAX_EXP: int = 128; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MIN_10_EXP: int = -37; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MAX_10_EXP: int = 38; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -61,7 +61,7 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32; pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32; /// Various useful constants. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "naming scheme needs to be revisited")] pub mod consts { // FIXME: replace with mathematical constants from cmath. @@ -118,7 +118,7 @@ pub mod consts { pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl Float for f32 { #[inline] fn nan() -> f32 { NAN } diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 1961b6cb0a8..84a457d78ca 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -26,11 +26,11 @@ use option::Option; // constants are implemented in favour of referencing the respective // members of `Bounded` and `Float`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const RADIX: uint = 2u; pub const MANTISSA_DIGITS: uint = 53u; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const DIGITS: uint = 15u; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -46,14 +46,14 @@ pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64; #[stable(feature = "grandfathered", since = "1.0.0")] pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MIN_EXP: int = -1021; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MAX_EXP: int = 1024; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MIN_10_EXP: int = -307; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "pending integer conventions")] +#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] pub const MAX_10_EXP: int = 308; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -64,7 +64,7 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64; pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64; /// Various useful constants. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "naming scheme needs to be revisited")] pub mod consts { // FIXME: replace with mathematical constants from cmath. @@ -125,7 +125,7 @@ pub mod consts { pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is unstable")] +#[unstable(feature = "unnamed_feature", reason = "trait is unstable")] impl Float for f64 { #[inline] fn nan() -> f64 { NAN } diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs index 2f0f6443877..af84f619a9d 100644 --- a/src/libcore/num/int_macros.rs +++ b/src/libcore/num/int_macros.rs @@ -14,11 +14,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => ( // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub const BITS : uint = $bits; // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub const BYTES : uint = ($bits / 8); // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 5b0b6f1b046..2321baf3780 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -50,25 +50,25 @@ pub trait Int { /// Returns the `0` value of this integer type. // FIXME (#5527): Should be an associated constant - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn zero() -> Self; /// Returns the `1` value of this integer type. // FIXME (#5527): Should be an associated constant - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn one() -> Self; /// Returns the smallest value that can be represented by this integer type. // FIXME (#5527): Should be and associated constant - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn min_value() -> Self; /// Returns the largest value that can be represented by this integer type. // FIXME (#5527): Should be and associated constant - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn max_value() -> Self; @@ -83,7 +83,7 @@ pub trait Int /// /// assert_eq!(n.count_ones(), 3); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn count_ones(self) -> uint; @@ -98,7 +98,7 @@ pub trait Int /// /// assert_eq!(n.count_zeros(), 5); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[inline] fn count_zeros(self) -> uint { @@ -117,7 +117,7 @@ pub trait Int /// /// assert_eq!(n.leading_zeros(), 10); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn leading_zeros(self) -> uint; @@ -133,7 +133,7 @@ pub trait Int /// /// assert_eq!(n.trailing_zeros(), 3); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn trailing_zeros(self) -> uint; @@ -150,7 +150,7 @@ pub trait Int /// /// assert_eq!(n.rotate_left(12), m); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn rotate_left(self, n: uint) -> Self; @@ -167,7 +167,7 @@ pub trait Int /// /// assert_eq!(n.rotate_right(12), m); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn rotate_right(self, n: uint) -> Self; @@ -368,7 +368,7 @@ pub trait Int /// /// assert_eq!(2i.pow(4), 16); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] #[inline] fn pow(self, mut exp: uint) -> Self { @@ -632,7 +632,7 @@ pub trait SignedInt { /// Computes the absolute value of `self`. `Int::min_value()` will be /// returned if the number is `Int::min_value()`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "overflow in debug builds?")] + #[unstable(feature = "unnamed_feature", reason = "overflow in debug builds?")] fn abs(self) -> Self; /// Returns a number representing sign of `self`. @@ -737,7 +737,7 @@ impl UnsignedInt for u32 {} impl UnsignedInt for u64 {} /// A generic trait for converting a value to a number. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")] pub trait ToPrimitive { /// Converts the value of `self` to an `int`. #[inline] @@ -1002,7 +1002,7 @@ impl_to_primitive_float! { f32 } impl_to_primitive_float! { f64 } /// A generic trait for converting a number to a value. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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. @@ -1084,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized { } /// A utility function that just calls `FromPrimitive::from_int`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "likely to be removed")] pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> { FromPrimitive::from_f64(n) } @@ -1201,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 } /// ``` /// #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is likely to be removed")] +#[unstable(feature = "unnamed_feature", reason = "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. @@ -1242,7 +1242,7 @@ impl_num_cast! { f64, to_f64 } /// Used for representing the classification of floating point numbers #[derive(Copy, PartialEq, Show)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")] +#[unstable(feature = "unnamed_feature", reason = "may be renamed")] pub enum FpCategory { /// "Not a Number", often obtained by dividing by zero Nan, @@ -1262,7 +1262,7 @@ pub enum FpCategory { // // FIXME(#8888): Several of these functions have a parameter named // `unused_self`. Removing it requires #8888 to be fixed. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "distribution of methods between core/std is unclear")] pub trait Float : Copy + Clone @@ -1418,20 +1418,20 @@ pub trait Float } /// A generic trait for converting a string with a radix (base) to a value -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might need to return Result")] +#[unstable(feature = "unnamed_feature", reason = "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. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "might need to return Result")] +#[unstable(feature = "unnamed_feature", reason = "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) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might need to return Result")] impl FromStr for $T { /// Convert a string in base 10 to a float. @@ -1465,7 +1465,7 @@ macro_rules! from_str_radix_float_impl { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might need to return Result")] impl FromStrRadix for $T { /// Convert a string in a given base to a float. @@ -1630,7 +1630,7 @@ from_str_radix_float_impl! { f64 } macro_rules! from_str_radix_int_impl { ($T:ty) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might need to return Result")] impl FromStr for $T { #[inline] @@ -1639,7 +1639,7 @@ macro_rules! from_str_radix_int_impl { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "might need to return Result")] impl FromStrRadix for $T { fn from_str_radix(src: &str, radix: uint) -> Option<$T> { diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs index 50c22d374c6..c584fc90557 100644 --- a/src/libcore/num/uint_macros.rs +++ b/src/libcore/num/uint_macros.rs @@ -12,9 +12,9 @@ macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => ( -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub const BITS : uint = $bits; -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub const BYTES : uint = ($bits / 8); #[stable(feature = "grandfathered", since = "1.0.0")] diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs index a490ad36020..17ba135eb7c 100644 --- a/src/libcore/ops.rs +++ b/src/libcore/ops.rs @@ -108,7 +108,7 @@ pub trait Drop { // based on "op T" where T is expected to be `Copy`able macro_rules! forward_ref_unop { (impl $imp:ident, $method:ident for $t:ty) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added, waiting for dust to settle")] impl<'a> $imp for &'a $t { type Output = <$t as $imp>::Output; @@ -125,7 +125,7 @@ macro_rules! forward_ref_unop { // based on "T op U" where T and U are expected to be `Copy`able macro_rules! forward_ref_binop { (impl $imp:ident, $method:ident for $t:ty, $u:ty) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added, waiting for dust to settle")] impl<'a> $imp<$u> for &'a $t { type Output = <$t as $imp<$u>>::Output; @@ -136,7 +136,7 @@ macro_rules! forward_ref_binop { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added, waiting for dust to settle")] impl<'a> $imp<&'a $u> for $t { type Output = <$t as $imp<$u>>::Output; @@ -147,7 +147,7 @@ macro_rules! forward_ref_binop { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added, waiting for dust to settle")] impl<'a, 'b> $imp<&'a $u> for &'b $t { type Output = <$t as $imp<$u>>::Output; @@ -974,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> { /// An unbounded range. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="full_range"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] pub struct FullRange; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl fmt::Show for FullRange { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { fmt::Show::fmt("..", fmt) @@ -987,7 +987,7 @@ impl fmt::Show for FullRange { /// A (half-open) range which is bounded at both ends. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] pub struct Range<Idx> { /// The lower bound of the range (inclusive). pub start: Idx, @@ -995,7 +995,7 @@ pub struct Range<Idx> { pub end: Idx, } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: Clone + Step> Iterator for Range<Idx> { type Item = Idx; @@ -1020,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { #[inline] fn next_back(&mut self) -> Option<Idx> { @@ -1033,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {} -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for Range<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "{:?}..{:?}", self.start, self.end) @@ -1046,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> { /// A range which is only bounded below. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range_from"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] pub struct RangeFrom<Idx> { /// The lower bound of the range (inclusive). pub start: Idx, } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { type Item = Idx; @@ -1065,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "{:?}..", self.start) @@ -1075,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> { /// A range which is only bounded above. #[derive(Copy, Clone, PartialEq, Eq)] #[lang="range_to"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] pub struct RangeTo<Idx> { /// The upper bound of the range (exclusive). pub end: Idx, } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "API still in development")] +#[unstable(feature = "unnamed_feature", reason = "API still in development")] impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { write!(fmt, "..{:?}", self.end) @@ -1196,7 +1196,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T { /// A version of the call operator that takes an immutable receiver. #[lang="fn"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "uncertain about variadic generics, input versus associated types")] pub trait Fn<Args,Result> { /// This is called when the call operator is used. @@ -1205,7 +1205,7 @@ pub trait Fn<Args,Result> { /// A version of the call operator that takes a mutable receiver. #[lang="fn_mut"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "uncertain about variadic generics, input versus associated types")] pub trait FnMut<Args,Result> { /// This is called when the call operator is used. @@ -1214,7 +1214,7 @@ pub trait FnMut<Args,Result> { /// A version of the call operator that takes a by-value receiver. #[lang="fn_once"] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "uncertain about variadic generics, input versus associated types")] pub trait FnOnce<Args,Result> { /// This is called when the call operator is used. diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 1c44ad00ae9..7b8e1ebd7b8 100644 --- a/src/libcore/option.rs +++ b/src/libcore/option.rs @@ -285,7 +285,7 @@ impl<T> Option<T> { /// assert_eq!(x, Some("Dirt")); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "waiting for mut conventions")] pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] { match *self { @@ -477,7 +477,7 @@ impl<T> Option<T> { /// assert_eq!(x.ok_or(0i), Err(0i)); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> { match self { Some(v) => Ok(v), @@ -543,7 +543,7 @@ impl<T> Option<T> { /// assert_eq!(x.iter_mut().next(), None); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "waiting for iterator conventions")] pub fn iter_mut(&mut self) -> IterMut<T> { IterMut { inner: Item { opt: self.as_mut() } } @@ -704,7 +704,7 @@ impl<T> Option<T> { impl<'a, T: Clone, D: Deref<Target=T>> Option<D> { /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option. /// Useful for converting an Option<&T> to an Option<T>. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added as part of collections reform")] pub fn cloned(self) -> Option<T> { self.map(|t| t.deref().clone()) @@ -748,7 +748,7 @@ impl<T: Default> Option<T> { // Trait implementations ///////////////////////////////////////////////////////////////////////////// -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "waiting on the stability of the trait itself")] impl<T> AsSlice<T> for Option<T> { /// Convert from `Option<T>` to `&[T]` (without copying) diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 36ee97051ba..a66ea639668 100644 --- a/src/libcore/ptr.rs +++ b/src/libcore/ptr.rs @@ -99,13 +99,13 @@ use cmp::Ordering::{self, Less, Equal, Greater}; // FIXME #19649: intrinsic docs don't render, so these have no docs :( -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub use intrinsics::copy_nonoverlapping_memory; -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub use intrinsics::copy_memory; -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "uncertain about naming and semantics")] pub use intrinsics::set_memory; @@ -146,7 +146,7 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T } /// Beyond accepting a raw pointer, this is unsafe because it will not drop the /// contents of `dst`, and may be used to create invalid instances of `T`. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may play a larger role in std::ptr future extensions")] pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) { set_memory(dst, 0, count); @@ -215,7 +215,7 @@ pub unsafe fn read<T>(src: *const T) -> T { /// /// This is unsafe for the same reasons that `read` is unsafe. #[inline(always)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may play a larger role in std::ptr future extensions")] pub unsafe fn read_and_zero<T>(dest: *mut T) -> T { // Copy the data out from `dest`: @@ -262,7 +262,7 @@ pub trait PtrExt: Sized { /// null-safety, it is important to note that this is still an unsafe /// operation because the returned value could be pointing to invalid /// memory. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>; @@ -291,7 +291,7 @@ pub trait MutPtrExt { /// /// As with `as_ref`, this is unsafe because it cannot verify the validity /// of the returned pointer. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Option is not clearly the right return type, and we may want \ to tie the return lifetime to a borrow of the raw pointer")] unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>; @@ -312,7 +312,7 @@ impl<T> PtrExt for *const T { } #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_ref<'a>(&self) -> Option<&'a T> { @@ -339,7 +339,7 @@ impl<T> PtrExt for *mut T { } #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_ref<'a>(&self) -> Option<&'a T> { @@ -356,7 +356,7 @@ impl<T> MutPtrExt for *mut T { type Target = T; #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "return value does not necessarily convey all possible \ information")] unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> { @@ -521,33 +521,33 @@ impl<T> PartialOrd for *mut T { /// raw `*mut T` (which conveys no particular ownership semantics). /// Useful for building abstractions like `Vec<T>` or `Box<T>`, which /// internally use raw pointers to manage the memory that they own. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")] +#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] pub struct Unique<T>(pub *mut T); /// `Unique` pointers are `Send` if `T` is `Send` because the data they /// reference is unaliased. Note that this aliasing invariant is /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")] +#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] unsafe impl<T:Send> Send for Unique<T> { } /// `Unique` pointers are `Sync` if `T` is `Sync` because the data they /// reference is unaliased. Note that this aliasing invariant is /// unenforced by the type system; the abstraction using the /// `Unique` must enforce it. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently added to this module")] +#[unstable(feature = "unnamed_feature", reason = "recently added to this module")] unsafe impl<T:Sync> Sync for Unique<T> { } impl<T> Unique<T> { /// Returns a null Unique. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added to this module")] pub fn null() -> Unique<T> { Unique(null_mut()) } /// Return an (unsafe) pointer into the memory owned by `self`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "recently added to this module")] pub unsafe fn offset(self, offset: int) -> *mut T { self.0.offset(offset) diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs index 4b4b493bad2..02d2d29ade1 100644 --- a/src/libcore/raw.rs +++ b/src/libcore/raw.rs @@ -9,7 +9,7 @@ // except according to those terms. #![allow(missing_docs)] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] //! Contains struct definitions for the layout of compiler built-in types. //! diff --git a/src/libcore/result.rs b/src/libcore/result.rs index a1a7ddcde57..51119b2fc03 100644 --- a/src/libcore/result.rs +++ b/src/libcore/result.rs @@ -417,7 +417,7 @@ impl<T, E> Result<T, E> { /// assert!(x.as_mut_slice().is_empty()); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "waiting for mut conventions")] pub fn as_mut_slice(&mut self) -> &mut [T] { match *self { @@ -950,7 +950,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] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn fold<T, V, E, diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs index 8a229ac08ec..086fff58910 100644 --- a/src/libcore/simd.rs +++ b/src/libcore/simd.rs @@ -36,7 +36,7 @@ #![allow(non_camel_case_types)] #![allow(missing_docs)] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -45,26 +45,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); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[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); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i32x4(pub i32, pub i32, pub i32, pub i32); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct i64x2(pub i64, pub i64); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] @@ -73,32 +73,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); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[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); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u32x4(pub u32, pub u32, pub u32, pub u32); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct u64x2(pub u64, pub u64); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] pub struct f32x4(pub f32, pub f32, pub f32, pub f32); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[simd] #[derive(Copy, Show)] #[repr(C)] diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs index 1c7478ddb76..779ace7a613 100644 --- a/src/libcore/slice.rs +++ b/src/libcore/slice.rs @@ -131,7 +131,7 @@ pub trait SliceExt { fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<T> SliceExt for [T] { type Item = T; @@ -258,7 +258,7 @@ impl<T> SliceExt for [T] { self.repr().data } - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where F: FnMut(&T) -> Ordering { @@ -452,12 +452,12 @@ impl<T> SliceExt for [T] { m >= n && needle == &self[(m-n)..] } - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord { self.binary_search_by(|p| p.cmp(x)) } - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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 } - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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,26 +630,26 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] { //////////////////////////////////////////////////////////////////////////////// /// Data that is viewable as a slice. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will be replaced by slice syntax")] pub trait AsSlice<T> { /// Work with `self` as a slice. fn as_slice<'a>(&'a self) -> &'a [T]; } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<T> AsSlice<T> for [T] { #[inline(always)] fn as_slice<'a>(&'a self) -> &'a [T] { self } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "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) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "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) } @@ -755,7 +755,7 @@ pub struct Iter<'a, T: 'a> { marker: marker::ContravariantLifetime<'a> } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -764,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -773,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { type Output = [T]; #[inline] @@ -782,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> { type Output = [T]; #[inline] @@ -796,7 +796,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn as_slice(&self) -> &'a [T] { make_slice!(T => &'a [T]: self.ptr, self.end) } @@ -814,7 +814,7 @@ impl<'a, T> Clone for Iter<'a, T> { fn clone(&self) -> Iter<'a, T> { *self } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<'a, T> RandomAccessIterator for Iter<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -848,7 +848,7 @@ pub struct IterMut<'a, T: 'a> { } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -856,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -864,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -872,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index(&ops::FullRange).index(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -881,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -889,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -897,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -905,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> { self.index_mut(&ops::FullRange).index_mut(index) } } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> { type Output = [T]; #[inline] @@ -922,7 +922,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn into_slice(self) -> &'a mut [T] { make_slice!(T => &'a mut [T]: self.ptr, self.end) } @@ -1270,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "trait is experimental")] +#[unstable(feature = "unnamed_feature", reason = "trait is experimental")] impl<'a, T> RandomAccessIterator for Chunks<'a, T> { #[inline] fn indexable(&self) -> uint { @@ -1354,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> { // /// Converts a pointer to A into a slice of length 1 (without copying). -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { unsafe { transmute(RawSlice { data: s, len: 1 }) @@ -1362,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] { } /// Converts a pointer to A into a slice of length 1 (without copying). -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { unsafe { let ptr: *const A = transmute(s); @@ -1396,7 +1396,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] { /// } /// ``` #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "should be renamed to from_raw_parts")] pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { transmute(RawSlice { data: *p, len: len }) @@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] { /// not being able to provide a non-aliasing guarantee of the returned mutable /// slice. #[inline] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "should be renamed to from_raw_parts_mut")] pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { transmute(RawSlice { data: *p, len: len }) @@ -1420,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] { // /// Operations on `[u8]`. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "needs review")] +#[unstable(feature = "unnamed_feature", reason = "needs review")] pub mod bytes { use ptr; use slice::SliceExt; @@ -1508,7 +1508,7 @@ impl<T: PartialOrd> PartialOrd for [T] { } /// Extension methods for slices containing integers. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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]; @@ -1523,7 +1523,7 @@ pub trait IntSliceExt<U, S> { macro_rules! impl_int_slice { ($u:ty, $s:ty, $t:ty) => { - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] impl IntSliceExt<$u, $s> for [$t] { #[inline] fn as_unsigned(&self) -> &[$u] { unsafe { transmute(self) } } diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs index c2f9e764a9f..2086d727053 100644 --- a/src/libcore/str/mod.rs +++ b/src/libcore/str/mod.rs @@ -108,7 +108,7 @@ macro_rules! delegate_iter { /// A trait to abstract the idea of creating a new instance of a type from a /// string. // FIXME(#17307): there should be an `E` associated type for a `Result` return -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "will return a Result once associated types are working")] pub trait FromStr { /// Parses a string `s` to return an optional value of this type. If the @@ -144,7 +144,7 @@ Section: Creating a string /// Errors which can occur when attempting to interpret a byte slice as a `str`. #[derive(Copy, Eq, PartialEq, Clone, Show)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "error enumeration recently added and definitions may be refined")] pub enum Utf8Error { /// An invalid byte was detected at the byte offset given. @@ -208,7 +208,7 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str { } /// Something that can be used to compare against a character -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "definition may change as pattern-related methods are stabilized")] pub trait CharEq { /// Determine if the splitter should split at the given character @@ -861,7 +861,7 @@ impl Searcher { /// An iterator over the start and end indices of the matches of a /// substring within a larger string #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "type may be removed")] +#[unstable(feature = "unnamed_feature", reason = "type may be removed")] pub struct MatchIndices<'a> { // constants haystack: &'a str, @@ -872,7 +872,7 @@ pub struct MatchIndices<'a> { /// An iterator over the substrings of a string separated by a given /// search string #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "type may be removed")] +#[unstable(feature = "unnamed_feature", reason = "type may be removed")] pub struct SplitStr<'a> { it: MatchIndices<'a>, last_end: uint, @@ -1056,7 +1056,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [ /// the next `char` in a string. This can be used as a data structure /// for iterating over the UTF-8 bytes of a string. #[derive(Copy)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "naming is uncertain with container conventions")] pub struct CharRange { /// Current `char` @@ -1151,7 +1151,7 @@ mod traits { } /// Any string that can be represented as a slice -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "Instead of taking this bound generically, this trait will be \ replaced with one of slicing syntax, deref coercions, or \ a more generic conversion trait")] @@ -1178,7 +1178,7 @@ delegate_iter!{pattern &'a str : Split<'a, P>} /// Return type of `StrExt::split_terminator` #[derive(Clone)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "might get removed in favour of a constructor method on Split")] pub struct SplitTerminator<'a, P>(CharSplits<'a, P>); delegate_iter!{pattern &'a str : SplitTerminator<'a, P>} diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index a5033a701bf..98c149300b1 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![allow(unknown_features)] #![feature(int_uint)] #![feature(unnamed_feature)] diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs index 282ff7c29ac..24e4fc20b75 100644 --- a/src/libfmt_macros/lib.rs +++ b/src/libfmt_macros/lib.rs @@ -15,7 +15,7 @@ //! generated instead. #![crate_name = "fmt_macros"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs index 829c89a6c66..52ffd86acc6 100644 --- a/src/libgetopts/lib.rs +++ b/src/libgetopts/lib.rs @@ -78,7 +78,7 @@ //! ``` #![crate_name = "getopts"] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "use the crates.io `getopts` library instead")] #![staged_api] #![crate_type = "rlib"] diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs index 300500df478..cdad4944113 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index ebdf9c95705..9f6ffb4005b 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -11,7 +11,7 @@ #![crate_name = "libc"] #![crate_type = "rlib"] #![cfg_attr(not(feature = "cargo-build"), - unstable(feature = "unnamed_feature", since = "1.0.0"))] + unstable(feature = "unnamed_feature"))] #![cfg_attr(not(feature = "cargo-build"), staged_api)] #![cfg_attr(not(feature = "cargo-build"), feature(unnamed_feature))] #![allow(unknown_features)] #![feature(int_uint)] diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index f1f106c73f6..d398406b2cb 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "use the crates.io `log` library instead")] #![staged_api] #![crate_type = "rlib"] diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index c03dbc280d3..8f259962f19 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use core::prelude::*; use core::num::{Float, Int}; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index b39fb3e9fb8..3abb22ec34c 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -25,7 +25,7 @@ #![feature(unnamed_feature)] #![allow(unknown_features)] #![feature(int_uint)] #![no_std] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #[macro_use] diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 60ad6a04d4b..e621f6f2b1b 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs index c575f9a849e..6c9ef494959 100644 --- a/src/libregex/lib.rs +++ b/src/libregex/lib.rs @@ -16,7 +16,7 @@ #![crate_name = "regex"] #![crate_type = "rlib"] #![crate_type = "dylib"] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "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", diff --git a/src/libregex/re.rs b/src/libregex/re.rs index 98d072bb954..c3d9477469c 100644 --- a/src/libregex/re.rs +++ b/src/libregex/re.rs @@ -255,7 +255,7 @@ impl Regex { } #[doc(hidden)] - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn names_iter<'a>(&'a self) -> NamesIter<'a> { match *self { Native(ref n) => NamesIterNative(n.names.iter()), diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index e37a2c91bca..507e093ed63 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs index 323aea893e4..0cb64a05c45 100644 --- a/src/librustc_back/lib.rs +++ b/src/librustc_back/lib.rs @@ -22,7 +22,7 @@ //! build speedups. #![crate_name = "rustc_back"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_bitflags/lib.rs b/src/librustc_bitflags/lib.rs index 63d97b1ebe5..0ef9d8a2e72 100644 --- a/src/librustc_bitflags/lib.rs +++ b/src/librustc_bitflags/lib.rs @@ -12,7 +12,7 @@ #![staged_api] #![crate_type = "rlib"] #![no_std] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] //! A typesafe bitmask flag generator. diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs index 585aaf8968f..573d752cdaf 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index a5fff5484f7..7a17d186524 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs index 3a74e2d255e..5d4b4dfe335 100644 --- a/src/librustc_llvm/lib.rs +++ b/src/librustc_llvm/lib.rs @@ -14,7 +14,7 @@ #![allow(dead_code)] #![crate_name = "rustc_llvm"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index bc2f69f62fb..6edfe04b9f7 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustc_privacy"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 6f9907853b7..c15995edbed 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs index a92d85673d9..bf345fd4fec 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index fa90ad88c19..71bfacaf5a5 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 22c8e1f3b32..abe22753758 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2496,7 +2496,8 @@ impl Clean<Stability> for attr::Stability { Stability { level: self.level, feature: self.feature.get().to_string(), - since: self.since.get().to_string(), + since: self.since.as_ref().map_or("".to_string(), + |interned| interned.get().to_string()), reason: self.reason.as_ref().map_or("".to_string(), |interned| interned.get().to_string()), } diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index fa5110454a1..b8704177314 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name = "rustdoc"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs index b662ba638a7..a2db8b48a51 100644 --- a/src/libserialize/lib.rs +++ b/src/libserialize/lib.rs @@ -15,7 +15,7 @@ Core encoding and decoding interfaces. */ #![crate_name = "serialize"] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "deprecated in favor of rustc-serialize on crates.io")] #![staged_api] #![crate_type = "rlib"] diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs index 9e301bf9c04..c316a8ba6c7 100644 --- a/src/libstd/ascii.rs +++ b/src/libstd/ascii.rs @@ -12,7 +12,7 @@ //! Operations on ASCII strings and characters -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "unsure about placement and naming")] use iter::IteratorExt; @@ -23,7 +23,7 @@ use string::String; use vec::Vec; /// Extension methods for ASCII-subset only operations on owned strings -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] pub trait OwnedAsciiExt { /// Convert the string to ASCII upper case: @@ -38,7 +38,7 @@ pub trait OwnedAsciiExt { } /// Extension methods for ASCII-subset only operations on string slices -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] pub trait AsciiExt<T = Self> { /// Check if within the ASCII range. @@ -60,7 +60,7 @@ pub trait AsciiExt<T = Self> { fn eq_ignore_ascii_case(&self, other: &Self) -> bool; } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl AsciiExt<String> for str { #[inline] @@ -86,7 +86,7 @@ impl AsciiExt<String> for str { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl OwnedAsciiExt for String { #[inline] @@ -102,7 +102,7 @@ impl OwnedAsciiExt for String { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl AsciiExt<Vec<u8>> for [u8] { #[inline] @@ -129,7 +129,7 @@ impl AsciiExt<Vec<u8>> for [u8] { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl OwnedAsciiExt for Vec<u8> { #[inline] @@ -149,7 +149,7 @@ impl OwnedAsciiExt for Vec<u8> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl AsciiExt for u8 { #[inline] @@ -173,7 +173,7 @@ impl AsciiExt for u8 { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "would prefer to do this in a more general way")] impl AsciiExt for char { #[inline] @@ -216,7 +216,7 @@ impl AsciiExt for char { /// - Any other chars in the range [0x20,0x7e] are not escaped. /// - Any other chars are given hex escapes. /// - Unicode escapes are never generated by this function. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "needs to be updated to use an iterator")] pub fn escape_default<F>(c: u8, mut f: F) where F: FnMut(u8), diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index 6690d3bd374..b9ddf54f2c8 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -539,7 +539,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// map.insert(1i, 2u); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "hasher stuff is unclear")] + #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> { HashMap { hash_state: hash_state, @@ -567,7 +567,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// map.insert(1i, 2u); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "hasher stuff is unclear")] + #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) -> HashMap<K, V, S> { let resize_policy = DefaultResizePolicy::new(); @@ -928,7 +928,7 @@ impl<K, V, S, H> HashMap<K, V, S> } /// Gets the given key's corresponding entry in the map for in-place manipulation. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "precise API still being fleshed out")] pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V> { @@ -990,7 +990,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// assert!(a.is_empty()); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain(&mut self) -> Drain<K, V> { fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) } @@ -1339,7 +1339,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> { } /// HashMap drain iterator -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub struct Drain<'a, K: 'a, V: 'a> { inner: iter::Map< @@ -1351,14 +1351,14 @@ pub struct Drain<'a, K: 'a, V: 'a> { } /// A view into a single occupied location in a HashMap -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still being fleshed out")] pub struct OccupiedEntry<'a, K: 'a, V: 'a> { elem: FullBucket<K, V, &'a mut RawTable<K, V>>, } /// A view into a single empty location in a HashMap -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still being fleshed out")] pub struct VacantEntry<'a, K: 'a, V: 'a> { hash: SafeHash, @@ -1367,7 +1367,7 @@ pub struct VacantEntry<'a, K: 'a, V: 'a> { } /// A view into a single location in a map, which may be vacant or occupied -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "precise API still being fleshed out")] pub enum Entry<'a, K: 'a, V: 'a> { /// An occupied Entry @@ -1457,7 +1457,7 @@ impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] impl<'a, K, V> Entry<'a, K, V> { /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant @@ -1469,7 +1469,7 @@ impl<'a, K, V> Entry<'a, K, V> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] impl<'a, K, V> OccupiedEntry<'a, K, V> { /// Gets a reference to the value in the entry @@ -1501,7 +1501,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "matches collection reform v2 specification, waiting for dust to settle")] impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { /// Sets the value of the entry with the VacantEntry's key, @@ -1554,14 +1554,14 @@ impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S> /// instances are unlikely to produce the same result for the same values. #[derive(Clone)] #[allow(missing_copy_implementations)] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "hashing an hash maps may be altered")] pub struct RandomState { k0: u64, k1: u64, } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "hashing an hash maps may be altered")] impl RandomState { /// Construct a new `RandomState` that is initialized with random keys. @@ -1572,7 +1572,7 @@ impl RandomState { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "hashing an hash maps may be altered")] impl HashState for RandomState { type Hasher = Hasher; @@ -1581,7 +1581,7 @@ impl HashState for RandomState { } } -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "hashing an hash maps may be altered")] impl Default for RandomState { #[inline] diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index c4fecc00bbd..18778c5ee27 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -147,7 +147,7 @@ impl<T, S, H> HashSet<T, S> /// set.insert(2u); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "hasher stuff is unclear")] + #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] pub fn with_hash_state(hash_state: S) -> HashSet<T, S> { HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state) } @@ -171,7 +171,7 @@ impl<T, S, H> HashSet<T, S> /// set.insert(1i); /// ``` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "hasher stuff is unclear")] + #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")] pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S) -> HashSet<T, S> { HashSet { @@ -419,7 +419,7 @@ impl<T, S, H> HashSet<T, S> /// Clears the set, returning all elements in an iterator. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "matches collection reform specification, waiting for dust to settle")] pub fn drain(&mut self) -> Drain<T> { fn first<A, B>((a, _): (A, B)) -> A { a } diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs index 2e2d70546ae..4d2d1e8e91c 100644 --- a/src/libstd/collections/mod.rs +++ b/src/libstd/collections/mod.rs @@ -337,7 +337,7 @@ pub mod hash_set { /// Experimental support for providing custom hash algorithms to a HashMap and /// HashSet. -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "module was recently added")] +#[unstable(feature = "unnamed_feature", reason = "module was recently added")] pub mod hash_state { pub use super::hash::state::*; } diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs index 493f5ad2dc6..7520e05be6a 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 -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![allow(missing_docs)] use prelude::v1::*; diff --git a/src/libstd/error.rs b/src/libstd/error.rs index 91603fb7119..3754daf0b47 100644 --- a/src/libstd/error.rs +++ b/src/libstd/error.rs @@ -86,7 +86,7 @@ use str::Utf8Error; use string::{FromUtf8Error, FromUtf16Error}; /// Base functionality for all errors in Rust. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "the exact API of this trait may change")] pub trait Error { /// A short description of the error; usually a static string. diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs index e6b3348e690..b996eefcd2d 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use prelude::v1::*; diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs index 6017a62e3be..59f2595adac 100644 --- a/src/libstd/ffi/mod.rs +++ b/src/libstd/ffi/mod.rs @@ -10,7 +10,7 @@ //! Utilities related to FFI bindings. -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "module just underwent fairly large reorganization and the dust \ still needs to settle")] diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index d28e84f3cdd..7d84b07da70 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -403,7 +403,7 @@ //! them with the same character. For example, the `{` character is escaped with //! `{{` and the `}` character is escaped with `}}`. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use string; @@ -432,7 +432,7 @@ pub use core::fmt::{argument, argumentuint}; /// let s = fmt::format(format_args!("Hello, {}!", "world")); /// assert_eq!(s, "Hello, world!".to_string()); /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "this is an implementation detail of format! and should not \ be called directly")] pub fn format(args: Arguments) -> string::String { diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 012728be56a..3abdbce71f7 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![deny(unused_must_use)] pub use self::SeekStyle::*; @@ -1743,7 +1743,7 @@ pub struct FileStat { /// /// Usage of this field is discouraged, but if access is desired then the /// fields are located here. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub unstable: UnstableFileStat, } @@ -1751,7 +1751,7 @@ pub struct FileStat { /// returned from a `stat` syscall which is not contained in the `FileStat` /// structure. This information is not necessarily platform independent, and may /// have different meanings or no meaning at all on some platforms. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[derive(Copy, Hash)] pub struct UnstableFileStat { /// The ID of the device containing the file. diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs index 6705b22c92f..835142d1c8f 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`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "the timeout argument is likely to change types")] pub fn connect_timeout<P>(path: P, timeout: Duration) -> IoResult<UnixStream> @@ -108,7 +108,7 @@ impl UnixStream { /// Sets the read/write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -117,7 +117,7 @@ impl UnixStream { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -126,7 +126,7 @@ impl UnixStream { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -221,7 +221,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "the name and arguments to this function are likely \ to change")] pub fn set_timeout(&mut self, timeout_ms: Option<u64>) { @@ -232,7 +232,7 @@ impl UnixAcceptor { /// /// This function has the same semantics as `TcpAcceptor::close_accept`, and /// more information can be found in that documentation. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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 88d74c5c288..1b8f51e1837 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`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "the timeout argument may eventually change types")] pub fn connect_timeout<A: ToSocketAddr>(addr: A, timeout: Duration) -> IoResult<TcpStream> { @@ -110,7 +110,7 @@ impl TcpStream { } /// Sets the nodelay flag on this connection to the boolean specified - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> { self.inner.set_nodelay(nodelay) } @@ -120,7 +120,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> { self.inner.set_keepalive(delay_in_seconds) } @@ -188,7 +188,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`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -206,7 +206,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -234,7 +234,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -398,7 +398,7 @@ impl TcpAcceptor { /// a.set_timeout(None); /// let socket = a.accept(); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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); } @@ -445,7 +445,7 @@ impl TcpAcceptor { /// // Signal our accept loop to exit /// assert!(a.close_accept().is_ok()); /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn close_accept(&mut self) -> IoResult<()> { self.inner.close_accept() } diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs index 9920e002795..0fc868969d9 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) - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> { self.inner.join_multicast(multi) } /// Leaves a multicast IP address (drops membership from it) - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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) - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> { self.inner.set_multicast_loop(on) } /// Sets the multicast TTL - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.multicast_time_to_live(ttl) } /// Sets this socket's TTL - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> { self.inner.time_to_live(ttl) } /// Sets the broadcast flag on or off - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] 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` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -141,7 +141,7 @@ impl UdpSocket { /// Sets the read timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) @@ -150,7 +150,7 @@ impl UdpSocket { /// Sets the write timeout for this socket. /// /// For more information, see `TcpStream::set_timeout` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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) diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs index dc15eb1302f..f567057d47a 100644 --- a/src/libstd/io/process.rs +++ b/src/libstd/io/process.rs @@ -689,7 +689,7 @@ impl Process { /// p.wait() /// } /// ``` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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 16d11077080..bbbbe2aa152 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] /// The entry point for panic of Rust tasks. /// @@ -148,7 +148,7 @@ macro_rules! try { /// /// For more information about select, see the `std::sync::mpsc::Select` structure. #[macro_export] -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 a9e40e96332..b689734b0a0 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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 ae5db0b1fd8..a8992012aa2 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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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] -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "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 38bb62d2414..6fa89be1f28 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![doc(hidden)] macro_rules! assert_approx_eq { diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs index 640d814c046..3bc40bebf73 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![doc(hidden)] macro_rules! int_module { ($T:ty) => ( diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index 82363a8e169..d074144d80a 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; -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be removed or relocated")] +#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")] pub mod strconv; /// Mathematical operations on primitive floating point numbers. @@ -52,27 +52,27 @@ pub trait Float { // inlined methods from `num::Float` /// Returns the NaN value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn nan() -> Self; /// Returns the infinite value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn infinity() -> Self; /// Returns the negative infinite value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn neg_infinity() -> Self; /// Returns the `0` value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn zero() -> Self; /// Returns -0.0. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn neg_zero() -> Self; /// Returns the `1` value. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn one() -> Self; @@ -109,37 +109,37 @@ pub trait Float fn max_10_exp(unused_self: Option<Self>) -> int; /// Returns the smallest finite value that this type can represent. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn min_value() -> Self; /// Returns the smallest normalized positive number that this type can represent. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn min_pos_value(unused_self: Option<Self>) -> Self; /// Returns the largest finite value that this type can represent. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn max_value() -> Self; /// Returns true if this value is NaN and false otherwise. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "position is undecided")] + #[unstable(feature = "unnamed_feature", reason = "position is undecided")] fn is_nan(self) -> bool; /// Returns true if this value is positive infinity or negative infinity and /// false otherwise. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "position is undecided")] + #[unstable(feature = "unnamed_feature", reason = "position is undecided")] fn is_infinite(self) -> bool; /// Returns true if this number is neither infinite nor NaN. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "position is undecided")] + #[unstable(feature = "unnamed_feature", reason = "position is undecided")] fn is_finite(self) -> bool; /// Returns true if this number is neither zero, infinite, denormal, or NaN. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "position is undecided")] + #[unstable(feature = "unnamed_feature", reason = "position is undecided")] fn is_normal(self) -> bool; /// Returns the category that this number falls into. #[stable(feature = "grandfathered", since = "1.0.0")] fn classify(self) -> FpCategory; /// Returns the mantissa, exponent and sign as integers, respectively. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "signature is undecided")] + #[unstable(feature = "unnamed_feature", reason = "signature is undecided")] fn integer_decode(self) -> (u64, i16, i8); /// Return the largest integer less than or equal to a number. @@ -182,11 +182,11 @@ pub trait Float /// Fused multiply-add. Computes `(self * a) + b` with only one rounding /// error. This produces a more accurate result with better performance than /// a separate multiplication operation followed by an add. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn mul_add(self, a: Self, b: Self) -> Self; /// Take the reciprocal (inverse) of a number, `1/x`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn recip(self) -> Self; @@ -205,7 +205,7 @@ pub trait Float #[stable(feature = "grandfathered", since = "1.0.0")] fn sqrt(self) -> Self; /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn rsqrt(self) -> Self; @@ -229,15 +229,15 @@ pub trait Float fn log10(self) -> Self; /// Convert radians to degrees. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "desirability is unclear")] + #[unstable(feature = "unnamed_feature", reason = "desirability is unclear")] fn to_degrees(self) -> Self; /// Convert degrees to radians. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "desirability is unclear")] + #[unstable(feature = "unnamed_feature", reason = "desirability is unclear")] fn to_radians(self) -> Self; /// Constructs a floating point number created by multiplying `x` by 2 /// raised to the power of `exp`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn ldexp(x: Self, exp: int) -> Self; /// Breaks the number into a normalized fraction and a base-2 exponent, @@ -246,13 +246,13 @@ pub trait Float /// * `self = x * pow(2, exp)` /// /// * `0.5 <= abs(x) < 1.0` - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn frexp(self) -> (Self, int); /// Returns the next representable floating-point value in the direction of /// `other`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn next_after(self, other: Self) -> Self; @@ -266,15 +266,15 @@ pub trait Float /// The positive difference of two numbers. Returns `0.0` if the number is /// less than or equal to `other`, otherwise the difference between`self` /// and `other` is returned. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed")] fn abs_sub(self, other: Self) -> Self; /// Take the cubic root of a number. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed")] fn cbrt(self) -> Self; /// Calculate the length of the hypotenuse of a right-angle triangle given /// legs of length `x` and `y`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure about its place in the world")] fn hypot(self, other: Self) -> Self; @@ -313,11 +313,11 @@ pub trait Float /// Returns the exponential of the number, minus 1, in a way that is /// accurate even if the number is close to zero. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed")] fn exp_m1(self) -> Self; /// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more /// accurately than if the operations were performed separately. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "may be renamed")] + #[unstable(feature = "unnamed_feature", reason = "may be renamed")] fn ln_1p(self) -> Self; /// Hyperbolic sine function. diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs index 786912f0028..fb23c5647c8 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![doc(hidden)] #![allow(unsigned_negation)] diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 2b5748604d1..26380515474 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![allow(missing_docs)] #![allow(non_snake_case)] diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs index 2a21f449551..864d49a430c 100644 --- a/src/libstd/path/mod.rs +++ b/src/libstd/path/mod.rs @@ -59,7 +59,7 @@ //! println!("path exists: {}", path.exists()); //! ``` -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use core::marker::Sized; use ffi::CString; diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs index e0302c54a5a..d03ca5bf78c 100644 --- a/src/libstd/prelude/v1.rs +++ b/src/libstd/prelude/v1.rs @@ -19,7 +19,7 @@ #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce}; // TEMPORARY -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] #[doc(no_inline)] pub use ops::FullRange; // Reexported functions diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 24969ddb01c..2b7b026af5e 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -219,7 +219,7 @@ //! } //! ``` -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use cell::RefCell; use clone::Clone; diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs index b4cc27ce926..aa16ee05ece 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] // FIXME: this should not be here. #![allow(missing_docs)] diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs index 1d8c7cd5910..bbe97dbe08f 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. -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] 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 4a178c7d384..d69c94bb020 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] // All platforms need to link to rustrt #[cfg(not(test))] diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs index 739e70720ca..a84decc2efa 100644 --- a/src/libstd/sync/condvar.rs +++ b/src/libstd/sync/condvar.rs @@ -76,7 +76,7 @@ unsafe impl Sync for Condvar {} /// /// static CVAR: StaticCondvar = CONDVAR_INIT; /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub struct StaticCondvar { inner: sys::Condvar, @@ -87,7 +87,7 @@ unsafe impl Send for StaticCondvar {} unsafe impl Sync for StaticCondvar {} /// Constant initializer for a statically allocated condition variable. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub const CONDVAR_INIT: StaticCondvar = StaticCondvar { inner: sys::CONDVAR_INIT, @@ -156,7 +156,7 @@ impl Condvar { /// /// Like `wait`, the lock specified will be re-acquired when this function /// returns, regardless of whether the timeout elapsed or not. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>, dur: Duration) -> LockResult<(MutexGuard<'a, T>, bool)> { unsafe { @@ -171,7 +171,7 @@ impl Condvar { /// The semantics of this function are equivalent to `wait_timeout` except /// that the implementation will repeatedly wait while the duration has not /// passed and the provided function returns `false`. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn wait_timeout_with<'a, T, F>(&self, guard: MutexGuard<'a, T>, dur: Duration, @@ -217,7 +217,7 @@ impl StaticCondvar { /// notification. /// /// See `Condvar::wait`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub fn wait<'a, T>(&'static self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>> { @@ -238,7 +238,7 @@ impl StaticCondvar { /// specified duration. /// /// See `Condvar::wait_timeout`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub fn wait_timeout<'a, T>(&'static self, guard: MutexGuard<'a, T>, dur: Duration) -> LockResult<(MutexGuard<'a, T>, bool)> { @@ -262,7 +262,7 @@ impl StaticCondvar { /// passed and the function returns `false`. /// /// See `Condvar::wait_timeout_with`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub fn wait_timeout_with<'a, T, F>(&'static self, guard: MutexGuard<'a, T>, @@ -303,14 +303,14 @@ impl StaticCondvar { /// Wake up one blocked thread on this condvar. /// /// See `Condvar::notify_one`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub fn notify_one(&'static self) { unsafe { self.inner.notify_one() } } /// Wake up all blocked threads on this condvar. /// /// See `Condvar::notify_all`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub fn notify_all(&'static self) { unsafe { self.inner.notify_all() } } @@ -320,7 +320,7 @@ impl StaticCondvar { /// active users of the condvar, and this also doesn't prevent any future /// users of the condvar. This method is required to be called to not leak /// memory on all platforms. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Condvar in the future")] pub unsafe fn destroy(&'static self) { self.inner.destroy() diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs index bb309d5c2e8..6218867521b 100644 --- a/src/libstd/sync/future.rs +++ b/src/libstd/sync/future.rs @@ -27,7 +27,7 @@ //! ``` #![allow(missing_docs)] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "futures as-is have yet to be deeply reevaluated with recent \ core changes to Rust's synchronization story, and will likely \ become stable in the future but are unstable until that time")] diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index 9747de3b7f9..b777df56a9c 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] // 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 1a433db2deb..1e25cc87b28 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -46,7 +46,7 @@ //! ``` #![allow(dead_code)] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "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 \ diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index cc7a34f8d4c..d12628a4f2f 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use core::prelude::*; diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index 343dfbf68c7..ec3b6576961 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -145,7 +145,7 @@ unsafe impl<T:Send> Sync for Mutex<T> { } /// } /// // lock is unlocked here. /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with Mutex in the future")] pub struct StaticMutex { lock: sys::Mutex, @@ -192,7 +192,7 @@ impl<'a, T> !marker::Send for MutexGuard<'a, T> {} /// Static initialization of a mutex. This constant can be used to initialize /// other mutex constants. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with Mutex in the future")] pub const MUTEX_INIT: StaticMutex = StaticMutex { lock: sys::MUTEX_INIT, @@ -267,7 +267,7 @@ static DUMMY: Dummy = Dummy(UnsafeCell { value: () }); impl StaticMutex { /// Acquires this lock, see `Mutex::lock` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Mutex in the future")] pub fn lock(&'static self) -> LockResult<MutexGuard<()>> { unsafe { self.lock.lock() } @@ -276,7 +276,7 @@ impl StaticMutex { /// Attempts to grab this lock, see `Mutex::try_lock` #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Mutex in the future")] pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> { if unsafe { self.lock.try_lock() } { @@ -296,7 +296,7 @@ impl StaticMutex { /// *all* platforms. It may be the case that some platforms do not leak /// memory if this method is not called, but this is not guaranteed to be /// true on all platforms. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with Mutex in the future")] pub unsafe fn destroy(&'static self) { self.lock.destroy() diff --git a/src/libstd/sync/poison.rs b/src/libstd/sync/poison.rs index 4443fc2be60..527343c4c19 100644 --- a/src/libstd/sync/poison.rs +++ b/src/libstd/sync/poison.rs @@ -110,17 +110,17 @@ impl<T> PoisonError<T> { /// Consumes this error indicating that a lock is poisoned, returning the /// underlying guard to allow access regardless. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn into_inner(self) -> T { self.guard } /// Reaches into this error indicating that a lock is poisoned, returning a /// reference to the underlying guard to allow access regardless. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn get_ref(&self) -> &T { &self.guard } /// Reaches into this error indicating that a lock is poisoned, returning a /// mutable reference to the underlying guard to allow access regardless. - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn get_mut(&mut self) -> &mut T { &mut self.guard } } diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index 6d0b34b3c87..f76bee16107 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -90,7 +90,7 @@ unsafe impl<T> Sync for RwLock<T> {} /// } /// unsafe { LOCK.destroy() } // free all resources /// ``` -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub struct StaticRwLock { lock: sys::RWLock, @@ -101,7 +101,7 @@ unsafe impl Send for StaticRwLock {} unsafe impl Sync for StaticRwLock {} /// Constant initialization for a statically-initialized rwlock. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock { lock: sys::RWLOCK_INIT, @@ -276,7 +276,7 @@ impl StaticRwLock { /// /// See `RwLock::read`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub fn read(&'static self) -> LockResult<RwLockReadGuard<'static, ()>> { unsafe { self.lock.read() } @@ -287,7 +287,7 @@ impl StaticRwLock { /// /// See `RwLock::try_read`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub fn try_read(&'static self) -> TryLockResult<RwLockReadGuard<'static, ()>> { @@ -303,7 +303,7 @@ impl StaticRwLock { /// /// See `RwLock::write`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub fn write(&'static self) -> LockResult<RwLockWriteGuard<'static, ()>> { unsafe { self.lock.write() } @@ -314,7 +314,7 @@ impl StaticRwLock { /// /// See `RwLock::try_write`. #[inline] - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub fn try_write(&'static self) -> TryLockResult<RwLockWriteGuard<'static, ()>> { @@ -331,7 +331,7 @@ impl StaticRwLock { /// active users of the lock, and this also doesn't prevent any future users /// of this lock. This method is required to be called to not leak memory on /// all platforms. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may be merged with RwLock in the future")] pub unsafe fn destroy(&'static self) { self.lock.destroy() diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs index 08b620c764a..e9528e1133c 100644 --- a/src/libstd/sync/semaphore.rs +++ b/src/libstd/sync/semaphore.rs @@ -8,7 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "the interaction between semaphores and the acquisition/release \ of resources is currently unclear")] diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs index ceec1885375..6fb60504615 100644 --- a/src/libstd/sync/task_pool.rs +++ b/src/libstd/sync/task_pool.rs @@ -10,7 +10,7 @@ //! Abstraction of a thread pool for basic parallelism. -#![unstable(feature = "unnamed_feature", since="1.0.0", +#![unstable(feature = "unnamed_feature", reason = "the semantics of a failing task and whether a thread is \ re-attached to a thread pool are somewhat unclear, and the \ utility of this type in `std::sync` is questionable with \ diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs index 4e846a42030..f12ad020d06 100644 --- a/src/libstd/sys/unix/ext.rs +++ b/src/libstd/sys/unix/ext.rs @@ -29,7 +29,7 @@ //! } //! ``` -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use sys_common::AsInner; use libc; diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs index edc46b9c162..25318551711 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. -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use sys_common::AsInner; use libc; diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index 7df7e750610..d4bad950180 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -207,7 +207,7 @@ impl Builder { } /// Redirect thread-local stdout. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Will likely go away after proc removal")] pub fn stdout(mut self, stdout: Box<Writer + Send>) -> Builder { self.stdout = Some(stdout); @@ -215,7 +215,7 @@ impl Builder { } /// Redirect thread-local stderr. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "Will likely go away after proc removal")] pub fn stderr(mut self, stderr: Box<Writer + Send>) -> Builder { self.stderr = Some(stderr); @@ -225,7 +225,7 @@ impl Builder { /// Spawn a new detached thread, and return a handle to it. /// /// See `Thead::spawn` and the module doc for more details. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may change with specifics of new Send semantics")] pub fn spawn<F>(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static { let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {})); @@ -237,7 +237,7 @@ impl Builder { /// scope, and return a `JoinGuard`. /// /// See `Thead::scoped` and the module doc for more details. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may change with specifics of new Send semantics")] pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where T: Send + 'a, F: FnOnce() -> T, F: Send + 'a @@ -354,7 +354,7 @@ impl Thread { /// main thread; the whole process is terminated when the main thread /// finishes.) The thread handle can be used for low-level /// synchronization. See the module documentation for additional details. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may change with specifics of new Send semantics")] pub fn spawn<F>(f: F) -> Thread where F: FnOnce(), F: Send + 'static { Builder::new().spawn(f) @@ -368,7 +368,7 @@ impl Thread { /// current thread's stack (hence the "scoped" name), it cannot be detached; /// it *must* be joined before the relevant stack frame is popped. See the /// module documentation for additional details. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "may change with specifics of new Send semantics")] pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where T: Send + 'a, F: FnOnce() -> T, F: Send + 'a @@ -383,7 +383,7 @@ impl Thread { } /// Cooperatively give up a timeslice to the OS scheduler. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "name may change")] + #[unstable(feature = "unnamed_feature", reason = "name may change")] pub fn yield_now() { unsafe { imp::yield_now() } } @@ -404,7 +404,7 @@ impl Thread { // future, this will be implemented in a more efficient way, perhaps along the lines of // http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp // or futuxes, and in either case may allow spurious wakeups. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently introduced")] + #[unstable(feature = "unnamed_feature", reason = "recently introduced")] pub fn park() { let thread = Thread::current(); let mut guard = thread.inner.lock.lock().unwrap(); @@ -417,7 +417,7 @@ impl Thread { /// Atomically makes the handle's token available if it is not already. /// /// See the module doc for more detail. - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "recently introduced")] + #[unstable(feature = "unnamed_feature", reason = "recently introduced")] pub fn unpark(&self) { let mut guard = self.inner.lock.lock().unwrap(); if !*guard { @@ -453,7 +453,7 @@ unsafe impl<T> Sync for Packet<T> {} /// /// The type `T` is the return type for the thread's main function. #[must_use] -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "may change with specifics of new Send semantics")] pub struct JoinGuard<'a, T: 'a> { native: imp::rust_thread, @@ -490,7 +490,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "unsure whether this API imposes limitations elsewhere")] pub fn detach(mut self) { unsafe { imp::detach(self.native) }; diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs index bf74acda721..6fc5347b71e 100644 --- a/src/libstd/thread_local/mod.rs +++ b/src/libstd/thread_local/mod.rs @@ -218,7 +218,7 @@ macro_rules! __thread_local_inner { } /// Indicator of the state of a thread local storage key. -#[unstable(feature = "unnamed_feature", since = "1.0.0", +#[unstable(feature = "unnamed_feature", reason = "state querying was recently added")] #[derive(Eq, PartialEq, Copy)] pub enum State { @@ -302,7 +302,7 @@ impl<T: 'static> Key<T> { /// initialization does not panic. Keys in the `Valid` state are guaranteed /// to be able to be accessed. Keys in the `Destroyed` state will panic on /// any call to `with`. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "state querying was recently added")] pub fn state(&'static self) -> State { unsafe { diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs index e7062b298d2..415219aaa83 100644 --- a/src/libstd/thread_local/scoped.rs +++ b/src/libstd/thread_local/scoped.rs @@ -38,7 +38,7 @@ //! }); //! ``` -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "scoped TLS has yet to have wide enough use to fully consider \ stabilizing its interface")] diff --git a/src/libstd/thunk.rs b/src/libstd/thunk.rs index 94c86fcf1c8..d861cfb5d03 100644 --- a/src/libstd/thunk.rs +++ b/src/libstd/thunk.rs @@ -10,7 +10,7 @@ // Because this module is temporary... #![allow(missing_docs)] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use alloc::boxed::Box; use core::marker::Send; diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs index 90fd3b0138f..953636749e2 100644 --- a/src/libstd/time/duration.rs +++ b/src/libstd/time/duration.rs @@ -10,7 +10,7 @@ //! Temporal quantification -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] use {fmt, i64}; use ops::{Add, Sub, Mul, Div, Neg, FnOnce}; diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs index 9aa226103f3..ff1dc5d0c35 100644 --- a/src/libsyntax/attr.rs +++ b/src/libsyntax/attr.rs @@ -350,7 +350,7 @@ pub fn cfg_matches(diagnostic: &SpanHandler, cfgs: &[P<MetaItem>], cfg: &ast::Me pub struct Stability { pub level: StabilityLevel, pub feature: InternedString, - pub since: InternedString, + pub since: Option<InternedString>, pub reason: Option<InternedString>, } @@ -424,14 +424,14 @@ pub fn find_stability_generic<'a, diagnostic.span_err(attr.span(), "missing 'feature'"); } - if since == None { + if since == None && level != Unstable { diagnostic.span_err(attr.span(), "missing 'since'"); } return Some((Stability { level: level, feature: feature.unwrap_or(intern_and_get_ident("bogus")), - since: since.unwrap_or(intern_and_get_ident("bogus")), + since: since, reason: reason, }, attr)); } diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index 4d533590dd6..975c714b3b4 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "dylib"] #![crate_type = "rlib"] diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs index d14aad40bf0..dccbe6051c6 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0", +#![unstable(feature = "unnamed_feature", reason = "use the crates.io `term` library instead")] #![staged_api] #![crate_type = "rlib"] diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs index fbdfce0eddf..68949d56256 100644 --- a/src/libtest/lib.rs +++ b/src/libtest/lib.rs @@ -24,7 +24,7 @@ // build off of. #![crate_name = "test"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] #![crate_type = "rlib"] #![crate_type = "dylib"] diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs index f47530a408f..5b8a5d8d07a 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"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![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/libunicode/u_char.rs b/src/libunicode/u_char.rs index 64515ddf22f..812a066cdfe 100644 --- a/src/libunicode/u_char.rs +++ b/src/libunicode/u_char.rs @@ -34,7 +34,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix > 36. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool; @@ -49,7 +49,7 @@ pub trait CharExt { /// # Panics /// /// Panics if given a radix outside the range [0..36]. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint>; @@ -92,7 +92,7 @@ pub trait CharExt { /// /// If the buffer is not large enough, nothing will be written into it /// and a `None` will be returned. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf8(self, dst: &mut [u8]) -> Option<uint>; @@ -101,7 +101,7 @@ pub trait CharExt { /// /// If the buffer is not large enough, nothing will be written into it /// and a `None` will be returned. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf16(self, dst: &mut [u16]) -> Option<uint>; @@ -116,7 +116,7 @@ pub trait CharExt { /// 'XID_Start' is a Unicode Derived Property specified in /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications), /// mostly similar to ID_Start but modified for closure under NFKx. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "mainly needed for compiler internals")] fn is_xid_start(self) -> bool; @@ -126,7 +126,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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "mainly needed for compiler internals")] fn is_xid_continue(self) -> bool; @@ -177,7 +177,7 @@ pub trait CharExt { /// /// Returns the lowercase equivalent of the character, or the character /// itself if no conversion is possible. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending case transformation decisions")] fn to_lowercase(self) -> char; @@ -201,7 +201,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 - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending case transformation decisions")] fn to_uppercase(self) -> char; @@ -214,17 +214,17 @@ 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. - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "needs expert opinion. is_cjk flag stands out as ugly")] fn width(self, is_cjk: bool) -> Option<uint>; } #[stable(feature = "grandfathered", since = "1.0.0")] impl CharExt for char { - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn is_digit(self, radix: uint) -> bool { C::is_digit(self, radix) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending integer conventions")] fn to_digit(self, radix: uint) -> Option<uint> { C::to_digit(self, radix) } #[stable(feature = "grandfathered", since = "1.0.0")] @@ -235,10 +235,10 @@ impl CharExt for char { fn len_utf8(self) -> uint { C::len_utf8(self) } #[stable(feature = "grandfathered", since = "1.0.0")] fn len_utf16(self) -> uint { C::len_utf16(self) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { C::encode_utf8(self, dst) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending decision about Iterator/Writer/Reader")] fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { C::encode_utf16(self, dst) } @@ -251,11 +251,11 @@ impl CharExt for char { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "mainly needed for compiler internals")] fn is_xid_start(self) -> bool { derived_property::XID_Start(self) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "mainly needed for compiler internals")] fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) } @@ -303,15 +303,15 @@ impl CharExt for char { } } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending case transformation decisions")] fn to_lowercase(self) -> char { conversions::to_lower(self) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "pending case transformation decisions")] fn to_uppercase(self) -> char { conversions::to_upper(self) } - #[unstable(feature = "unnamed_feature", since = "1.0.0", + #[unstable(feature = "unnamed_feature", reason = "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 ada75c0e149..cfe201a87b3 100644 --- a/src/test/auxiliary/inherited_stability.rs +++ b/src/test/auxiliary/inherited_stability.rs @@ -9,7 +9,7 @@ // except according to those terms. #![crate_name="inherited_stability"] #![crate_type = "lib"] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #![staged_api] pub fn unstable() {} @@ -25,7 +25,7 @@ pub mod stable_mod { pub fn stable() {} } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub mod unstable_mod { #[deprecated(feature = "unnamed_feature", since = "1.0.0")] pub fn deprecated() {} diff --git a/src/test/auxiliary/lint_output_format.rs b/src/test/auxiliary/lint_output_format.rs index e47d1eeb401..2962ff88b21 100755 --- a/src/test/auxiliary/lint_output_format.rs +++ b/src/test/auxiliary/lint_output_format.rs @@ -11,19 +11,19 @@ #![crate_name="lint_output_format"] #![crate_type = "lib"] #![staged_api] -#![unstable(feature = "unnamed_feature", since = "1.0.0")] +#![unstable(feature = "unnamed_feature")] #[deprecated(feature = "oldstuff", since = "1.0.0")] pub fn foo() -> uint { 20 } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn bar() -> uint { 40 } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn baz() -> uint { 30 } diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs index 31746c062b5..915fe661ee5 100644 --- a/src/test/auxiliary/lint_stability.rs +++ b/src/test/auxiliary/lint_stability.rs @@ -16,9 +16,9 @@ pub fn deprecated() {} #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] pub fn deprecated_text() {} -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub fn unstable() {} -#[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] +#[unstable(feature = "unnamed_feature", reason = "text")] pub fn unstable_text() {} pub fn unmarked() {} @@ -37,9 +37,9 @@ impl MethodTester { #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] pub fn method_deprecated_text(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn method_unstable(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] + #[unstable(feature = "unnamed_feature", reason = "text")] pub fn method_unstable_text(&self) {} pub fn method_unmarked(&self) {} @@ -66,9 +66,9 @@ pub trait Trait { #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] fn trait_deprecated_text(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn trait_unstable(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] + #[unstable(feature = "unnamed_feature", reason = "text")] fn trait_unstable_text(&self) {} fn trait_unmarked(&self) {} @@ -91,12 +91,12 @@ pub trait Trait { impl Trait for MethodTester {} -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub trait UnstableTrait {} #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedStruct { pub i: int } -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct UnstableStruct { pub i: int } pub struct UnmarkedStruct { pub i: int } #[stable(feature = "grandfathered", since = "1.0.0")] @@ -104,7 +104,7 @@ pub struct StableStruct { pub i: int } #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedUnitStruct; -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct UnstableUnitStruct; pub struct UnmarkedUnitStruct; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -113,7 +113,7 @@ pub struct StableUnitStruct; pub enum Enum { #[deprecated(feature = "oldstuff", since = "1.0.0")] DeprecatedVariant, - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] UnstableVariant, UnmarkedVariant, @@ -123,7 +123,7 @@ pub enum Enum { #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedTupleStruct(pub int); -#[unstable(feature = "unnamed_feature", since = "1.0.0")] +#[unstable(feature = "unnamed_feature")] pub struct UnstableTupleStruct(pub int); pub struct UnmarkedTupleStruct(pub int); #[stable(feature = "grandfathered", since = "1.0.0")] diff --git a/src/test/auxiliary/stability_cfg2.rs b/src/test/auxiliary/stability_cfg2.rs index 19fa7a4f988..d694f2154c6 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, unstable(feature = "unnamed_feature", since = "1.0.0"))] +#![cfg_attr(foo, unstable(feature = "unnamed_feature"))] #![cfg_attr(not(foo), stable(feature = "unnamed_feature", since = "1.0.0"))] #![staged_api] diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs index 130b396387c..dd3b2754419 100644 --- a/src/test/compile-fail/lint-stability.rs +++ b/src/test/compile-fail/lint-stability.rs @@ -143,9 +143,9 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] pub fn deprecated_text() {} - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn unstable() {} - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] + #[unstable(feature = "unnamed_feature", reason = "text")] pub fn unstable_text() {} pub fn unmarked() {} @@ -164,9 +164,9 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] pub fn method_deprecated_text(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub fn method_unstable(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] + #[unstable(feature = "unnamed_feature", reason = "text")] pub fn method_unstable_text(&self) {} pub fn method_unmarked(&self) {} @@ -183,9 +183,9 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")] fn trait_deprecated_text(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] fn trait_unstable(&self) {} - #[unstable(feature = "unnamed_feature", since = "1.0.0", reason = "text")] + #[unstable(feature = "unnamed_feature", reason = "text")] fn trait_unstable_text(&self) {} fn trait_unmarked(&self) {} @@ -200,7 +200,7 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedStruct { i: isize } - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub struct UnstableStruct { i: isize } pub struct UnmarkedStruct { i: isize } #[stable(feature = "grandfathered", since = "1.0.0")] @@ -208,7 +208,7 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedUnitStruct; - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub struct UnstableUnitStruct; pub struct UnmarkedUnitStruct; #[stable(feature = "grandfathered", since = "1.0.0")] @@ -217,7 +217,7 @@ mod this_crate { pub enum Enum { #[deprecated(feature = "oldstuff", since = "1.0.0")] DeprecatedVariant, - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] UnstableVariant, UnmarkedVariant, @@ -227,7 +227,7 @@ mod this_crate { #[deprecated(feature = "oldstuff", since = "1.0.0")] pub struct DeprecatedTupleStruct(isize); - #[unstable(feature = "unnamed_feature", since = "1.0.0")] + #[unstable(feature = "unnamed_feature")] pub struct UnstableTupleStruct(isize); pub struct UnmarkedTupleStruct(isize); #[stable(feature = "grandfathered", since = "1.0.0")] |