Set unstable feature names appropriately

* `core` - for the core crate
* `hash` - hashing
* `io` - io
* `path` - path
* `alloc` - alloc crate
* `rand` - rand crate
* `collections` - collections crate
* `std_misc` - other parts of std
* `test` - test crate
* `rustc_private` - everything else

148 files changed, 864 insertions, 741 deletions

diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index b23c867d5c9..802fb05796d 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -13,7 +13,6 @@
 #![feature(slicing_syntax, unboxed_closures)]
 #![feature(box_syntax)]
 #![feature(int_uint)]
-#![feature(unnamed_feature)]
 
 #![deny(warnings)]
 
diff --git a/src/driver/driver.rs b/src/driver/driver.rs
index 6e436ec41d5..601f130341b 100644
--- a/src/driver/driver.rs
+++ b/src/driver/driver.rs
@@ -9,7 +9,8 @@
 // except according to those terms.
 
 #![allow(unknown_features)]
-#![feature(unnamed_feature)]
+#![cfg_attr(rustc, feature(rustc_private))]
+#![cfg_attr(rustdoc, feature(rustdoc))]
 
 #[cfg(rustdoc)]
 extern crate "rustdoc" as this;
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 821933f3f0a..ad4cb2076c2 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -126,7 +126,7 @@ unsafe impl<T: Sync + Send> Sync for Arc<T> { }
 /// Weak pointers will not keep the data inside of the `Arc` alive, and can be used to break cycles
 /// between `Arc` pointers.
 #[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 pub struct Weak<T> {
     // FIXME #12808: strange name to try to avoid interfering with
@@ -180,7 +180,7 @@ impl<T> Arc<T> {
     ///
     /// let weak_five = five.downgrade();
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "alloc",
                reason = "Weak pointers may not belong in this module.")]
     pub fn downgrade(&self) -> Weak<T> {
         // See the clone() impl for why this is relaxed
@@ -202,12 +202,12 @@ impl<T> Arc<T> {
 
 /// Get the number of weak references to this value.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn weak_count<T>(this: &Arc<T>) -> uint { this.inner().weak.load(SeqCst) - 1 }
 
 /// Get the number of strong references to this value.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn strong_count<T>(this: &Arc<T>) -> uint { this.inner().strong.load(SeqCst) }
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -273,7 +273,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
     /// let mut_five = five.make_unique();
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "alloc")]
     pub fn make_unique(&mut self) -> &mut T {
         // Note that we hold a strong reference, which also counts as a weak reference, so we only
         // clone if there is an additional reference of either kind.
@@ -357,7 +357,7 @@ impl<T: Sync + Send> Drop for Arc<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T: Sync + Send> Weak<T> {
     /// Upgrades a weak reference to a strong reference.
@@ -396,7 +396,7 @@ impl<T: Sync + Send> Weak<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T: Sync + Send> Clone for Weak<T> {
     /// Makes a clone of the `Weak<T>`.
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index 7351f1f3306..ed371e577a6 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -44,7 +44,7 @@ use core::ops::{Deref, DerefMut};
 /// }
 /// ```
 #[lang = "exchange_heap"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "may be renamed; uncertain about custom allocator design")]
 pub static HEAP: () = ();
 
@@ -126,7 +126,7 @@ impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
 }
 
 /// Extension methods for an owning `Any` trait object.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "this trait will likely disappear once compiler bugs blocking \
                      a direct impl on `Box<Any>` have been fixed ")]
 // FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're
diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
index 19496616a5d..9a72d7d0510 100644
--- a/src/liballoc/heap.rs
+++ b/src/liballoc/heap.rs
@@ -80,7 +80,7 @@ pub fn usable_size(size: uint, align: uint) -> uint {
 ///
 /// These statistics may be inconsistent if other threads use the allocator
 /// during the call.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn stats_print() {
     imp::stats_print();
 }
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index c30bd280c8f..cadb8907cf8 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -57,7 +57,7 @@
 //! default global allocator. It is not compatible with the libc allocator API.
 
 #![crate_name = "alloc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "alloc")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -70,8 +70,10 @@
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(libc)]
 
 #[macro_use]
 extern crate core;
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index 4e3c165361b..81336cfd230 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -268,7 +268,7 @@ impl<T> Rc<T> {
     /// let weak_five = five.downgrade();
     /// ```
     #[cfg(stage0)] // NOTE remove after next snapshot
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "alloc",
                reason = "Weak pointers may not belong in this module")]
     pub fn downgrade(&self) -> Weak<T> {
         self.inc_weak();
@@ -291,7 +291,7 @@ impl<T> Rc<T> {
     /// let weak_five = five.downgrade();
     /// ```
     #[cfg(not(stage0))] // NOTE remove cfg after next snapshot
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "alloc",
                reason = "Weak pointers may not belong in this module")]
     pub fn downgrade(&self) -> Weak<T> {
         self.inc_weak();
@@ -301,12 +301,12 @@ impl<T> Rc<T> {
 
 /// Get the number of weak references to this value.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn weak_count<T>(this: &Rc<T>) -> uint { this.weak() - 1 }
 
 /// Get the number of strong references to this value.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
 
 /// Returns true if there are no other `Rc` or `Weak<T>` values that share the same inner value.
@@ -322,7 +322,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() }
 /// rc::is_unique(&five);
 /// ```
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn is_unique<T>(rc: &Rc<T>) -> bool {
     weak_count(rc) == 0 && strong_count(rc) == 1
 }
@@ -344,7 +344,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool {
 /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
 /// ```
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
     if is_unique(&rc) {
         unsafe {
@@ -378,7 +378,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
 /// assert!(rc::get_mut(&mut x).is_none());
 /// ```
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "alloc")]
 pub fn get_mut<'a, T>(rc: &'a mut Rc<T>) -> Option<&'a mut T> {
     if is_unique(rc) {
         let inner = unsafe { &mut **rc._ptr };
@@ -404,7 +404,7 @@ impl<T: Clone> Rc<T> {
     /// let mut_five = five.make_unique();
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "alloc")]
     pub fn make_unique(&mut self) -> &mut T {
         if !is_unique(self) {
             *self = Rc::new((**self).clone())
@@ -695,7 +695,7 @@ impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")]
+#[unstable(feature = "alloc", reason = "Show is experimental.")]
 impl<T: fmt::Show> fmt::Show for Rc<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Rc({:?})", **self)
@@ -716,7 +716,7 @@ impl<T: fmt::String> fmt::String for Rc<T> {
 /// See the [module level documentation](../index.html) for more.
 #[unsafe_no_drop_flag]
 #[cfg(stage0)] // NOTE remove impl after next snapshot
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 pub struct Weak<T> {
     // FIXME #12808: strange names to try to avoid interfering with
@@ -732,7 +732,7 @@ pub struct Weak<T> {
 ///
 /// See the [module level documentation](../index.html) for more.
 #[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 #[cfg(not(stage0))] // NOTE remove cfg after next snapshot
 pub struct Weak<T> {
@@ -748,7 +748,7 @@ impl<T> !marker::Send for Weak<T> {}
 impl<T> !marker::Sync for Weak<T> {}
 
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T> Weak<T> {
     /// Upgrades a weak reference to a strong reference.
@@ -850,7 +850,7 @@ impl<T> Drop for Weak<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "alloc",
            reason = "Weak pointers may not belong in this module.")]
 impl<T> Clone for Weak<T> {
     /// Makes a clone of the `Weak<T>`.
@@ -894,7 +894,7 @@ impl<T> Clone for Weak<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "Show is experimental.")]
+#[unstable(feature = "alloc", reason = "Show is experimental.")]
 impl<T: fmt::Show> fmt::Show for Weak<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "(Weak)")
diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index 79025e639c8..de0f15dd08d 100644
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -20,7 +20,7 @@
 //! more complex, slower arena which can hold objects of any type.
 
 #![crate_name = "arena"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -33,9 +33,10 @@
 #![feature(unsafe_destructor)]
 #![feature(unboxed_closures)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(missing_docs)]
+#![feature(alloc)]
+#![feature(core)]
 
 extern crate alloc;
 
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
index 003a05f6b04..3e02ac2137d 100644
--- a/src/libcollections/binary_heap.rs
+++ b/src/libcollections/binary_heap.rs
@@ -551,7 +551,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Clears the binary heap, returning an iterator over the removed elements.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain(&mut self) -> Drain<T> {
         Drain { iter: self.data.drain() }
@@ -623,7 +623,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// An iterator that drains a `BinaryHeap`.
-#[unstable(feature = "unnamed_feature", reason = "recent addition")]
+#[unstable(feature = "collections", reason = "recent addition")]
 pub struct Drain<'a, T: 'a> {
     iter: vec::Drain<'a, T>,
 }
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index 66f2b7c69db..867e034e442 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -156,7 +156,7 @@ static FALSE: bool = false;
 /// println!("{:?}", bv);
 /// println!("total bits set to true: {}", bv.iter().filter(|x| *x).count());
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "RFC 509")]
 pub struct Bitv {
     /// Internal representation of the bit vector
@@ -403,7 +403,7 @@ impl Bitv {
     /// assert_eq!(bv[3], true);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "panic semantics are likely to change in the future")]
     pub fn set(&mut self, i: uint, x: bool) {
         assert!(i < self.nbits);
@@ -1109,7 +1109,7 @@ impl<'a> RandomAccessIterator for Iter<'a> {
 /// assert!(bv[3]);
 /// ```
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "RFC 509")]
 pub struct BitvSet {
     bitv: Bitv,
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index fc68b982995..f6873855b3e 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -136,7 +136,7 @@ pub struct RangeMut<'a, K: 'a, V: 'a> {
 }
 
 /// A view into a single entry in a map, which may either be vacant or occupied.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "precise API still under development")]
 pub enum Entry<'a, K:'a, V:'a> {
     /// A vacant Entry
@@ -146,7 +146,7 @@ pub enum Entry<'a, K:'a, V:'a> {
 }
 
 /// A vacant Entry.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "precise API still under development")]
 pub struct VacantEntry<'a, K:'a, V:'a> {
     key: K,
@@ -154,7 +154,7 @@ pub struct VacantEntry<'a, K:'a, V:'a> {
 }
 
 /// An occupied Entry.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "precise API still under development")]
 pub struct OccupiedEntry<'a, K:'a, V:'a> {
     stack: stack::SearchStack<'a, K, V, node::handle::KV, node::handle::LeafOrInternal>,
@@ -1099,7 +1099,7 @@ impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {
 }
 
 impl<'a, K: Ord, V> Entry<'a, K, V> {
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
     pub fn get(self) -> Result<&'a mut V, VacantEntry<'a, K, V>> {
@@ -1113,7 +1113,7 @@ impl<'a, K: Ord, V> Entry<'a, K, V> {
 impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
     /// Sets the value of the entry with the VacantEntry's key,
     /// and returns a mutable reference to it.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn insert(self, value: V) -> &'a mut V {
         self.stack.insert(self.key, value)
@@ -1122,21 +1122,21 @@ impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
 
 impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
     /// Gets a reference to the value in the entry.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn get(&self) -> &V {
         self.stack.peek()
     }
 
     /// Gets a mutable reference to the value in the entry.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn get_mut(&mut self) -> &mut V {
         self.stack.peek_mut()
     }
 
     /// Converts the entry into a mutable reference to its value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn into_mut(self) -> &'a mut V {
         self.stack.into_top()
@@ -1144,7 +1144,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
 
     /// Sets the value of the entry with the OccupiedEntry's key,
     /// and returns the entry's old value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn insert(&mut self, mut value: V) -> V {
         mem::swap(self.stack.peek_mut(), &mut value);
@@ -1152,7 +1152,7 @@ impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
     }
 
     /// Takes the value of the entry out of the map, and returns it.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform v2 specification, waiting for dust to settle")]
     pub fn remove(self) -> V {
         self.stack.remove()
@@ -1480,7 +1480,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// }
     /// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next());
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn range<'a>(&'a self, min: Bound<&K>, max: Bound<&K>) -> Range<'a, K, V> {
         range_impl!(&self.root, min, max, as_slices_internal, iter, Range, edges, [])
@@ -1507,7 +1507,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     ///     println!("{} => {}", name, balance);
     /// }
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn range_mut<'a>(&'a mut self, min: Bound<&K>, max: Bound<&K>) -> RangeMut<'a, K, V> {
         range_impl!(&mut self.root, min, max, as_slices_internal_mut, iter_mut, RangeMut,
@@ -1540,7 +1540,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// assert_eq!(count["a"], 3u);
     /// ```
     /// The key must have the same ordering before or after `.to_owned()` is called.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "precise API still under development")]
     pub fn entry<'a>(&'a mut self, mut key: K) -> Entry<'a, K, V> {
         // same basic logic of `swap` and `pop`, blended together
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
index b1672d6184a..dd281e0836b 100644
--- a/src/libcollections/btree/set.rs
+++ b/src/libcollections/btree/set.rs
@@ -102,7 +102,7 @@ impl<T: Ord> BTreeSet<T> {
     /// Makes a new BTreeSet with the given B.
     ///
     /// B cannot be less than 2.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "probably want this to be on the type, eventually")]
     pub fn with_b(b: uint) -> BTreeSet<T> {
         BTreeSet { map: BTreeMap::with_b(b) }
@@ -173,7 +173,7 @@ impl<T: Ord> BTreeSet<T> {
     /// }
     /// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next());
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn range<'a>(&'a self, min: Bound<&T>, max: Bound<&T>) -> Range<'a, T> {
         fn first<A, B>((a, _): (A, B)) -> A { a }
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index cb1e2e16f06..6dc988219ea 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -770,7 +770,7 @@ impl<'a, A> IterMut<'a, A> {
     /// }
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this is probably better handled by a cursor type -- we'll see")]
     pub fn insert_next(&mut self, elt: A) {
         self.insert_next_node(box Node::new(elt))
@@ -792,7 +792,7 @@ impl<'a, A> IterMut<'a, A> {
     /// assert_eq!(it.next().unwrap(), &2);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this is probably better handled by a cursor type -- we'll see")]
     pub fn peek_next(&mut self) -> Option<&mut A> {
         if self.nelem == 0 {
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index a18634539a8..fddea51c534 100644
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -82,21 +82,21 @@ fn bit<E:CLike>(e: &E) -> uint {
 
 impl<E:CLike> EnumSet<E> {
     /// Returns an empty `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn new() -> EnumSet<E> {
         EnumSet {bits: 0}
     }
 
     /// Returns the number of elements in the given `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn len(&self) -> uint {
         self.bits.count_ones()
     }
 
     /// Returns true if the `EnumSet` is empty.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn is_empty(&self) -> bool {
         self.bits == 0
@@ -107,21 +107,21 @@ impl<E:CLike> EnumSet<E> {
     }
 
     /// Returns `false` if the `EnumSet` contains any enum of the given `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn is_disjoint(&self, other: &EnumSet<E>) -> bool {
         (self.bits & other.bits) == 0
     }
 
     /// Returns `true` if a given `EnumSet` is included in this `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn is_superset(&self, other: &EnumSet<E>) -> bool {
         (self.bits & other.bits) == other.bits
     }
 
     /// Returns `true` if this `EnumSet` is included in the given `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn is_subset(&self, other: &EnumSet<E>) -> bool {
         other.is_superset(self)
@@ -138,7 +138,7 @@ impl<E:CLike> EnumSet<E> {
     }
 
     /// Adds an enum to the `EnumSet`, and returns `true` if it wasn't there before
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn insert(&mut self, e: E) -> bool {
         let result = !self.contains(&e);
@@ -147,7 +147,7 @@ impl<E:CLike> EnumSet<E> {
     }
 
     /// Removes an enum from the EnumSet
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn remove(&mut self, e: &E) -> bool {
         let result = self.contains(e);
@@ -156,14 +156,14 @@ impl<E:CLike> EnumSet<E> {
     }
 
     /// Returns `true` if an `EnumSet` contains a given enum.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn contains(&self, e: &E) -> bool {
         (self.bits & bit(e)) != 0
     }
 
     /// Returns an iterator over an `EnumSet`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn iter(&self) -> Iter<E> {
         Iter::new(self.bits)
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index c8b5b82d0a5..b836fe61a75 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -14,7 +14,7 @@
 
 
 #![crate_name = "collections"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "collections")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -27,9 +27,12 @@
 #![feature(unsafe_destructor, slicing_syntax)]
 #![feature(box_syntax)]
 #![feature(unboxed_closures)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![no_std]
+#![feature(core)]
+#![feature(alloc)]
+#![feature(unicode)]
+#![feature(hash)]
 
 #[macro_use]
 extern crate core;
@@ -71,13 +74,13 @@ pub mod string;
 pub mod vec;
 pub mod vec_map;
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "RFC 509")]
 pub mod bitv {
     pub use bit::{Bitv, Iter};
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "RFC 509")]
 pub mod bitv_set {
     pub use bit::{BitvSet, Union, Intersection, Difference, SymmetricDifference};
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index edd3b174edb..72b5eba8aaa 100644
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -480,7 +480,7 @@ impl<T> RingBuf<T> {
     /// assert_eq!(buf.len(), 1);
     /// assert_eq!(Some(&5), buf.get(0));
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
     pub fn truncate(&mut self, len: uint) {
         for _ in range(len, self.len()) {
@@ -550,7 +550,7 @@ impl<T> RingBuf<T> {
     /// Returns a pair of slices which contain, in order, the contents of the
     /// `RingBuf`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
         unsafe {
@@ -570,7 +570,7 @@ impl<T> RingBuf<T> {
     /// Returns a pair of slices which contain, in order, the contents of the
     /// `RingBuf`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
         unsafe {
@@ -635,7 +635,7 @@ impl<T> RingBuf<T> {
     /// assert!(v.is_empty());
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain(&mut self) -> Drain<T> {
         Drain {
@@ -876,7 +876,7 @@ impl<T> RingBuf<T> {
     /// buf.push_back(10);
     /// assert_eq!(buf.swap_back_remove(1), Some(99));
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "the naming of this function may be altered")]
     pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
         let length = self.len();
@@ -909,7 +909,7 @@ impl<T> RingBuf<T> {
     /// buf.push_back(20i);
     /// assert_eq!(buf.swap_front_remove(3), Some(99));
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "the naming of this function may be altered")]
     pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
         let length = self.len();
@@ -1310,7 +1310,7 @@ impl<T: Clone> RingBuf<T> {
     ///     assert_eq!(a, b);
     /// }
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
     pub fn resize(&mut self, new_len: uint, value: T) {
         let len = self.len();
@@ -1500,7 +1500,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
 /// A draining RingBuf iterator
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "matches collection reform specification, waiting for dust to settle")]
 pub struct Drain<'a, T: 'a> {
     inner: &'a mut RingBuf<T>,
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 45537746baa..6765eda4cb7 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -166,7 +166,7 @@ pub trait SliceExt {
     /// assert_eq!(num_moved, 3);
     /// assert!(a == [6i, 7, 8, 4, 5]);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "uncertain about this API approach")]
     fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
 
@@ -176,7 +176,7 @@ pub trait SliceExt {
     /// original slice (i.e. when `end > self.len()`) or when `start > end`.
     ///
     /// Slicing with `start` equal to `end` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice(&self, start: uint, end: uint) -> &[Self::Item];
 
@@ -185,7 +185,7 @@ pub trait SliceExt {
     /// Panics when `start` is strictly greater than the length of the original slice.
     ///
     /// Slicing from `self.len()` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice_from(&self, start: uint) -> &[Self::Item];
 
@@ -194,7 +194,7 @@ pub trait SliceExt {
     /// Panics when `end` is strictly greater than the length of the original slice.
     ///
     /// Slicing to `0` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice_to(&self, end: uint) -> &[Self::Item];
 
@@ -288,11 +288,11 @@ pub trait SliceExt {
     fn first(&self) -> Option<&Self::Item>;
 
     /// Returns all but the first element of a slice.
-    #[unstable(feature = "unnamed_feature", reason = "likely to be renamed")]
+    #[unstable(feature = "collections", reason = "likely to be renamed")]
     fn tail(&self) -> &[Self::Item];
 
     /// Returns all but the last element of a slice.
-    #[unstable(feature = "unnamed_feature", reason = "likely to be renamed")]
+    #[unstable(feature = "collections", reason = "likely to be renamed")]
     fn init(&self) -> &[Self::Item];
 
     /// Returns the last element of a slice, or `None` if it is empty.
@@ -388,7 +388,7 @@ pub trait SliceExt {
     /// original slice (i.e. when `end > self.len()`) or when `start > end`.
     ///
     /// Slicing with `start` equal to `end` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
 
@@ -397,7 +397,7 @@ pub trait SliceExt {
     /// Panics when `start` is strictly greater than the length of the original slice.
     ///
     /// Slicing from `self.len()` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
 
@@ -406,7 +406,7 @@ pub trait SliceExt {
     /// Panics when `end` is strictly greater than the length of the original slice.
     ///
     /// Slicing to `0` yields an empty slice.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
 
@@ -419,12 +419,12 @@ pub trait SliceExt {
     fn first_mut(&mut self) -> Option<&mut Self::Item>;
 
     /// Returns all but the first element of a mutable slice
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "likely to be renamed or removed")]
     fn tail_mut(&mut self) -> &mut [Self::Item];
 
     /// Returns all but the last element of a mutable slice
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "likely to be renamed or removed")]
     fn init_mut(&mut self) -> &mut [Self::Item];
 
@@ -577,7 +577,7 @@ pub trait SliceExt {
     /// assert_eq!(Some(vec![1i, 3, 2]), perms.next());
     /// assert_eq!(Some(vec![3i, 1, 2]), perms.next());
     /// ```
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone;
 
     /// Copies as many elements from `src` as it can into `self` (the
@@ -597,7 +597,7 @@ pub trait SliceExt {
     /// assert!(dst.clone_from_slice(&src2) == 3);
     /// assert!(dst == [3i, 4, 5]);
     /// ```
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
 
     /// Sorts the slice, in place.
@@ -663,7 +663,7 @@ pub trait SliceExt {
     /// let b: &mut [_] = &mut [1i, 0, 2];
     /// assert!(v == b);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "uncertain if this merits inclusion in std")]
     fn next_permutation(&mut self) -> bool where Self::Item: Ord;
 
@@ -683,16 +683,16 @@ pub trait SliceExt {
     /// let b: &mut [_] = &mut [0i, 1, 2];
     /// assert!(v == b);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "uncertain if this merits inclusion in std")]
     fn prev_permutation(&mut self) -> bool where Self::Item: Ord;
 
     /// Find the first index containing a matching value.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
 
     /// Find the last index containing a matching value.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
 
     /// Return true if the slice contains an element with the given value.
@@ -708,7 +708,7 @@ pub trait SliceExt {
     fn ends_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
 
     /// Convert `self` into a vector without clones or allocation.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     fn into_vec(self: Box<Self>) -> Vec<Self::Item>;
 }
 
@@ -1000,7 +1000,7 @@ impl<T> SliceExt for [T] {
 ////////////////////////////////////////////////////////////////////////////////
 // Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "unnamed_feature", reason = "U should be an associated type")]
+#[unstable(feature = "collections", reason = "U should be an associated type")]
 /// An extension trait for concatenating slices
 pub trait SliceConcatExt<T: ?Sized, U> {
     /// Flattens a slice of `T` into a single value `U`.
@@ -1045,7 +1045,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
 ///
 /// The last generated swap is always (0, 1), and it returns the
 /// sequence to its initial order.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 #[derive(Clone)]
 pub struct ElementSwaps {
     sdir: Vec<SizeDirection>,
@@ -1057,7 +1057,7 @@ pub struct ElementSwaps {
 
 impl ElementSwaps {
     /// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     pub fn new(length: uint) -> ElementSwaps {
         // Initialize `sdir` with a direction that position should move in
         // (all negative at the beginning) and the `size` of the
@@ -1074,17 +1074,17 @@ impl ElementSwaps {
 // Standard trait implementations for slices
 ////////////////////////////////////////////////////////////////////////////////
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl<T> BorrowFrom<Vec<T>> for [T] {
     fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl<T> BorrowFromMut<Vec<T>> for [T] {
     fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl<T: Clone> ToOwned<Vec<T>> for [T] {
     fn to_owned(&self) -> Vec<T> { self.to_vec() }
 }
@@ -1166,13 +1166,13 @@ impl Iterator for ElementSwaps {
 /// swap applied.
 ///
 /// Generates even and odd permutations alternately.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct Permutations<T> {
     swaps: ElementSwaps,
     v: Vec<T>,
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl<T: Clone> Iterator for Permutations<T> {
     type Item = Vec<T>;
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index db5aa166674..57db5d6decf 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -165,7 +165,7 @@ enum DecompositionType {
 /// External iterator for a string's decomposition's characters.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct Decompositions<'a> {
     kind: DecompositionType,
     iter: Chars<'a>,
@@ -255,7 +255,7 @@ enum RecompositionState {
 /// External iterator for a string's recomposition's characters.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct Recompositions<'a> {
     iter: Decompositions<'a>,
     state: RecompositionState,
@@ -352,7 +352,7 @@ impl<'a> Iterator for Recompositions<'a> {
 /// External iterator for a string's UTF16 codeunits.
 /// Use with the `std::iter` module.
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct Utf16Units<'a> {
     encoder: Utf16Encoder<Chars<'a>>
 }
@@ -384,12 +384,12 @@ macro_rules! utf8_acc_cont_byte {
     ($ch:expr, $byte:expr) => (($ch << 6) | ($byte & 63u8) as u32)
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl BorrowFrom<String> for str {
     fn borrow_from(owned: &String) -> &str { &owned[] }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "collections", reason = "trait is unstable")]
 impl ToOwned<String> for str {
     fn to_owned(&self) -> String {
         unsafe {
@@ -410,14 +410,14 @@ Section: Trait implementations
 #[stable(feature = "grandfathered", since = "1.0.0")]
 pub trait StrExt: Index<FullRange, Output = str> {
     /// Escapes each char in `s` with `char::escape_default`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "return type may change to be an iterator")]
     fn escape_default(&self) -> String {
         self.chars().flat_map(|c| c.escape_default()).collect()
     }
 
     /// Escapes each char in `s` with `char::escape_unicode`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "return type may change to be an iterator")]
     fn escape_unicode(&self) -> String {
         self.chars().flat_map(|c| c.escape_unicode()).collect()
@@ -463,7 +463,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// Returns an iterator over the string in Unicode Normalization Form D
     /// (canonical decomposition).
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
     fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
         Decompositions {
@@ -477,7 +477,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// Returns an iterator over the string in Unicode Normalization Form KD
     /// (compatibility decomposition).
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
     fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
         Decompositions {
@@ -491,7 +491,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// An Iterator over the string in Unicode Normalization Form C
     /// (canonical decomposition followed by canonical composition).
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
     fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
         Recompositions {
@@ -506,7 +506,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// An Iterator over the string in Unicode Normalization Form KC
     /// (compatibility decomposition followed by canonical composition).
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
     fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
         Recompositions {
@@ -545,7 +545,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```rust
     /// assert!("hello".contains_char('e'));
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "might get removed in favour of a more generic contains()")]
     fn contains_char<P: CharEq>(&self, pat: P) -> bool {
         core_str::StrExt::contains_char(&self[], pat)
@@ -658,7 +658,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').rev().collect();
     /// assert_eq!(v, vec!["leopard", "tiger", "", "lion"]);
     /// ```
-    #[unstable(feature = "unnamed_feature", reason = "might get removed")]
+    #[unstable(feature = "collections", reason = "might get removed")]
     fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
         core_str::StrExt::split_terminator(&self[], pat)
     }
@@ -704,7 +704,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
     /// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "might have its iterator type changed")]
     fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
         core_str::StrExt::match_indices(&self[], pat)
@@ -721,7 +721,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// let v: Vec<&str> = "1abcabc2".split_str("abc").collect();
     /// assert_eq!(v, vec!["1", "", "2"]);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "might get removed in the future in favor of a more generic split()")]
     fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
         core_str::StrExt::split_str(&self[], pat)
@@ -789,7 +789,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// // byte 100 is outside the string
     /// // s.slice(3, 100);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "use slice notation [a..b] instead")]
     fn slice(&self, begin: uint, end: uint) -> &str {
         core_str::StrExt::slice(&self[], begin, end)
@@ -803,7 +803,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// out of bounds.
     ///
     /// See also `slice`, `slice_to` and `slice_chars`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "use slice notation [a..] instead")]
     fn slice_from(&self, begin: uint) -> &str {
         core_str::StrExt::slice_from(&self[], begin)
@@ -818,7 +818,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// out of bounds.
     ///
     /// See also `slice`, `slice_from` and `slice_chars`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "use slice notation [..a] instead")]
     fn slice_to(&self, end: uint) -> &str {
         core_str::StrExt::slice_to(&self[], end)
@@ -847,7 +847,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// assert_eq!(s.slice_chars(0, 4), "Löwe");
     /// assert_eq!(s.slice_chars(5, 7), "老虎");
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "may have yet to prove its worth")]
     fn slice_chars(&self, begin: uint, end: uint) -> &str {
         core_str::StrExt::slice_chars(&self[], begin, end)
@@ -971,7 +971,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// // third byte of `老`
     /// assert!(!s.is_char_boundary(8));
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
     fn is_char_boundary(&self, index: uint) -> bool {
         core_str::StrExt::is_char_boundary(&self[], index)
@@ -1030,7 +1030,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     ///
     /// If `i` is greater than or equal to the length of the string.
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
     fn char_range_at(&self, start: uint) -> CharRange {
         core_str::StrExt::char_range_at(&self[], start)
@@ -1046,7 +1046,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     ///
     /// If `i` is greater than the length of the string.
     /// If `i` is not an index following a valid UTF-8 character.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
     fn char_range_at_reverse(&self, start: uint) -> CharRange {
         core_str::StrExt::char_range_at_reverse(&self[], start)
@@ -1067,7 +1067,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     ///
     /// If `i` is greater than or equal to the length of the string.
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
     fn char_at(&self, i: uint) -> char {
         core_str::StrExt::char_at(&self[], i)
@@ -1079,7 +1079,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     ///
     /// If `i` is greater than the length of the string.
     /// If `i` is not an index following a valid UTF-8 character.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
     fn char_at_reverse(&self, i: uint) -> char {
         core_str::StrExt::char_at_reverse(&self[], i)
@@ -1172,7 +1172,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// assert_eq!(s.find_str("老虎 L"), Some(6));
     /// assert_eq!(s.find_str("muffin man"), None);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "might get removed in favor of a more generic find in the future")]
     fn find_str(&self, needle: &str) -> Option<uint> {
         core_str::StrExt::find_str(&self[], needle)
@@ -1196,7 +1196,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// assert_eq!(c, 'ö');
     /// assert_eq!(s2, "we 老虎 Léopard");
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "awaiting conventions about shifting and slices")]
     fn slice_shift_char(&self) -> Option<(char, &str)> {
         core_str::StrExt::slice_shift_char(&self[])
@@ -1216,7 +1216,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// assert!(string.subslice_offset(lines[1]) == 2); // &"b"
     /// assert!(string.subslice_offset(lines[2]) == 4); // &"c"
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "awaiting convention about comparability of arbitrary slices")]
     fn subslice_offset(&self, inner: &str) -> uint {
         core_str::StrExt::subslice_offset(&self[], inner)
@@ -1234,7 +1234,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     }
 
     /// Return an iterator of `u16` over the string encoded as UTF-16.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
     fn utf16_units(&self) -> Utf16Units {
         Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
@@ -1276,7 +1276,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// assert_eq!("j".parse::<u32>(), None);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this method was just created")]
     fn parse<F: FromStr>(&self) -> Option<F> {
         core_str::StrExt::parse(&self[])
@@ -1301,7 +1301,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
     /// assert_eq!(gr2.as_slice(), b);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
     fn graphemes(&self, is_extended: bool) -> Graphemes {
         UnicodeStr::graphemes(&self[], is_extended)
@@ -1317,7 +1317,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
     /// assert_eq!(gr_inds.as_slice(), b);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
     fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
         UnicodeStr::grapheme_indices(&self[], is_extended)
@@ -1348,7 +1348,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
     /// recommends that these characters be treated as 1 column (i.e.,
     /// `is_cjk` = `false`) if the locale is unknown.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
     fn width(&self, is_cjk: bool) -> uint {
         UnicodeStr::width(&self[], is_cjk)
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 3fe4d99ee18..86adf89b749 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -92,7 +92,7 @@ impl String {
     /// assert_eq!(s.as_slice(), "hello");
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "needs investigation to see if to_string() can match perf")]
     pub fn from_str(string: &str) -> String {
         String { vec: ::slice::SliceExt::to_vec(string.as_bytes()) }
@@ -725,7 +725,7 @@ impl<'a> FromIterator<&'a str> for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "waiting on Extend stabilization")]
 impl Extend<char> for String {
     fn extend<I:Iterator<Item=char>>(&mut self, mut iterator: I) {
@@ -737,7 +737,7 @@ impl Extend<char> for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "waiting on Extend stabilization")]
 impl<'a> Extend<&'a str> for String {
     fn extend<I: Iterator<Item=&'a str>>(&mut self, mut iterator: I) {
@@ -798,7 +798,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
     fn ne(&self, other: &CowString<'a>) -> bool { PartialEq::ne(&**self, &**other) }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Str stabilization")]
+#[unstable(feature = "collections", reason = "waiting on Str stabilization")]
 impl Str for String {
     #[inline]
     #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -824,7 +824,7 @@ impl fmt::String for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on fmt stabilization")]
+#[unstable(feature = "collections", reason = "waiting on fmt stabilization")]
 impl fmt::Show for String {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -832,7 +832,7 @@ impl fmt::Show for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Hash stabilization")]
+#[unstable(feature = "collections", reason = "waiting on Hash stabilization")]
 impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
     #[inline]
     fn hash(&self, hasher: &mut H) {
@@ -840,7 +840,7 @@ impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "recent addition, needs more experience")]
 impl<'a> Add<&'a str> for String {
     type Output = String;
@@ -892,7 +892,7 @@ impl ops::Deref for String {
 }
 
 /// Wrapper type providing a `&String` reference via `Deref`.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct DerefString<'a> {
     x: DerefVec<'a, u8>
 }
@@ -920,7 +920,7 @@ impl<'a> Deref for DerefString<'a> {
 /// let string = as_string("foo").clone();
 /// string_consumer(string);
 /// ```
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
     DerefString { x: as_vec(x.as_bytes()) }
 }
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 32ff3e37c83..cdf04d18a9f 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -255,7 +255,7 @@ impl<T> Vec<T> {
     /// owned by the returned `Vec<T>`. The elements of the buffer are copied into the vector
     /// without cloning, as if `ptr::read()` were called on them.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "may be better expressed via composition")]
     pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
         let mut dst = Vec::with_capacity(elts);
@@ -377,7 +377,7 @@ impl<T> Vec<T> {
     /// Note that this will drop any excess capacity. Calling this and
     /// converting back to a vector with `into_vec()` is equivalent to calling
     /// `shrink_to_fit()`.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     pub fn into_boxed_slice(mut self) -> Box<[T]> {
         self.shrink_to_fit();
         unsafe {
@@ -697,7 +697,7 @@ impl<T> Vec<T> {
     /// assert_eq!(vec2, vec![]);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "new API, waiting for dust to settle")]
     pub fn append(&mut self, other: &mut Self) {
         if mem::size_of::<T>() == 0 {
@@ -734,7 +734,7 @@ impl<T> Vec<T> {
     /// assert!(v.is_empty());
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
         unsafe {
@@ -817,7 +817,7 @@ impl<T> Vec<T> {
     /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
     /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice());
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "API may change to provide stronger guarantees")]
     pub fn map_in_place<U, F>(self, mut f: F) -> Vec<U> where F: FnMut(T) -> U {
         // FIXME: Assert statically that the types `T` and `U` have the same
@@ -1012,7 +1012,7 @@ impl<T: Clone> Vec<T> {
     /// vec.resize(2, 0);
     /// assert_eq!(vec, vec![1, 2]);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting for dust to settle")]
     pub fn resize(&mut self, new_len: uint, value: T) {
         let len = self.len();
@@ -1037,7 +1037,7 @@ impl<T: Clone> Vec<T> {
     /// assert_eq!(vec, vec![1, 2, 3, 4]);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "likely to be replaced by a more optimized extend")]
     pub fn push_all(&mut self, other: &[T]) {
         self.reserve(other.len());
@@ -1206,7 +1206,7 @@ unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
 // Common trait implementations for Vec
 ////////////////////////////////////////////////////////////////////////////////
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 impl<T:Clone> Clone for Vec<T> {
     fn clone(&self) -> Vec<T> { ::slice::SliceExt::to_vec(self.as_slice()) }
 
@@ -1235,7 +1235,7 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Index stability")]
+#[unstable(feature = "collections", reason = "waiting on Index stability")]
 impl<T> Index<uint> for Vec<T> {
     type Output = T;
 
@@ -1339,7 +1339,7 @@ impl<T> FromIterator<T> for Vec<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Extend stability")]
+#[unstable(feature = "collections", reason = "waiting on Extend stability")]
 impl<T> Extend<T> for Vec<T> {
     #[inline]
     fn extend<I: Iterator<Item=T>>(&mut self, mut iterator: I) {
@@ -1414,7 +1414,7 @@ macro_rules! impl_eq_for_cowvec {
 impl_eq_for_cowvec! { &'b [B] }
 impl_eq_for_cowvec! { &'b mut [B] }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "waiting on PartialOrd stability")]
 impl<T: PartialOrd> PartialOrd for Vec<T> {
     #[inline]
@@ -1423,10 +1423,10 @@ impl<T: PartialOrd> PartialOrd for Vec<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Eq stability")]
+#[unstable(feature = "collections", reason = "waiting on Eq stability")]
 impl<T: Eq> Eq for Vec<T> {}
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Ord stability")]
+#[unstable(feature = "collections", reason = "waiting on Ord stability")]
 impl<T: Ord> Ord for Vec<T> {
     #[inline]
     fn cmp(&self, other: &Vec<T>) -> Ordering {
@@ -1457,7 +1457,7 @@ impl<T> AsSlice<T> for Vec<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "recent addition, needs more experience")]
 impl<'a, T: Clone> Add<&'a [T]> for Vec<T> {
     type Output = Vec<T>;
@@ -1494,7 +1494,7 @@ impl<T> Default for Vec<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "waiting on Show stability")]
+#[unstable(feature = "collections", reason = "waiting on Show stability")]
 impl<T: fmt::Show> fmt::Show for Vec<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Show::fmt(self.as_slice(), f)
@@ -1512,12 +1512,12 @@ impl<'a> fmt::Writer for Vec<u8> {
 // Clone-on-write
 ////////////////////////////////////////////////////////////////////////////////
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "unclear how valuable this alias is")]
 /// A clone-on-write vector
 pub type CowVec<'a, T> = Cow<'a, Vec<T>, [T]>;
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 impl<'a, T> FromIterator<T> for CowVec<'a, T> where T: Clone {
     fn from_iter<I: Iterator<Item=T>>(it: I) -> CowVec<'a, T> {
         Cow::Owned(FromIterator::from_iter(it))
@@ -1555,7 +1555,7 @@ unsafe impl<T: Sync> Sync for IntoIter<T> { }
 impl<T> IntoIter<T> {
     #[inline]
     /// Drops all items that have not yet been moved and returns the empty vector.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "collections")]
     pub fn into_inner(mut self) -> Vec<T> {
         unsafe {
             for _x in self { }
@@ -1646,7 +1646,7 @@ impl<T> Drop for IntoIter<T> {
 
 /// An iterator that drains a vector.
 #[unsafe_no_drop_flag]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "collections",
            reason = "recently added as part of collections reform 2")]
 pub struct Drain<'a, T> {
     ptr: *const T,
@@ -1735,13 +1735,13 @@ impl<'a, T> Drop for Drain<'a, T> {
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Wrapper type providing a `&Vec<T>` reference via `Deref`.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct DerefVec<'a, T> {
     x: Vec<T>,
     l: ContravariantLifetime<'a>
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 impl<'a, T> Deref for DerefVec<'a, T> {
     type Target = Vec<T>;
 
@@ -1761,7 +1761,7 @@ impl<'a, T> Drop for DerefVec<'a, T> {
 }
 
 /// Convert a slice to a wrapper type providing a `&Vec<T>` reference.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> {
     unsafe {
         DerefVec {
diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
index ea95d91349e..93af9a10b4c 100644
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@@ -310,7 +310,7 @@ impl<V> VecMap<V> {
     ///
     /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
         fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
@@ -700,7 +700,7 @@ pub struct IntoIter<V> {
     fn((uint, Option<V>)) -> Option<(uint, V)>>
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 pub struct Drain<'a, V> {
     iter: FilterMap<
     (uint, Option<V>),
@@ -709,7 +709,7 @@ pub struct Drain<'a, V> {
     fn((uint, Option<V>)) -> Option<(uint, V)>>
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 impl<'a, V> Iterator for Drain<'a, V> {
     type Item = (uint, V);
 
@@ -717,7 +717,7 @@ impl<'a, V> Iterator for Drain<'a, V> {
     fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "collections")]
 impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
     fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
 }
diff --git a/src/libcore/any.rs b/src/libcore/any.rs
index 098e96ef4cb..259c749c7c1 100644
--- a/src/libcore/any.rs
+++ b/src/libcore/any.rs
@@ -89,7 +89,7 @@ use intrinsics;
 #[stable(feature = "grandfathered", since = "1.0.0")]
 pub trait Any: 'static {
     /// Get the `TypeId` of `self`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "this method will likely be replaced by an associated static")]
     fn get_type_id(&self) -> TypeId;
 }
@@ -177,7 +177,7 @@ impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been
     /// instantiated with
     #[cfg(not(stage0))]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "may grow a `Reflect` bound soon via marker traits")]
     pub fn of<T: ?Sized + 'static>() -> TypeId {
         TypeId {
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index c8a26ff8e9b..3d654907348 100644
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -12,7 +12,7 @@
 //! up to a certain length. Eventually we should able to generalize
 //! to all lengths.
 
-#![unstable(feature = "unnamed_feature")] // not yet reviewed
+#![unstable(feature = "core")] // not yet reviewed
 
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
@@ -39,7 +39,7 @@ macro_rules! array_impls {
                 }
             }
 
-            #[unstable(feature = "unnamed_feature",
+            #[unstable(feature = "core",
                        reason = "waiting for Show to stabilize")]
             impl<T:fmt::Show> fmt::Show for [T; $N] {
                 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
diff --git a/src/libcore/atomic.rs b/src/libcore/atomic.rs
index 44b1f2e4560..e4e6fcd3afc 100644
--- a/src/libcore/atomic.rs
+++ b/src/libcore/atomic.rs
@@ -1036,7 +1036,7 @@ pub fn fence(order: Ordering) {
     }
 }
 
-#[deprecated(feature = "unnamed_feature", since = "1.0.0",
+#[deprecated(feature = "core", since = "1.0.0",
              reason = "renamed to AtomicIsize")]
 #[allow(missing_docs)]
 pub struct AtomicInt {
@@ -1045,7 +1045,7 @@ pub struct AtomicInt {
 
 unsafe impl Sync for AtomicInt {}
 
-#[deprecated(feature = "unnamed_feature", since = "1.0.0",
+#[deprecated(feature = "core", since = "1.0.0",
              reason = "renamed to AtomicUsize")]
 #[allow(missing_docs)]
 pub struct AtomicUint {
@@ -1054,12 +1054,12 @@ pub struct AtomicUint {
 
 unsafe impl Sync for AtomicUint {}
 
-#[deprecated(feature = "unnamed_feature", since = "1.0.0",
+#[deprecated(feature = "core", since = "1.0.0",
              reason = "use ATOMIC_ISIZE_INIT instead")]
 #[allow(missing_docs, deprecated)]
 pub const ATOMIC_INT_INIT: AtomicInt =
         AtomicInt { v: UnsafeCell { value: 0 } };
-#[deprecated(feature = "unnamed_feature", since = "1.0.0",
+#[deprecated(feature = "core", since = "1.0.0",
              reason = "use ATOMIC_USIZE_INIT instead")]
 #[allow(missing_docs, deprecated)]
 pub const ATOMIC_UINT_INIT: AtomicUint =
diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs
index 998b2e1b608..0acff877927 100644
--- a/src/libcore/borrow.rs
+++ b/src/libcore/borrow.rs
@@ -42,7 +42,7 @@
 //! is desired, `to_mut` will obtain a mutable references to an owned
 //! value, cloning if necessary.
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "core",
             reason = "recently added as part of collections reform")]
 
 use clone::Clone;
diff --git a/src/libcore/cell.rs b/src/libcore/cell.rs
index 854a68211e4..dfb8d9be81b 100644
--- a/src/libcore/cell.rs
+++ b/src/libcore/cell.rs
@@ -201,7 +201,7 @@ impl<T:Copy> Cell<T> {
     ///
     /// This function is `unsafe` because `UnsafeCell`'s field is public.
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
         &self.value
     }
@@ -271,7 +271,7 @@ impl<T> RefCell<T> {
     /// immutable borrows can be taken out at the same time.
     ///
     /// Returns `None` if the value is currently mutably borrowed.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")]
+    #[unstable(feature = "core", reason = "may be renamed or removed")]
     pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> {
         match BorrowRef::new(&self.borrow) {
             Some(b) => Some(Ref { _value: unsafe { &*self.value.get() }, _borrow: b }),
@@ -301,7 +301,7 @@ impl<T> RefCell<T> {
     /// cannot be borrowed while this borrow is active.
     ///
     /// Returns `None` if the value is currently borrowed.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed or removed")]
+    #[unstable(feature = "core", reason = "may be renamed or removed")]
     pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> {
         match BorrowRefMut::new(&self.borrow) {
             Some(b) => Some(RefMut { _value: unsafe { &mut *self.value.get() }, _borrow: b }),
@@ -331,7 +331,7 @@ impl<T> RefCell<T> {
     ///
     /// This function is `unsafe` because `UnsafeCell`'s field is public.
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T> {
         &self.value
     }
@@ -423,7 +423,7 @@ impl<'b, T> Deref for Ref<'b, T> {
 ///
 /// A `Clone` implementation would interfere with the widespread
 /// use of `r.borrow().clone()` to clone the contents of a `RefCell`.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be moved to a method, pending language changes")]
 pub fn clone_ref<'b, T:Clone>(orig: &Ref<'b, T>) -> Ref<'b, T> {
     Ref {
@@ -528,7 +528,7 @@ pub struct UnsafeCell<T> {
     ///
     /// This field should not be accessed directly, it is made public for static
     /// initializers.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub value: T,
 }
 
diff --git a/src/libcore/char.rs b/src/libcore/char.rs
index 49faefde118..e0b3cb1c1ec 100644
--- a/src/libcore/char.rs
+++ b/src/libcore/char.rs
@@ -92,7 +92,7 @@ pub fn from_u32(i: u32) -> Option<char> {
 /// Panics if given an `radix` > 36.
 ///
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub fn from_digit(num: uint, radix: uint) -> Option<char> {
     if radix > 36 {
         panic!("from_digit: radix is too high (maximum 36)");
@@ -126,7 +126,7 @@ pub trait CharExt {
     /// # Panics
     ///
     /// Panics if given a radix > 36.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn is_digit(self, radix: uint) -> bool;
 
@@ -141,7 +141,7 @@ pub trait CharExt {
     /// # Panics
     ///
     /// Panics if given a radix outside the range [0..36].
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn to_digit(self, radix: uint) -> Option<uint>;
 
@@ -198,13 +198,13 @@ pub trait CharExt {
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
 impl CharExt for char {
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn is_digit(self, radix: uint) -> bool {
         self.to_digit(radix).is_some()
     }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn to_digit(self, radix: uint) -> Option<uint> {
         if radix > 36 {
@@ -260,7 +260,7 @@ impl CharExt for char {
     }
 
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> {
         // Marked #[inline] to allow llvm optimizing it away
@@ -289,7 +289,7 @@ impl CharExt for char {
     }
 
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> {
         // Marked #[inline] to allow llvm optimizing it away
@@ -320,7 +320,7 @@ pub struct EscapeUnicode {
 }
 
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 enum EscapeUnicodeState {
     Backslash,
     Type,
@@ -382,7 +382,7 @@ pub struct EscapeDefault {
 }
 
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 enum EscapeDefaultState {
     Backslash(char),
     Char(char),
diff --git a/src/libcore/clone.rs b/src/libcore/clone.rs
index 243a30c6737..360bcdddc85 100644
--- a/src/libcore/clone.rs
+++ b/src/libcore/clone.rs
@@ -36,7 +36,7 @@ pub trait Clone : Sized {
     /// but can be overridden to reuse the resources of `a` to avoid unnecessary
     /// allocations.
     #[inline(always)]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "this function is rarely used")]
     fn clone_from(&mut self, source: &Self) {
         *self = source.clone()
@@ -82,7 +82,7 @@ clone_impl! { char }
 
 macro_rules! extern_fn_clone {
     ($($A:ident),*) => (
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "this may not be sufficient for fns with region parameters")]
         impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
             /// Return a copy of a function pointer
diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs
index 079293aa502..8a2188f543a 100644
--- a/src/libcore/cmp.rs
+++ b/src/libcore/cmp.rs
@@ -290,7 +290,7 @@ pub fn max<T: Ord>(v1: T, v2: T) -> T {
 ///
 /// Returns the first argument if the comparison determines them to be equal.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
     match v1.partial_cmp(&v2) {
         Some(Less) | Some(Equal) => Some(v1),
@@ -303,7 +303,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 ///
 /// Returns the first argument if the comparison determines them to be equal.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
     match v1.partial_cmp(&v2) {
         Some(Less) => Some(v2),
diff --git a/src/libcore/finally.rs b/src/libcore/finally.rs
index fdc659a300b..2bd90e7c964 100644
--- a/src/libcore/finally.rs
+++ b/src/libcore/finally.rs
@@ -30,7 +30,7 @@
 //! })
 //! ```
 
-#![deprecated(feature = "unnamed_feature", since = "1.0.0",
+#![deprecated(feature = "core", since = "1.0.0",
               reason = "It is unclear if this module is more robust than implementing \
                         Drop on a custom type, and this module is being removed with no \
                         replacement. Use a custom Drop implementation to regain existing \
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index 532071a8600..1503d585887 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -36,7 +36,7 @@ mod num;
 mod float;
 pub mod rt;
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "core and I/O reconciliation may alter this definition")]
 /// The type returned by formatter methods.
 pub type Result = result::Result<(), Error>;
@@ -46,7 +46,7 @@ pub type Result = result::Result<(), Error>;
 /// This type does not support transmission of an error other than that an error
 /// occurred. Any extra information must be arranged to be transmitted through
 /// some other means.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "core and I/O reconciliation may alter this definition")]
 #[derive(Copy)]
 pub struct Error;
@@ -60,7 +60,7 @@ pub struct Error;
 /// This trait should generally not be implemented by consumers of the standard
 /// library. The `write!` macro accepts an instance of `io::Writer`, and the
 /// `io::Writer` trait is favored over implementing this trait.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "waiting for core and I/O reconciliation")]
 pub trait Writer {
     /// Writes a slice of bytes into this writer, returning whether the write
@@ -104,7 +104,7 @@ pub trait Writer {
 /// A struct to represent both where to emit formatting strings to and how they
 /// should be formatted. A mutable version of this is passed to all formatting
 /// traits.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "name may change and implemented traits are also unstable")]
 pub struct Formatter<'a> {
     flags: uint,
@@ -127,7 +127,7 @@ enum Void {}
 /// family of functions. It contains a function to format the given value. At
 /// compile time it is ensured that the function and the value have the correct
 /// types, and then this struct is used to canonicalize arguments to one type.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "implementation detail of the `format_args!` macro")]
 #[derive(Copy)]
 pub struct Argument<'a> {
@@ -167,7 +167,7 @@ impl<'a> Arguments<'a> {
     /// When using the format_args!() macro, this function is used to generate the
     /// Arguments structure.
     #[doc(hidden)] #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "implementation detail of the `format_args!` macro")]
     pub fn new(pieces: &'a [&'a str],
                args: &'a [Argument<'a>]) -> Arguments<'a> {
@@ -185,7 +185,7 @@ impl<'a> Arguments<'a> {
     /// created with `argumentuint`. However, failing to do so doesn't cause
     /// unsafety, but will ignore invalid .
     #[doc(hidden)] #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "implementation detail of the `format_args!` macro")]
     pub fn with_placeholders(pieces: &'a [&'a str],
                              fmt: &'a [rt::Argument],
@@ -236,7 +236,7 @@ impl<'a> String for Arguments<'a> {
 
 /// Format trait for the `:?` format. Useful for debugging, most all types
 /// should implement this.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait Show {
     /// Formats the value using the given formatter.
@@ -245,7 +245,7 @@ pub trait Show {
 
 /// When a value can be semantically expressed as a String, this trait may be
 /// used. It corresponds to the default format, `{}`.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait String {
     /// Formats the value using the given formatter.
@@ -254,7 +254,7 @@ pub trait String {
 
 
 /// Format trait for the `o` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait Octal {
     /// Formats the value using the given formatter.
@@ -262,7 +262,7 @@ pub trait Octal {
 }
 
 /// Format trait for the `b` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait Binary {
     /// Formats the value using the given formatter.
@@ -270,7 +270,7 @@ pub trait Binary {
 }
 
 /// Format trait for the `x` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait LowerHex {
     /// Formats the value using the given formatter.
@@ -278,7 +278,7 @@ pub trait LowerHex {
 }
 
 /// Format trait for the `X` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait UpperHex {
     /// Formats the value using the given formatter.
@@ -286,7 +286,7 @@ pub trait UpperHex {
 }
 
 /// Format trait for the `p` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait Pointer {
     /// Formats the value using the given formatter.
@@ -294,7 +294,7 @@ pub trait Pointer {
 }
 
 /// Format trait for the `e` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait LowerExp {
     /// Formats the value using the given formatter.
@@ -302,7 +302,7 @@ pub trait LowerExp {
 }
 
 /// Format trait for the `E` character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "I/O and core have yet to be reconciled")]
 pub trait UpperExp {
     /// Formats the value using the given formatter.
@@ -317,7 +317,7 @@ pub trait UpperExp {
 ///
 ///   * output - the buffer to write output to
 ///   * args - the precompiled arguments generated by `format_args!`
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "libcore and I/O have yet to be reconciled, and this is an \
                      implementation detail which should not otherwise be exported")]
 pub fn write(output: &mut Writer, args: Arguments) -> Result {
@@ -415,7 +415,7 @@ impl<'a> Formatter<'a> {
     ///
     /// This function will correctly account for the flags provided as well as
     /// the minimum width. It will not take precision into account.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "definition may change slightly over time")]
     pub fn pad_integral(&mut self,
                         is_positive: bool,
@@ -492,7 +492,7 @@ impl<'a> Formatter<'a> {
     ///               is longer than this length
     ///
     /// Notably this function ignored the `flag` parameters
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "definition may change slightly over time")]
     pub fn pad(&mut self, s: &str) -> Result {
         // Make sure there's a fast path up front
@@ -570,38 +570,38 @@ impl<'a> Formatter<'a> {
 
     /// Writes some data to the underlying buffer contained within this
     /// formatter.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "reconciling core and I/O may alter this definition")]
     pub fn write_str(&mut self, data: &str) -> Result {
         self.buf.write_str(data)
     }
 
     /// Writes some formatted information into this instance
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "reconciling core and I/O may alter this definition")]
     pub fn write_fmt(&mut self, fmt: Arguments) -> Result {
         write(self.buf, fmt)
     }
 
     /// Flags for formatting (packed version of rt::Flag)
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "return type may change and method was just created")]
     pub fn flags(&self) -> uint { self.flags }
 
     /// Character used as 'fill' whenever there is alignment
-    #[unstable(feature = "unnamed_feature", reason = "method was just created")]
+    #[unstable(feature = "core", reason = "method was just created")]
     pub fn fill(&self) -> char { self.fill }
 
     /// Flag indicating what form of alignment was requested
-    #[unstable(feature = "unnamed_feature", reason = "method was just created")]
+    #[unstable(feature = "core", reason = "method was just created")]
     pub fn align(&self) -> rt::Alignment { self.align }
 
     /// Optionally specified integer width that the output should be
-    #[unstable(feature = "unnamed_feature", reason = "method was just created")]
+    #[unstable(feature = "core", reason = "method was just created")]
     pub fn width(&self) -> Option<uint> { self.width }
 
     /// Optionally specified precision for numeric types
-    #[unstable(feature = "unnamed_feature", reason = "method was just created")]
+    #[unstable(feature = "core", reason = "method was just created")]
     pub fn precision(&self) -> Option<uint> { self.precision }
 }
 
@@ -614,7 +614,7 @@ impl Show for Error {
 /// This is a function which calls are emitted to by the compiler itself to
 /// create the Argument structures that are passed into the `format` function.
 #[doc(hidden)] #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "implementation detail of the `format_args!` macro")]
 pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
                        t: &'a T) -> Argument<'a> {
@@ -624,7 +624,7 @@ pub fn argument<'a, T>(f: fn(&T, &mut Formatter) -> Result,
 /// When the compiler determines that the type of an argument *must* be a uint
 /// (such as for width and precision), then it invokes this method.
 #[doc(hidden)] #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "implementation detail of the `format_args!` macro")]
 pub fn argumentuint<'a>(s: &'a uint) -> Argument<'a> {
     Argument::from_uint(s)
@@ -879,7 +879,7 @@ impl<T: Copy + Show> Show for Cell<T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<T: Show> Show for RefCell<T> {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match self.try_borrow() {
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 710446e42be..83397e5dc99 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -111,7 +111,7 @@ radix! { UpperHex, 16, "0x", x @  0 ...  9 => b'0' + x,
 
 /// A radix with in the range of `2..36`.
 #[derive(Clone, Copy, PartialEq)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may be renamed or move to a different module")]
 pub struct Radix {
     base: u8,
@@ -136,7 +136,7 @@ impl GenericRadix for Radix {
 }
 
 /// A helper type for formatting radixes.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may be renamed or move to a different module")]
 #[derive(Copy)]
 pub struct RadixFmt<T, R>(T, R);
@@ -149,7 +149,7 @@ pub struct RadixFmt<T, R>(T, R);
 /// use std::fmt::radix;
 /// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string());
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may be renamed or move to a different module")]
 pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
     RadixFmt(x, Radix::new(base))
diff --git a/src/libcore/fmt/rt.rs b/src/libcore/fmt/rt.rs
index 483d701c2c3..0b2c1efbc5d 100644
--- a/src/libcore/fmt/rt.rs
+++ b/src/libcore/fmt/rt.rs
@@ -14,7 +14,7 @@
 //! These definitions are similar to their `ct` equivalents, but differ in that
 //! these can be statically allocated and are slightly optimized for the runtime
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "core",
             reason = "implementation detail of the `format_args!` macro")]
 
 pub use self::Alignment::*;
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index f070b4e0610..5a4d2fffade 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -56,7 +56,7 @@
 //! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
 //! ```
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "hash",
             reason = "module was recently redesigned")]
 
 use prelude::*;
@@ -96,7 +96,7 @@ pub trait Hasher {
 
 /// A common bound on the `Hasher` parameter to `Hash` implementations in order
 /// to generically hash an aggregate.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "hash",
            reason = "this trait will likely be replaced by io::Writer")]
 #[allow(missing_docs)]
 pub trait Writer {
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 3957cba5a00..872b2d031f6 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -39,7 +39,7 @@
 //!   guaranteed to happen in order. This is the standard mode for working
 //!   with atomic types and is equivalent to Java's `volatile`.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
 #![allow(missing_docs)]
 
 use marker::Sized;
@@ -303,7 +303,7 @@ extern "rust-intrinsic" {
     ///     }
     /// }
     /// ```
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn copy_nonoverlapping_memory<T>(dst: *mut T, src: *const T, count: uint);
 
     /// Copies `count * size_of<T>` bytes from `src` to `dst`. The source
@@ -333,12 +333,12 @@ extern "rust-intrinsic" {
     /// }
     /// ```
     ///
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn copy_memory<T>(dst: *mut T, src: *const T, count: uint);
 
     /// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
     /// bytes of memory starting at `dst` to `c`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "uncertain about naming and semantics")]
     pub fn set_memory<T>(dst: *mut T, val: u8, count: uint);
 
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index d0e0b737419..fef11ecba18 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -564,7 +564,7 @@ pub trait IteratorExt: Iterator + Sized {
     /// assert_eq!(even, vec![2, 4]);
     /// assert_eq!(odd, vec![1, 3]);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "recently added as part of collections reform")]
     fn partition<B, F>(mut self, mut f: F) -> (B, B) where
         B: Default + Extend<Self::Item>,
@@ -760,7 +760,7 @@ pub trait IteratorExt: Iterator + Sized {
     /// let v = [1i, 1, 1, 1];
     /// assert!(v.iter().min_max() == MinMax(&1, &1));
     /// ```
-    #[unstable(feature = "unnamed_feature", reason = "return type may change")]
+    #[unstable(feature = "core", reason = "return type may change")]
     fn min_max(mut self) -> MinMaxResult<Self::Item> where Self::Item: Ord
     {
         let (mut min, mut max) = match self.next() {
@@ -817,7 +817,7 @@ pub trait IteratorExt: Iterator + Sized {
     /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "may want to produce an Ordering directly; see #15311")]
     fn max_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
         F: FnMut(&Self::Item) -> B,
@@ -847,7 +847,7 @@ pub trait IteratorExt: Iterator + Sized {
     /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "may want to produce an Ordering directly; see #15311")]
     fn min_by<B: Ord, F>(self, mut f: F) -> Option<Self::Item> where
         F: FnMut(&Self::Item) -> B,
@@ -887,7 +887,7 @@ pub trait IteratorExt: Iterator + Sized {
     ///
     /// Loops through the entire iterator, collecting the first component of
     /// each item into one new container, and the second component into another.
-    #[unstable(feature = "unnamed_feature", reason = "recent addition")]
+    #[unstable(feature = "core", reason = "recent addition")]
     fn unzip<A, B, FromA, FromB>(mut self) -> (FromA, FromB) where
         FromA: Default + Extend<A>,
         FromB: Default + Extend<B>,
@@ -920,7 +920,7 @@ pub trait IteratorExt: Iterator + Sized {
 
     /// Creates an iterator that clones the elements it yields. Useful for converting an
     /// Iterator<&T> to an Iterator<T>.
-    #[unstable(feature = "unnamed_feature", reason = "recent addition")]
+    #[unstable(feature = "core", reason = "recent addition")]
     fn cloned<T, D>(self) -> Cloned<Self> where
         Self: Iterator<Item=D>,
         D: Deref<Target=T>,
@@ -948,7 +948,7 @@ pub trait IteratorExt: Iterator + Sized {
     }
 
     /// Use an iterator to reverse a container in place.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "uncertain about placement or widespread use")]
     fn reverse_in_place<'a, T: 'a>(&mut self) where
         Self: Iterator<Item=&'a mut T> + DoubleEndedIterator
@@ -982,7 +982,7 @@ pub trait DoubleEndedIterator: Iterator {
 /// Calling `next()` or `next_back()` on a `RandomAccessIterator`
 /// reduces the indexable range accordingly. That is, `it.idx(1)` will become `it.idx(0)`
 /// after `it.next()` is called.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "not widely used, may be better decomposed into Index and ExactSizeIterator")]
 pub trait RandomAccessIterator: Iterator {
     /// Return the number of indexable elements. At most `std::uint::MAX`
@@ -1058,7 +1058,7 @@ impl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {
     fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Rev<I> where I: DoubleEndedIterator + RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint { self.iter.indexable() }
@@ -1093,7 +1093,7 @@ impl<'a, I> DoubleEndedIterator for ByRef<'a, I> where I: 'a + DoubleEndedIterat
 }
 
 /// A trait for iterators over elements which can be added together
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "needs to be re-evaluated as part of numerics reform")]
 pub trait AdditiveIterator<A> {
     /// Iterates over the entire iterator, summing up all the elements
@@ -1112,7 +1112,7 @@ pub trait AdditiveIterator<A> {
 
 macro_rules! impl_additive {
     ($A:ty, $init:expr) => {
-        #[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+        #[unstable(feature = "core", reason = "trait is experimental")]
         impl<T: Iterator<Item=$A>> AdditiveIterator<$A> for T {
             #[inline]
             fn sum(self) -> $A {
@@ -1135,7 +1135,7 @@ impl_additive! { f32,  0.0 }
 impl_additive! { f64,  0.0 }
 
 /// A trait for iterators over elements which can be multiplied together.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "needs to be re-evaluated as part of numerics reform")]
 pub trait MultiplicativeIterator<A> {
     /// Iterates over the entire iterator, multiplying all the elements
@@ -1157,7 +1157,7 @@ pub trait MultiplicativeIterator<A> {
 
 macro_rules! impl_multiplicative {
     ($A:ty, $init:expr) => {
-        #[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+        #[unstable(feature = "core", reason = "trait is experimental")]
         impl<T: Iterator<Item=$A>> MultiplicativeIterator<$A> for T {
             #[inline]
             fn product(self) -> $A {
@@ -1181,7 +1181,7 @@ impl_multiplicative! { f64,  1.0 }
 
 /// `MinMaxResult` is an enum returned by `min_max`. See `IteratorOrdExt::min_max` for more detail.
 #[derive(Clone, PartialEq, Show)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "unclear whether such a fine-grained result is widely useful")]
 pub enum MinMaxResult<T> {
     /// Empty iterator
@@ -1214,7 +1214,7 @@ impl<T: Clone> MinMaxResult<T> {
     /// let r = MinMax(1i,2i);
     /// assert_eq!(r.into_option(), Some((1,2)));
     /// ```
-    #[unstable(feature = "unnamed_feature", reason = "type is unstable")]
+    #[unstable(feature = "core", reason = "type is unstable")]
     pub fn into_option(self) -> Option<(T,T)> {
         match self {
             NoElements => None,
@@ -1225,7 +1225,7 @@ impl<T: Clone> MinMaxResult<T> {
 }
 
 /// An iterator that clones the elements of an underlying iterator
-#[unstable(feature = "unnamed_feature", reason = "recent addition")]
+#[unstable(feature = "core", reason = "recent addition")]
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
 #[derive(Clone)]
 pub struct Cloned<I> {
@@ -1299,7 +1299,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Cycle<I> where
     I: Clone + RandomAccessIterator,
 {
@@ -1384,7 +1384,7 @@ impl<T, A, B> DoubleEndedIterator for Chain<A, B> where
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<T, A, B> RandomAccessIterator for Chain<A, B> where
     A: RandomAccessIterator<Item=T>,
     B: RandomAccessIterator<Item=T>,
@@ -1476,7 +1476,7 @@ impl<T, U, A, B> DoubleEndedIterator for Zip<A, B> where
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<T, U, A, B> RandomAccessIterator for Zip<A, B> where
     A: RandomAccessIterator<Item=T>,
     B: RandomAccessIterator<Item=U>,
@@ -1558,7 +1558,7 @@ impl<A, B, I, F> DoubleEndedIterator for Map<A, B, I, F> where
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<A, B, I, F> RandomAccessIterator for Map<A, B, I, F> where
     I: RandomAccessIterator<Item=A>,
     F: FnMut(A) -> B,
@@ -1747,7 +1747,7 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint {
@@ -1973,7 +1973,7 @@ impl<I> Iterator for Skip<I> where I: Iterator {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Skip<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> uint {
@@ -2028,7 +2028,7 @@ impl<I> Iterator for Take<I> where I: Iterator{
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Take<I> where I: RandomAccessIterator{
     #[inline]
     fn indexable(&self) -> uint {
@@ -2241,7 +2241,7 @@ impl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {
 }
 
 // Allow RandomAccessIterators to be fused without affecting random-access behavior
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<I> RandomAccessIterator for Fuse<I> where I: RandomAccessIterator {
     #[inline]
     fn indexable(&self) -> uint {
@@ -2258,7 +2258,7 @@ impl<I> Fuse<I> {
     /// Resets the fuse such that the next call to .next() or .next_back() will
     /// call the underlying iterator again even if it previously returned None.
     #[inline]
-    #[unstable(feature = "unnamed_feature", reason = "seems marginal")]
+    #[unstable(feature = "core", reason = "seems marginal")]
     pub fn reset_fuse(&mut self) {
         self.done = false
     }
@@ -2327,7 +2327,7 @@ impl<A, I, F> DoubleEndedIterator for Inspect<A, I, F> where
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
     I: RandomAccessIterator<Item=A>,
     F: FnMut(&A),
@@ -2376,7 +2376,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
 ///     println!("{}", i);
 /// }
 /// ```
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
     f: F,
     /// Internal state that will be passed to the closure on the next iteration
@@ -2397,7 +2397,7 @@ impl<A, St, F> Clone for Unfold<A, St, F> where
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
     /// Creates a new iterator with the specified closure as the "iterator
     /// function" and an initial state to eventually pass to the closure
@@ -2429,7 +2429,7 @@ impl<A, St, F> Iterator for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A
 /// An infinite iterator starting at `start` and advancing by `step` with each
 /// iteration
 #[derive(Clone, Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may be renamed or replaced by range notation adapaters")]
 pub struct Counter<A> {
     /// The current state the counter is at (next value to be yielded)
@@ -2440,7 +2440,7 @@ pub struct Counter<A> {
 
 /// Creates a new counter with the specified start/step
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may be renamed or replaced by range notation adapaters")]
 pub fn count<A>(start: A, step: A) -> Counter<A> {
     Counter{state: start, step: step}
@@ -2465,7 +2465,7 @@ impl<A: Add<Output=A> + Clone> Iterator for Counter<A> {
 
 /// An iterator over the range [start, stop)
 #[derive(Clone, Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be replaced by range notation")]
 pub struct Range<A> {
     state: A,
@@ -2487,7 +2487,7 @@ pub struct Range<A> {
 /// }
 /// ```
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be replaced by range notation")]
 pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
     Range {
@@ -2498,7 +2498,7 @@ pub fn range<A: Int>(start: A, stop: A) -> Range<A> {
 }
 
 // FIXME: #10414: Unfortunate type bound
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be replaced by range notation")]
 impl<A: Int + ToPrimitive> Iterator for Range<A> {
     type Item = A;
@@ -2549,7 +2549,7 @@ impl<A: Int + ToPrimitive> Iterator for Range<A> {
 
 /// `Int` is required to ensure the range will be the same regardless of
 /// the direction it is consumed.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be replaced by range notation")]
 impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
     #[inline]
@@ -2565,7 +2565,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for Range<A> {
 
 /// An iterator over the range [start, stop]
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub struct RangeInclusive<A> {
     range: Range<A>,
@@ -2574,7 +2574,7 @@ pub struct RangeInclusive<A> {
 
 /// Return an iterator over the range [start, stop]
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
     RangeInclusive {
@@ -2583,7 +2583,7 @@ pub fn range_inclusive<A: Int>(start: A, stop: A) -> RangeInclusive<A> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
     type Item = A;
@@ -2619,7 +2619,7 @@ impl<A: Int + ToPrimitive> Iterator for RangeInclusive<A> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
     #[inline]
@@ -2639,7 +2639,7 @@ impl<A: Int + ToPrimitive> DoubleEndedIterator for RangeInclusive<A> {
 
 /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub struct RangeStep<A> {
     state: A,
@@ -2650,14 +2650,14 @@ pub struct RangeStep<A> {
 
 /// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub fn range_step<A: Int>(start: A, stop: A, step: A) -> RangeStep<A> {
     let rev = step < Int::zero();
     RangeStep{state: start, stop: stop, step: step, rev: rev}
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A: Int> Iterator for RangeStep<A> {
     type Item = A;
@@ -2679,7 +2679,7 @@ impl<A: Int> Iterator for RangeStep<A> {
 
 /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub struct RangeStepInclusive<A> {
     state: A,
@@ -2691,7 +2691,7 @@ pub struct RangeStepInclusive<A> {
 
 /// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepInclusive<A> {
     let rev = step < Int::zero();
@@ -2704,7 +2704,7 @@ pub fn range_step_inclusive<A: Int>(start: A, stop: A, step: A) -> RangeStepIncl
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to be replaced by range notation and adapters")]
 impl<A: Int> Iterator for RangeStepInclusive<A> {
     type Item = A;
@@ -2730,7 +2730,7 @@ impl<A: Int> Iterator for RangeStepInclusive<A> {
 /// directions. The `steps_between` function provides a way to
 /// compare two Step objects (it could be provided using `step()` and `Ord`,
 /// but the implementation would be so inefficient as to be useless).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "design of range notation/iteration is in flux")]
 pub trait Step: Ord {
     /// Change self to the next object.
@@ -2746,7 +2746,7 @@ pub trait Step: Ord {
 
 macro_rules! step_impl {
     ($($t:ty)*) => ($(
-        #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")]
+        #[unstable(feature = "core", reason = "Trait is unstable.")]
         impl Step for $t {
             #[inline]
             fn step(&mut self) { *self += 1; }
@@ -2763,7 +2763,7 @@ macro_rules! step_impl {
 
 macro_rules! step_impl_no_between {
     ($($t:ty)*) => ($(
-        #[unstable(feature = "unnamed_feature", reason = "Trait is unstable.")]
+        #[unstable(feature = "core", reason = "Trait is unstable.")]
         impl Step for $t {
             #[inline]
             fn step(&mut self) { *self += 1; }
@@ -2807,7 +2807,7 @@ impl<A: Clone> DoubleEndedIterator for Repeat<A> {
     fn next_back(&mut self) -> Option<A> { self.idx(0) }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<A: Clone> RandomAccessIterator for Repeat<A> {
     #[inline]
     fn indexable(&self) -> uint { uint::MAX }
@@ -2819,12 +2819,12 @@ type IterateState<T, F> = (F, Option<T>, bool);
 
 /// An iterator that repeatedly applies a given function, starting
 /// from a given seed value.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
 
 /// Create a new iterator that produces an infinite sequence of
 /// repeated applications of the given function `f`.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
     T: Clone,
     F: FnMut(T) -> T,
@@ -2867,7 +2867,7 @@ pub fn repeat<T: Clone>(elt: T) -> Repeat<T> {
 ///
 /// If two sequences are equal up until the point where one ends,
 /// the shorter sequence compares less.
-#[unstable(feature = "unnamed_feature", reason = "needs review and revision")]
+#[unstable(feature = "core", 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 17460c0d52b..ea697ed769d 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -48,7 +48,7 @@
 // separate crate, libcoretest, to avoid bizarre issues.
 
 #![crate_name = "core"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index 393f8825f5e..87f21e91c62 100644
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -235,7 +235,7 @@ macro_rules! writeln {
 /// }
 /// ```
 #[macro_export]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "relationship with panic is unclear")]
 macro_rules! unreachable {
     () => ({
@@ -252,7 +252,7 @@ macro_rules! unreachable {
 /// A standardised placeholder for marking unfinished code. It panics with the
 /// message `"not yet implemented"` when executed.
 #[macro_export]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "relationship with panic is unclear")]
 macro_rules! unimplemented {
     () => (panic!("not yet implemented"))
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 9d8509cd11f..96f65a2b732 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -28,7 +28,7 @@
 use clone::Clone;
 
 /// Types able to be transferred across task boundaries.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be overhauled with new lifetime rules; see RFC 458")]
 #[lang="send"]
 pub unsafe trait Send: 'static {
@@ -192,7 +192,7 @@ pub trait Copy {
 /// around the value(s) which can be mutated when behind a `&`
 /// reference; not doing this is undefined behaviour (for example,
 /// `transmute`-ing from `&T` to `&mut T` is illegal).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be overhauled with new lifetime rules; see RFC 458")]
 #[lang="sync"]
 pub unsafe trait Sync {
@@ -237,7 +237,7 @@ pub unsafe trait Sync {
 /// `S<T>` is a subtype of `S<U>` if `T` is a subtype of `U`
 /// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
 /// for some lifetime `'a`, but not the other way around).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="covariant_type"]
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
@@ -287,7 +287,7 @@ impl<T: ?Sized> Clone for CovariantType<T> {
 /// subtype of `S<U>` if `U` is a subtype of `T`; given that the
 /// function requires arguments of type `T`, it must also accept
 /// arguments of type `U`, hence such a conversion is safe.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="contravariant_type"]
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
@@ -318,16 +318,16 @@ impl<T: ?Sized> Clone for ContravariantType<T> {
 /// The type system would infer that `value` is only read here and
 /// never written, but in fact `Cell` uses unsafe code to achieve
 /// interior mutability.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="invariant_type"]
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 pub struct InvariantType<T: ?Sized>;
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 impl<T: ?Sized> Copy for InvariantType<T> {}
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 impl<T: ?Sized> Clone for InvariantType<T> {
     fn clone(&self) -> InvariantType<T> { *self }
@@ -349,7 +349,7 @@ impl<T: ?Sized> Clone for InvariantType<T> {
 ///
 /// For more information about variance, refer to this Wikipedia
 /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="covariant_lifetime"]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -367,7 +367,7 @@ pub struct CovariantLifetime<'a>;
 ///
 /// For more information about variance, refer to this Wikipedia
 /// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="contravariant_lifetime"]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -380,7 +380,7 @@ pub struct ContravariantLifetime<'a>;
 /// pointer that is actually a pointer into memory with lifetime `'a`,
 /// and this pointer is itself stored in an inherently mutable
 /// location (such as a `Cell`).
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="invariant_lifetime"]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -390,7 +390,7 @@ pub struct InvariantLifetime<'a>;
 /// be safely sent between tasks, even if it is owned. This is
 /// typically embedded in other types, such as `Gc`, to ensure that
 /// their instances remain thread-local.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="no_send_bound"]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -400,7 +400,7 @@ pub struct NoSend;
 /// A type which is considered "not POD", meaning that it is not
 /// implicitly copyable. This is typically embedded in other types to
 /// ensure that they are never copied, even if they lack a destructor.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="no_copy_bound"]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
@@ -410,7 +410,7 @@ pub struct NoCopy;
 /// A type which is considered "not sync", meaning that
 /// its contents are not threadsafe, hence they cannot be
 /// shared between tasks.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="no_sync_bound"]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -419,7 +419,7 @@ pub struct NoSync;
 
 /// A type which is considered managed by the GC. This is typically
 /// embedded in other types.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "likely to change with new variance strategy")]
 #[lang="managed_bound"]
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index bfaf897b3a4..001b58c2460 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -318,7 +318,7 @@ pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
 
 /// Transforms lifetime of the second pointer to match the first.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "this function may be removed in the future due to its \
                      questionable utility")]
 pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
@@ -328,7 +328,7 @@ pub unsafe fn copy_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a S,
 
 /// Transforms lifetime of the second mutable pointer to match the first.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "this function may be removed in the future due to its \
                      questionable utility")]
 pub unsafe fn copy_mut_lifetime<'a, S: ?Sized, T: ?Sized + 'a>(_ptr: &'a mut S,
diff --git a/src/libcore/nonzero.rs b/src/libcore/nonzero.rs
index 601e1b192a9..7c8be79d075 100644
--- a/src/libcore/nonzero.rs
+++ b/src/libcore/nonzero.rs
@@ -32,7 +32,7 @@ unsafe impl Zeroable for u64 {}
 /// NULL or 0 that might allow certain optimizations.
 #[lang="non_zero"]
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Show)]
-#[unstable(feature = "unnamed_feature")]
+#[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 4d5a0c1af4d..8e28bb18aef 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -22,12 +22,12 @@ use num::Float;
 use num::FpCategory as Fp;
 use option::Option;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const RADIX: uint = 2u;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MANTISSA_DIGITS: uint = 24u;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const DIGITS: uint = 6u;
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -43,14 +43,14 @@ pub const MIN_POS_VALUE: f32 = 1.17549435e-38_f32;
 #[stable(feature = "grandfathered", since = "1.0.0")]
 pub const MAX_VALUE: f32 = 3.40282347e+38_f32;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MIN_EXP: int = -125;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MAX_EXP: int = 128;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MIN_10_EXP: int = -37;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MAX_10_EXP: int = 38;
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -61,7 +61,7 @@ pub const INFINITY: f32 = 1.0_f32/0.0_f32;
 pub const NEG_INFINITY: f32 = -1.0_f32/0.0_f32;
 
 /// Various useful constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "naming scheme needs to be revisited")]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
@@ -118,7 +118,7 @@ pub mod consts {
     pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[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 84a457d78ca..4fee89e923c 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -26,11 +26,11 @@ use option::Option;
 // constants are implemented in favour of referencing the respective
 // members of `Bounded` and `Float`.
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const RADIX: uint = 2u;
 
 pub const MANTISSA_DIGITS: uint = 53u;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const DIGITS: uint = 15u;
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -46,14 +46,14 @@ pub const MIN_POS_VALUE: f64 = 2.2250738585072014e-308_f64;
 #[stable(feature = "grandfathered", since = "1.0.0")]
 pub const MAX_VALUE: f64 = 1.7976931348623157e+308_f64;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MIN_EXP: int = -1021;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MAX_EXP: int = 1024;
 
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MIN_10_EXP: int = -307;
-#[unstable(feature = "unnamed_feature", reason = "pending integer conventions")]
+#[unstable(feature = "core", reason = "pending integer conventions")]
 pub const MAX_10_EXP: int = 308;
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -64,7 +64,7 @@ pub const INFINITY: f64 = 1.0_f64/0.0_f64;
 pub const NEG_INFINITY: f64 = -1.0_f64/0.0_f64;
 
 /// Various useful constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "naming scheme needs to be revisited")]
 pub mod consts {
     // FIXME: replace with mathematical constants from cmath.
@@ -125,7 +125,7 @@ pub mod consts {
     pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is unstable")]
+#[unstable(feature = "core", reason = "trait is unstable")]
 impl Float for f64 {
     #[inline]
     fn nan() -> f64 { NAN }
diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs
index af84f619a9d..899f08fb622 100644
--- a/src/libcore/num/int_macros.rs
+++ b/src/libcore/num/int_macros.rs
@@ -14,11 +14,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => (
 
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
 // calling the `mem::size_of` function.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub const BITS : uint = $bits;
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
 // calling the `mem::size_of` function.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub const BYTES : uint = ($bits / 8);
 
 // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 2321baf3780..5e4956dfccf 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -50,25 +50,25 @@ pub trait Int
 {
     /// Returns the `0` value of this integer type.
     // FIXME (#5527): Should be an associated constant
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "unsure about its place in the world")]
     fn zero() -> Self;
 
     /// Returns the `1` value of this integer type.
     // FIXME (#5527): Should be an associated constant
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "unsure about its place in the world")]
     fn one() -> Self;
 
     /// Returns the smallest value that can be represented by this integer type.
     // FIXME (#5527): Should be and associated constant
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "unsure about its place in the world")]
     fn min_value() -> Self;
 
     /// Returns the largest value that can be represented by this integer type.
     // FIXME (#5527): Should be and associated constant
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "unsure about its place in the world")]
     fn max_value() -> Self;
 
@@ -83,7 +83,7 @@ pub trait Int
     ///
     /// assert_eq!(n.count_ones(), 3);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn count_ones(self) -> uint;
 
@@ -98,7 +98,7 @@ pub trait Int
     ///
     /// assert_eq!(n.count_zeros(), 5);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     #[inline]
     fn count_zeros(self) -> uint {
@@ -117,7 +117,7 @@ pub trait Int
     ///
     /// assert_eq!(n.leading_zeros(), 10);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn leading_zeros(self) -> uint;
 
@@ -133,7 +133,7 @@ pub trait Int
     ///
     /// assert_eq!(n.trailing_zeros(), 3);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn trailing_zeros(self) -> uint;
 
@@ -150,7 +150,7 @@ pub trait Int
     ///
     /// assert_eq!(n.rotate_left(12), m);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn rotate_left(self, n: uint) -> Self;
 
@@ -167,7 +167,7 @@ pub trait Int
     ///
     /// assert_eq!(n.rotate_right(12), m);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     fn rotate_right(self, n: uint) -> Self;
 
@@ -368,7 +368,7 @@ pub trait Int
     ///
     /// assert_eq!(2i.pow(4), 16);
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "pending integer conventions")]
     #[inline]
     fn pow(self, mut exp: uint) -> Self {
@@ -632,7 +632,7 @@ pub trait SignedInt
 {
     /// Computes the absolute value of `self`. `Int::min_value()` will be
     /// returned if the number is `Int::min_value()`.
-    #[unstable(feature = "unnamed_feature", reason = "overflow in debug builds?")]
+    #[unstable(feature = "core", reason = "overflow in debug builds?")]
     fn abs(self) -> Self;
 
     /// Returns a number representing sign of `self`.
@@ -737,7 +737,7 @@ impl UnsignedInt for u32 {}
 impl UnsignedInt for u64 {}
 
 /// A generic trait for converting a value to a number.
-#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")]
+#[unstable(feature = "core", reason = "trait is likely to be removed")]
 pub trait ToPrimitive {
     /// Converts the value of `self` to an `int`.
     #[inline]
@@ -1002,7 +1002,7 @@ impl_to_primitive_float! { f32 }
 impl_to_primitive_float! { f64 }
 
 /// A generic trait for converting a number to a value.
-#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")]
+#[unstable(feature = "core", reason = "trait is likely to be removed")]
 pub trait FromPrimitive : ::marker::Sized {
     /// Convert an `int` to return an optional value of this type. If the
     /// value cannot be represented by this value, the `None` is returned.
@@ -1084,73 +1084,73 @@ pub trait FromPrimitive : ::marker::Sized {
 }
 
 /// A utility function that just calls `FromPrimitive::from_int`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_int<A: FromPrimitive>(n: int) -> Option<A> {
     FromPrimitive::from_int(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_i8`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_i8<A: FromPrimitive>(n: i8) -> Option<A> {
     FromPrimitive::from_i8(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_i16`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_i16<A: FromPrimitive>(n: i16) -> Option<A> {
     FromPrimitive::from_i16(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_i32`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_i32<A: FromPrimitive>(n: i32) -> Option<A> {
     FromPrimitive::from_i32(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_i64`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_i64<A: FromPrimitive>(n: i64) -> Option<A> {
     FromPrimitive::from_i64(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_uint`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_uint<A: FromPrimitive>(n: uint) -> Option<A> {
     FromPrimitive::from_uint(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_u8`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_u8<A: FromPrimitive>(n: u8) -> Option<A> {
     FromPrimitive::from_u8(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_u16`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_u16<A: FromPrimitive>(n: u16) -> Option<A> {
     FromPrimitive::from_u16(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_u32`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_u32<A: FromPrimitive>(n: u32) -> Option<A> {
     FromPrimitive::from_u32(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_u64`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_u64<A: FromPrimitive>(n: u64) -> Option<A> {
     FromPrimitive::from_u64(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_f32`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_f32<A: FromPrimitive>(n: f32) -> Option<A> {
     FromPrimitive::from_f32(n)
 }
 
 /// A utility function that just calls `FromPrimitive::from_f64`.
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn from_f64<A: FromPrimitive>(n: f64) -> Option<A> {
     FromPrimitive::from_f64(n)
 }
@@ -1201,13 +1201,13 @@ impl_from_primitive! { f64, to_f64 }
 /// ```
 ///
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "likely to be removed")]
+#[unstable(feature = "core", reason = "likely to be removed")]
 pub fn cast<T: NumCast,U: NumCast>(n: T) -> Option<U> {
     NumCast::from(n)
 }
 
 /// An interface for casting between machine scalars.
-#[unstable(feature = "unnamed_feature", reason = "trait is likely to be removed")]
+#[unstable(feature = "core", reason = "trait is likely to be removed")]
 pub trait NumCast: ToPrimitive {
     /// Creates a number from another value that can be converted into a primitive via the
     /// `ToPrimitive` trait.
@@ -1242,7 +1242,7 @@ impl_num_cast! { f64,   to_f64 }
 
 /// Used for representing the classification of floating point numbers
 #[derive(Copy, PartialEq, Show)]
-#[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+#[unstable(feature = "core", reason = "may be renamed")]
 pub enum FpCategory {
     /// "Not a Number", often obtained by dividing by zero
     Nan,
@@ -1262,7 +1262,7 @@ pub enum FpCategory {
 //
 // FIXME(#8888): Several of these functions have a parameter named
 //               `unused_self`. Removing it requires #8888 to be fixed.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "distribution of methods between core/std is unclear")]
 pub trait Float
     : Copy + Clone
@@ -1418,20 +1418,20 @@ pub trait Float
 }
 
 /// A generic trait for converting a string with a radix (base) to a value
-#[unstable(feature = "unnamed_feature", reason = "might need to return Result")]
+#[unstable(feature = "core", reason = "might need to return Result")]
 pub trait FromStrRadix {
     fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }
 
 /// A utility function that just calls FromStrRadix::from_str_radix.
-#[unstable(feature = "unnamed_feature", reason = "might need to return Result")]
+#[unstable(feature = "core", reason = "might need to return Result")]
 pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
     FromStrRadix::from_str_radix(str, radix)
 }
 
 macro_rules! from_str_radix_float_impl {
     ($T:ty) => {
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "might need to return Result")]
         impl FromStr for $T {
             /// Convert a string in base 10 to a float.
@@ -1465,7 +1465,7 @@ macro_rules! from_str_radix_float_impl {
             }
         }
 
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "might need to return Result")]
         impl FromStrRadix for $T {
             /// Convert a string in a given base to a float.
@@ -1630,7 +1630,7 @@ from_str_radix_float_impl! { f64 }
 
 macro_rules! from_str_radix_int_impl {
     ($T:ty) => {
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "might need to return Result")]
         impl FromStr for $T {
             #[inline]
@@ -1639,7 +1639,7 @@ macro_rules! from_str_radix_int_impl {
             }
         }
 
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "might need to return Result")]
         impl FromStrRadix for $T {
             fn from_str_radix(src: &str, radix: uint) -> Option<$T> {
diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs
index c584fc90557..c18333892d9 100644
--- a/src/libcore/num/uint_macros.rs
+++ b/src/libcore/num/uint_macros.rs
@@ -12,9 +12,9 @@
 
 macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => (
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub const BITS : uint = $bits;
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub const BYTES : uint = ($bits / 8);
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 17ba135eb7c..1ba4f629390 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -108,7 +108,7 @@ pub trait Drop {
 // based on "op T" where T is expected to be `Copy`able
 macro_rules! forward_ref_unop {
     (impl $imp:ident, $method:ident for $t:ty) => {
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "recently added, waiting for dust to settle")]
         impl<'a> $imp for &'a $t {
             type Output = <$t as $imp>::Output;
@@ -125,7 +125,7 @@ macro_rules! forward_ref_unop {
 // based on "T op U" where T and U are expected to be `Copy`able
 macro_rules! forward_ref_binop {
     (impl $imp:ident, $method:ident for $t:ty, $u:ty) => {
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "recently added, waiting for dust to settle")]
         impl<'a> $imp<$u> for &'a $t {
             type Output = <$t as $imp<$u>>::Output;
@@ -136,7 +136,7 @@ macro_rules! forward_ref_binop {
             }
         }
 
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "recently added, waiting for dust to settle")]
         impl<'a> $imp<&'a $u> for $t {
             type Output = <$t as $imp<$u>>::Output;
@@ -147,7 +147,7 @@ macro_rules! forward_ref_binop {
             }
         }
 
-        #[unstable(feature = "unnamed_feature",
+        #[unstable(feature = "core",
                    reason = "recently added, waiting for dust to settle")]
         impl<'a, 'b> $imp<&'a $u> for &'b $t {
             type Output = <$t as $imp<$u>>::Output;
@@ -974,10 +974,10 @@ pub trait IndexMut<Index: ?Sized> {
 /// An unbounded range.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="full_range"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 pub struct FullRange;
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl fmt::Show for FullRange {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt::Show::fmt("..", fmt)
@@ -987,7 +987,7 @@ impl fmt::Show for FullRange {
 /// A (half-open) range which is bounded at both ends.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 pub struct Range<Idx> {
     /// The lower bound of the range (inclusive).
     pub start: Idx,
@@ -995,7 +995,7 @@ pub struct Range<Idx> {
     pub end: Idx,
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: Clone + Step> Iterator for Range<Idx> {
     type Item = Idx;
 
@@ -1020,7 +1020,7 @@ impl<Idx: Clone + Step> Iterator for Range<Idx> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     #[inline]
     fn next_back(&mut self) -> Option<Idx> {
@@ -1033,10 +1033,10 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{:?}..{:?}", self.start, self.end)
@@ -1046,13 +1046,13 @@ impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
 /// A range which is only bounded below.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range_from"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
     pub start: Idx,
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
     type Item = Idx;
 
@@ -1065,7 +1065,7 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{:?}..", self.start)
@@ -1075,13 +1075,13 @@ impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
 /// A range which is only bounded above.
 #[derive(Copy, Clone, PartialEq, Eq)]
 #[lang="range_to"]
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 pub struct RangeTo<Idx> {
     /// The upper bound of the range (exclusive).
     pub end: Idx,
 }
 
-#[unstable(feature = "unnamed_feature", reason = "API still in development")]
+#[unstable(feature = "core", reason = "API still in development")]
 impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "..{:?}", self.end)
@@ -1196,7 +1196,7 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T {
 
 /// A version of the call operator that takes an immutable receiver.
 #[lang="fn"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "uncertain about variadic generics, input versus associated types")]
 pub trait Fn<Args,Result> {
     /// This is called when the call operator is used.
@@ -1205,7 +1205,7 @@ pub trait Fn<Args,Result> {
 
 /// A version of the call operator that takes a mutable receiver.
 #[lang="fn_mut"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "uncertain about variadic generics, input versus associated types")]
 pub trait FnMut<Args,Result> {
     /// This is called when the call operator is used.
@@ -1214,7 +1214,7 @@ pub trait FnMut<Args,Result> {
 
 /// A version of the call operator that takes a by-value receiver.
 #[lang="fn_once"]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "uncertain about variadic generics, input versus associated types")]
 pub trait FnOnce<Args,Result> {
     /// This is called when the call operator is used.
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 7b8e1ebd7b8..8e27c039aa2 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -285,7 +285,7 @@ impl<T> Option<T> {
     /// assert_eq!(x, Some("Dirt"));
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "waiting for mut conventions")]
     pub fn as_mut_slice<'r>(&'r mut self) -> &'r mut [T] {
         match *self {
@@ -477,7 +477,7 @@ impl<T> Option<T> {
     /// assert_eq!(x.ok_or(0i), Err(0i));
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn ok_or<E>(self, err: E) -> Result<T, E> {
         match self {
             Some(v) => Ok(v),
@@ -498,7 +498,7 @@ impl<T> Option<T> {
     /// assert_eq!(x.ok_or_else(|| 0i), Err(0i));
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {
         match self {
             Some(v) => Ok(v),
@@ -543,7 +543,7 @@ impl<T> Option<T> {
     /// assert_eq!(x.iter_mut().next(), None);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "waiting for iterator conventions")]
     pub fn iter_mut(&mut self) -> IterMut<T> {
         IterMut { inner: Item { opt: self.as_mut() } }
@@ -704,7 +704,7 @@ impl<T> Option<T> {
 impl<'a, T: Clone, D: Deref<Target=T>> Option<D> {
     /// Maps an Option<D> to an Option<T> by dereffing and cloning the contents of the Option.
     /// Useful for converting an Option<&T> to an Option<T>.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "recently added as part of collections reform")]
     pub fn cloned(self) -> Option<T> {
         self.map(|t| t.deref().clone())
@@ -748,7 +748,7 @@ impl<T: Default> Option<T> {
 // Trait implementations
 /////////////////////////////////////////////////////////////////////////////
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "waiting on the stability of the trait itself")]
 impl<T> AsSlice<T> for Option<T> {
     /// Convert from `Option<T>` to `&[T]` (without copying)
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index a66ea639668..9b6d5bfc71f 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -99,13 +99,13 @@ use cmp::Ordering::{self, Less, Equal, Greater};
 
 // FIXME #19649: intrinsic docs don't render, so these have no docs :(
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub use intrinsics::copy_nonoverlapping_memory;
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub use intrinsics::copy_memory;
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "uncertain about naming and semantics")]
 pub use intrinsics::set_memory;
 
@@ -146,7 +146,7 @@ pub fn null_mut<T>() -> *mut T { 0 as *mut T }
 /// Beyond accepting a raw pointer, this is unsafe because it will not drop the
 /// contents of `dst`, and may be used to create invalid instances of `T`.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may play a larger role in std::ptr future extensions")]
 pub unsafe fn zero_memory<T>(dst: *mut T, count: uint) {
     set_memory(dst, 0, count);
@@ -215,7 +215,7 @@ pub unsafe fn read<T>(src: *const T) -> T {
 ///
 /// This is unsafe for the same reasons that `read` is unsafe.
 #[inline(always)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "may play a larger role in std::ptr future extensions")]
 pub unsafe fn read_and_zero<T>(dest: *mut T) -> T {
     // Copy the data out from `dest`:
@@ -262,7 +262,7 @@ pub trait PtrExt: Sized {
     /// null-safety, it is important to note that this is still an unsafe
     /// operation because the returned value could be pointing to invalid
     /// memory.
-    #[unstable(feature = "unnamed_feature",
+    #[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")]
     unsafe fn as_ref<'a>(&self) -> Option<&'a Self::Target>;
@@ -291,7 +291,7 @@ pub trait MutPtrExt {
     ///
     /// As with `as_ref`, this is unsafe because it cannot verify the validity
     /// of the returned pointer.
-    #[unstable(feature = "unnamed_feature",
+    #[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")]
     unsafe fn as_mut<'a>(&self) -> Option<&'a mut Self::Target>;
@@ -312,7 +312,7 @@ impl<T> PtrExt for *const T {
     }
 
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "return value does not necessarily convey all possible \
                          information")]
     unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
@@ -339,7 +339,7 @@ impl<T> PtrExt for *mut T {
     }
 
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "return value does not necessarily convey all possible \
                          information")]
     unsafe fn as_ref<'a>(&self) -> Option<&'a T> {
@@ -356,7 +356,7 @@ impl<T> MutPtrExt for *mut T {
     type Target = T;
 
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "return value does not necessarily convey all possible \
                          information")]
     unsafe fn as_mut<'a>(&self) -> Option<&'a mut T> {
@@ -521,33 +521,33 @@ impl<T> PartialOrd for *mut T {
 /// raw `*mut T` (which conveys no particular ownership semantics).
 /// Useful for building abstractions like `Vec<T>` or `Box<T>`, which
 /// internally use raw pointers to manage the memory that they own.
-#[unstable(feature = "unnamed_feature", reason = "recently added to this module")]
+#[unstable(feature = "core", reason = "recently added to this module")]
 pub struct Unique<T>(pub *mut T);
 
 /// `Unique` pointers are `Send` if `T` is `Send` because the data they
 /// reference is unaliased. Note that this aliasing invariant is
 /// unenforced by the type system; the abstraction using the
 /// `Unique` must enforce it.
-#[unstable(feature = "unnamed_feature", reason = "recently added to this module")]
+#[unstable(feature = "core", reason = "recently added to this module")]
 unsafe impl<T:Send> Send for Unique<T> { }
 
 /// `Unique` pointers are `Sync` if `T` is `Sync` because the data they
 /// reference is unaliased. Note that this aliasing invariant is
 /// unenforced by the type system; the abstraction using the
 /// `Unique` must enforce it.
-#[unstable(feature = "unnamed_feature", reason = "recently added to this module")]
+#[unstable(feature = "core", reason = "recently added to this module")]
 unsafe impl<T:Sync> Sync for Unique<T> { }
 
 impl<T> Unique<T> {
     /// Returns a null Unique.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "recently added to this module")]
     pub fn null() -> Unique<T> {
         Unique(null_mut())
     }
 
     /// Return an (unsafe) pointer into the memory owned by `self`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "recently added to this module")]
     pub unsafe fn offset(self, offset: int) -> *mut T {
         self.0.offset(offset)
diff --git a/src/libcore/raw.rs b/src/libcore/raw.rs
index 02d2d29ade1..3fd244b46e3 100644
--- a/src/libcore/raw.rs
+++ b/src/libcore/raw.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "core")]
 
 //! Contains struct definitions for the layout of compiler built-in types.
 //!
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 51119b2fc03..2965cf71c18 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -417,7 +417,7 @@ impl<T, E> Result<T, E> {
     /// assert!(x.as_mut_slice().is_empty());
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "core",
                reason = "waiting for mut conventions")]
     pub fn as_mut_slice(&mut self) -> &mut [T] {
         match *self {
@@ -950,7 +950,7 @@ impl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {
 /// If an `Err` is encountered, it is immediately returned.
 /// Otherwise, the folded value is returned.
 #[inline]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn fold<T,
             V,
             E,
diff --git a/src/libcore/simd.rs b/src/libcore/simd.rs
index 086fff58910..4a1c123668f 100644
--- a/src/libcore/simd.rs
+++ b/src/libcore/simd.rs
@@ -36,7 +36,7 @@
 #![allow(non_camel_case_types)]
 #![allow(missing_docs)]
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
@@ -45,26 +45,26 @@ pub struct i8x16(pub i8, pub i8, pub i8, pub i8,
                  pub i8, pub i8, pub i8, pub i8,
                  pub i8, pub i8, pub i8, pub i8);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct i16x8(pub i16, pub i16, pub i16, pub i16,
                  pub i16, pub i16, pub i16, pub i16);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct i32x4(pub i32, pub i32, pub i32, pub i32);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct i64x2(pub i64, pub i64);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
@@ -73,32 +73,32 @@ pub struct u8x16(pub u8, pub u8, pub u8, pub u8,
                  pub u8, pub u8, pub u8, pub u8,
                  pub u8, pub u8, pub u8, pub u8);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct u16x8(pub u16, pub u16, pub u16, pub u16,
                  pub u16, pub u16, pub u16, pub u16);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct u32x4(pub u32, pub u32, pub u32, pub u32);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct u64x2(pub u64, pub u64);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
 pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 #[simd]
 #[derive(Copy, Show)]
 #[repr(C)]
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index 779ace7a613..7095fa319d0 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -131,7 +131,7 @@ pub trait SliceExt {
     fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<T> SliceExt for [T] {
     type Item = T;
 
@@ -258,7 +258,7 @@ impl<T> SliceExt for [T] {
         self.repr().data
     }
 
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     fn binary_search_by<F>(&self, mut f: F) -> Result<uint, uint> where
         F: FnMut(&T) -> Ordering
     {
@@ -452,12 +452,12 @@ impl<T> SliceExt for [T] {
         m >= n && needle == &self[(m-n)..]
     }
 
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
         self.binary_search_by(|p| p.cmp(x))
     }
 
-    #[unstable(feature = "unnamed_feature")]
+    #[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; }
@@ -488,7 +488,7 @@ impl<T> SliceExt for [T] {
         true
     }
 
-    #[unstable(feature = "unnamed_feature")]
+    #[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; }
@@ -630,26 +630,26 @@ impl<T> ops::IndexMut<ops::FullRange> for [T] {
 ////////////////////////////////////////////////////////////////////////////////
 
 /// Data that is viewable as a slice.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will be replaced by slice syntax")]
 pub trait AsSlice<T> {
     /// Work with `self` as a slice.
     fn as_slice<'a>(&'a self) -> &'a [T];
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<T> AsSlice<T> for [T] {
     #[inline(always)]
     fn as_slice<'a>(&'a self) -> &'a [T] { self }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a U {
     #[inline(always)]
     fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<'a, T, U: ?Sized + AsSlice<T>> AsSlice<T> for &'a mut U {
     #[inline(always)]
     fn as_slice(&self) -> &[T] { AsSlice::as_slice(*self) }
@@ -755,7 +755,7 @@ pub struct Iter<'a, T: 'a> {
     marker: marker::ContravariantLifetime<'a>
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
     type Output = [T];
     #[inline]
@@ -764,7 +764,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for Iter<'a, T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
     type Output = [T];
     #[inline]
@@ -773,7 +773,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for Iter<'a, T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
     type Output = [T];
     #[inline]
@@ -782,7 +782,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for Iter<'a, T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::FullRange> for Iter<'a, T> {
     type Output = [T];
     #[inline]
@@ -796,7 +796,7 @@ impl<'a, T> Iter<'a, T> {
     ///
     /// This has the same lifetime as the original slice, and so the
     /// iterator can continue to be used while this exists.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn as_slice(&self) -> &'a [T] {
         make_slice!(T => &'a [T]: self.ptr, self.end)
     }
@@ -814,7 +814,7 @@ impl<'a, T> Clone for Iter<'a, T> {
     fn clone(&self) -> Iter<'a, T> { *self }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -848,7 +848,7 @@ pub struct IterMut<'a, T: 'a> {
 }
 
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -856,7 +856,7 @@ impl<'a, T> ops::Index<ops::Range<uint>> for IterMut<'a, T> {
         self.index(&ops::FullRange).index(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -864,7 +864,7 @@ impl<'a, T> ops::Index<ops::RangeTo<uint>> for IterMut<'a, T> {
         self.index(&ops::FullRange).index(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -872,7 +872,7 @@ impl<'a, T> ops::Index<ops::RangeFrom<uint>> for IterMut<'a, T> {
         self.index(&ops::FullRange).index(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -881,7 +881,7 @@ impl<'a, T> ops::Index<ops::FullRange> for IterMut<'a, T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -889,7 +889,7 @@ impl<'a, T> ops::IndexMut<ops::Range<uint>> for IterMut<'a, T> {
         self.index_mut(&ops::FullRange).index_mut(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -897,7 +897,7 @@ impl<'a, T> ops::IndexMut<ops::RangeTo<uint>> for IterMut<'a, T> {
         self.index_mut(&ops::FullRange).index_mut(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -905,7 +905,7 @@ impl<'a, T> ops::IndexMut<ops::RangeFrom<uint>> for IterMut<'a, T> {
         self.index_mut(&ops::FullRange).index_mut(index)
     }
 }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 impl<'a, T> ops::IndexMut<ops::FullRange> for IterMut<'a, T> {
     type Output = [T];
     #[inline]
@@ -922,7 +922,7 @@ impl<'a, T> IterMut<'a, T> {
     /// to consume the iterator. Consider using the `Slice` and
     /// `SliceMut` implementations for obtaining slices with more
     /// restricted lifetimes that do not consume the iterator.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "core")]
     pub fn into_slice(self) -> &'a mut [T] {
         make_slice!(T => &'a mut [T]: self.ptr, self.end)
     }
@@ -1270,7 +1270,7 @@ impl<'a, T> DoubleEndedIterator for Chunks<'a, T> {
     }
 }
 
-#[unstable(feature = "unnamed_feature", reason = "trait is experimental")]
+#[unstable(feature = "core", reason = "trait is experimental")]
 impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
     #[inline]
     fn indexable(&self) -> uint {
@@ -1354,7 +1354,7 @@ impl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {
 //
 
 /// Converts a pointer to A into a slice of length 1 (without copying).
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
     unsafe {
         transmute(RawSlice { data: s, len: 1 })
@@ -1362,7 +1362,7 @@ pub fn ref_slice<'a, A>(s: &'a A) -> &'a [A] {
 }
 
 /// Converts a pointer to A into a slice of length 1 (without copying).
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
     unsafe {
         let ptr: *const A = transmute(s);
@@ -1396,7 +1396,7 @@ pub fn mut_ref_slice<'a, A>(s: &'a mut A) -> &'a mut [A] {
 /// }
 /// ```
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "should be renamed to from_raw_parts")]
 pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
     transmute(RawSlice { data: *p, len: len })
@@ -1409,7 +1409,7 @@ pub unsafe fn from_raw_buf<'a, T>(p: &'a *const T, len: uint) -> &'a [T] {
 /// not being able to provide a non-aliasing guarantee of the returned mutable
 /// slice.
 #[inline]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "should be renamed to from_raw_parts_mut")]
 pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
     transmute(RawSlice { data: *p, len: len })
@@ -1420,7 +1420,7 @@ pub unsafe fn from_raw_mut_buf<'a, T>(p: &'a *mut T, len: uint) -> &'a mut [T] {
 //
 
 /// Operations on `[u8]`.
-#[unstable(feature = "unnamed_feature", reason = "needs review")]
+#[unstable(feature = "core", reason = "needs review")]
 pub mod bytes {
     use ptr;
     use slice::SliceExt;
@@ -1508,7 +1508,7 @@ impl<T: PartialOrd> PartialOrd for [T] {
 }
 
 /// Extension methods for slices containing integers.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "core")]
 pub trait IntSliceExt<U, S> {
     /// Converts the slice to an immutable slice of unsigned integers with the same width.
     fn as_unsigned<'a>(&'a self) -> &'a [U];
@@ -1523,7 +1523,7 @@ pub trait IntSliceExt<U, S> {
 
 macro_rules! impl_int_slice {
     ($u:ty, $s:ty, $t:ty) => {
-        #[unstable(feature = "unnamed_feature")]
+        #[unstable(feature = "core")]
         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 2086d727053..8daf71edb33 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -108,7 +108,7 @@ macro_rules! delegate_iter {
 /// A trait to abstract the idea of creating a new instance of a type from a
 /// string.
 // FIXME(#17307): there should be an `E` associated type for a `Result` return
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "will return a Result once associated types are working")]
 pub trait FromStr {
     /// Parses a string `s` to return an optional value of this type. If the
@@ -144,7 +144,7 @@ Section: Creating a string
 
 /// Errors which can occur when attempting to interpret a byte slice as a `str`.
 #[derive(Copy, Eq, PartialEq, Clone, Show)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "error enumeration recently added and definitions may be refined")]
 pub enum Utf8Error {
     /// An invalid byte was detected at the byte offset given.
@@ -208,7 +208,7 @@ pub unsafe fn from_c_str(s: *const i8) -> &'static str {
 }
 
 /// Something that can be used to compare against a character
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "definition may change as pattern-related methods are stabilized")]
 pub trait CharEq {
     /// Determine if the splitter should split at the given character
@@ -861,7 +861,7 @@ impl Searcher {
 /// An iterator over the start and end indices of the matches of a
 /// substring within a larger string
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature", reason = "type may be removed")]
+#[unstable(feature = "core", reason = "type may be removed")]
 pub struct MatchIndices<'a> {
     // constants
     haystack: &'a str,
@@ -872,7 +872,7 @@ pub struct MatchIndices<'a> {
 /// An iterator over the substrings of a string separated by a given
 /// search string
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature", reason = "type may be removed")]
+#[unstable(feature = "core", reason = "type may be removed")]
 pub struct SplitStr<'a> {
     it: MatchIndices<'a>,
     last_end: uint,
@@ -1056,7 +1056,7 @@ static UTF8_CHAR_WIDTH: [u8; 256] = [
 /// the next `char` in a string.  This can be used as a data structure
 /// for iterating over the UTF-8 bytes of a string.
 #[derive(Copy)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "naming is uncertain with container conventions")]
 pub struct CharRange {
     /// Current `char`
@@ -1151,7 +1151,7 @@ mod traits {
 }
 
 /// Any string that can be represented as a slice
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "Instead of taking this bound generically, this trait will be \
                      replaced with one of slicing syntax, deref coercions, or \
                      a more generic conversion trait")]
@@ -1178,7 +1178,7 @@ delegate_iter!{pattern &'a str : Split<'a, P>}
 
 /// Return type of `StrExt::split_terminator`
 #[derive(Clone)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "core",
            reason = "might get removed in favour of a constructor method on Split")]
 pub struct SplitTerminator<'a, P>(CharSplits<'a, P>);
 delegate_iter!{pattern &'a str : SplitTerminator<'a, P>}
diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs
index 1aa302aa8ed..0d371dbe153 100644
--- a/src/libcoretest/lib.rs
+++ b/src/libcoretest/lib.rs
@@ -11,7 +11,6 @@
 #![feature(unsafe_destructor, slicing_syntax)]
 #![feature(unboxed_closures)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 
 extern crate core;
diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs
index 9c67748f9c5..5f3a68a9e34 100644
--- a/src/libflate/lib.rs
+++ b/src/libflate/lib.rs
@@ -15,16 +15,18 @@
 //! [mz]: https://code.google.com/p/miniz/
 
 #![crate_name = "flate"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![allow(unknown_features)] #![feature(int_uint)]
-#![feature(unnamed_feature)]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
+#![feature(hash)]
+#![feature(core)]
+#![feature(libc)]
 
 #[cfg(test)] #[macro_use] extern crate log;
 
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 874bce88082..d76e4b2ed95 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -15,7 +15,7 @@
 //! generated instead.
 
 #![crate_name = "fmt_macros"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -27,7 +27,9 @@
 
 #![feature(slicing_syntax)]
 #![allow(unknown_features)] #![feature(int_uint)]
-#![feature(unnamed_feature)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(unicode)]
 
 pub use self::Piece::*;
 pub use self::Position::*;
diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index be1a343b169..c7ccebb7ce8 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -78,7 +78,7 @@
 //! ```
 
 #![crate_name = "getopts"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
             reason = "use the crates.io `getopts` library instead")]
 #![feature(staged_api)]
 #![staged_api]
@@ -89,9 +89,10 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
 
 #[cfg(test)] #[macro_use] extern crate log;
 
diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index 2a8a5bcf216..23597af68bc 100644
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -265,7 +265,7 @@
 //! * [DOT language](http://www.graphviz.org/doc/info/lang.html)
 
 #![crate_name = "graphviz"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -274,8 +274,11 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 #![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(path)]
 
 use self::LabelText::*;
 
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 73a4214788d..c1de5a627be 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -11,10 +11,10 @@
 #![crate_name = "libc"]
 #![crate_type = "rlib"]
 #![cfg_attr(not(feature = "cargo-build"),
-            unstable(feature = "unnamed_feature"))]
+            unstable(feature = "libc"))]
 #![cfg_attr(not(feature = "cargo-build"), feature(staged_api))]
 #![cfg_attr(not(feature = "cargo-build"), staged_api)]
-#![cfg_attr(not(feature = "cargo-build"), feature(unnamed_feature))]
+#![cfg_attr(not(feature = "cargo-build"), feature(core))]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![no_std]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -75,7 +75,6 @@
 //! one from Berkeley after the lawsuits died down and the CSRG dissolved.
 
 #![allow(bad_style, raw_pointer_derive)]
-#![cfg_attr(not(feature = "cargo-build"), feature(unnamed_feature))]
 #[cfg(feature = "cargo-build")] extern crate "std" as core;
 #[cfg(not(feature = "cargo-build"))] extern crate core;
 
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index 217eb8d0d3e..6fe789f3e31 100644
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -156,7 +156,7 @@
 //! if logging is disabled, none of the components of the log will be executed.
 
 #![crate_name = "log"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
             reason = "use the crates.io `log` library instead")]
 #![feature(staged_api)]
 #![staged_api]
@@ -170,9 +170,14 @@
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
 
 extern crate regex;
 
diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs
index 8f259962f19..25c205b2bf2 100644
--- a/src/librand/distributions/mod.rs
+++ b/src/librand/distributions/mod.rs
@@ -17,7 +17,7 @@
 //! internally. The `IndependentSample` trait is for generating values
 //! that do not need to record state.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
 
 use core::prelude::*;
 use core::num::{Float, Int};
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 947e13046a8..76258151850 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -22,12 +22,12 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![no_std]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
 #![feature(staged_api)]
 #![staged_api]
+#![feature(core)]
 
 #[macro_use]
 extern crate core;
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index f667c6b258d..40a29b88b99 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -16,7 +16,7 @@
 //!     http://www.matroska.org/technical/specs/rfc/index.html
 
 #![crate_name = "rbml"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -27,8 +27,11 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(rustc_private)]
 
 extern crate serialize;
 #[macro_use] extern crate log;
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index 3e80bc78d02..9631eb36056 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -16,7 +16,7 @@
 #![crate_name = "regex"]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
             reason = "use the crates.io `regex` library instead")]
 #![feature(staged_api)]
 #![staged_api]
@@ -28,9 +28,11 @@
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(unicode)]
 
 #[cfg(test)]
 extern crate "test" as stdtest;
diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index c3d9477469c..8c9df74635a 100644
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -255,7 +255,6 @@ impl Regex {
     }
 
     #[doc(hidden)]
-    #[unstable(feature = "unnamed_feature")]
     pub fn names_iter<'a>(&'a self) -> NamesIter<'a> {
         match *self {
             Native(ref n) => NamesIterNative(n.names.iter()),
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index 80714dd5e93..a5ae9e9f40a 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -15,7 +15,7 @@
 //! This API is completely unstable and subject to change.
 
 #![crate_name = "rustc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -28,9 +28,18 @@
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![feature(rustc_diagnostic_macros)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
+#![feature(hash)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs
index 21cfb4ab180..13dec65d13e 100644
--- a/src/librustc_back/lib.rs
+++ b/src/librustc_back/lib.rs
@@ -22,7 +22,7 @@
 //! build speedups.
 
 #![crate_name = "rustc_back"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -32,8 +32,14 @@
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 #![allow(unknown_features)]
 #![feature(slicing_syntax, box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
 
 extern crate syntax;
 extern crate serialize;
diff --git a/src/librustc_bitflags/lib.rs b/src/librustc_bitflags/lib.rs
index 6b7976f765b..e0f5b5c387f 100644
--- a/src/librustc_bitflags/lib.rs
+++ b/src/librustc_bitflags/lib.rs
@@ -14,7 +14,7 @@
 #![staged_api]
 #![crate_type = "rlib"]
 #![no_std]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 
 //! A typesafe bitmask flag generator.
 
diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs
index 7800a09f1ac..0182c90df1c 100644
--- a/src/librustc_borrowck/lib.rs
+++ b/src/librustc_borrowck/lib.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_name = "rustc_borrowck"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -22,9 +22,11 @@
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(non_camel_case_types)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index 9d359a23c95..772d72e59b6 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -15,7 +15,7 @@
 //! This API is completely unstable and subject to change.
 
 #![crate_name = "rustc_driver"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -29,8 +29,16 @@
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs
index 8bb794d289f..18ed2987c1c 100644
--- a/src/librustc_llvm/lib.rs
+++ b/src/librustc_llvm/lib.rs
@@ -14,7 +14,7 @@
 #![allow(dead_code)]
 
 #![crate_name = "rustc_llvm"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -26,8 +26,12 @@
 #![allow(unknown_features)]
 #![feature(link_args)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(libc)]
+#![feature(path)]
+#![feature(std_misc)]
 
 extern crate libc;
 #[macro_use] #[no_link] extern crate rustc_bitflags;
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index a24a7f40f0e..83ace21721b 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_name = "rustc_privacy"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -19,8 +19,10 @@
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index e31170855ff..a2e72fa1c55 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_name = "rustc_resolve"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -20,8 +20,12 @@
 
 #![feature(slicing_syntax)]
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(alloc)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index 0b143417668..049cc0bd0da 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -15,7 +15,7 @@
 //! This API is completely unstable and subject to change.
 
 #![crate_name = "rustc_trans"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -29,8 +29,17 @@
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(alloc)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
 
 extern crate arena;
 extern crate flate;
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index e2cf87673d2..ced77ebe892 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -64,7 +64,7 @@ This API is completely unstable and subject to change.
 */
 
 #![crate_name = "rustc_typeck"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -78,9 +78,12 @@ This API is completely unstable and subject to change.
 #![feature(slicing_syntax, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![allow(non_camel_case_types)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
 
 #[macro_use] extern crate log;
 #[macro_use] extern crate syntax;
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 4d2eaa778cd..1f5d1538302 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![crate_name = "rustdoc"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustdoc")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -20,8 +20,17 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(test)]
+#![feature(unicode)]
 
 extern crate arena;
 extern crate getopts;
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 4fe3c56b5c9..9dac8e09ad2 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -15,7 +15,7 @@ Core encoding and decoding interfaces.
 */
 
 #![crate_name = "serialize"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
             reason = "deprecated in favor of rustc-serialize on crates.io")]
 #![feature(staged_api)]
 #![staged_api]
@@ -29,8 +29,14 @@ Core encoding and decoding interfaces.
 #![feature(box_syntax)]
 #![feature(old_impl_check)]
 #![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
 
 // test harness access
 #[cfg(test)] extern crate test;
diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index c316a8ba6c7..9aa38e711e7 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -12,7 +12,7 @@
 
 //! Operations on ASCII strings and characters
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "unsure about placement and naming")]
 
 use iter::IteratorExt;
@@ -23,7 +23,7 @@ use string::String;
 use vec::Vec;
 
 /// Extension methods for ASCII-subset only operations on owned strings
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 pub trait OwnedAsciiExt {
     /// Convert the string to ASCII upper case:
@@ -38,7 +38,7 @@ pub trait OwnedAsciiExt {
 }
 
 /// Extension methods for ASCII-subset only operations on string slices
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 pub trait AsciiExt<T = Self> {
     /// Check if within the ASCII range.
@@ -60,7 +60,7 @@ pub trait AsciiExt<T = Self> {
     fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl AsciiExt<String> for str {
     #[inline]
@@ -86,7 +86,7 @@ impl AsciiExt<String> for str {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl OwnedAsciiExt for String {
     #[inline]
@@ -102,7 +102,7 @@ impl OwnedAsciiExt for String {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl AsciiExt<Vec<u8>> for [u8] {
     #[inline]
@@ -129,7 +129,7 @@ impl AsciiExt<Vec<u8>> for [u8] {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl OwnedAsciiExt for Vec<u8> {
     #[inline]
@@ -149,7 +149,7 @@ impl OwnedAsciiExt for Vec<u8> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl AsciiExt for u8 {
     #[inline]
@@ -173,7 +173,7 @@ impl AsciiExt for u8 {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "would prefer to do this in a more general way")]
 impl AsciiExt for char {
     #[inline]
@@ -216,7 +216,7 @@ impl AsciiExt for char {
 /// - Any other chars in the range [0x20,0x7e] are not escaped.
 /// - Any other chars are given hex escapes.
 /// - Unicode escapes are never generated by this function.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "needs to be updated to use an iterator")]
 pub fn escape_default<F>(c: u8, mut f: F) where
     F: FnMut(u8),
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index b9ddf54f2c8..0a0aaa9da87 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -539,7 +539,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// map.insert(1i, 2u);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")]
+    #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
     pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> {
         HashMap {
             hash_state:    hash_state,
@@ -567,7 +567,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// map.insert(1i, 2u);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")]
+    #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
     pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
                                         -> HashMap<K, V, S> {
         let resize_policy = DefaultResizePolicy::new();
@@ -928,7 +928,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     }
 
     /// Gets the given key's corresponding entry in the map for in-place manipulation.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "precise API still being fleshed out")]
     pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
     {
@@ -990,7 +990,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// assert!(a.is_empty());
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain(&mut self) -> Drain<K, V> {
         fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
@@ -1339,7 +1339,7 @@ impl<'a, K, V> Clone for Values<'a, K, V> {
 }
 
 /// HashMap drain iterator
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "matches collection reform specification, waiting for dust to settle")]
 pub struct Drain<'a, K: 'a, V: 'a> {
     inner: iter::Map<
@@ -1351,14 +1351,14 @@ pub struct Drain<'a, K: 'a, V: 'a> {
 }
 
 /// A view into a single occupied location in a HashMap
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "precise API still being fleshed out")]
 pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
     elem: FullBucket<K, V, &'a mut RawTable<K, V>>,
 }
 
 /// A view into a single empty location in a HashMap
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "precise API still being fleshed out")]
 pub struct VacantEntry<'a, K: 'a, V: 'a> {
     hash: SafeHash,
@@ -1367,7 +1367,7 @@ pub struct VacantEntry<'a, K: 'a, V: 'a> {
 }
 
 /// A view into a single location in a map, which may be vacant or occupied
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "precise API still being fleshed out")]
 pub enum Entry<'a, K: 'a, V: 'a> {
     /// An occupied Entry
@@ -1457,7 +1457,7 @@ impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {
     #[inline] fn len(&self) -> usize { self.inner.len() }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
 impl<'a, K, V> Entry<'a, K, V> {
     /// Returns a mutable reference to the entry if occupied, or the VacantEntry if vacant
@@ -1469,7 +1469,7 @@ impl<'a, K, V> Entry<'a, K, V> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
 impl<'a, K, V> OccupiedEntry<'a, K, V> {
     /// Gets a reference to the value in the entry
@@ -1501,7 +1501,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "matches collection reform v2 specification, waiting for dust to settle")]
 impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
     /// Sets the value of the entry with the VacantEntry's key,
@@ -1554,14 +1554,14 @@ impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S>
 /// instances are unlikely to produce the same result for the same values.
 #[derive(Clone)]
 #[allow(missing_copy_implementations)]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "hashing an hash maps may be altered")]
 pub struct RandomState {
     k0: u64,
     k1: u64,
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "hashing an hash maps may be altered")]
 impl RandomState {
     /// Construct a new `RandomState` that is initialized with random keys.
@@ -1572,7 +1572,7 @@ impl RandomState {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "hashing an hash maps may be altered")]
 impl HashState for RandomState {
     type Hasher = Hasher;
@@ -1581,7 +1581,7 @@ impl HashState for RandomState {
     }
 }
 
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "hashing an hash maps may be altered")]
 impl Default for RandomState {
     #[inline]
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 18778c5ee27..98c67186a3c 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -147,7 +147,7 @@ impl<T, S, H> HashSet<T, S>
     /// set.insert(2u);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")]
+    #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
     pub fn with_hash_state(hash_state: S) -> HashSet<T, S> {
         HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state)
     }
@@ -171,7 +171,7 @@ impl<T, S, H> HashSet<T, S>
     /// set.insert(1i);
     /// ```
     #[inline]
-    #[unstable(feature = "unnamed_feature", reason = "hasher stuff is unclear")]
+    #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
     pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
                                         -> HashSet<T, S> {
         HashSet {
@@ -419,7 +419,7 @@ impl<T, S, H> HashSet<T, S>
 
     /// Clears the set, returning all elements in an iterator.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain(&mut self) -> Drain<T> {
         fn first<A, B>((a, _): (A, B)) -> A { a }
diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 4d2d1e8e91c..fae17af472c 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -337,7 +337,7 @@ pub mod hash_set {
 
 /// Experimental support for providing custom hash algorithms to a HashMap and
 /// HashSet.
-#[unstable(feature = "unnamed_feature", reason = "module was recently added")]
+#[unstable(feature = "std_misc", reason = "module was recently added")]
 pub mod hash_state {
     pub use super::hash::state::*;
 }
diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs
index 7520e05be6a..f35f63143ef 100644
--- a/src/libstd/dynamic_lib.rs
+++ b/src/libstd/dynamic_lib.rs
@@ -12,7 +12,7 @@
 //!
 //! A simple wrapper over the platform's dynamic library facilities
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 #![allow(missing_docs)]
 
 use prelude::v1::*;
diff --git a/src/libstd/error.rs b/src/libstd/error.rs
index 76942c901e1..df949ab03aa 100644
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@@ -86,7 +86,7 @@ use str::Utf8Error;
 use string::{FromUtf8Error, FromUtf16Error};
 
 /// Base functionality for all errors in Rust.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "the exact API of this trait may change")]
 pub trait Error {
     /// A short description of the error; usually a static string.
diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs
index b996eefcd2d..028973a1cf1 100644
--- a/src/libstd/failure.rs
+++ b/src/libstd/failure.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use prelude::v1::*;
 
diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs
index 59f2595adac..8c11a2584d3 100644
--- a/src/libstd/ffi/mod.rs
+++ b/src/libstd/ffi/mod.rs
@@ -10,7 +10,7 @@
 
 //! Utilities related to FFI bindings.
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "module just underwent fairly large reorganization and the dust \
                       still needs to settle")]
 
diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 7d84b07da70..57b57bdfe95 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -403,7 +403,7 @@
 //! them with the same character. For example, the `{` character is escaped with
 //! `{{` and the `}` character is escaped with `}}`.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use string;
 
@@ -432,7 +432,7 @@ pub use core::fmt::{argument, argumentuint};
 /// let s = fmt::format(format_args!("Hello, {}!", "world"));
 /// assert_eq!(s, "Hello, world!".to_string());
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "this is an implementation detail of format! and should not \
                      be called directly")]
 pub fn format(args: Arguments) -> string::String {
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 3abdbce71f7..dc3cfa7ead8 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -219,7 +219,7 @@
 //! concerned with error handling; instead its caller is responsible for
 //! responding to errors that may occur while attempting to read the numbers.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "io")]
 #![deny(unused_must_use)]
 
 pub use self::SeekStyle::*;
@@ -1743,7 +1743,7 @@ pub struct FileStat {
     ///
     /// Usage of this field is discouraged, but if access is desired then the
     /// fields are located here.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub unstable: UnstableFileStat,
 }
 
@@ -1751,7 +1751,7 @@ pub struct FileStat {
 /// returned from a `stat` syscall which is not contained in the `FileStat`
 /// structure. This information is not necessarily platform independent, and may
 /// have different meanings or no meaning at all on some platforms.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "io")]
 #[derive(Copy, Hash)]
 pub struct UnstableFileStat {
     /// The ID of the device containing the file.
diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs
index 835142d1c8f..ac7e9ce5dde 100644
--- a/src/libstd/io/net/pipe.rs
+++ b/src/libstd/io/net/pipe.rs
@@ -68,7 +68,7 @@ impl UnixStream {
     ///
     /// If a `timeout` with zero or negative duration is specified then
     /// the function returns `Err`, with the error kind set to `TimedOut`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument is likely to change types")]
     pub fn connect_timeout<P>(path: P, timeout: Duration)
                               -> IoResult<UnixStream>
@@ -108,7 +108,7 @@ impl UnixStream {
     /// Sets the read/write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_timeout(timeout_ms)
@@ -117,7 +117,7 @@ impl UnixStream {
     /// Sets the read timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_read_timeout(timeout_ms)
@@ -126,7 +126,7 @@ impl UnixStream {
     /// Sets the write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_write_timeout(timeout_ms)
@@ -221,7 +221,7 @@ impl UnixAcceptor {
     /// When using this method, it is likely necessary to reset the timeout as
     /// appropriate, the timeout specified is specific to this object, not
     /// specific to the next request.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the name and arguments to this function are likely \
                          to change")]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
@@ -232,7 +232,7 @@ impl UnixAcceptor {
     ///
     /// This function has the same semantics as `TcpAcceptor::close_accept`, and
     /// more information can be found in that documentation.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn close_accept(&mut self) -> IoResult<()> {
         self.inner.close_accept()
     }
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 1b8f51e1837..d5feb5977fb 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -85,7 +85,7 @@ impl TcpStream {
     ///
     /// If a `timeout` with zero or negative duration is specified then
     /// the function returns `Err`, with the error kind set to `TimedOut`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may eventually change types")]
     pub fn connect_timeout<A: ToSocketAddr>(addr: A,
                                             timeout: Duration) -> IoResult<TcpStream> {
@@ -110,7 +110,7 @@ impl TcpStream {
     }
 
     /// Sets the nodelay flag on this connection to the boolean specified
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_nodelay(&mut self, nodelay: bool) -> IoResult<()> {
         self.inner.set_nodelay(nodelay)
     }
@@ -120,7 +120,7 @@ impl TcpStream {
     /// If the value specified is `None`, then the keepalive flag is cleared on
     /// this connection. Otherwise, the keepalive timeout will be set to the
     /// specified time, in seconds.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_keepalive(&mut self, delay_in_seconds: Option<uint>) -> IoResult<()> {
         self.inner.set_keepalive(delay_in_seconds)
     }
@@ -188,7 +188,7 @@ impl TcpStream {
     ///
     /// For clarification on the semantics of interrupting a read and a write,
     /// take a look at `set_read_timeout` and `set_write_timeout`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_timeout(timeout_ms)
@@ -206,7 +206,7 @@ impl TcpStream {
     /// action is taken. Otherwise, the read operation will be scheduled to
     /// promptly return. If a timeout error is returned, then no data was read
     /// during the timeout period.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_read_timeout(timeout_ms)
@@ -234,7 +234,7 @@ impl TcpStream {
     /// does not know how many bytes were written as part of the timeout
     /// operation. It may be the case that bytes continue to be written in an
     /// asynchronous fashion after the call to write returns.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_write_timeout(timeout_ms)
@@ -398,7 +398,7 @@ impl TcpAcceptor {
     /// a.set_timeout(None);
     /// let socket = a.accept();
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the type of the argument and name of this function are \
                          subject to change")]
     pub fn set_timeout(&mut self, ms: Option<u64>) { self.inner.set_timeout(ms); }
@@ -445,7 +445,7 @@ impl TcpAcceptor {
     /// // Signal our accept loop to exit
     /// assert!(a.close_accept().is_ok());
     /// ```
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn close_accept(&mut self) -> IoResult<()> {
         self.inner.close_accept()
     }
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 0fc868969d9..6e336168b16 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -92,13 +92,13 @@ impl UdpSocket {
     }
 
     /// Joins a multicast IP address (becomes a member of it)
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn join_multicast(&mut self, multi: IpAddr) -> IoResult<()> {
         self.inner.join_multicast(multi)
     }
 
     /// Leaves a multicast IP address (drops membership from it)
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn leave_multicast(&mut self, multi: IpAddr) -> IoResult<()> {
         self.inner.leave_multicast(multi)
     }
@@ -106,25 +106,25 @@ impl UdpSocket {
     /// Set the multicast loop flag to the specified value
     ///
     /// This lets multicast packets loop back to local sockets (if enabled)
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_multicast_loop(&mut self, on: bool) -> IoResult<()> {
         self.inner.set_multicast_loop(on)
     }
 
     /// Sets the multicast TTL
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_multicast_ttl(&mut self, ttl: int) -> IoResult<()> {
         self.inner.multicast_time_to_live(ttl)
     }
 
     /// Sets this socket's TTL
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_ttl(&mut self, ttl: int) -> IoResult<()> {
         self.inner.time_to_live(ttl)
     }
 
     /// Sets the broadcast flag on or off
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "io")]
     pub fn set_broadcast(&mut self, broadcast: bool) -> IoResult<()> {
         self.inner.set_broadcast(broadcast)
     }
@@ -132,7 +132,7 @@ impl UdpSocket {
     /// Sets the read/write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_timeout(timeout_ms)
@@ -141,7 +141,7 @@ impl UdpSocket {
     /// Sets the read timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_read_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_read_timeout(timeout_ms)
@@ -150,7 +150,7 @@ impl UdpSocket {
     /// Sets the write timeout for this socket.
     ///
     /// For more information, see `TcpStream::set_timeout`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the timeout argument may change in type and value")]
     pub fn set_write_timeout(&mut self, timeout_ms: Option<u64>) {
         self.inner.set_write_timeout(timeout_ms)
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index f567057d47a..6b09ac9a58f 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -689,7 +689,7 @@ impl Process {
     ///     p.wait()
     /// }
     /// ```
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "io",
                reason = "the type of the timeout is likely to change")]
     pub fn set_timeout(&mut self, timeout_ms: Option<u64>) {
         self.deadline = timeout_ms.map(|i| i + sys::timer::now()).unwrap_or(0);
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 5ad90a76ef8..025552e6094 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -114,7 +114,13 @@
 #![feature(optin_builtin_traits)]
 #![feature(int_uint)]
 #![feature(int_uint)]
-#![feature(unnamed_feature)]
+#![feature(core)]
+#![feature(libc)]
+#![feature(alloc)]
+#![feature(unicode)]
+#![feature(collections)]
+#![feature(rand)]
+#![feature(hash)]
 
 // Don't link to std. We are std.
 #![no_std]
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index bbbbe2aa152..7c9ee95bc20 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -14,7 +14,7 @@
 //! library. Each macro is available for use when linking against the standard
 //! library.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 /// The entry point for panic of Rust tasks.
 ///
@@ -148,7 +148,7 @@ macro_rules! try {
 ///
 /// For more information about select, see the `std::sync::mpsc::Select` structure.
 #[macro_export]
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
 macro_rules! select {
     (
         $($name:pat = $rx:ident.$meth:ident() => $code:expr),+
diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index b689734b0a0..5413f3a900f 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -366,7 +366,7 @@ impl Float for f32 {
 ///
 /// * num - The float value
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_string(num: f32) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigAll, ExpNone, false);
@@ -379,7 +379,7 @@ pub fn to_string(num: f32) -> String {
 ///
 /// * num - The float value
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_hex(num: f32) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 16u, true, SignNeg, DigAll, ExpNone, false);
@@ -394,7 +394,7 @@ pub fn to_str_hex(num: f32) -> String {
 /// * num - The float value
 /// * radix - The base to use
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) {
     strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
 }
@@ -407,7 +407,7 @@ pub fn to_str_radix_special(num: f32, rdx: uint) -> (String, bool) {
 /// * num - The float value
 /// * digits - The number of significant digits
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exact(num: f32, dig: uint) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
@@ -422,7 +422,7 @@ pub fn to_str_exact(num: f32, dig: uint) -> String {
 /// * num - The float value
 /// * digits - The number of significant digits
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_digits(num: f32, dig: uint) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
@@ -438,7 +438,7 @@ pub fn to_str_digits(num: f32, dig: uint) -> String {
 /// * digits - The number of digits after the decimal point
 /// * upper - Use `E` instead of `e` for the exponent sign
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
@@ -454,7 +454,7 @@ pub fn to_str_exp_exact(num: f32, dig: uint, upper: bool) -> String {
 /// * digits - The number of digits after the decimal point
 /// * upper - Use `E` instead of `e` for the exponent sign
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exp_digits(num: f32, dig: uint, upper: bool) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index a8992012aa2..1fd4f056a2d 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -375,7 +375,7 @@ impl Float for f64 {
 ///
 /// * num - The float value
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_string(num: f64) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigAll, ExpNone, false);
@@ -388,7 +388,7 @@ pub fn to_string(num: f64) -> String {
 ///
 /// * num - The float value
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_hex(num: f64) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 16u, true, SignNeg, DigAll, ExpNone, false);
@@ -403,7 +403,7 @@ pub fn to_str_hex(num: f64) -> String {
 /// * num - The float value
 /// * radix - The base to use
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) {
     strconv::float_to_str_common(num, rdx, true, SignNeg, DigAll, ExpNone, false)
 }
@@ -416,7 +416,7 @@ pub fn to_str_radix_special(num: f64, rdx: uint) -> (String, bool) {
 /// * num - The float value
 /// * digits - The number of significant digits
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exact(num: f64, dig: uint) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigExact(dig), ExpNone, false);
@@ -431,7 +431,7 @@ pub fn to_str_exact(num: f64, dig: uint) -> String {
 /// * num - The float value
 /// * digits - The number of significant digits
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_digits(num: f64, dig: uint) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigMax(dig), ExpNone, false);
@@ -447,7 +447,7 @@ pub fn to_str_digits(num: f64, dig: uint) -> String {
 /// * digits - The number of digits after the decimal point
 /// * upper - Use `E` instead of `e` for the exponent sign
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigExact(dig), ExpDec, upper);
@@ -463,7 +463,7 @@ pub fn to_str_exp_exact(num: f64, dig: uint, upper: bool) -> String {
 /// * digits - The number of digits after the decimal point
 /// * upper - Use `E` instead of `e` for the exponent sign
 #[inline]
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub fn to_str_exp_digits(num: f64, dig: uint, upper: bool) -> String {
     let (r, _) = strconv::float_to_str_common(
         num, 10u, true, SignNeg, DigMax(dig), ExpDec, upper);
diff --git a/src/libstd/num/float_macros.rs b/src/libstd/num/float_macros.rs
index 6fa89be1f28..2b730cd6f9a 100644
--- a/src/libstd/num/float_macros.rs
+++ b/src/libstd/num/float_macros.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 #![doc(hidden)]
 
 macro_rules! assert_approx_eq {
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 3bc40bebf73..af1976d5750 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 #![doc(hidden)]
 
 macro_rules! int_module { ($T:ty) => (
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index d074144d80a..b73882c76c1 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -33,7 +33,7 @@ pub use core::num::{FpCategory};
 
 use option::Option;
 
-#[unstable(feature = "unnamed_feature", reason = "may be removed or relocated")]
+#[unstable(feature = "std_misc", reason = "may be removed or relocated")]
 pub mod strconv;
 
 /// Mathematical operations on primitive floating point numbers.
@@ -52,27 +52,27 @@ pub trait Float
 {
     // inlined methods from `num::Float`
     /// Returns the NaN value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn nan() -> Self;
     /// Returns the infinite value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn infinity() -> Self;
     /// Returns the negative infinite value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn neg_infinity() -> Self;
     /// Returns the `0` value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn zero() -> Self;
     /// Returns -0.0.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn neg_zero() -> Self;
     /// Returns the `1` value.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn one() -> Self;
 
@@ -109,37 +109,37 @@ pub trait Float
     fn max_10_exp(unused_self: Option<Self>) -> int;
 
     /// Returns the smallest finite value that this type can represent.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn min_value() -> Self;
     /// Returns the smallest normalized positive number that this type can represent.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn min_pos_value(unused_self: Option<Self>) -> Self;
     /// Returns the largest finite value that this type can represent.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn max_value() -> Self;
 
     /// Returns true if this value is NaN and false otherwise.
-    #[unstable(feature = "unnamed_feature", reason = "position is undecided")]
+    #[unstable(feature = "std_misc", reason = "position is undecided")]
     fn is_nan(self) -> bool;
     /// Returns true if this value is positive infinity or negative infinity and
     /// false otherwise.
-    #[unstable(feature = "unnamed_feature", reason = "position is undecided")]
+    #[unstable(feature = "std_misc", reason = "position is undecided")]
     fn is_infinite(self) -> bool;
     /// Returns true if this number is neither infinite nor NaN.
-    #[unstable(feature = "unnamed_feature", reason = "position is undecided")]
+    #[unstable(feature = "std_misc", reason = "position is undecided")]
     fn is_finite(self) -> bool;
     /// Returns true if this number is neither zero, infinite, denormal, or NaN.
-    #[unstable(feature = "unnamed_feature", reason = "position is undecided")]
+    #[unstable(feature = "std_misc", reason = "position is undecided")]
     fn is_normal(self) -> bool;
     /// Returns the category that this number falls into.
     #[stable(feature = "grandfathered", since = "1.0.0")]
     fn classify(self) -> FpCategory;
 
     /// Returns the mantissa, exponent and sign as integers, respectively.
-    #[unstable(feature = "unnamed_feature", reason = "signature is undecided")]
+    #[unstable(feature = "std_misc", reason = "signature is undecided")]
     fn integer_decode(self) -> (u64, i16, i8);
 
     /// Return the largest integer less than or equal to a number.
@@ -182,11 +182,11 @@ pub trait Float
     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
     /// error. This produces a more accurate result with better performance than
     /// a separate multiplication operation followed by an add.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn mul_add(self, a: Self, b: Self) -> Self;
     /// Take the reciprocal (inverse) of a number, `1/x`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn recip(self) -> Self;
 
@@ -205,7 +205,7 @@ pub trait Float
     #[stable(feature = "grandfathered", since = "1.0.0")]
     fn sqrt(self) -> Self;
     /// Take the reciprocal (inverse) square root of a number, `1/sqrt(x)`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn rsqrt(self) -> Self;
 
@@ -229,15 +229,15 @@ pub trait Float
     fn log10(self) -> Self;
 
     /// Convert radians to degrees.
-    #[unstable(feature = "unnamed_feature", reason = "desirability is unclear")]
+    #[unstable(feature = "std_misc", reason = "desirability is unclear")]
     fn to_degrees(self) -> Self;
     /// Convert degrees to radians.
-    #[unstable(feature = "unnamed_feature", reason = "desirability is unclear")]
+    #[unstable(feature = "std_misc", reason = "desirability is unclear")]
     fn to_radians(self) -> Self;
 
     /// Constructs a floating point number created by multiplying `x` by 2
     /// raised to the power of `exp`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "pending integer conventions")]
     fn ldexp(x: Self, exp: int) -> Self;
     /// Breaks the number into a normalized fraction and a base-2 exponent,
@@ -246,13 +246,13 @@ pub trait Float
     ///  * `self = x * pow(2, exp)`
     ///
     ///  * `0.5 <= abs(x) < 1.0`
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "pending integer conventions")]
     fn frexp(self) -> (Self, int);
 
     /// Returns the next representable floating-point value in the direction of
     /// `other`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn next_after(self, other: Self) -> Self;
 
@@ -266,15 +266,15 @@ pub trait Float
     /// The positive difference of two numbers. Returns `0.0` if the number is
     /// less than or equal to `other`, otherwise the difference between`self`
     /// and `other` is returned.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+    #[unstable(feature = "std_misc", reason = "may be renamed")]
     fn abs_sub(self, other: Self) -> Self;
 
     /// Take the cubic root of a number.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+    #[unstable(feature = "std_misc", reason = "may be renamed")]
     fn cbrt(self) -> Self;
     /// Calculate the length of the hypotenuse of a right-angle triangle given
     /// legs of length `x` and `y`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure about its place in the world")]
     fn hypot(self, other: Self) -> Self;
 
@@ -313,11 +313,11 @@ pub trait Float
 
     /// Returns the exponential of the number, minus 1, in a way that is
     /// accurate even if the number is close to zero.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+    #[unstable(feature = "std_misc", reason = "may be renamed")]
     fn exp_m1(self) -> Self;
     /// Returns the natural logarithm of the number plus 1 (`ln(1+n)`) more
     /// accurately than if the operations were performed separately.
-    #[unstable(feature = "unnamed_feature", reason = "may be renamed")]
+    #[unstable(feature = "std_misc", reason = "may be renamed")]
     fn ln_1p(self) -> Self;
 
     /// Hyperbolic sine function.
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index fb23c5647c8..82c55d7b5b8 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 #![doc(hidden)]
 #![allow(unsigned_negation)]
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 26380515474..efd571be9e2 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -22,7 +22,7 @@
 //! so we will not _hide_ the facts of which OS the user is on -- they should be given the
 //! opportunity to write OS-ignorant code by default.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "os")]
 
 #![allow(missing_docs)]
 #![allow(non_snake_case)]
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 864d49a430c..7a34a1d8c38 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -59,7 +59,7 @@
 //! println!("path exists: {}", path.exists());
 //! ```
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "path")]
 
 use core::marker::Sized;
 use ffi::CString;
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index d03ca5bf78c..3251656cd16 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -19,7 +19,7 @@
 #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // TEMPORARY
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
 #[doc(no_inline)] pub use ops::FullRange;
 
 // Reexported functions
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 2b7b026af5e..5844cc85c31 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -219,7 +219,7 @@
 //! }
 //! ```
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rand")]
 
 use cell::RefCell;
 use clone::Clone;
diff --git a/src/libstd/rt/mod.rs b/src/libstd/rt/mod.rs
index aa16ee05ece..7e19f1cac2c 100644
--- a/src/libstd/rt/mod.rs
+++ b/src/libstd/rt/mod.rs
@@ -16,7 +16,7 @@
 //! and should be considered as private implementation details for the
 //! time being.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 // FIXME: this should not be here.
 #![allow(missing_docs)]
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index bbe97dbe08f..7d886f9936f 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -582,7 +582,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
 /// Only a limited number of callbacks can be registered, and this function
 /// returns whether the callback was successfully registered or not. It is not
 /// currently possible to unregister a callback once it has been registered.
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "std_misc")]
 pub unsafe fn register(f: Callback) -> bool {
     match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) {
         // The invocation code has knowledge of this window where the count has
diff --git a/src/libstd/rtdeps.rs b/src/libstd/rtdeps.rs
index d69c94bb020..06b68162487 100644
--- a/src/libstd/rtdeps.rs
+++ b/src/libstd/rtdeps.rs
@@ -12,7 +12,7 @@
 //! the standard library This varies per-platform, but these libraries are
 //! necessary for running libstd.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 // All platforms need to link to rustrt
 #[cfg(not(test))]
diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs
index a84decc2efa..e36dd943386 100644
--- a/src/libstd/sync/condvar.rs
+++ b/src/libstd/sync/condvar.rs
@@ -76,7 +76,7 @@ unsafe impl Sync for Condvar {}
 ///
 /// static CVAR: StaticCondvar = CONDVAR_INIT;
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with Condvar in the future")]
 pub struct StaticCondvar {
     inner: sys::Condvar,
@@ -87,7 +87,7 @@ unsafe impl Send for StaticCondvar {}
 unsafe impl Sync for StaticCondvar {}
 
 /// Constant initializer for a statically allocated condition variable.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with Condvar in the future")]
 pub const CONDVAR_INIT: StaticCondvar = StaticCondvar {
     inner: sys::CONDVAR_INIT,
@@ -156,7 +156,7 @@ impl Condvar {
     ///
     /// Like `wait`, the lock specified will be re-acquired when this function
     /// returns, regardless of whether the timeout elapsed or not.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "std_misc")]
     pub fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>, dur: Duration)
                            -> LockResult<(MutexGuard<'a, T>, bool)> {
         unsafe {
@@ -171,7 +171,7 @@ impl Condvar {
     /// The semantics of this function are equivalent to `wait_timeout` except
     /// that the implementation will repeatedly wait while the duration has not
     /// passed and the provided function returns `false`.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "std_misc")]
     pub fn wait_timeout_with<'a, T, F>(&self,
                                        guard: MutexGuard<'a, T>,
                                        dur: Duration,
@@ -217,7 +217,7 @@ impl StaticCondvar {
     /// notification.
     ///
     /// See `Condvar::wait`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub fn wait<'a, T>(&'static self, guard: MutexGuard<'a, T>)
                        -> LockResult<MutexGuard<'a, T>> {
@@ -238,7 +238,7 @@ impl StaticCondvar {
     /// specified duration.
     ///
     /// See `Condvar::wait_timeout`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub fn wait_timeout<'a, T>(&'static self, guard: MutexGuard<'a, T>, dur: Duration)
                                -> LockResult<(MutexGuard<'a, T>, bool)> {
@@ -262,7 +262,7 @@ impl StaticCondvar {
     /// passed and the function returns `false`.
     ///
     /// See `Condvar::wait_timeout_with`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub fn wait_timeout_with<'a, T, F>(&'static self,
                                        guard: MutexGuard<'a, T>,
@@ -303,14 +303,14 @@ impl StaticCondvar {
     /// Wake up one blocked thread on this condvar.
     ///
     /// See `Condvar::notify_one`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub fn notify_one(&'static self) { unsafe { self.inner.notify_one() } }
 
     /// Wake up all blocked threads on this condvar.
     ///
     /// See `Condvar::notify_all`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub fn notify_all(&'static self) { unsafe { self.inner.notify_all() } }
 
@@ -320,7 +320,7 @@ impl StaticCondvar {
     /// active users of the condvar, and this also doesn't prevent any future
     /// users of the condvar. This method is required to be called to not leak
     /// memory on all platforms.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Condvar in the future")]
     pub unsafe fn destroy(&'static self) {
         self.inner.destroy()
diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs
index 6218867521b..a79fb684f47 100644
--- a/src/libstd/sync/future.rs
+++ b/src/libstd/sync/future.rs
@@ -27,7 +27,7 @@
 //! ```
 
 #![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "futures as-is have yet to be deeply reevaluated with recent \
                       core changes to Rust's synchronization story, and will likely \
                       become stable in the future but are unstable until that time")]
diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index b777df56a9c..8afd8e59979 100644
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -35,7 +35,7 @@
 //! method, and see the method for more information about it. Due to this
 //! caveat, this queue may not be appropriate for all use-cases.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 // http://www.1024cores.net/home/lock-free-algorithms
 //                         /queues/non-intrusive-mpsc-node-based-queue
diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 1e25cc87b28..ee4d3a55481 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -46,7 +46,7 @@
 //! ```
 
 #![allow(dead_code)]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "This implementation, while likely sufficient, is unsafe and \
                       likely to be error prone. At some point in the future this \
                       module will likely be replaced, and it is currently \
diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs
index d12628a4f2f..893260415eb 100644
--- a/src/libstd/sync/mpsc/spsc_queue.rs
+++ b/src/libstd/sync/mpsc/spsc_queue.rs
@@ -33,7 +33,7 @@
 //! concurrently between two tasks. This data structure is safe to use and
 //! enforces the semantics that there is one pusher and one popper.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use core::prelude::*;
 
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index ec3b6576961..0d18c05f71a 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -145,7 +145,7 @@ unsafe impl<T:Send> Sync for Mutex<T> { }
 /// }
 /// // lock is unlocked here.
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with Mutex in the future")]
 pub struct StaticMutex {
     lock: sys::Mutex,
@@ -192,7 +192,7 @@ impl<'a, T> !marker::Send for MutexGuard<'a, T> {}
 
 /// Static initialization of a mutex. This constant can be used to initialize
 /// other mutex constants.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with Mutex in the future")]
 pub const MUTEX_INIT: StaticMutex = StaticMutex {
     lock: sys::MUTEX_INIT,
@@ -267,7 +267,7 @@ static DUMMY: Dummy = Dummy(UnsafeCell { value: () });
 impl StaticMutex {
     /// Acquires this lock, see `Mutex::lock`
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Mutex in the future")]
     pub fn lock(&'static self) -> LockResult<MutexGuard<()>> {
         unsafe { self.lock.lock() }
@@ -276,7 +276,7 @@ impl StaticMutex {
 
     /// Attempts to grab this lock, see `Mutex::try_lock`
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Mutex in the future")]
     pub fn try_lock(&'static self) -> TryLockResult<MutexGuard<()>> {
         if unsafe { self.lock.try_lock() } {
@@ -296,7 +296,7 @@ impl StaticMutex {
     /// *all* platforms. It may be the case that some platforms do not leak
     /// memory if this method is not called, but this is not guaranteed to be
     /// true on all platforms.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with Mutex in the future")]
     pub unsafe fn destroy(&'static self) {
         self.lock.destroy()
diff --git a/src/libstd/sync/poison.rs b/src/libstd/sync/poison.rs
index 527343c4c19..d2362eefcf1 100644
--- a/src/libstd/sync/poison.rs
+++ b/src/libstd/sync/poison.rs
@@ -110,17 +110,17 @@ impl<T> PoisonError<T> {
 
     /// Consumes this error indicating that a lock is poisoned, returning the
     /// underlying guard to allow access regardless.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "std_misc")]
     pub fn into_inner(self) -> T { self.guard }
 
     /// Reaches into this error indicating that a lock is poisoned, returning a
     /// reference to the underlying guard to allow access regardless.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "std_misc")]
     pub fn get_ref(&self) -> &T { &self.guard }
 
     /// Reaches into this error indicating that a lock is poisoned, returning a
     /// mutable reference to the underlying guard to allow access regardless.
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "std_misc")]
     pub fn get_mut(&mut self) -> &mut T { &mut self.guard }
 }
 
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index f76bee16107..abed6fd99a5 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -90,7 +90,7 @@ unsafe impl<T> Sync for RwLock<T> {}
 /// }
 /// unsafe { LOCK.destroy() } // free all resources
 /// ```
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with RwLock in the future")]
 pub struct StaticRwLock {
     lock: sys::RWLock,
@@ -101,7 +101,7 @@ unsafe impl Send for StaticRwLock {}
 unsafe impl Sync for StaticRwLock {}
 
 /// Constant initialization for a statically-initialized rwlock.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may be merged with RwLock in the future")]
 pub const RW_LOCK_INIT: StaticRwLock = StaticRwLock {
     lock: sys::RWLOCK_INIT,
@@ -276,7 +276,7 @@ impl StaticRwLock {
     ///
     /// See `RwLock::read`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with RwLock in the future")]
     pub fn read(&'static self) -> LockResult<RwLockReadGuard<'static, ()>> {
         unsafe { self.lock.read() }
@@ -287,7 +287,7 @@ impl StaticRwLock {
     ///
     /// See `RwLock::try_read`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with RwLock in the future")]
     pub fn try_read(&'static self)
                     -> TryLockResult<RwLockReadGuard<'static, ()>> {
@@ -303,7 +303,7 @@ impl StaticRwLock {
     ///
     /// See `RwLock::write`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with RwLock in the future")]
     pub fn write(&'static self) -> LockResult<RwLockWriteGuard<'static, ()>> {
         unsafe { self.lock.write() }
@@ -314,7 +314,7 @@ impl StaticRwLock {
     ///
     /// See `RwLock::try_write`.
     #[inline]
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with RwLock in the future")]
     pub fn try_write(&'static self)
                      -> TryLockResult<RwLockWriteGuard<'static, ()>> {
@@ -331,7 +331,7 @@ impl StaticRwLock {
     /// active users of the lock, and this also doesn't prevent any future users
     /// of this lock. This method is required to be called to not leak memory on
     /// all platforms.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may be merged with RwLock in the future")]
     pub unsafe fn destroy(&'static self) {
         self.lock.destroy()
diff --git a/src/libstd/sync/semaphore.rs b/src/libstd/sync/semaphore.rs
index e9528e1133c..25f31d6e147 100644
--- a/src/libstd/sync/semaphore.rs
+++ b/src/libstd/sync/semaphore.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "the interaction between semaphores and the acquisition/release \
                       of resources is currently unclear")]
 
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index 6fb60504615..3fac998d3e7 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -10,7 +10,7 @@
 
 //! Abstraction of a thread pool for basic parallelism.
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "the semantics of a failing task and whether a thread is \
                       re-attached to a thread pool are somewhat unclear, and the \
                       utility of this type in `std::sync` is questionable with \
diff --git a/src/libstd/sys/unix/ext.rs b/src/libstd/sys/unix/ext.rs
index f12ad020d06..5edcc3745ac 100644
--- a/src/libstd/sys/unix/ext.rs
+++ b/src/libstd/sys/unix/ext.rs
@@ -29,7 +29,7 @@
 //! }
 //! ```
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use sys_common::AsInner;
 use libc;
diff --git a/src/libstd/sys/windows/ext.rs b/src/libstd/sys/windows/ext.rs
index 25318551711..c078bc21be6 100644
--- a/src/libstd/sys/windows/ext.rs
+++ b/src/libstd/sys/windows/ext.rs
@@ -14,7 +14,7 @@
 //! descriptors, and sockets, but its functionality will grow over
 //! time.
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use sys_common::AsInner;
 use libc;
diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index d4bad950180..1012edfc2fe 100644
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -207,7 +207,7 @@ impl Builder {
     }
 
     /// Redirect thread-local stdout.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "Will likely go away after proc removal")]
     pub fn stdout(mut self, stdout: Box<Writer + Send>) -> Builder {
         self.stdout = Some(stdout);
@@ -215,7 +215,7 @@ impl Builder {
     }
 
     /// Redirect thread-local stderr.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "Will likely go away after proc removal")]
     pub fn stderr(mut self, stderr: Box<Writer + Send>) -> Builder {
         self.stderr = Some(stderr);
@@ -225,7 +225,7 @@ impl Builder {
     /// Spawn a new detached thread, and return a handle to it.
     ///
     /// See `Thead::spawn` and the module doc for more details.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may change with specifics of new Send semantics")]
     pub fn spawn<F>(self, f: F) -> Thread where F: FnOnce(), F: Send + 'static {
         let (native, thread) = self.spawn_inner(Thunk::new(f), Thunk::with_arg(|_| {}));
@@ -237,7 +237,7 @@ impl Builder {
     /// scope, and return a `JoinGuard`.
     ///
     /// See `Thead::scoped` and the module doc for more details.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may change with specifics of new Send semantics")]
     pub fn scoped<'a, T, F>(self, f: F) -> JoinGuard<'a, T> where
         T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
@@ -354,7 +354,7 @@ impl Thread {
     /// main thread; the whole process is terminated when the main thread
     /// finishes.) The thread handle can be used for low-level
     /// synchronization. See the module documentation for additional details.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may change with specifics of new Send semantics")]
     pub fn spawn<F>(f: F) -> Thread where F: FnOnce(), F: Send + 'static {
         Builder::new().spawn(f)
@@ -368,7 +368,7 @@ impl Thread {
     /// current thread's stack (hence the "scoped" name), it cannot be detached;
     /// it *must* be joined before the relevant stack frame is popped. See the
     /// module documentation for additional details.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "may change with specifics of new Send semantics")]
     pub fn scoped<'a, T, F>(f: F) -> JoinGuard<'a, T> where
         T: Send + 'a, F: FnOnce() -> T, F: Send + 'a
@@ -383,7 +383,7 @@ impl Thread {
     }
 
     /// Cooperatively give up a timeslice to the OS scheduler.
-    #[unstable(feature = "unnamed_feature", reason = "name may change")]
+    #[unstable(feature = "std_misc", reason = "name may change")]
     pub fn yield_now() {
         unsafe { imp::yield_now() }
     }
@@ -404,7 +404,7 @@ impl Thread {
     // future, this will be implemented in a more efficient way, perhaps along the lines of
     //   http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp
     // or futuxes, and in either case may allow spurious wakeups.
-    #[unstable(feature = "unnamed_feature", reason = "recently introduced")]
+    #[unstable(feature = "std_misc", reason = "recently introduced")]
     pub fn park() {
         let thread = Thread::current();
         let mut guard = thread.inner.lock.lock().unwrap();
@@ -417,7 +417,7 @@ impl Thread {
     /// Atomically makes the handle's token available if it is not already.
     ///
     /// See the module doc for more detail.
-    #[unstable(feature = "unnamed_feature", reason = "recently introduced")]
+    #[unstable(feature = "std_misc", reason = "recently introduced")]
     pub fn unpark(&self) {
         let mut guard = self.inner.lock.lock().unwrap();
         if !*guard {
@@ -453,7 +453,7 @@ unsafe impl<T> Sync for Packet<T> {}
 ///
 /// The type `T` is the return type for the thread's main function.
 #[must_use]
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "may change with specifics of new Send semantics")]
 pub struct JoinGuard<'a, T: 'a> {
     native: imp::rust_thread,
@@ -490,7 +490,7 @@ impl<'a, T: Send + 'a> JoinGuard<'a, T> {
 
 impl<T: Send> JoinGuard<'static, T> {
     /// Detaches the child thread, allowing it to outlive its parent.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "unsure whether this API imposes limitations elsewhere")]
     pub fn detach(mut self) {
         unsafe { imp::detach(self.native) };
diff --git a/src/libstd/thread_local/mod.rs b/src/libstd/thread_local/mod.rs
index 6fc5347b71e..94e5d19d61b 100644
--- a/src/libstd/thread_local/mod.rs
+++ b/src/libstd/thread_local/mod.rs
@@ -218,7 +218,7 @@ macro_rules! __thread_local_inner {
 }
 
 /// Indicator of the state of a thread local storage key.
-#[unstable(feature = "unnamed_feature",
+#[unstable(feature = "std_misc",
            reason = "state querying was recently added")]
 #[derive(Eq, PartialEq, Copy)]
 pub enum State {
@@ -302,7 +302,7 @@ impl<T: 'static> Key<T> {
     /// initialization does not panic. Keys in the `Valid` state are guaranteed
     /// to be able to be accessed. Keys in the `Destroyed` state will panic on
     /// any call to `with`.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "std_misc",
                reason = "state querying was recently added")]
     pub fn state(&'static self) -> State {
         unsafe {
diff --git a/src/libstd/thread_local/scoped.rs b/src/libstd/thread_local/scoped.rs
index 415219aaa83..1a20612d60a 100644
--- a/src/libstd/thread_local/scoped.rs
+++ b/src/libstd/thread_local/scoped.rs
@@ -38,7 +38,7 @@
 //! });
 //! ```
 
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "std_misc",
             reason = "scoped TLS has yet to have wide enough use to fully consider \
                       stabilizing its interface")]
 
diff --git a/src/libstd/thunk.rs b/src/libstd/thunk.rs
index d861cfb5d03..2e53d0ceecb 100644
--- a/src/libstd/thunk.rs
+++ b/src/libstd/thunk.rs
@@ -10,7 +10,7 @@
 
 // Because this module is temporary...
 #![allow(missing_docs)]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use alloc::boxed::Box;
 use core::marker::Send;
diff --git a/src/libstd/time/duration.rs b/src/libstd/time/duration.rs
index 953636749e2..1bf3454eaa1 100644
--- a/src/libstd/time/duration.rs
+++ b/src/libstd/time/duration.rs
@@ -10,7 +10,7 @@
 
 //! Temporal quantification
 
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "std_misc")]
 
 use {fmt, i64};
 use ops::{Add, Sub, Mul, Div, Neg, FnOnce};
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index a37a9a14694..ff4c7b565cb 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -15,7 +15,7 @@
 //! This API is completely unstable and subject to change.
 
 #![crate_name = "syntax"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "rustc_private")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "dylib"]
@@ -28,8 +28,17 @@
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
 #![feature(quote, unsafe_destructor)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(hash)]
+#![feature(io)]
+#![feature(libc)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
 
 extern crate arena;
 extern crate fmt_macros;
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index b834af60591..213b7ba11b7 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -39,7 +39,7 @@
 //! [ti]: https://en.wikipedia.org/wiki/Terminfo
 
 #![crate_name = "term"]
-#![unstable(feature = "unnamed_feature",
+#![unstable(feature = "rustc_private",
             reason = "use the crates.io `term` library instead")]
 #![feature(staged_api)]
 #![staged_api]
@@ -53,9 +53,16 @@
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
 #![deny(missing_docs)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
+#![feature(unicode)]
 
 #[macro_use] extern crate log;
 
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 3749d17e2db..512120243c3 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -24,7 +24,7 @@
 // build off of.
 
 #![crate_name = "test"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -35,8 +35,14 @@
 #![allow(unknown_features)]
 #![feature(asm, slicing_syntax)]
 #![feature(box_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(std_misc)]
 
 extern crate getopts;
 extern crate regex;
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index 4e642e8a5c0..6d64d3d3d35 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -21,7 +21,7 @@
 //! (yet) aim to provide a full set of Unicode tables.
 
 #![crate_name = "unicode"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "unicode")]
 #![feature(staged_api)]
 #![staged_api]
 #![crate_type = "rlib"]
@@ -31,8 +31,8 @@
        html_playground_url = "http://play.rust-lang.org/")]
 #![no_std]
 #![feature(slicing_syntax)]
-#![feature(unnamed_feature)]
 #![allow(unknown_features)] #![feature(int_uint)]
+#![feature(core)]
 
 extern crate core;
 
diff --git a/src/libunicode/u_char.rs b/src/libunicode/u_char.rs
index 812a066cdfe..31007d8b5b3 100644
--- a/src/libunicode/u_char.rs
+++ b/src/libunicode/u_char.rs
@@ -34,7 +34,7 @@ pub trait CharExt {
     /// # Panics
     ///
     /// Panics if given a radix > 36.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending integer conventions")]
     fn is_digit(self, radix: uint) -> bool;
 
@@ -49,7 +49,7 @@ pub trait CharExt {
     /// # Panics
     ///
     /// Panics if given a radix outside the range [0..36].
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending integer conventions")]
     fn to_digit(self, radix: uint) -> Option<uint>;
 
@@ -92,7 +92,7 @@ pub trait CharExt {
     ///
     /// If the buffer is not large enough, nothing will be written into it
     /// and a `None` will be returned.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf8(self, dst: &mut [u8]) -> Option<uint>;
 
@@ -101,7 +101,7 @@ pub trait CharExt {
     ///
     /// If the buffer is not large enough, nothing will be written into it
     /// and a `None` will be returned.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf16(self, dst: &mut [u16]) -> Option<uint>;
 
@@ -116,7 +116,7 @@ pub trait CharExt {
     /// 'XID_Start' is a Unicode Derived Property specified in
     /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
     /// mostly similar to ID_Start but modified for closure under NFKx.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "mainly needed for compiler internals")]
     fn is_xid_start(self) -> bool;
 
@@ -126,7 +126,7 @@ pub trait CharExt {
     /// 'XID_Continue' is a Unicode Derived Property specified in
     /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
     /// mostly similar to 'ID_Continue' but modified for closure under NFKx.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "mainly needed for compiler internals")]
     fn is_xid_continue(self) -> bool;
 
@@ -177,7 +177,7 @@ pub trait CharExt {
     ///
     /// Returns the lowercase equivalent of the character, or the character
     /// itself if no conversion is possible.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending case transformation decisions")]
     fn to_lowercase(self) -> char;
 
@@ -201,7 +201,7 @@ pub trait CharExt {
     /// [`SpecialCasing`.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
     ///
     /// [2]: http://www.unicode.org/versions/Unicode4.0.0/ch03.pdf#G33992
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending case transformation decisions")]
     fn to_uppercase(self) -> char;
 
@@ -214,17 +214,17 @@ pub trait CharExt {
     /// [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
     /// recommends that these characters be treated as 1 column (i.e.,
     /// `is_cjk` = `false`) if the context cannot be reliably determined.
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "needs expert opinion. is_cjk flag stands out as ugly")]
     fn width(self, is_cjk: bool) -> Option<uint>;
 }
 
 #[stable(feature = "grandfathered", since = "1.0.0")]
 impl CharExt for char {
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending integer conventions")]
     fn is_digit(self, radix: uint) -> bool { C::is_digit(self, radix) }
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending integer conventions")]
     fn to_digit(self, radix: uint) -> Option<uint> { C::to_digit(self, radix) }
     #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -235,10 +235,10 @@ impl CharExt for char {
     fn len_utf8(self) -> uint { C::len_utf8(self) }
     #[stable(feature = "grandfathered", since = "1.0.0")]
     fn len_utf16(self) -> uint { C::len_utf16(self) }
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf8(self, dst: &mut [u8]) -> Option<uint> { C::encode_utf8(self, dst) }
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending decision about Iterator/Writer/Reader")]
     fn encode_utf16(self, dst: &mut [u16]) -> Option<uint> { C::encode_utf16(self, dst) }
 
@@ -251,11 +251,11 @@ impl CharExt for char {
         }
     }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "mainly needed for compiler internals")]
     fn is_xid_start(self) -> bool { derived_property::XID_Start(self) }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "mainly needed for compiler internals")]
     fn is_xid_continue(self) -> bool { derived_property::XID_Continue(self) }
 
@@ -303,15 +303,15 @@ impl CharExt for char {
         }
     }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending case transformation decisions")]
     fn to_lowercase(self) -> char { conversions::to_lower(self) }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "pending case transformation decisions")]
     fn to_uppercase(self) -> char { conversions::to_upper(self) }
 
-    #[unstable(feature = "unnamed_feature",
+    #[unstable(feature = "unicode",
                reason = "needs expert opinion. is_cjk flag stands out as ugly")]
     fn width(self, is_cjk: bool) -> Option<uint> { charwidth::width(self, is_cjk) }
 }
diff --git a/src/rustbook/main.rs b/src/rustbook/main.rs
index 1e5c571888e..6d9078c6687 100644
--- a/src/rustbook/main.rs
+++ b/src/rustbook/main.rs
@@ -9,7 +9,13 @@
 // except according to those terms.
 
 #![feature(slicing_syntax, box_syntax)]
-#![feature(unnamed_feature)]
+#![feature(collections)]
+#![feature(core)]
+#![feature(io)]
+#![feature(os)]
+#![feature(path)]
+#![feature(rustc_private)]
+#![feature(rustdoc)]
 
 extern crate regex;
 
diff --git a/src/test/auxiliary/inherited_stability.rs b/src/test/auxiliary/inherited_stability.rs
index 3c79d40e45c..1fb3e4656f8 100644
--- a/src/test/auxiliary/inherited_stability.rs
+++ b/src/test/auxiliary/inherited_stability.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 #![crate_name="inherited_stability"]
 #![crate_type = "lib"]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test_feature")]
 #![feature(staged_api)]
 #![staged_api]
 
@@ -26,9 +26,9 @@ pub mod stable_mod {
     pub fn stable() {}
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub mod unstable_mod {
-    #[deprecated(feature = "unnamed_feature", since = "1.0.0")]
+    #[deprecated(feature = "test_feature", since = "1.0.0")]
     pub fn deprecated() {}
 
     pub fn unstable() {}
diff --git a/src/test/auxiliary/lint_output_format.rs b/src/test/auxiliary/lint_output_format.rs
index 9a797c197fb..c6b1579cecb 100755
--- a/src/test/auxiliary/lint_output_format.rs
+++ b/src/test/auxiliary/lint_output_format.rs
@@ -12,19 +12,19 @@
 #![crate_type = "lib"]
 #![feature(staged_api)]
 #![staged_api]
-#![unstable(feature = "unnamed_feature")]
+#![unstable(feature = "test_feature")]
 
 #[deprecated(feature = "oldstuff", since = "1.0.0")]
 pub fn foo() -> uint {
     20
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub fn bar() -> uint {
     40
 }
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub fn baz() -> uint {
     30
 }
diff --git a/src/test/auxiliary/lint_stability.rs b/src/test/auxiliary/lint_stability.rs
index d6c09cd78e8..0f2749b0b19 100644
--- a/src/test/auxiliary/lint_stability.rs
+++ b/src/test/auxiliary/lint_stability.rs
@@ -17,9 +17,9 @@ pub fn deprecated() {}
 #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
 pub fn deprecated_text() {}
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub fn unstable() {}
-#[unstable(feature = "unnamed_feature", reason = "text")]
+#[unstable(feature = "test_feature", reason = "text")]
 pub fn unstable_text() {}
 
 pub fn unmarked() {}
@@ -38,9 +38,9 @@ impl MethodTester {
     #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
     pub fn method_deprecated_text(&self) {}
 
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     pub fn method_unstable(&self) {}
-    #[unstable(feature = "unnamed_feature", reason = "text")]
+    #[unstable(feature = "test_feature", reason = "text")]
     pub fn method_unstable_text(&self) {}
 
     pub fn method_unmarked(&self) {}
@@ -67,9 +67,9 @@ pub trait Trait {
     #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
     fn trait_deprecated_text(&self) {}
 
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     fn trait_unstable(&self) {}
-    #[unstable(feature = "unnamed_feature", reason = "text")]
+    #[unstable(feature = "test_feature", reason = "text")]
     fn trait_unstable_text(&self) {}
 
     fn trait_unmarked(&self) {}
@@ -92,12 +92,12 @@ pub trait Trait {
 
 impl Trait for MethodTester {}
 
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub trait UnstableTrait {}
 
 #[deprecated(feature = "oldstuff", since = "1.0.0")]
 pub struct DeprecatedStruct { pub i: int }
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub struct UnstableStruct { pub i: int }
 pub struct UnmarkedStruct { pub i: int }
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -105,7 +105,7 @@ pub struct StableStruct { pub i: int }
 
 #[deprecated(feature = "oldstuff", since = "1.0.0")]
 pub struct DeprecatedUnitStruct;
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub struct UnstableUnitStruct;
 pub struct UnmarkedUnitStruct;
 #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -114,7 +114,7 @@ pub struct StableUnitStruct;
 pub enum Enum {
     #[deprecated(feature = "oldstuff", since = "1.0.0")]
     DeprecatedVariant,
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     UnstableVariant,
 
     UnmarkedVariant,
@@ -124,7 +124,7 @@ pub enum Enum {
 
 #[deprecated(feature = "oldstuff", since = "1.0.0")]
 pub struct DeprecatedTupleStruct(pub int);
-#[unstable(feature = "unnamed_feature")]
+#[unstable(feature = "test_feature")]
 pub struct UnstableTupleStruct(pub int);
 pub struct UnmarkedTupleStruct(pub int);
 #[stable(feature = "grandfathered", since = "1.0.0")]
diff --git a/src/test/auxiliary/stability_cfg1.rs b/src/test/auxiliary/stability_cfg1.rs
index 59f4d0ae9d9..3a92cf59611 100644
--- a/src/test/auxiliary/stability_cfg1.rs
+++ b/src/test/auxiliary/stability_cfg1.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 #![cfg_attr(foo, experimental)]
-#![cfg_attr(not(foo), stable(feature = "unnamed_feature", since = "1.0.0"))]
+#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))]
 #![feature(staged_api)]
 #![staged_api]
diff --git a/src/test/auxiliary/stability_cfg2.rs b/src/test/auxiliary/stability_cfg2.rs
index 33407293e59..d9ed76e5c58 100644
--- a/src/test/auxiliary/stability_cfg2.rs
+++ b/src/test/auxiliary/stability_cfg2.rs
@@ -10,7 +10,7 @@
 
 // compile-flags:--cfg foo
 
-#![cfg_attr(foo, unstable(feature = "unnamed_feature"))]
-#![cfg_attr(not(foo), stable(feature = "unnamed_feature", since = "1.0.0"))]
+#![cfg_attr(foo, unstable(feature = "test_feature"))]
+#![cfg_attr(not(foo), stable(feature = "test_feature", since = "1.0.0"))]
 #![feature(staged_api)]
 #![staged_api]
diff --git a/src/test/compile-fail/enable-unstable-lib-feature.rs b/src/test/compile-fail/enable-unstable-lib-feature.rs
index a5c09725817..c65b2366bf1 100644
--- a/src/test/compile-fail/enable-unstable-lib-feature.rs
+++ b/src/test/compile-fail/enable-unstable-lib-feature.rs
@@ -12,7 +12,7 @@
 
 // aux-build:stability_cfg2.rs
 
-#![feature(unnamed_feature)]
+#![feature(test_feature)]
 #![deny(non_snake_case)] // To trigger a hard error
 
 // Shouldn't generate a warning about unstable features
diff --git a/src/test/compile-fail/fail-no-dead-code-core.rs b/src/test/compile-fail/fail-no-dead-code-core.rs
index 850b4168c52..9923db3c566 100644
--- a/src/test/compile-fail/fail-no-dead-code-core.rs
+++ b/src/test/compile-fail/fail-no-dead-code-core.rs
@@ -10,7 +10,7 @@
 
 #![deny(dead_code)]
 #![allow(unreachable_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
 
 #[macro_use] extern crate core;
 
diff --git a/src/test/compile-fail/issue-17999.rs b/src/test/compile-fail/issue-17999.rs
index e8d22071800..a8804a6df06 100644
--- a/src/test/compile-fail/issue-17999.rs
+++ b/src/test/compile-fail/issue-17999.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![deny(unused_variables)]
-#![feature(unnamed_feature)]
+#![feature(core)]
 
 fn main() {
     for _ in range(1is, 101) {
diff --git a/src/test/compile-fail/lint-ctypes.rs b/src/test/compile-fail/lint-ctypes.rs
index 6d111e8ab45..3f25e9c7b76 100644
--- a/src/test/compile-fail/lint-ctypes.rs
+++ b/src/test/compile-fail/lint-ctypes.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![deny(improper_ctypes)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
 
 extern crate libc;
 
diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs
index 089aca7c84a..dc591943731 100644
--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@@ -14,7 +14,7 @@
 #![allow(non_upper_case_globals)]
 #![allow(missing_copy_implementations)]
 #![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
 
 #![crate_type="lib"]
 
diff --git a/src/test/compile-fail/lint-dead-code-3.rs b/src/test/compile-fail/lint-dead-code-3.rs
index 30782b71645..be135978d2d 100644
--- a/src/test/compile-fail/lint-dead-code-3.rs
+++ b/src/test/compile-fail/lint-dead-code-3.rs
@@ -11,7 +11,7 @@
 #![allow(unused_variables)]
 #![allow(non_camel_case_types)]
 #![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
 
 #![crate_type="lib"]
 
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index b474805748b..22570bad616 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -11,7 +11,9 @@
 #![allow(unused_variables)]
 #![allow(non_camel_case_types)]
 #![deny(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
+#![feature(core)]
+#![feature(collections)]
 
 extern crate libc;
 
diff --git a/src/test/compile-fail/lint-exceeding-bitshifts.rs b/src/test/compile-fail/lint-exceeding-bitshifts.rs
index a61cdd7fc3a..98853a2e9a1 100644
--- a/src/test/compile-fail/lint-exceeding-bitshifts.rs
+++ b/src/test/compile-fail/lint-exceeding-bitshifts.rs
@@ -11,7 +11,7 @@
 #![deny(exceeding_bitshifts)]
 #![allow(unused_variables)]
 #![allow(dead_code)]
-#![feature(unnamed_feature)]
+#![feature(core)]
 
 fn main() {
       let n = 1u8 << 7;
diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs
index ed474b6ef98..e89151aa746 100644
--- a/src/test/compile-fail/lint-stability.rs
+++ b/src/test/compile-fail/lint-stability.rs
@@ -43,9 +43,9 @@ mod cross_crate {
         foo.method_unstable(); //~ WARNING use of unstable library feature
         foo.trait_unstable(); //~ WARNING use of unstable library feature
 
-        unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
-        foo.method_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
-        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+        unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
+        foo.method_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
+        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
 
         unmarked(); //~ ERROR use of unmarked library feature
         foo.method_unmarked(); //~ ERROR use of unmarked library feature
@@ -94,7 +94,7 @@ mod cross_crate {
         foo.trait_deprecated(); //~ ERROR use of deprecated item
         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
         foo.trait_unstable(); //~ WARNING use of unstable library feature
-        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
         foo.trait_unmarked(); //~ ERROR use of unmarked library feature
         foo.trait_stable();
     }
@@ -103,7 +103,7 @@ mod cross_crate {
         foo.trait_deprecated(); //~ ERROR use of deprecated item
         foo.trait_deprecated_text(); //~ ERROR use of deprecated item: text
         foo.trait_unstable(); //~ WARNING use of unstable library feature
-        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'unnamed_feature': text
+        foo.trait_unstable_text(); //~ WARNING use of unstable library feature 'test_feature': text
         foo.trait_unmarked(); //~ ERROR use of unmarked library feature
         foo.trait_stable();
     }
@@ -144,9 +144,9 @@ mod this_crate {
     #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
     pub fn deprecated_text() {}
 
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     pub fn unstable() {}
-    #[unstable(feature = "unnamed_feature", reason = "text")]
+    #[unstable(feature = "test_feature", reason = "text")]
     pub fn unstable_text() {}
 
     pub fn unmarked() {}
@@ -165,9 +165,9 @@ mod this_crate {
         #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
         pub fn method_deprecated_text(&self) {}
 
-        #[unstable(feature = "unnamed_feature")]
+        #[unstable(feature = "test_feature")]
         pub fn method_unstable(&self) {}
-        #[unstable(feature = "unnamed_feature", reason = "text")]
+        #[unstable(feature = "test_feature", reason = "text")]
         pub fn method_unstable_text(&self) {}
 
         pub fn method_unmarked(&self) {}
@@ -184,9 +184,9 @@ mod this_crate {
         #[deprecated(feature = "oldstuff", since = "1.0.0", reason = "text")]
         fn trait_deprecated_text(&self) {}
 
-        #[unstable(feature = "unnamed_feature")]
+        #[unstable(feature = "test_feature")]
         fn trait_unstable(&self) {}
-        #[unstable(feature = "unnamed_feature", reason = "text")]
+        #[unstable(feature = "test_feature", reason = "text")]
         fn trait_unstable_text(&self) {}
 
         fn trait_unmarked(&self) {}
@@ -201,7 +201,7 @@ mod this_crate {
 
     #[deprecated(feature = "oldstuff", since = "1.0.0")]
     pub struct DeprecatedStruct { i: isize }
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     pub struct UnstableStruct { i: isize }
     pub struct UnmarkedStruct { i: isize }
     #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -209,7 +209,7 @@ mod this_crate {
 
     #[deprecated(feature = "oldstuff", since = "1.0.0")]
     pub struct DeprecatedUnitStruct;
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     pub struct UnstableUnitStruct;
     pub struct UnmarkedUnitStruct;
     #[stable(feature = "grandfathered", since = "1.0.0")]
@@ -218,7 +218,7 @@ mod this_crate {
     pub enum Enum {
         #[deprecated(feature = "oldstuff", since = "1.0.0")]
         DeprecatedVariant,
-        #[unstable(feature = "unnamed_feature")]
+        #[unstable(feature = "test_feature")]
         UnstableVariant,
 
         UnmarkedVariant,
@@ -228,7 +228,7 @@ mod this_crate {
 
     #[deprecated(feature = "oldstuff", since = "1.0.0")]
     pub struct DeprecatedTupleStruct(isize);
-    #[unstable(feature = "unnamed_feature")]
+    #[unstable(feature = "test_feature")]
     pub struct UnstableTupleStruct(isize);
     pub struct UnmarkedTupleStruct(isize);
     #[stable(feature = "grandfathered", since = "1.0.0")]
diff --git a/src/test/compile-fail/lint-unused-extern-crate.rs b/src/test/compile-fail/lint-unused-extern-crate.rs
index 08df9c70973..03bb7cc1f15 100644
--- a/src/test/compile-fail/lint-unused-extern-crate.rs
+++ b/src/test/compile-fail/lint-unused-extern-crate.rs
@@ -12,7 +12,9 @@
 
 #![deny(unused_extern_crates)]
 #![allow(unused_variables)]
-#![feature(unnamed_feature)]
+#![feature(libc)]
+#![feature(collections)]
+#![feature(rand)]
 
 extern crate libc; //~ ERROR: unused extern crate
 
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index df622b92f8a..6b3c680749f 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -12,7 +12,8 @@
 
 #![allow(dead_code)]
 #![deny(non_snake_case)]
-#![feature(unnamed_feature)]
+#![feature(path)]
+#![feature(io)]
 
 use std::io::File;
 use std::io::IoError;
diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs
index 7ce4cf518e4..4a3f7e9cad9 100644
--- a/src/test/compile-fail/liveness-unused.rs
+++ b/src/test/compile-fail/liveness-unused.rs
@@ -11,7 +11,8 @@
 #![deny(unused_variables)]
 #![deny(unused_assignments)]
 #![allow(dead_code, non_camel_case_types)]
-#![feature(unnamed_feature)]
+#![feature(core)]
+#![feature(os)]
 
 fn f1(x: isize) {
     //~^ ERROR unused variable: `x`
diff --git a/src/test/compile-fail/unused-attr.rs b/src/test/compile-fail/unused-attr.rs
index 89570aabff9..50217ff9e5d 100644
--- a/src/test/compile-fail/unused-attr.rs
+++ b/src/test/compile-fail/unused-attr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 #![deny(unused_attributes)]
 #![allow(dead_code, unused_imports)]
-#![feature(unnamed_feature)]
+#![feature(core)]
 
 #![foo] //~ ERROR unused attribute