Stabilization of impls and fallout from stabilization

10 files changed, 69 insertions, 28 deletions

diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs
index 7e4d73d598d..63b3be00f55 100644
--- a/src/libcore/borrow.rs
+++ b/src/libcore/borrow.rs
@@ -191,6 +191,7 @@ impl<'a, T, Sized? B> Cow<'a, T, B> where B: ToOwned<T> {
     }
 }
 
+#[stable]
 impl<'a, T, Sized? B> Deref for Cow<'a, T, B> where B: ToOwned<T>  {
     type Target = B;
 
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index eb772388dce..fd18d6ac3f3 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -419,7 +419,7 @@ pub struct Ref<'b, T:'b> {
     _borrow: BorrowRef<'b>,
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
+#[stable]
 impl<'b, T> Deref for Ref<'b, T> {
     type Target = T;
 
@@ -477,7 +477,7 @@ pub struct RefMut<'b, T:'b> {
     _borrow: BorrowRefMut<'b>,
 }
 
-#[unstable = "waiting for `Deref` to become stable"]
+#[stable]
 impl<'b, T> Deref for RefMut<'b, T> {
     type Target = T;
 
@@ -487,7 +487,7 @@ impl<'b, T> Deref for RefMut<'b, T> {
     }
 }
 
-#[unstable = "waiting for `DerefMut` to become stable"]
+#[stable]
 impl<'b, T> DerefMut for RefMut<'b, T> {
     #[inline]
     fn deref_mut<'a>(&'a mut self) -> &'a mut T {
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 291b7f2ece4..caac894c0da 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -314,6 +314,7 @@ pub struct EscapeUnicode {
 }
 
 #[derive(Clone)]
+#[unstable]
 enum EscapeUnicodeState {
     Backslash,
     Type,
@@ -375,6 +376,7 @@ pub struct EscapeDefault {
 }
 
 #[derive(Clone)]
+#[unstable]
 enum EscapeDefaultState {
     Backslash(char),
     Char(char),
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index 4782a763dc8..e5753f6cc2e 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -2401,7 +2401,7 @@ impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
     }
 }
 
-#[experimental]
+#[stable]
 impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
     type Item = A;
 
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index da2e95832e7..74702c66f7b 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -984,6 +984,7 @@ pub struct Range<Idx> {
 
 // FIXME(#19391) needs a snapshot
 //impl<Idx: Clone + Step<T=uint>> Iterator<Idx> for Range<Idx> {
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> Iterator for Range<Idx> {
     type Item = Idx;
 
@@ -1008,6 +1009,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> {
     }
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     #[inline]
     fn next_back(&mut self) -> Option<Idx> {
@@ -1020,6 +1022,7 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     }
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
 
 /// A range which is only bounded below.
@@ -1031,6 +1034,7 @@ pub struct RangeFrom<Idx> {
     pub start: Idx,
 }
 
+#[unstable = "API still in development"]
 impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
     type Item = Idx;
 
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index a9a1857ec97..39d0f024d4d 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -807,6 +807,7 @@ impl<A> ExactSizeIterator for Item<A> {}
 #[stable]
 pub struct Iter<'a, A: 'a> { inner: Item<&'a A> }
 
+#[stable]
 impl<'a, A> Iterator for Iter<'a, A> {
     type Item = &'a A;
 
@@ -816,11 +817,13 @@ impl<'a, A> Iterator for Iter<'a, A> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<'a, A> DoubleEndedIterator for Iter<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<'a, A> ExactSizeIterator for Iter<'a, A> {}
 
 #[stable]
@@ -834,6 +837,7 @@ impl<'a, A> Clone for Iter<'a, A> {
 #[stable]
 pub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }
 
+#[stable]
 impl<'a, A> Iterator for IterMut<'a, A> {
     type Item = &'a mut A;
 
@@ -843,17 +847,20 @@ impl<'a, A> Iterator for IterMut<'a, A> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<'a, A> DoubleEndedIterator for IterMut<'a, A> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
 
 /// An iterator over the item contained inside an Option.
 #[stable]
 pub struct IntoIter<A> { inner: Item<A> }
 
+#[stable]
 impl<A> Iterator for IntoIter<A> {
     type Item = A;
 
@@ -863,11 +870,13 @@ impl<A> Iterator for IntoIter<A> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
 }
 
+#[stable]
 impl<A> DoubleEndedIterator for IntoIter<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> { self.inner.next_back() }
 }
 
+#[stable]
 impl<A> ExactSizeIterator for IntoIter<A> {}
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index d4aca1bb73c..e88cb73c8a9 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -43,8 +43,7 @@ pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use iter::{Extend, IteratorExt};
 pub use iter::{Iterator, DoubleEndedIterator};
-pub use iter::{IteratorCloneExt, CloneIteratorExt};
-pub use iter::{IteratorOrdExt, ExactSizeIterator};
+pub use iter::{ExactSizeIterator};
 pub use option::Option::{self, Some, None};
 pub use ptr::{PtrExt, MutPtrExt};
 pub use result::Result::{self, Ok, Err};
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 7135faaa765..7293ed6455b 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -807,6 +807,7 @@ impl<T, E> AsSlice<T> for Result<T, E> {
 #[stable]
 pub struct Iter<'a, T: 'a> { inner: Option<&'a T> }
 
+#[stable]
 impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
 
@@ -819,11 +820,13 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 }
 
+#[stable]
 impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }
 }
 
+#[stable]
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 impl<'a, T> Clone for Iter<'a, T> {
@@ -834,6 +837,7 @@ impl<'a, T> Clone for Iter<'a, T> {
 #[stable]
 pub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }
 
+#[stable]
 impl<'a, T> Iterator for IterMut<'a, T> {
     type Item = &'a mut T;
 
@@ -846,17 +850,20 @@ impl<'a, T> Iterator for IterMut<'a, T> {
     }
 }
 
+#[stable]
 impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }
 }
 
+#[stable]
 impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// An iterator over the value in a `Ok` variant of a `Result`.
 #[stable]
 pub struct IntoIter<T> { inner: Option<T> }
 
+#[stable]
 impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
@@ -869,11 +876,13 @@ impl<T> Iterator for IntoIter<T> {
     }
 }
 
+#[stable]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
     fn next_back(&mut self) -> Option<T> { self.inner.take() }
 }
 
+#[stable]
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /////////////////////////////////////////////////////////////////////////////
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 8174596e65e..7161bfdcd5a 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -672,7 +672,7 @@ impl<'a, T> Default for &'a [T] {
 // The shared definition of the `Iter` and `IterMut` iterators
 macro_rules! iterator {
     (struct $name:ident -> $ptr:ty, $elem:ty) => {
-        #[experimental = "needs review"]
+        #[stable]
         impl<'a, T> Iterator for $name<'a, T> {
             type Item = $elem;
 
@@ -710,7 +710,7 @@ macro_rules! iterator {
             }
         }
 
-        #[experimental = "needs review"]
+        #[stable]
         impl<'a, T> DoubleEndedIterator for $name<'a, T> {
             #[inline]
             fn next_back(&mut self) -> Option<$elem> {
@@ -793,7 +793,7 @@ impl<'a,T> Copy for Iter<'a,T> {}
 
 iterator!{struct Iter -> *const T, &'a T}
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
 #[stable]
@@ -801,7 +801,7 @@ impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> { *self }
 }
 
-#[experimental = "needs review"]
+#[experimental = "trait is experimental"]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -887,7 +887,7 @@ impl<'a, T> IterMut<'a, T> {
 
 iterator!{struct IterMut -> *mut T, &'a mut T}
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
 
 /// An internal abstraction over the splitting iterators, so that
@@ -919,7 +919,7 @@ impl<'a, T, P> Clone for Split<'a, T, P> where P: Clone + FnMut(&T) -> bool {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     type Item = &'a [T];
 
@@ -947,7 +947,7 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
@@ -992,7 +992,7 @@ impl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     type Item = &'a mut [T];
 
@@ -1027,7 +1027,7 @@ impl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where
     P: FnMut(&T) -> bool,
 {
@@ -1060,7 +1060,6 @@ struct GenericSplitN<I> {
     invert: bool
 }
 
-#[experimental = "needs review"]
 impl<T, I: SplitIter + Iterator<Item=T>> Iterator for GenericSplitN<I> {
     type Item = T;
 
@@ -1113,6 +1112,7 @@ pub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {
 
 macro_rules! forward_iterator {
     ($name:ident: $elem:ident, $iter_of:ty) => {
+        #[stable]
         impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where
             P: FnMut(&T) -> bool
         {
@@ -1144,6 +1144,7 @@ pub struct Windows<'a, T:'a> {
     size: uint
 }
 
+#[stable]
 impl<'a, T> Iterator for Windows<'a, T> {
     type Item = &'a [T];
 
@@ -1181,7 +1182,7 @@ pub struct Chunks<'a, T:'a> {
     size: uint
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> Iterator for Chunks<'a, T> {
     type Item = &'a [T];
 
@@ -1210,7 +1211,7 @@ impl<'a, T> Iterator for Chunks<'a, T> {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a [T]> {
@@ -1226,7 +1227,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
     }
 }
 
-#[experimental = "needs review"]
+#[experimental = "trait is experimental"]
 impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -1256,7 +1257,7 @@ pub struct ChunksMut<'a, T:'a> {
     chunk_size: uint
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> Iterator for ChunksMut<'a, T> {
     type Item = &'a mut [T];
 
@@ -1286,7 +1287,7 @@ impl<'a, T> Iterator for ChunksMut<'a, T> {
     }
 }
 
-#[experimental = "needs review"]
+#[stable]
 impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a mut [T]> {
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index d069744f8da..a3c6a3fe470 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -37,18 +37,16 @@ use uint;
 macro_rules! delegate_iter {
     (exact $te:ty in $ti:ty) => {
         delegate_iter!{$te in $ti}
+        #[stable]
         impl<'a> ExactSizeIterator for $ti {
             #[inline]
-            fn rposition<P>(&mut self, predicate: P) -> Option<uint> where P: FnMut($te) -> bool{
-                self.0.rposition(predicate)
-            }
-            #[inline]
             fn len(&self) -> uint {
                 self.0.len()
             }
         }
     };
     ($te:ty in $ti:ty) => {
+        #[stable]
         impl<'a> Iterator for $ti {
             type Item = $te;
 
@@ -61,6 +59,7 @@ macro_rules! delegate_iter {
                 self.0.size_hint()
             }
         }
+        #[stable]
         impl<'a> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
@@ -69,6 +68,7 @@ macro_rules! delegate_iter {
         }
     };
     (pattern $te:ty in $ti:ty) => {
+        #[stable]
         impl<'a, P: CharEq> Iterator for $ti {
             type Item = $te;
 
@@ -81,6 +81,7 @@ macro_rules! delegate_iter {
                 self.0.size_hint()
             }
         }
+        #[stable]
         impl<'a, P: CharEq> DoubleEndedIterator for $ti {
             #[inline]
             fn next_back(&mut self) -> Option<$te> {
@@ -89,6 +90,7 @@ macro_rules! delegate_iter {
         }
     };
     (pattern forward $te:ty in $ti:ty) => {
+        #[stable]
         impl<'a, P: CharEq> Iterator for $ti {
             type Item = $te;
 
@@ -275,6 +277,7 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
     }
 }
 
+#[stable]
 impl<'a> Iterator for Chars<'a> {
     type Item = char;
 
@@ -320,6 +323,7 @@ impl<'a> Iterator for Chars<'a> {
     }
 }
 
+#[stable]
 impl<'a> DoubleEndedIterator for Chars<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<char> {
@@ -356,11 +360,13 @@ impl<'a> DoubleEndedIterator for Chars<'a> {
 /// External iterator for a string's characters and their byte offsets.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
+#[stable]
 pub struct CharIndices<'a> {
     front_offset: uint,
     iter: Chars<'a>,
 }
 
+#[stable]
 impl<'a> Iterator for CharIndices<'a> {
     type Item = (uint, char);
 
@@ -384,6 +390,7 @@ impl<'a> Iterator for CharIndices<'a> {
     }
 }
 
+#[stable]
 impl<'a> DoubleEndedIterator for CharIndices<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<(uint, char)> {
@@ -465,6 +472,7 @@ impl<'a, Sep> CharSplits<'a, Sep> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
     type Item = &'a str;
 
@@ -499,6 +507,7 @@ impl<'a, Sep: CharEq> Iterator for CharSplits<'a, Sep> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> {
@@ -540,6 +549,7 @@ impl<'a, Sep: CharEq> DoubleEndedIterator for CharSplits<'a, Sep> {
     }
 }
 
+#[stable]
 impl<'a, Sep: CharEq> Iterator for CharSplitsN<'a, Sep> {
     type Item = &'a str;
 
@@ -865,6 +875,7 @@ pub struct SplitStr<'a> {
     finished: bool
 }
 
+#[stable]
 impl<'a> Iterator for MatchIndices<'a> {
     type Item = (uint, uint);
 
@@ -881,6 +892,7 @@ impl<'a> Iterator for MatchIndices<'a> {
     }
 }
 
+#[stable]
 impl<'a> Iterator for SplitStr<'a> {
     type Item = &'a str;
 
@@ -1586,6 +1598,7 @@ impl<'a> Default for &'a str {
     fn default() -> &'a str { "" }
 }
 
+#[stable]
 impl<'a> Iterator for Lines<'a> {
     type Item = &'a str;
 
@@ -1593,11 +1606,13 @@ impl<'a> Iterator for Lines<'a> {
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
-}
+
+#[stable]}
 impl<'a> DoubleEndedIterator for Lines<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }
-}
+
+#[stable]}
 impl<'a> Iterator for LinesAny<'a> {
     type Item = &'a str;
 
@@ -1605,7 +1620,8 @@ impl<'a> Iterator for LinesAny<'a> {
     fn next(&mut self) -> Option<&'a str> { self.inner.next() }
     #[inline]
     fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
-}
+
+#[stable]}
 impl<'a> DoubleEndedIterator for LinesAny<'a> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str> { self.inner.next_back() }