Auto merge of #26192 - alexcrichton:features-clean, r=aturon

This commit shards the all-encompassing `core`, `std_misc`, `collections`, and `alloc` features into finer-grained components that are much more easily opted into and tracked. This reflects the effort to push forward current unstable APIs to either stabilization or removal. Keeping track of unstable features on a much more fine-grained basis will enable the library subteam to quickly analyze a feature and help prioritize internally about what APIs should be stabilized.

A few assorted APIs were deprecated along the way, but otherwise this change is just changing the feature name associated with each API. Soon we will have a dashboard for keeping track of all the unstable APIs in the standard library, and I'll also start making issues for each unstable API after performing a first-pass for stabilization.

37 files changed, 355 insertions, 272 deletions

diff --git a/src/libcore/any.rs b/src/libcore/any.rs
index a65394f5268..f0c77ae866d 100644
--- a/src/libcore/any.rs
+++ b/src/libcore/any.rs
@@ -92,7 +92,7 @@ use marker::{Reflect, Sized};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Any: Reflect + 'static {
     /// Gets the `TypeId` of `self`.
-    #[unstable(feature = "core",
+    #[unstable(feature = "get_type_id",
                reason = "this method will likely be replaced by an associated static")]
     fn get_type_id(&self) -> TypeId;
 }
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index 91301ee558c..a9b240de30b 100644
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -12,9 +12,10 @@
 //! up to a certain length. Eventually we should able to generalize
 //! to all lengths.
 
-#![unstable(feature = "core")] // not yet reviewed
-
 #![doc(primitive = "array")]
+#![unstable(feature = "fixed_size_array",
+            reason = "traits and impls are better expressed through generic \
+                      integer constants")]
 
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
@@ -30,7 +31,6 @@ use slice::{Iter, IterMut, SliceExt};
 ///
 /// This trait can be used to implement other traits on fixed-size arrays
 /// without causing much metadata bloat.
-#[unstable(feature = "core")]
 pub trait FixedSizeArray<T> {
     /// Converts the array to immutable slice
     fn as_slice(&self) -> &[T];
@@ -42,7 +42,6 @@ pub trait FixedSizeArray<T> {
 macro_rules! array_impls {
     ($($N:expr)+) => {
         $(
-            #[unstable(feature = "core")]
             impl<T> FixedSizeArray<T> for [T; $N] {
                 #[inline]
                 fn as_slice(&self) -> &[T] {
@@ -54,8 +53,6 @@ macro_rules! array_impls {
                 }
             }
 
-            #[unstable(feature = "array_as_ref",
-                       reason = "should ideally be implemented for all fixed-sized arrays")]
             impl<T> AsRef<[T]> for [T; $N] {
                 #[inline]
                 fn as_ref(&self) -> &[T] {
@@ -63,8 +60,6 @@ macro_rules! array_impls {
                 }
             }
 
-            #[unstable(feature = "array_as_ref",
-                       reason = "should ideally be implemented for all fixed-sized arrays")]
             impl<T> AsMut<[T]> for [T; $N] {
                 #[inline]
                 fn as_mut(&mut self) -> &mut [T] {
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 175dabaf1d2..37f37654c1f 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -221,7 +221,7 @@ impl<T:Copy> Cell<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(as_unsafe_cell)]
     /// use std::cell::Cell;
     ///
     /// let c = Cell::new(5);
@@ -229,7 +229,7 @@ impl<T:Copy> Cell<T> {
     /// let uc = unsafe { c.as_unsafe_cell() };
     /// ```
     #[inline]
-    #[unstable(feature = "core")]
+    #[unstable(feature = "as_unsafe_cell")]
     pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
         &self.value
     }
@@ -277,7 +277,7 @@ pub struct RefCell<T: ?Sized> {
 
 /// An enumeration of values returned from the `state` method on a `RefCell<T>`.
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
-#[unstable(feature = "std_misc")]
+#[unstable(feature = "borrow_state")]
 pub enum BorrowState {
     /// The cell is currently being read, there is at least one active `borrow`.
     Reading,
@@ -339,7 +339,7 @@ impl<T: ?Sized> RefCell<T> {
     ///
     /// The returned value can be dispatched on to determine if a call to
     /// `borrow` or `borrow_mut` would succeed.
-    #[unstable(feature = "std_misc")]
+    #[unstable(feature = "borrow_state")]
     #[inline]
     pub fn borrow_state(&self) -> BorrowState {
         match self.borrow.get() {
@@ -448,7 +448,7 @@ impl<T: ?Sized> RefCell<T> {
     ///
     /// This function is `unsafe` because `UnsafeCell`'s field is public.
     #[inline]
-    #[unstable(feature = "core")]
+    #[unstable(feature = "as_unsafe_cell")]
     pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
         &self.value
     }
@@ -564,9 +564,10 @@ impl<'b, T: ?Sized> Ref<'b, T> {
     ///
     /// The `RefCell` is already immutably borrowed, so this cannot fail.
     ///
-    /// This is an associated function that needs to be used as `Ref::clone(...)`.
-    /// A `Clone` implementation or a method would interfere with the widespread
-    /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
+    /// This is an associated function that needs to be used as
+    /// `Ref::clone(...)`.  A `Clone` implementation or a method would interfere
+    /// with the widespread use of `r.borrow().clone()` to clone the contents of
+    /// a `RefCell`.
     #[unstable(feature = "cell_extras",
                reason = "likely to be moved to a method, pending language changes")]
     #[inline]
@@ -582,8 +583,8 @@ impl<'b, T: ?Sized> Ref<'b, T> {
     /// The `RefCell` is already immutably borrowed, so this cannot fail.
     ///
     /// This is an associated function that needs to be used as `Ref::map(...)`.
-    /// A method would interfere with methods of the same name on the contents of a `RefCell`
-    /// used through `Deref`.
+    /// A method would interfere with methods of the same name on the contents
+    /// of a `RefCell` used through `Deref`.
     ///
     /// # Example
     ///
@@ -607,13 +608,14 @@ impl<'b, T: ?Sized> Ref<'b, T> {
         }
     }
 
-    /// Make a new `Ref` for a optional component of the borrowed data, e.g. an enum variant.
+    /// Make a new `Ref` for a optional component of the borrowed data, e.g. an
+    /// enum variant.
     ///
     /// The `RefCell` is already immutably borrowed, so this cannot fail.
     ///
-    /// This is an associated function that needs to be used as `Ref::filter_map(...)`.
-    /// A method would interfere with methods of the same name on the contents of a `RefCell`
-    /// used through `Deref`.
+    /// This is an associated function that needs to be used as
+    /// `Ref::filter_map(...)`.  A method would interfere with methods of the
+    /// same name on the contents of a `RefCell` used through `Deref`.
     ///
     /// # Example
     ///
@@ -639,13 +641,14 @@ impl<'b, T: ?Sized> Ref<'b, T> {
 }
 
 impl<'b, T: ?Sized> RefMut<'b, T> {
-    /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum variant.
+    /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum
+    /// variant.
     ///
     /// The `RefCell` is already mutably borrowed, so this cannot fail.
     ///
-    /// This is an associated function that needs to be used as `RefMut::map(...)`.
-    /// A method would interfere with methods of the same name on the contents of a `RefCell`
-    /// used through `Deref`.
+    /// This is an associated function that needs to be used as
+    /// `RefMut::map(...)`.  A method would interfere with methods of the same
+    /// name on the contents of a `RefCell` used through `Deref`.
     ///
     /// # Example
     ///
@@ -673,13 +676,14 @@ impl<'b, T: ?Sized> RefMut<'b, T> {
         }
     }
 
-    /// Make a new `RefMut` for a optional component of the borrowed data, e.g. an enum variant.
+    /// Make a new `RefMut` for a optional component of the borrowed data, e.g.
+    /// an enum variant.
     ///
     /// The `RefCell` is already mutably borrowed, so this cannot fail.
     ///
-    /// This is an associated function that needs to be used as `RefMut::filter_map(...)`.
-    /// A method would interfere with methods of the same name on the contents of a `RefCell`
-    /// used through `Deref`.
+    /// This is an associated function that needs to be used as
+    /// `RefMut::filter_map(...)`.  A method would interfere with methods of the
+    /// same name on the contents of a `RefCell` used through `Deref`.
     ///
     /// # Example
     ///
@@ -690,7 +694,9 @@ impl<'b, T: ?Sized> RefMut<'b, T> {
     /// let c = RefCell::new(Ok(5));
     /// {
     ///     let b1: RefMut<Result<u32, ()>> = c.borrow_mut();
-    ///     let mut b2: RefMut<u32> = RefMut::filter_map(b1, |o| o.as_mut().ok()).unwrap();
+    ///     let mut b2: RefMut<u32> = RefMut::filter_map(b1, |o| {
+    ///         o.as_mut().ok()
+    ///     }).unwrap();
     ///     assert_eq!(*b2, 5);
     ///     *b2 = 42;
     /// }
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index df371752b86..12aa06667a1 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -14,6 +14,7 @@
 
 #![allow(non_snake_case)]
 #![doc(primitive = "char")]
+#![stable(feature = "core_char", since = "1.2.0")]
 
 use iter::Iterator;
 use mem::transmute;
@@ -131,6 +132,8 @@ pub fn from_digit(num: u32, radix: u32) -> Option<char> {
 // unicode/char.rs, not here
 #[allow(missing_docs)] // docs in libunicode/u_char.rs
 #[doc(hidden)]
+#[unstable(feature = "core_char_ext",
+           reason = "the stable interface is `impl char` in later crate")]
 pub trait CharExt {
     fn is_digit(self, radix: u32) -> bool;
     fn to_digit(self, radix: u32) -> Option<u32>;
@@ -220,6 +223,9 @@ impl CharExt for char {
 /// If the buffer is not large enough, nothing will be written into it
 /// and a `None` will be returned.
 #[inline]
+#[unstable(feature = "char_internals",
+           reason = "this function should not be exposed publicly")]
+#[doc(hidden)]
 pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
     // Marked #[inline] to allow llvm optimizing it away
     if code < MAX_ONE_B && !dst.is_empty() {
@@ -251,6 +257,9 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
 /// If the buffer is not large enough, nothing will be written into it
 /// and a `None` will be returned.
 #[inline]
+#[unstable(feature = "char_internals",
+           reason = "this function should not be exposed publicly")]
+#[doc(hidden)]
 pub fn encode_utf16_raw(mut ch: u32, dst: &mut [u16]) -> Option<usize> {
     // Marked #[inline] to allow llvm optimizing it away
     if (ch & 0xFFFF) == ch && !dst.is_empty() {
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index f11c01507dc..a13160b3a19 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -89,29 +89,28 @@ clone_impl! { char }
 
 macro_rules! extern_fn_clone {
     ($($A:ident),*) => (
-        #[unstable(feature = "core",
-                   reason = "this may not be sufficient for fns with region parameters")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
             /// Returns a copy of a function pointer.
             #[inline]
             fn clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
         }
 
-        #[unstable(feature = "core", reason = "brand new")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<$($A,)* ReturnType> Clone for extern "C" fn($($A),*) -> ReturnType {
             /// Returns a copy of a function pointer.
             #[inline]
             fn clone(&self) -> extern "C" fn($($A),*) -> ReturnType { *self }
         }
 
-        #[unstable(feature = "core", reason = "brand new")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<$($A,)* ReturnType> Clone for unsafe extern "Rust" fn($($A),*) -> ReturnType {
             /// Returns a copy of a function pointer.
             #[inline]
             fn clone(&self) -> unsafe extern "Rust" fn($($A),*) -> ReturnType { *self }
         }
 
-        #[unstable(feature = "core", reason = "brand new")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<$($A,)* ReturnType> Clone for unsafe extern "C" fn($($A),*) -> ReturnType {
             /// Returns a copy of a function pointer.
             #[inline]
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index dab549f784c..0269499ad54 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -10,10 +10,10 @@
 
 //! Functionality for ordering and comparison.
 //!
-//! This module defines both `PartialOrd` and `PartialEq` traits which are used by the compiler to
-//! implement comparison operators. Rust programs may implement `PartialOrd` to overload the `<`,
-//! `<=`, `>`, and `>=` operators, and may implement `PartialEq` to overload the `==` and `!=`
-//! operators.
+//! This module defines both `PartialOrd` and `PartialEq` traits which are used
+//! by the compiler to implement comparison operators. Rust programs may
+//! implement `PartialOrd` to overload the `<`, `<=`, `>`, and `>=` operators,
+//! and may implement `PartialEq` to overload the `==` and `!=` operators.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -22,29 +22,31 @@ use self::Ordering::*;
 use marker::Sized;
 use option::Option::{self, Some, None};
 
-/// Trait for equality comparisons which are [partial equivalence relations](
-/// http://en.wikipedia.org/wiki/Partial_equivalence_relation).
+/// Trait for equality comparisons which are [partial equivalence
+/// relations](http://en.wikipedia.org/wiki/Partial_equivalence_relation).
 ///
-/// This trait allows for partial equality, for types that do not have a full equivalence relation.
-/// For example, in floating point numbers `NaN != NaN`, so floating point types implement
-/// `PartialEq` but not `Eq`.
+/// This trait allows for partial equality, for types that do not have a full
+/// equivalence relation.  For example, in floating point numbers `NaN != NaN`,
+/// so floating point types implement `PartialEq` but not `Eq`.
 ///
 /// Formally, the equality must be (for all `a`, `b` and `c`):
 ///
 /// - symmetric: `a == b` implies `b == a`; and
 /// - transitive: `a == b` and `b == c` implies `a == c`.
 ///
-/// Note that these requirements mean that the trait itself must be implemented symmetrically and
-/// transitively: if `T: PartialEq<U>` and `U: PartialEq<V>` then `U: PartialEq<T>` and `T:
-/// PartialEq<V>`.
+/// Note that these requirements mean that the trait itself must be implemented
+/// symmetrically and transitively: if `T: PartialEq<U>` and `U: PartialEq<V>`
+/// then `U: PartialEq<T>` and `T: PartialEq<V>`.
 ///
-/// PartialEq only requires the `eq` method to be implemented; `ne` is defined in terms of it by
-/// default. Any manual implementation of `ne` *must* respect the rule that `eq` is a strict
-/// inverse of `ne`; that is, `!(a == b)` if and only if `a != b`.
+/// PartialEq only requires the `eq` method to be implemented; `ne` is defined
+/// in terms of it by default. Any manual implementation of `ne` *must* respect
+/// the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and
+/// only if `a != b`.
 #[lang = "eq"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PartialEq<Rhs: ?Sized = Self> {
-    /// This method tests for `self` and `other` values to be equal, and is used by `==`.
+    /// This method tests for `self` and `other` values to be equal, and is used
+    /// by `==`.
     #[stable(feature = "rust1", since = "1.0.0")]
     fn eq(&self, other: &Rhs) -> bool;
 
@@ -379,7 +381,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 /// # Examples
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(cmp_partial)]
 /// use std::cmp;
 ///
 /// assert_eq!(Some(1), cmp::partial_min(1, 2));
@@ -389,14 +391,14 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 /// When comparison is impossible:
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(cmp_partial)]
 /// use std::cmp;
 ///
 /// let result = cmp::partial_min(std::f64::NAN, 1.0);
 /// assert_eq!(result, None);
 /// ```
 #[inline]
-#[unstable(feature = "core")]
+#[unstable(feature = "cmp_partial")]
 pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
     match v1.partial_cmp(&v2) {
         Some(Less) | Some(Equal) => Some(v1),
@@ -412,7 +414,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 /// # Examples
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(cmp_partial)]
 /// use std::cmp;
 ///
 /// assert_eq!(Some(2), cmp::partial_max(1, 2));
@@ -422,14 +424,14 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 /// When comparison is impossible:
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(cmp_partial)]
 /// use std::cmp;
 ///
 /// let result = cmp::partial_max(std::f64::NAN, 1.0);
 /// assert_eq!(result, None);
 /// ```
 #[inline]
-#[unstable(feature = "core")]
+#[unstable(feature = "cmp_partial")]
 pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
     match v1.partial_cmp(&v2) {
         Some(Equal) | Some(Less) => Some(v2),
diff --git a/src/libcore/convert.rs b/src/libcore/convert.rs
index f6987c19664..70868805299 100644
--- a/src/libcore/convert.rs
+++ b/src/libcore/convert.rs
@@ -10,11 +10,12 @@
 
 //! Traits for conversions between types.
 //!
-//! The traits in this module provide a general way to talk about conversions from one type to
-//! another. They follow the standard Rust conventions of `as`/`into`/`from`.
+//! The traits in this module provide a general way to talk about conversions
+//! from one type to another. They follow the standard Rust conventions of
+//! `as`/`into`/`from`.
 //!
-//! Like many traits, these are often used as bounds for generic functions, to support arguments of
-//! multiple types.
+//! Like many traits, these are often used as bounds for generic functions, to
+//! support arguments of multiple types.
 //!
 //! See each trait for usage examples.
 
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 76a40dc8a52..cbbb186af76 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -33,7 +33,7 @@ pub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugList, DebugMap}
 mod num;
 mod builders;
 
-#[unstable(feature = "core", reason = "internal to format_args!")]
+#[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
 #[doc(hidden)]
 pub mod rt {
     pub mod v1;
@@ -146,7 +146,7 @@ enum Void {}
 /// 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.
 #[derive(Copy)]
-#[unstable(feature = "core", reason = "internal to format_args!")]
+#[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
 #[doc(hidden)]
 pub struct ArgumentV1<'a> {
     value: &'a Void,
@@ -166,7 +166,7 @@ impl<'a> ArgumentV1<'a> {
     }
 
     #[doc(hidden)]
-    #[unstable(feature = "core", reason = "internal to format_args!")]
+    #[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
     pub fn new<'b, T>(x: &'b T,
                       f: fn(&T, &mut Formatter) -> Result) -> ArgumentV1<'b> {
         unsafe {
@@ -178,7 +178,7 @@ impl<'a> ArgumentV1<'a> {
     }
 
     #[doc(hidden)]
-    #[unstable(feature = "core", reason = "internal to format_args!")]
+    #[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
     pub fn from_usize(x: &usize) -> ArgumentV1 {
         ArgumentV1::new(x, ArgumentV1::show_usize)
     }
@@ -201,7 +201,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 = "core", reason = "internal to format_args!")]
+    #[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
     pub fn new_v1(pieces: &'a [&'a str],
                   args: &'a [ArgumentV1<'a>]) -> Arguments<'a> {
         Arguments {
@@ -218,7 +218,7 @@ impl<'a> Arguments<'a> {
     /// created with `argumentusize`. However, failing to do so doesn't cause
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
-    #[unstable(feature = "core", reason = "internal to format_args!")]
+    #[unstable(feature = "fmt_internals", reason = "internal to format_args!")]
     pub fn new_v1_formatted(pieces: &'a [&'a str],
                             args: &'a [ArgumentV1<'a>],
                             fmt: &'a [rt::v1::Argument]) -> Arguments<'a> {
@@ -742,19 +742,19 @@ impl<'a> Formatter<'a> {
     pub fn flags(&self) -> u32 { self.flags }
 
     /// Character used as 'fill' whenever there is alignment
-    #[unstable(feature = "core", reason = "method was just created")]
+    #[unstable(feature = "fmt_flags", reason = "method was just created")]
     pub fn fill(&self) -> char { self.fill }
 
     /// Flag indicating what form of alignment was requested
-    #[unstable(feature = "core", reason = "method was just created")]
+    #[unstable(feature = "fmt_flags", reason = "method was just created")]
     pub fn align(&self) -> Alignment { self.align }
 
     /// Optionally specified integer width that the output should be
-    #[unstable(feature = "core", reason = "method was just created")]
+    #[unstable(feature = "fmt_flags", reason = "method was just created")]
     pub fn width(&self) -> Option<usize> { self.width }
 
     /// Optionally specified precision for numeric types
-    #[unstable(feature = "core", reason = "method was just created")]
+    #[unstable(feature = "fmt_flags", reason = "method was just created")]
     pub fn precision(&self) -> Option<usize> { self.precision }
 
     /// Creates a `DebugStruct` builder designed to assist with creation of
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 122fffc5959..fc49f87d107 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -127,7 +127,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 = "core",
+#[unstable(feature = "fmt_radix",
            reason = "may be renamed or move to a different module")]
 pub struct Radix {
     base: u8,
@@ -152,7 +152,7 @@ impl GenericRadix for Radix {
 }
 
 /// A helper type for formatting radixes.
-#[unstable(feature = "core",
+#[unstable(feature = "fmt_radix",
            reason = "may be renamed or move to a different module")]
 #[derive(Copy, Clone)]
 pub struct RadixFmt<T, R>(T, R);
@@ -162,11 +162,11 @@ pub struct RadixFmt<T, R>(T, R);
 /// # Examples
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(fmt_radix)]
 /// use std::fmt::radix;
 /// assert_eq!(format!("{}", radix(55, 36)), "1j".to_string());
 /// ```
-#[unstable(feature = "core",
+#[unstable(feature = "fmt_radix",
            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/v1.rs b/src/libcore/fmt/rt/v1.rs
index 2afd8abeb31..033834dd5aa 100644
--- a/src/libcore/fmt/rt/v1.rs
+++ b/src/libcore/fmt/rt/v1.rs
@@ -14,8 +14,6 @@
 //! 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 = "core", reason = "internal to format_args!")]
-
 #[derive(Copy, Clone)]
 pub struct Argument {
     pub position: Position,
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index e848a44e01c..abf9e55a1f2 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -16,7 +16,7 @@
 //! # Examples
 //!
 //! ```rust
-//! # #![feature(hash)]
+//! # #![feature(hash_default)]
 //! use std::hash::{hash, Hash, SipHasher};
 //!
 //! #[derive(Hash)]
@@ -36,7 +36,7 @@
 //! the trait `Hash`:
 //!
 //! ```rust
-//! # #![feature(hash)]
+//! # #![feature(hash_default)]
 //! use std::hash::{hash, Hash, Hasher, SipHasher};
 //!
 //! struct Person {
@@ -89,7 +89,8 @@ pub trait Hash {
     fn hash<H: Hasher>(&self, state: &mut H);
 
     /// Feeds a slice of this type into the state provided.
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hash_slice",
+               reason = "module was recently redesigned")]
     fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) where Self: Sized {
         for piece in data {
             piece.hash(state);
@@ -110,29 +111,29 @@ pub trait Hasher {
 
     /// Write a single `u8` into this hasher
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_u8(&mut self, i: u8) { self.write(&[i]) }
     /// Write a single `u16` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_u16(&mut self, i: u16) {
         self.write(&unsafe { mem::transmute::<_, [u8; 2]>(i) })
     }
     /// Write a single `u32` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_u32(&mut self, i: u32) {
         self.write(&unsafe { mem::transmute::<_, [u8; 4]>(i) })
     }
     /// Write a single `u64` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_u64(&mut self, i: u64) {
         self.write(&unsafe { mem::transmute::<_, [u8; 8]>(i) })
     }
     /// Write a single `usize` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_usize(&mut self, i: usize) {
         if cfg!(target_pointer_width = "32") {
             self.write_u32(i as u32)
@@ -143,23 +144,23 @@ pub trait Hasher {
 
     /// Write a single `i8` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_i8(&mut self, i: i8) { self.write_u8(i as u8) }
     /// Write a single `i16` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_i16(&mut self, i: i16) { self.write_u16(i as u16) }
     /// Write a single `i32` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_i32(&mut self, i: i32) { self.write_u32(i as u32) }
     /// Write a single `i64` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_i64(&mut self, i: i64) { self.write_u64(i as u64) }
     /// Write a single `isize` into this hasher.
     #[inline]
-    #[unstable(feature = "hash", reason = "module was recently redesigned")]
+    #[unstable(feature = "hasher_write", reason = "module was recently redesigned")]
     fn write_isize(&mut self, i: isize) { self.write_usize(i as usize) }
 }
 
@@ -167,7 +168,9 @@ pub trait Hasher {
 ///
 /// The specified value will be hashed with this hasher and then the resulting
 /// hash will be returned.
-#[unstable(feature = "hash", reason = "module was recently redesigned")]
+#[unstable(feature = "hash_default",
+           reason = "not the most ergonomic interface unless `H` is defaulted \
+                     to SipHasher, but perhaps not ready to commit to that")]
 pub fn hash<T: Hash, H: Hasher + Default>(value: &T) -> u64 {
     let mut h: H = Default::default();
     value.hash(&mut h);
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 774f86563d7..455928077da 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -39,7 +39,10 @@
 //!   guaranteed to happen in order. This is the standard mode for working
 //!   with atomic types and is equivalent to Java's `volatile`.
 
-#![unstable(feature = "core")]
+#![unstable(feature = "core_intrinsics",
+            reason = "intrinsics are unlikely to ever be stabilized, instead \
+                      they should be used through stabilized interfaces \
+                      in the rest of the standard library")]
 #![allow(missing_docs)]
 
 use marker::Sized;
@@ -141,10 +144,10 @@ extern "rust-intrinsic" {
 
     /// A compiler-only memory barrier.
     ///
-    /// Memory accesses will never be reordered across this barrier by the compiler,
-    /// but no instructions will be emitted for it. This is appropriate for operations
-    /// on the same thread that may be preempted, such as when interacting with signal
-    /// handlers.
+    /// Memory accesses will never be reordered across this barrier by the
+    /// compiler, but no instructions will be emitted for it. This is
+    /// appropriate for operations on the same thread that may be preempted,
+    /// such as when interacting with signal handlers.
     pub fn atomic_singlethreadfence();
     pub fn atomic_singlethreadfence_acq();
     pub fn atomic_singlethreadfence_rel();
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index ae2248206c4..3026f91e853 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -51,8 +51,8 @@
 //! }
 //! ```
 //!
-//! Because `Iterator`s implement `IntoIterator`, this `for` loop syntax can be applied to any
-//! iterator over any type.
+//! Because `Iterator`s implement `IntoIterator`, this `for` loop syntax can be
+//! applied to any iterator over any type.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -822,7 +822,7 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_min_max)]
     /// use std::iter::MinMaxResult::{NoElements, OneElement, MinMax};
     ///
     /// let a: [i32; 0] = [];
@@ -837,7 +837,9 @@ pub trait Iterator {
     /// let a = [1, 1, 1, 1];
     /// assert_eq!(a.iter().min_max(), MinMax(&1, &1));
     /// ```
-    #[unstable(feature = "core", reason = "return type may change")]
+    #[unstable(feature = "iter_min_max",
+               reason = "return type may change or may wish to have a closure \
+                         based version as well")]
     fn min_max(mut self) -> MinMaxResult<Self::Item> where Self: Sized, Self::Item: Ord
     {
         let (mut min, mut max) = match self.next() {
@@ -892,12 +894,12 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_cmp)]
     /// let a = [-3_i32, 0, 1, 5, -10];
     /// assert_eq!(*a.iter().max_by(|x| x.abs()).unwrap(), -10);
     /// ```
     #[inline]
-    #[unstable(feature = "core",
+    #[unstable(feature = "iter_cmp",
                reason = "may want to produce an Ordering directly; see #15311")]
     fn max_by<B: Ord, F>(self, f: F) -> Option<Self::Item> where
         Self: Sized,
@@ -920,12 +922,12 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_cmp)]
     /// let a = [-3_i32, 0, 1, 5, -10];
     /// assert_eq!(*a.iter().min_by(|x| x.abs()).unwrap(), 0);
     /// ```
     #[inline]
-    #[unstable(feature = "core",
+    #[unstable(feature = "iter_cmp",
                reason = "may want to produce an Ordering directly; see #15311")]
     fn min_by<B: Ord, F>(self, f: F) -> Option<Self::Item> where
         Self: Sized,
@@ -1041,6 +1043,8 @@ pub trait Iterator {
     /// Use an iterator to reverse a container in place.
     #[unstable(feature = "core",
                reason = "uncertain about placement or widespread use")]
+    #[deprecated(since = "1.2.0",
+                 reason = "not performant enough to justify inclusion")]
     fn reverse_in_place<'a, T: 'a>(&mut self) where
         Self: Sized + Iterator<Item=&'a mut T> + DoubleEndedIterator
     {
@@ -1057,12 +1061,12 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_arith)]
     /// let a = [1, 2, 3, 4, 5];
     /// let it = a.iter();
     /// assert_eq!(it.sum::<i32>(), 15);
     /// ```
-    #[unstable(feature="core")]
+    #[unstable(feature="iter_arith", reason = "bounds recently changed")]
     fn sum<S=<Self as Iterator>::Item>(self) -> S where
         S: Add<Self::Item, Output=S> + Zero,
         Self: Sized,
@@ -1075,7 +1079,7 @@ pub trait Iterator {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_arith)]
     /// fn factorial(n: u32) -> u32 {
     ///     (1..).take_while(|&i| i <= n).product()
     /// }
@@ -1083,7 +1087,7 @@ pub trait Iterator {
     /// assert_eq!(factorial(1), 1);
     /// assert_eq!(factorial(5), 120);
     /// ```
-    #[unstable(feature="core")]
+    #[unstable(feature="iter_arith", reason = "bounds recently changed")]
     fn product<P=<Self as Iterator>::Item>(self) -> P where
         P: Mul<Self::Item, Output=P> + One,
         Self: Sized,
@@ -1223,9 +1227,14 @@ impl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I {
 /// `DoubleEndedIterator`.  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 = "core",
+#[unstable(feature = "iter_idx",
            reason = "not widely used, may be better decomposed into Index \
                      and ExactSizeIterator")]
+#[deprecated(since = "1.2.0",
+             reason = "trait has not proven itself as a widely useful \
+                       abstraction for iterators, and more time may be needed \
+                       for iteration on the design")]
+#[allow(deprecated)]
 pub trait RandomAccessIterator: Iterator {
     /// Returns the number of indexable elements. At most `std::usize::MAX`
     /// elements are indexable, even if the iterator represents a longer range.
@@ -1304,7 +1313,8 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
     fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Rev<I>
     where I: DoubleEndedIterator + RandomAccessIterator
 {
@@ -1324,7 +1334,7 @@ impl<I> RandomAccessIterator for Rev<I>
 /// `MinMaxResult` is an enum returned by `min_max`. See `Iterator::min_max` for
 /// more detail.
 #[derive(Clone, PartialEq, Debug)]
-#[unstable(feature = "core",
+#[unstable(feature = "iter_min_max",
            reason = "unclear whether such a fine-grained result is widely useful")]
 pub enum MinMaxResult<T> {
     /// Empty iterator
@@ -1338,6 +1348,7 @@ pub enum MinMaxResult<T> {
     MinMax(T, T)
 }
 
+#[unstable(feature = "iter_min_max", reason = "type is unstable")]
 impl<T: Clone> MinMaxResult<T> {
     /// `into_option` creates an `Option` of type `(T,T)`. The returned `Option`
     /// has variant `None` if and only if the `MinMaxResult` has variant
@@ -1348,7 +1359,7 @@ impl<T: Clone> MinMaxResult<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(iter_min_max)]
     /// use std::iter::MinMaxResult::{self, NoElements, OneElement, MinMax};
     ///
     /// let r: MinMaxResult<i32> = NoElements;
@@ -1360,7 +1371,6 @@ impl<T: Clone> MinMaxResult<T> {
     /// let r = MinMax(1, 2);
     /// assert_eq!(r.into_option(), Some((1, 2)));
     /// ```
-    #[unstable(feature = "core", reason = "type is unstable")]
     pub fn into_option(self) -> Option<(T,T)> {
         match self {
             NoElements => None,
@@ -1407,7 +1417,8 @@ impl<'a, I, T: 'a> ExactSizeIterator for Cloned<I>
     where I: ExactSizeIterator<Item=&'a T>, T: Clone
 {}
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<'a, I, T: 'a> RandomAccessIterator for Cloned<I>
     where I: RandomAccessIterator<Item=&'a T>, T: Clone
 {
@@ -1454,7 +1465,8 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Cycle<I> where
     I: Clone + RandomAccessIterator,
 {
@@ -1568,7 +1580,8 @@ impl<A, B> DoubleEndedIterator for Chain<A, B> where
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<A, B> RandomAccessIterator for Chain<A, B> where
     A: RandomAccessIterator,
     B: RandomAccessIterator<Item = A::Item>,
@@ -1656,7 +1669,8 @@ impl<A, B> DoubleEndedIterator for Zip<A, B> where
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<A, B> RandomAccessIterator for Zip<A, B> where
     A: RandomAccessIterator,
     B: RandomAccessIterator
@@ -1710,7 +1724,8 @@ impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for Map<I, F> where
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<B, I: RandomAccessIterator, F> RandomAccessIterator for Map<I, F> where
     F: FnMut(I::Item) -> B,
 {
@@ -1884,7 +1899,8 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> usize {
@@ -2134,7 +2150,8 @@ impl<I> Iterator for Skip<I> where I: Iterator {
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> usize {
@@ -2206,7 +2223,8 @@ impl<I> Iterator for Take<I> where I: Iterator{
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> usize {
@@ -2236,7 +2254,8 @@ pub struct Scan<I, St, F> {
     f: F,
 
     /// The current internal state to be passed to the closure next.
-    #[unstable(feature = "core")]
+    #[unstable(feature = "scan_state",
+               reason = "public fields are otherwise rare in the stdlib")]
     pub state: St,
 }
 
@@ -2406,7 +2425,8 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
 }
 
 // Allow RandomAccessIterators to be fused without affecting random-access behavior
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> usize {
@@ -2427,7 +2447,7 @@ impl<I> Fuse<I> {
     /// `.next_back()` will call the underlying iterator again even if it
     /// previously returned `None`.
     #[inline]
-    #[unstable(feature = "core", reason = "seems marginal")]
+    #[unstable(feature = "iter_reset_fuse", reason = "seems marginal")]
     pub fn reset_fuse(&mut self) {
         self.done = false
     }
@@ -2481,7 +2501,8 @@ impl<I: DoubleEndedIterator, F> DoubleEndedIterator for Inspect<I, F>
     }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
     where F: FnMut(&I::Item),
 {
@@ -2504,7 +2525,7 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
 /// An iterator that yields sequential Fibonacci numbers, and stops on overflow.
 ///
 /// ```
-/// #![feature(core)]
+/// #![feature(iter_unfold)]
 /// use std::iter::Unfold;
 ///
 /// // This iterator will yield up to the last Fibonacci number before the max
@@ -2531,16 +2552,24 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
 ///     println!("{}", i);
 /// }
 /// ```
-#[unstable(feature = "core")]
+#[unstable(feature = "iter_unfold")]
 #[derive(Clone)]
+#[deprecated(since = "1.2.0",
+             reason = "has gained enough traction to retain its position \
+                       in the standard library")]
+#[allow(deprecated)]
 pub struct Unfold<St, F> {
     f: F,
     /// Internal state that will be passed to the closure on the next iteration
-    #[unstable(feature = "core")]
+    #[unstable(feature = "iter_unfold")]
     pub state: St,
 }
 
-#[unstable(feature = "core")]
+#[unstable(feature = "iter_unfold")]
+#[deprecated(since = "1.2.0",
+             reason = "has gained enough traction to retain its position \
+                       in the standard library")]
+#[allow(deprecated)]
 impl<A, St, F> Unfold<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
@@ -2554,6 +2583,7 @@ impl<A, St, F> Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
 impl<A, St, F> Iterator for Unfold<St, F> where F: FnMut(&mut St) -> Option<A> {
     type Item = A;
 
@@ -2767,7 +2797,7 @@ impl<A> Iterator for StepBy<A, RangeFrom<A>> where
 
 /// An iterator over the range [start, stop]
 #[derive(Clone)]
-#[unstable(feature = "core",
+#[unstable(feature = "range_inclusive",
            reason = "likely to be replaced by range notation and adapters")]
 pub struct RangeInclusive<A> {
     range: ops::Range<A>,
@@ -2776,7 +2806,7 @@ pub struct RangeInclusive<A> {
 
 /// Returns an iterator over the range [start, stop].
 #[inline]
-#[unstable(feature = "core",
+#[unstable(feature = "range_inclusive",
            reason = "likely to be replaced by range notation and adapters")]
 pub fn range_inclusive<A>(start: A, stop: A) -> RangeInclusive<A>
     where A: Step + One + Clone
@@ -2787,7 +2817,7 @@ pub fn range_inclusive<A>(start: A, stop: A) -> RangeInclusive<A>
     }
 }
 
-#[unstable(feature = "core",
+#[unstable(feature = "range_inclusive",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A> Iterator for RangeInclusive<A> where
     A: PartialEq + Step + One + Clone,
@@ -2820,7 +2850,7 @@ impl<A> Iterator for RangeInclusive<A> where
     }
 }
 
-#[unstable(feature = "core",
+#[unstable(feature = "range_inclusive",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A> DoubleEndedIterator for RangeInclusive<A> where
     A: PartialEq + Step + One + Clone,
@@ -2962,7 +2992,7 @@ impl<A: Clone> Iterator for Repeat<A> {
     type Item = A;
 
     #[inline]
-    fn next(&mut self) -> Option<A> { self.idx(0) }
+    fn next(&mut self) -> Option<A> { Some(self.element.clone()) }
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) { (usize::MAX, None) }
 }
@@ -2970,10 +3000,11 @@ impl<A: Clone> Iterator for Repeat<A> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<A: Clone> DoubleEndedIterator for Repeat<A> {
     #[inline]
-    fn next_back(&mut self) -> Option<A> { self.idx(0) }
+    fn next_back(&mut self) -> Option<A> { Some(self.element.clone()) }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<A: Clone> RandomAccessIterator for Repeat<A> {
     #[inline]
     fn indexable(&self) -> usize { usize::MAX }
@@ -2985,12 +3016,20 @@ type IterateState<T, F> = (F, Option<T>, bool);
 
 /// An iterator that repeatedly applies a given function, starting
 /// from a given seed value.
-#[unstable(feature = "core")]
+#[unstable(feature = "iter_iterate")]
+#[deprecated(since = "1.2.0",
+             reason = "has gained enough traction to retain its position \
+                       in the standard library")]
+#[allow(deprecated)]
 pub type Iterate<T, F> = Unfold<IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
 
 /// Creates a new iterator that produces an infinite sequence of
 /// repeated applications of the given function `f`.
-#[unstable(feature = "core")]
+#[unstable(feature = "iter_iterate")]
+#[deprecated(since = "1.2.0",
+             reason = "has gained enough traction to retain its position \
+                       in the standard library")]
+#[allow(deprecated)]
 pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
     T: Clone,
     F: FnMut(T) -> T,
@@ -3022,10 +3061,10 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
 }
 
 /// An iterator that yields nothing.
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 pub struct Empty<T>(marker::PhantomData<T>);
 
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 impl<T> Iterator for Empty<T> {
     type Item = T;
 
@@ -3038,14 +3077,14 @@ impl<T> Iterator for Empty<T> {
     }
 }
 
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 impl<T> DoubleEndedIterator for Empty<T> {
     fn next_back(&mut self) -> Option<T> {
         None
     }
 }
 
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 impl<T> ExactSizeIterator for Empty<T> {
     fn len(&self) -> usize {
         0
@@ -3054,7 +3093,7 @@ impl<T> ExactSizeIterator for Empty<T> {
 
 // not #[derive] because that adds a Clone bound on T,
 // which isn't necessary.
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 impl<T> Clone for Empty<T> {
     fn clone(&self) -> Empty<T> {
         Empty(marker::PhantomData)
@@ -3063,7 +3102,7 @@ impl<T> Clone for Empty<T> {
 
 // not #[derive] because that adds a Default bound on T,
 // which isn't necessary.
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 impl<T> Default for Empty<T> {
     fn default() -> Empty<T> {
         Empty(marker::PhantomData)
@@ -3071,19 +3110,19 @@ impl<T> Default for Empty<T> {
 }
 
 /// Creates an iterator that yields nothing.
-#[unstable(feature="iter_empty", reason = "new addition")]
+#[stable(feature = "iter_empty", since = "1.2.0")]
 pub fn empty<T>() -> Empty<T> {
     Empty(marker::PhantomData)
 }
 
 /// An iterator that yields an element exactly once.
 #[derive(Clone)]
-#[unstable(feature="iter_once", reason = "new addition")]
+#[stable(feature = "iter_once", since = "1.2.0")]
 pub struct Once<T> {
     inner: ::option::IntoIter<T>
 }
 
-#[unstable(feature="iter_once", reason = "new addition")]
+#[stable(feature = "iter_once", since = "1.2.0")]
 impl<T> Iterator for Once<T> {
     type Item = T;
 
@@ -3096,14 +3135,14 @@ impl<T> Iterator for Once<T> {
     }
 }
 
-#[unstable(feature="iter_once", reason = "new addition")]
+#[stable(feature = "iter_once", since = "1.2.0")]
 impl<T> DoubleEndedIterator for Once<T> {
     fn next_back(&mut self) -> Option<T> {
         self.inner.next_back()
     }
 }
 
-#[unstable(feature="iter_once", reason = "new addition")]
+#[stable(feature = "iter_once", since = "1.2.0")]
 impl<T> ExactSizeIterator for Once<T> {
     fn len(&self) -> usize {
         self.inner.len()
@@ -3111,7 +3150,7 @@ impl<T> ExactSizeIterator for Once<T> {
 }
 
 /// Creates an iterator that yields an element exactly once.
-#[unstable(feature="iter_once", reason = "new addition")]
+#[stable(feature = "iter_once", since = "1.2.0")]
 pub fn once<T>(value: T) -> Once<T> {
     Once { inner: Some(value).into_iter() }
 }
@@ -3123,7 +3162,7 @@ pub fn once<T>(value: T) -> Once<T> {
 ///
 /// If two sequences are equal up until the point where one ends,
 /// the shorter sequence compares less.
-#[unstable(feature = "core", reason = "needs review and revision")]
+#[unstable(feature = "iter_order", 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 9dfaec0095a..030d2a33f8f 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -49,7 +49,9 @@
 // Do not remove on snapshot creation. Needed for bootstrap. (Issue #22364)
 #![cfg_attr(stage0, feature(custom_attribute))]
 #![crate_name = "core"]
-#![unstable(feature = "core")]
+#![unstable(feature = "core",
+            reason = "the libcore library has not yet been scrutinized for \
+                      stabilization in terms of structure and naming")]
 #![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -63,7 +65,8 @@
 #![allow(raw_pointer_derive)]
 #![deny(missing_docs)]
 
-#![feature(intrinsics, lang_items)]
+#![feature(intrinsics)]
+#![feature(lang_items)]
 #![feature(on_unimplemented)]
 #![feature(simd)]
 #![feature(staged_api)]
@@ -75,6 +78,7 @@
 #![feature(reflect)]
 #![feature(custom_attribute)]
 #![feature(const_fn)]
+#![feature(allow_internal_unstable)]
 
 #[macro_use]
 mod macros;
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index b5555fa5119..14bb82dff7d 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -10,6 +10,7 @@
 
 /// Entry point of thread panic, for details, see std::macros
 #[macro_export]
+#[allow_internal_unstable]
 macro_rules! panic {
     () => (
         panic!("explicit panic")
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 7c20722b26d..dd60164a114 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -54,7 +54,7 @@ pub trait Sized {
 }
 
 /// Types that can be "unsized" to a dynamically sized type.
-#[unstable(feature = "core")]
+#[unstable(feature = "unsize")]
 #[lang="unsize"]
 pub trait Unsize<T> {
     // Empty.
@@ -223,7 +223,10 @@ impl<T> !Sync for *mut T { }
 /// ensure that they are never copied, even if they lack a destructor.
 #[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
+#[deprecated(since = "1.2.0",
+             reason = "structs are by default not copyable")]
 #[lang = "no_copy_bound"]
+#[allow(deprecated)]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NoCopy;
 
@@ -385,7 +388,7 @@ mod impls {
 /// that function. Here is an example:
 ///
 /// ```
-/// #![feature(core)]
+/// #![feature(reflect_marker)]
 /// use std::marker::Reflect;
 /// use std::any::Any;
 /// fn foo<T:Reflect+'static>(x: &T) {
@@ -410,7 +413,8 @@ mod impls {
 ///
 /// [1]: http://en.wikipedia.org/wiki/Parametricity
 #[rustc_reflect_like]
-#[unstable(feature = "core", reason = "requires RFC and more experience")]
+#[unstable(feature = "reflect_marker",
+           reason = "requires RFC and more experience")]
 #[allow(deprecated)]
 #[rustc_on_unimplemented = "`{Self}` does not implement `Any`; \
                             ensure all type parameters are bounded by `Any`"]
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index 26c6e899df1..15e7cdbde40 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -459,9 +459,13 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline]
-#[unstable(feature = "core",
+#[unstable(feature = "copy_lifetime",
            reason = "this function may be removed in the future due to its \
                      questionable utility")]
+#[deprecated(since = "1.2.0",
+             reason = "unclear that this function buys more safety and \
+                       lifetimes are generally not handled as such in unsafe \
+                       code today")]
 pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
                                                         ptr: &T) -> &'a T {
     transmute(ptr)
@@ -469,9 +473,13 @@ 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 = "core",
+#[unstable(feature = "copy_lifetime",
            reason = "this function may be removed in the future due to its \
                      questionable utility")]
+#[deprecated(since = "1.2.0",
+             reason = "unclear that this function buys more safety and \
+                       lifetimes are generally not handled as such in unsafe \
+                       code today")]
 pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
                                                                ptr: &mut T)
                                                               -> &'a mut T
diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs
index 32522794254..1b5fa4e0e95 100644
--- a/src/libcore/nonzero.rs
+++ b/src/libcore/nonzero.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 //! Exposes the NonZero lang item which provides optimization hints.
+#![unstable(feature = "nonzero",
+            reason = "needs an RFC to flesh out the design")]
 
 use marker::Sized;
 use ops::{CoerceUnsized, Deref};
@@ -33,7 +35,6 @@ unsafe impl Zeroable for u64 {}
 /// NULL or 0 that might allow certain optimizations.
 #[lang = "non_zero"]
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug, Hash)]
-#[unstable(feature = "core")]
 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 50dd3f1661a..aade9061657 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -71,7 +71,9 @@ pub mod consts {
     pub const PI: f32 = 3.14159265358979323846264338327950288_f32;
 
     /// pi * 2.0
-    #[unstable(feature = "core", reason = "unclear naming convention/usefulness")]
+    #[unstable(feature = "float_consts",
+               reason = "unclear naming convention/usefulness")]
+    #[deprecated(since = "1.2.0", reason = "unclear on usefulness")]
     pub const PI_2: f32 = 6.28318530717958647692528676655900576_f32;
 
     /// pi/2.0
@@ -135,7 +137,6 @@ pub mod consts {
     pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
 }
 
-#[unstable(feature = "core", 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 62b566e7eb4..7c9e846af9b 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -71,7 +71,9 @@ pub mod consts {
     pub const PI: f64 = 3.14159265358979323846264338327950288_f64;
 
     /// pi * 2.0
-    #[unstable(feature = "core", reason = "unclear naming convention/usefulness")]
+    #[unstable(feature = "float_consts",
+               reason = "unclear naming convention/usefulness")]
+    #[deprecated(since = "1.2.0", reason = "unclear on usefulness")]
     pub const PI_2: f64 = 6.28318530717958647692528676655900576_f64;
 
     /// pi/2.0
@@ -135,7 +137,6 @@ pub mod consts {
     pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
 }
 
-#[unstable(feature = "core", reason = "trait is unstable")]
 impl Float for f64 {
     #[inline]
     fn nan() -> f64 { NAN }
diff --git a/src/libcore/num/flt2dec/mod.rs b/src/libcore/num/flt2dec/mod.rs
index f51dcf54a19..f3a7e8f09a9 100644
--- a/src/libcore/num/flt2dec/mod.rs
+++ b/src/libcore/num/flt2dec/mod.rs
@@ -126,6 +126,8 @@ functions.
 // while this is extensively documented, this is in principle private which is
 // only made public for testing. do not expose us.
 #![doc(hidden)]
+#![unstable(feature = "flt2dec",
+            reason = "internal routines only exposed for testing")]
 
 use prelude::*;
 use i16;
diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs
index 3113521e0af..efc91238809 100644
--- a/src/libcore/num/int_macros.rs
+++ b/src/libcore/num/int_macros.rs
@@ -14,11 +14,13 @@ 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 = "core")]
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function")]
 pub const BITS : usize = $bits;
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
 // calling the `mem::size_of` function.
-#[unstable(feature = "core")]
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function")]
 pub const BYTES : usize = ($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 bf26022692d..c1297d3c19c 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -41,10 +41,7 @@ use str::{FromStr, StrExt};
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
 pub struct Wrapping<T>(#[stable(feature = "rust1", since = "1.0.0")] pub T);
 
-#[unstable(feature = "core", reason = "may be removed or relocated")]
 pub mod wrapping;
-
-#[unstable(feature = "core", reason = "internal routines only exposed for testing")]
 pub mod flt2dec;
 
 /// Types that have a "zero" value.
@@ -471,7 +468,7 @@ macro_rules! int_impl {
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
         /// itself..
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {
             self.overflowing_div(rhs).0
@@ -484,7 +481,7 @@ macro_rules! int_impl {
         /// implementation artifacts make `x % y` illegal for `MIN /
         /// -1` on a signed type illegal (where `MIN` is the negative
         /// minimal value). In such a case, this function returns `0`.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_rem(self, rhs: Self) -> Self {
             self.overflowing_rem(rhs).0
@@ -498,7 +495,7 @@ macro_rules! int_impl {
         /// negative minimal value for the type); this is a positive
         /// value that is too large to represent in the type. In such
         /// a case, this function returns `MIN` itself.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_neg(self) -> Self {
             self.overflowing_neg().0
@@ -507,7 +504,7 @@ macro_rules! int_impl {
         /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_shl(self, rhs: u32) -> Self {
             self.overflowing_shl(rhs).0
@@ -516,7 +513,7 @@ macro_rules! int_impl {
         /// Panic-free bitwise shift-left; yields `self >> mask(rhs)`,
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_shr(self, rhs: u32) -> Self {
             self.overflowing_shr(rhs).0
@@ -1041,7 +1038,7 @@ macro_rules! uint_impl {
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
         /// itself..
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {
             self.overflowing_div(rhs).0
@@ -1054,7 +1051,7 @@ macro_rules! uint_impl {
         /// implementation artifacts make `x % y` illegal for `MIN /
         /// -1` on a signed type illegal (where `MIN` is the negative
         /// minimal value). In such a case, this function returns `0`.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_rem(self, rhs: Self) -> Self {
             self.overflowing_rem(rhs).0
@@ -1068,7 +1065,7 @@ macro_rules! uint_impl {
         /// negative minimal value for the type); this is a positive
         /// value that is too large to represent in the type. In such
         /// a case, this function returns `MIN` itself.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_neg(self) -> Self {
             self.overflowing_neg().0
@@ -1077,7 +1074,7 @@ macro_rules! uint_impl {
         /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_shl(self, rhs: u32) -> Self {
             self.overflowing_shl(rhs).0
@@ -1086,7 +1083,7 @@ macro_rules! uint_impl {
         /// Panic-free bitwise shift-left; yields `self >> mask(rhs)`,
         /// where `mask` removes any high-order bits of `rhs` that
         /// would cause the shift to exceed the bitwidth of the type.
-        #[unstable(feature = "core", since = "1.0.0")]
+        #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_shr(self, rhs: u32) -> Self {
             self.overflowing_shr(rhs).0
@@ -1262,6 +1259,8 @@ pub enum FpCategory {
 
 /// A built-in floating point number.
 #[doc(hidden)]
+#[unstable(feature = "core_float",
+           reason = "stable interface is via `impl f{32,64}` in later crates")]
 pub trait Float {
     /// Returns the NaN value.
     fn nan() -> Self;
@@ -1512,8 +1511,11 @@ enum IntErrorKind {
 }
 
 impl ParseIntError {
-    #[unstable(feature = "core", reason = "available through Error trait")]
-    pub fn description(&self) -> &str {
+    #[unstable(feature = "int_error_internals",
+               reason = "available through Error trait and this method should \
+                         not be exposed publicly")]
+    #[doc(hidden)]
+    pub fn __description(&self) -> &str {
         match self.kind {
             IntErrorKind::Empty => "cannot parse integer from empty string",
             IntErrorKind::InvalidDigit => "invalid digit found in string",
@@ -1526,7 +1528,7 @@ impl ParseIntError {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Display for ParseIntError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
+        self.__description().fmt(f)
     }
 }
 
@@ -1535,10 +1537,15 @@ impl fmt::Display for ParseIntError {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct ParseFloatError {
     #[doc(hidden)]
+    #[unstable(feature = "float_error_internals",
+               reason = "should not be exposed publicly")]
     pub __kind: FloatErrorKind
 }
 
 #[derive(Debug, Clone, PartialEq)]
+#[unstable(feature = "float_error_internals",
+           reason = "should not be exposed publicly")]
+#[doc(hidden)]
 pub enum FloatErrorKind {
     Empty,
     Invalid,
diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs
index 86782950745..0719d7c17cc 100644
--- a/src/libcore/num/uint_macros.rs
+++ b/src/libcore/num/uint_macros.rs
@@ -12,9 +12,11 @@
 
 macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
 
-#[unstable(feature = "core")]
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function")]
 pub const BITS : usize = $bits;
-#[unstable(feature = "core")]
+#[unstable(feature = "num_bits_bytes",
+           reason = "may want to be an associated function")]
 pub const BYTES : usize = ($bits / 8);
 
 #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/src/libcore/num/wrapping.rs b/src/libcore/num/wrapping.rs
index 69c22229490..748ed29e3a3 100644
--- a/src/libcore/num/wrapping.rs
+++ b/src/libcore/num/wrapping.rs
@@ -10,6 +10,7 @@
 
 #![allow(missing_docs)]
 #![allow(deprecated)]
+#![unstable(feature = "wrapping", reason = "may be removed or relocated")]
 
 use super::Wrapping;
 
@@ -30,7 +31,6 @@ use intrinsics::{i64_mul_with_overflow, u64_mul_with_overflow};
 
 use ::{i8,i16,i32,i64};
 
-#[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]
 pub trait OverflowingOps {
     fn overflowing_add(self, rhs: Self) -> (Self, bool);
     fn overflowing_sub(self, rhs: Self) -> (Self, bool);
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index c52f4de732f..48b1cbeef4f 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -29,8 +29,8 @@
 //!
 //! # Examples
 //!
-//! This example creates a `Point` struct that implements `Add` and `Sub`, and then
-//! demonstrates adding and subtracting two `Point`s.
+//! This example creates a `Point` struct that implements `Add` and `Sub`, and
+//! then demonstrates adding and subtracting two `Point`s.
 //!
 //! ```rust
 //! use std::ops::{Add, Sub};
@@ -62,21 +62,21 @@
 //! }
 //! ```
 //!
-//! See the documentation for each trait for a minimum implementation that prints
-//! something to the screen.
+//! See the documentation for each trait for a minimum implementation that
+//! prints something to the screen.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use marker::{Sized, Unsize};
 use fmt;
 
-/// The `Drop` trait is used to run some code when a value goes out of scope. This
-/// is sometimes called a 'destructor'.
+/// The `Drop` trait is used to run some code when a value goes out of scope.
+/// This is sometimes called a 'destructor'.
 ///
 /// # Examples
 ///
-/// A trivial implementation of `Drop`. The `drop` method is called when `_x` goes
-/// out of scope, and therefore `main` prints `Dropping!`.
+/// A trivial implementation of `Drop`. The `drop` method is called when `_x`
+/// goes out of scope, and therefore `main` prints `Dropping!`.
 ///
 /// ```
 /// struct HasDrop;
@@ -103,8 +103,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 = "core",
-                   reason = "recently added, waiting for dust to settle")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<'a> $imp for &'a $t {
             type Output = <$t as $imp>::Output;
 
@@ -120,8 +119,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 = "core",
-                   reason = "recently added, waiting for dust to settle")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<'a> $imp<$u> for &'a $t {
             type Output = <$t as $imp<$u>>::Output;
 
@@ -131,8 +129,7 @@ macro_rules! forward_ref_binop {
             }
         }
 
-        #[unstable(feature = "core",
-                   reason = "recently added, waiting for dust to settle")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<'a> $imp<&'a $u> for $t {
             type Output = <$t as $imp<$u>>::Output;
 
@@ -142,8 +139,7 @@ macro_rules! forward_ref_binop {
             }
         }
 
-        #[unstable(feature = "core",
-                   reason = "recently added, waiting for dust to settle")]
+        #[stable(feature = "rust1", since = "1.0.0")]
         impl<'a, 'b> $imp<&'a $u> for &'b $t {
             type Output = <$t as $imp<$u>>::Output;
 
@@ -1210,7 +1206,7 @@ mod impls {
 
 /// Trait that indicates that this is a pointer or a wrapper for one,
 /// where unsizing can be performed on the pointee.
-#[unstable(feature = "core")]
+#[unstable(feature = "coerce_unsized")]
 #[lang="coerce_unsized"]
 pub trait CoerceUnsized<T> {
     // Empty.
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 593c5e79d34..c5203c5111b 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -274,7 +274,7 @@ impl<T> Option<T> {
     /// # Examples
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(as_slice)]
     /// let mut x = Some("Diamonds");
     /// {
     ///     let v = x.as_mut_slice();
@@ -285,7 +285,7 @@ impl<T> Option<T> {
     /// assert_eq!(x, Some("Dirt"));
     /// ```
     #[inline]
-    #[unstable(feature = "core",
+    #[unstable(feature = "as_slice",
                reason = "waiting for mut conventions")]
     pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
         match *self {
diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs
index 635150c0886..8133db097df 100644
--- a/src/libcore/panicking.rs
+++ b/src/libcore/panicking.rs
@@ -29,6 +29,9 @@
 //! library, but the location of this may change over time.
 
 #![allow(dead_code, missing_docs)]
+#![unstable(feature = "core_panic",
+            reason = "internal details of the implementation of the `panic!` \
+                      and related macros")]
 
 use fmt;
 
diff --git a/src/libcore/prelude.rs b/src/libcore/prelude.rs
index a4d529ad47d..ac153d64ab2 100644
--- a/src/libcore/prelude.rs
+++ b/src/libcore/prelude.rs
@@ -24,6 +24,10 @@
 //! use core::prelude::*;
 //! ```
 
+#![unstable(feature = "core_prelude",
+            reason = "the libcore prelude has not been scrutinized and \
+                      stabilized yet")]
+
 // Reexported core operators
 pub use marker::{Copy, Send, Sized, Sync};
 pub use ops::{Drop, Fn, FnMut, FnOnce};
@@ -32,7 +36,6 @@ pub use ops::{Drop, Fn, FnMut, FnOnce};
 pub use mem::drop;
 
 // Reexported types and traits
-
 pub use char::CharExt;
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 9ca9b4fc46c..31cdb6093c8 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -49,7 +49,7 @@
 //! the raw pointer. It doesn't destroy `T` or deallocate any memory.
 //!
 //! ```
-//! # #![feature(alloc)]
+//! # #![feature(box_raw)]
 //! use std::boxed;
 //!
 //! unsafe {
@@ -204,7 +204,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 = "core",
+#[unstable(feature = "read_and_zero",
            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`:
@@ -219,7 +219,7 @@ pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
 /// Variant of read_and_zero that writes the specific drop-flag byte
 /// (which may be more appropriate than zero).
 #[inline(always)]
-#[unstable(feature = "core",
+#[unstable(feature = "filling_drop",
            reason = "may play a larger role in std::ptr future extensions")]
 pub unsafe fn read_and_drop<T>(dest: *mut T) -> T {
     // Copy the data out from `dest`:
@@ -267,9 +267,10 @@ impl<T: ?Sized> *const T {
     /// 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 = "core",
-               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")]
+    #[unstable(feature = "ptr_as_ref",
+               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")]
     #[inline]
     pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> where T: Sized {
         if self.is_null() {
@@ -314,9 +315,10 @@ impl<T: ?Sized> *mut T {
     /// 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 = "core",
-               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")]
+    #[unstable(feature = "ptr_as_ref",
+               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")]
     #[inline]
     pub unsafe fn as_ref<'a>(&self) -> Option<&'a T> where T: Sized {
         if self.is_null() {
@@ -347,7 +349,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// As with `as_ref`, this is unsafe because it cannot verify the validity
     /// of the returned pointer.
-    #[unstable(feature = "core",
+    #[unstable(feature = "ptr_as_ref",
                reason = "return value does not necessarily convey all possible \
                          information")]
     #[inline]
@@ -507,7 +509,7 @@ impl<T: ?Sized> PartialOrd for *mut T {
 /// modified without a unique path to the `Unique` reference. Useful
 /// for building abstractions like `Vec<T>` or `Box<T>`, which
 /// internally use raw pointers to manage the memory that they own.
-#[unstable(feature = "unique")]
+#[unstable(feature = "unique", reason = "needs an RFC to flesh out design")]
 pub struct Unique<T: ?Sized> {
     pointer: NonZero<*const T>,
     _marker: PhantomData<T>,
@@ -527,21 +529,19 @@ unsafe impl<T: Send + ?Sized> Send for Unique<T> { }
 #[unstable(feature = "unique")]
 unsafe impl<T: Sync + ?Sized> Sync for Unique<T> { }
 
+#[unstable(feature = "unique")]
 impl<T: ?Sized> Unique<T> {
     /// Creates a new `Unique`.
-    #[unstable(feature = "unique")]
     pub unsafe fn new(ptr: *mut T) -> Unique<T> {
         Unique { pointer: NonZero::new(ptr), _marker: PhantomData }
     }
 
     /// Dereferences the content.
-    #[unstable(feature = "unique")]
     pub unsafe fn get(&self) -> &T {
         &**self.pointer
     }
 
     /// Mutably dereferences the content.
-    #[unstable(feature = "unique")]
     pub unsafe fn get_mut(&mut self) -> &mut T {
         &mut ***self
     }
diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs
index ec84ef7986a..43535ddd1d5 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 = "core")]
+#![unstable(feature = "raw")]
 
 //! Contains struct definitions for the layout of compiler built-in types.
 //!
@@ -49,7 +49,7 @@ use mem;
 /// # Examples
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(raw)]
 /// use std::raw::{self, Repr};
 ///
 /// let slice: &[u16] = &[1, 2, 3, 4];
@@ -98,7 +98,7 @@ impl<T> Clone for Slice<T> {
 /// # Examples
 ///
 /// ```
-/// # #![feature(core)]
+/// # #![feature(raw)]
 /// use std::mem;
 /// use std::raw;
 ///
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 772831b1a58..d87c1020dcc 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -420,7 +420,7 @@ impl<T, E> Result<T, E> {
     /// Converts from `Result<T, E>` to `&mut [T]` (without copying)
     ///
     /// ```
-    /// # #![feature(core)]
+    /// # #![feature(as_slice)]
     /// let mut x: Result<&str, u32> = Ok("Gold");
     /// {
     ///     let v = x.as_mut_slice();
@@ -434,7 +434,7 @@ impl<T, E> Result<T, E> {
     /// assert!(x.as_mut_slice().is_empty());
     /// ```
     #[inline]
-    #[unstable(feature = "core",
+    #[unstable(feature = "as_slice",
                reason = "waiting for mut conventions")]
     pub fn as_mut_slice(&mut self) -> &mut [T] {
         match *self {
@@ -966,7 +966,11 @@ 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 = "core")]
+#[unstable(feature = "result_fold",
+           reason = "unclear if this function should exist")]
+#[deprecated(since = "1.2.0",
+             reason = "has not seen enough usage to justify its position in \
+                       the standard library")]
 pub fn fold<T,
             V,
             E,
diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs
index 7b55ba49a07..7ecd08bea35 100644
--- a/src/libcore/simd.rs
+++ b/src/libcore/simd.rs
@@ -19,7 +19,7 @@
 //! provided beyond this module.
 //!
 //! ```rust
-//! # #![feature(core)]
+//! # #![feature(core_simd)]
 //! fn main() {
 //!     use std::simd::f32x4;
 //!     let a = f32x4(40.0, 41.0, 42.0, 43.0);
@@ -33,10 +33,12 @@
 //! These are all experimental. The interface may change entirely, without
 //! warning.
 
+#![unstable(feature = "core_simd",
+            reason = "needs an RFC to flesh out the design")]
+
 #![allow(non_camel_case_types)]
 #![allow(missing_docs)]
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
@@ -45,26 +47,22 @@ 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 = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
                  pub i16, pub i16, pub i16, pub i16);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct i64x2(pub i64, pub i64);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
@@ -73,32 +71,27 @@ 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 = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
                  pub u16, pub u16, pub u16, pub u16);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct u64x2(pub u64, pub u64);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
 pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
 
-#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 2dc28a4786f..a8c995f37cc 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -64,6 +64,8 @@ use raw::Slice as RawSlice;
 /// Extension methods for slices.
 #[allow(missing_docs)] // docs in libcollections
 #[doc(hidden)]
+#[unstable(feature = "core_slice_ext",
+           reason = "stable interface provided by `impl [T]` in later crates")]
 pub trait SliceExt {
     type Item;
 
@@ -148,7 +150,6 @@ macro_rules! slice_ref {
     }};
 }
 
-#[unstable(feature = "core")]
 impl<T> SliceExt for [T] {
     type Item = T;
 
@@ -256,7 +257,6 @@ impl<T> SliceExt for [T] {
         self.repr().data
     }
 
-    #[unstable(feature = "core")]
     fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize> where
         F: FnMut(&T) -> Ordering
     {
@@ -437,12 +437,10 @@ impl<T> SliceExt for [T] {
         m >= n && needle == &self[m-n..]
     }
 
-    #[unstable(feature = "core")]
     fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord {
         self.binary_search_by(|p| p.cmp(x))
     }
 
-    #[unstable(feature = "core")]
     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; }
@@ -473,7 +471,6 @@ impl<T> SliceExt for [T] {
         true
     }
 
-    #[unstable(feature = "core")]
     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; }
@@ -774,7 +771,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 = "core")]
+    #[unstable(feature = "iter_to_slice")]
     pub fn as_slice(&self) -> &'a [T] {
         make_slice!(self.ptr, self.end)
     }
@@ -804,7 +801,8 @@ impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> { Iter { ptr: self.ptr, end: self.end, _marker: self._marker } }
 }
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> usize {
@@ -842,7 +840,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 = "core")]
+    #[unstable(feature = "iter_to_slice")]
     pub fn into_slice(self) -> &'a mut [T] {
         make_mut_slice!(self.ptr, self.end)
     }
@@ -1176,7 +1174,8 @@ impl<'a, T> DoubleEndedIterator for Windows<'a, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> ExactSizeIterator for Windows<'a, T> {}
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<'a, T> RandomAccessIterator for Windows<'a, T> {
     #[inline]
     fn indexable(&self) -> usize {
@@ -1263,7 +1262,8 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> ExactSizeIterator for Chunks<'a, T> {}
 
-#[unstable(feature = "core", reason = "trait is experimental")]
+#[unstable(feature = "iter_idx", reason = "trait is experimental")]
+#[allow(deprecated)]
 impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
     #[inline]
     fn indexable(&self) -> usize {
@@ -1349,7 +1349,7 @@ impl<'a, T> ExactSizeIterator for ChunksMut<'a, T> {}
 //
 
 /// Converts a pointer to A into a slice of length 1 (without copying).
-#[unstable(feature = "core")]
+#[unstable(feature = "ref_slice")]
 pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
     unsafe {
         from_raw_parts(s, 1)
@@ -1357,7 +1357,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 = "core")]
+#[unstable(feature = "ref_slice")]
 pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
     unsafe {
         from_raw_parts_mut(s, 1)
@@ -1415,7 +1415,7 @@ pub unsafe fn from_raw_parts_mut<'a, T>(p: *mut T, len: usize) -> &'a mut [T] {
 //
 
 /// Operations on `[u8]`.
-#[unstable(feature = "core", reason = "needs review")]
+#[unstable(feature = "slice_bytes", reason = "needs review")]
 pub mod bytes {
     use ptr;
     use slice::SliceExt;
@@ -1503,7 +1503,11 @@ impl<T: PartialOrd> PartialOrd for [T] {
 }
 
 /// Extension methods for slices containing integers.
-#[unstable(feature = "core")]
+#[unstable(feature = "int_slice")]
+#[deprecated(since = "1.2.0",
+             reason = "has not seen much usage and may want to live in the \
+                       standard library now that most slice methods are \
+                       on an inherent implementation block")]
 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];
@@ -1518,7 +1522,8 @@ pub trait IntSliceExt<U, S> {
 
 macro_rules! impl_int_slice {
     ($u:ty, $s:ty, $t:ty) => {
-        #[unstable(feature = "core")]
+        #[unstable(feature = "int_slice")]
+        #[allow(deprecated)]
         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 ef8b371f061..5a621176c4a 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -13,6 +13,7 @@
 //! For more details, see std::str
 
 #![doc(primitive = "str")]
+#![stable(feature = "rust1", since = "1.0.0")]
 
 use self::OldSearcher::{TwoWay, TwoWayLong};
 use self::pattern::Pattern;
@@ -191,7 +192,7 @@ fn unwrap_or_0(opt: Option<&u8>) -> u8 {
 
 /// Reads the next code point out of a byte iterator (assuming a
 /// UTF-8-like encoding).
-#[unstable(feature = "core")]
+#[unstable(feature = "str_internals")]
 #[inline]
 pub fn next_code_point(bytes: &mut slice::Iter<u8>) -> Option<u32> {
     // Decode UTF-8
@@ -226,9 +227,8 @@ pub fn next_code_point(bytes: &mut slice::Iter<u8>) -> Option<u32> {
 
 /// Reads the last code point out of a byte iterator (assuming a
 /// UTF-8-like encoding).
-#[unstable(feature = "core")]
 #[inline]
-pub fn next_code_point_reverse(bytes: &mut slice::Iter<u8>) -> Option<u32> {
+fn next_code_point_reverse(bytes: &mut slice::Iter<u8>) -> Option<u32> {
     // Decode UTF-8
     let w = match bytes.next_back() {
         None => return None,
@@ -738,7 +738,7 @@ generate_pattern_iterators! {
         #[doc="Created with the method `.rmatch_indices()`."]
         struct RMatchIndices;
     stability:
-        #[unstable(feature = "core",
+        #[unstable(feature = "str_match_indices",
                    reason = "type may be removed or have its iterator impl changed")]
     internal:
         MatchIndicesInternal yielding ((usize, usize));
@@ -779,7 +779,7 @@ generate_pattern_iterators! {
         #[doc="Created with the method `.rmatches()`."]
         struct RMatches;
     stability:
-        #[unstable(feature = "core", reason = "type got recently added")]
+        #[stable(feature = "str_matches", since = "1.2.0")]
     internal:
         MatchesInternal yielding (&'a str);
     delegate double ended;
@@ -1470,6 +1470,8 @@ mod traits {
 /// Methods for string slices
 #[allow(missing_docs)]
 #[doc(hidden)]
+#[unstable(feature = "core_str_ext",
+           reason = "stable interface provided by `impl str` in later crates")]
 pub trait StrExt {
     // NB there are no docs here are they're all located on the StrExt trait in
     // libcollections, not here.
@@ -1870,8 +1872,7 @@ impl AsRef<[u8]> for str {
 /// Pluck a code point out of a UTF-8-like byte slice and return the
 /// index of the next code point.
 #[inline]
-#[unstable(feature = "core")]
-pub fn char_range_at_raw(bytes: &[u8], i: usize) -> (u32, usize) {
+fn char_range_at_raw(bytes: &[u8], i: usize) -> (u32, usize) {
     if bytes[i] < 128 {
         return (bytes[i] as u32, i + 1);
     }
diff --git a/src/libcore/str/pattern.rs b/src/libcore/str/pattern.rs
index 9a96612195c..8bdbab55211 100644
--- a/src/libcore/str/pattern.rs
+++ b/src/libcore/str/pattern.rs
@@ -13,6 +13,9 @@
 //! For more details, see the traits `Pattern`, `Searcher`,
 //! `ReverseSearcher` and `DoubleEndedSearcher`.
 
+#![unstable(feature = "pattern",
+            reason = "API not fully fleshed out and ready to be stabilized")]
+
 use prelude::*;
 
 // Pattern
diff --git a/src/libcore/ty.rs b/src/libcore/ty.rs
deleted file mode 100644
index 35c1cb09281..00000000000
--- a/src/libcore/ty.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Types dealing with unsafe actions.
-
-use marker;