Remove deprecated functionality

This removes a large array of deprecated functionality, regardless of how
recently it was deprecated. The purpose of this commit is to clean out the
standard libraries and compiler for the upcoming alpha release.

Some notable compiler changes were to enable warnings for all now-deprecated
command line arguments (previously the deprecated versions were silently
accepted) as well as removing deriving(Zero) entirely (the trait was removed).

The distribution no longer contains the libtime or libregex_macros crates. Both
of these have been deprecated for some time and are available externally.

51 files changed, 242 insertions, 1027 deletions

diff --git a/src/libstd/ascii.rs b/src/libstd/ascii.rs
index 857a7072009..bcd87f6786d 100644
--- a/src/libstd/ascii.rs
+++ b/src/libstd/ascii.rs
@@ -13,7 +13,6 @@
 //! Operations on ASCII strings and characters
 
 #![unstable = "unsure about placement and naming"]
-#![allow(deprecated)]
 
 use core::kinds::Sized;
 use iter::IteratorExt;
diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index 4fb4f220c59..9c96a9cac78 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -266,10 +266,6 @@ impl CString {
         self.buf
     }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub unsafe fn unwrap(self) -> *const libc::c_char { self.into_inner() }
-
     /// Return the number of bytes in the CString (not including the NUL
     /// terminator).
     #[inline]
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 40942f1b987..4a20208f31a 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -150,10 +150,6 @@ impl<T> CVec<T> {
         self.base
     }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub unsafe fn unwrap(self) -> *mut T { self.into_inner() }
-
     /// Returns the number of items in this vector.
     pub fn len(&self) -> uint { self.len }
 
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index c63484396d2..651f31b205d 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -16,7 +16,7 @@ use self::VacantEntryState::*;
 
 use borrow::BorrowFrom;
 use clone::Clone;
-use cmp::{max, Eq, Equiv, PartialEq};
+use cmp::{max, Eq, PartialEq};
 use default::Default;
 use fmt::{self, Show};
 use hash::{Hash, Hasher, RandomSipHasher};
@@ -444,20 +444,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         table::make_hash(&self.hasher, x)
     }
 
-    #[allow(deprecated)]
-    fn search_equiv<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a self, q: &Q)
-                    -> Option<FullBucketImm<'a, K, V>> {
-        let hash = self.make_hash(q);
-        search_hashed(&self.table, hash, |k| q.equiv(k)).into_option()
-    }
-
-    #[allow(deprecated)]
-    fn search_equiv_mut<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a mut self, q: &Q)
-                    -> Option<FullBucketMut<'a, K, V>> {
-        let hash = self.make_hash(q);
-        search_hashed(&mut self.table, hash, |k| q.equiv(k)).into_option()
-    }
-
     /// Search for a key, yielding the index if it's found in the hashtable.
     /// If you already have the hash for the key lying around, use
     /// search_hashed.
@@ -807,30 +793,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         }
     }
 
-    /// Deprecated: use `contains_key` and `BorrowFrom` instead.
-    #[deprecated = "use contains_key and BorrowFrom instead"]
-    pub fn contains_key_equiv<Sized? Q: Hash<S> + Equiv<K>>(&self, key: &Q) -> bool {
-        self.search_equiv(key).is_some()
-    }
-
-    /// Deprecated: use `get` and `BorrowFrom` instead.
-    #[deprecated = "use get and BorrowFrom instead"]
-    pub fn find_equiv<'a, Sized? Q: Hash<S> + Equiv<K>>(&'a self, k: &Q) -> Option<&'a V> {
-        self.search_equiv(k).map(|bucket| bucket.into_refs().1)
-    }
-
-    /// Deprecated: use `remove` and `BorrowFrom` instead.
-    #[deprecated = "use remove and BorrowFrom instead"]
-    pub fn pop_equiv<Sized? Q:Hash<S> + Equiv<K>>(&mut self, k: &Q) -> Option<V> {
-        if self.table.size() == 0 {
-            return None
-        }
-
-        self.reserve(1);
-
-        self.search_equiv_mut(k).map(|bucket| pop_internal(bucket).1)
-    }
-
     /// An iterator visiting all keys in arbitrary order.
     /// Iterator element type is `&'a K`.
     ///
@@ -1047,12 +1009,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         self.drain();
     }
 
-    /// Deprecated: Renamed to `get`.
-    #[deprecated = "Renamed to `get`"]
-    pub fn find(&self, k: &K) -> Option<&V> {
-        self.get(k)
-    }
-
     /// Returns a reference to the value corresponding to the key.
     ///
     /// The key may be any borrowed form of the map's key type, but
@@ -1099,12 +1055,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         self.search(k).is_some()
     }
 
-    /// Deprecated: Renamed to `get_mut`.
-    #[deprecated = "Renamed to `get_mut`"]
-    pub fn find_mut(&mut self, k: &K) -> Option<&mut V> {
-        self.get_mut(k)
-    }
-
     /// Returns a mutable reference to the value corresponding to the key.
     ///
     /// The key may be any borrowed form of the map's key type, but
@@ -1131,12 +1081,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         self.search_mut(k).map(|bucket| bucket.into_mut_refs().1)
     }
 
-    /// Deprecated: Renamed to `insert`.
-    #[deprecated = "Renamed to `insert`"]
-    pub fn swap(&mut self, k: K, v: V) -> Option<V> {
-        self.insert(k, v)
-    }
-
     /// Inserts a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise, `None` is returned.
     ///
@@ -1165,12 +1109,6 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
         retval
     }
 
-    /// Deprecated: Renamed to `remove`.
-    #[deprecated = "Renamed to `remove`"]
-    pub fn pop(&mut self, k: &K) -> Option<V> {
-        self.remove(k)
-    }
-
     /// Removes a key from the map, returning the value at the key if the key
     /// was previously in the map.
     ///
@@ -1246,24 +1184,6 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas
     }
 }
 
-impl<K: Eq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> {
-    /// Deprecated: Use `map.get(k).cloned()`.
-    ///
-    /// Return a copy of the value corresponding to the key.
-    #[deprecated = "Use `map.get(k).cloned()`"]
-    pub fn find_copy(&self, k: &K) -> Option<V> {
-        self.get(k).cloned()
-    }
-
-    /// Deprecated: Use `map[k].clone()`.
-    ///
-    /// Return a copy of the value corresponding to the key.
-    #[deprecated = "Use `map[k].clone()`"]
-    pub fn get_copy(&self, k: &K) -> V {
-        self[*k].clone()
-    }
-}
-
 #[stable]
 impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> {
     fn eq(&self, other: &HashMap<K, V, H>) -> bool {
@@ -1574,30 +1494,12 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Extend<(K, V)> for HashMap<K
 mod test_map {
     use prelude::v1::*;
 
-    use cmp::Equiv;
     use super::HashMap;
     use super::Entry::{Occupied, Vacant};
-    use hash;
-    use iter::{range_inclusive, range_step_inclusive};
+    use iter::{range_inclusive, range_step_inclusive, repeat};
     use cell::RefCell;
     use rand::{weak_rng, Rng};
 
-    struct KindaIntLike(int);
-
-    #[allow(deprecated)]
-    impl Equiv<int> for KindaIntLike {
-        fn equiv(&self, other: &int) -> bool {
-            let KindaIntLike(this) = *self;
-            this == *other
-        }
-    }
-    impl<S: hash::Writer> hash::Hash<S> for KindaIntLike {
-        fn hash(&self, state: &mut S) {
-            let KindaIntLike(this) = *self;
-            this.hash(state)
-        }
-    }
-
     #[test]
     fn test_create_capacity_zero() {
         let mut m = HashMap::with_capacity(0);
@@ -1654,7 +1556,7 @@ mod test_map {
     #[test]
     fn test_drops() {
         DROP_VECTOR.with(|slot| {
-            *slot.borrow_mut() = Vec::from_elem(200, 0i);
+            *slot.borrow_mut() = repeat(0i).take(200).collect();
         });
 
         {
@@ -1713,7 +1615,7 @@ mod test_map {
     #[test]
     fn test_move_iter_drops() {
         DROP_VECTOR.with(|v| {
-            *v.borrow_mut() = Vec::from_elem(200, 0i);
+            *v.borrow_mut() = repeat(0).take(200).collect();
         });
 
         let hm = {
@@ -1912,15 +1814,6 @@ mod test_map {
     }
 
     #[test]
-    #[allow(deprecated)]
-    fn test_pop_equiv() {
-        let mut m = HashMap::new();
-        m.insert(1i, 2i);
-        assert_eq!(m.pop_equiv(&KindaIntLike(1)), Some(2));
-        assert_eq!(m.pop_equiv(&KindaIntLike(1)), None);
-    }
-
-    #[test]
     fn test_iterate() {
         let mut m = HashMap::with_capacity(4);
         for i in range(0u, 32) {
@@ -1971,27 +1864,6 @@ mod test_map {
     }
 
     #[test]
-    #[allow(deprecated)]
-    fn test_find_copy() {
-        let mut m = HashMap::new();
-        assert!(m.get(&1i).is_none());
-
-        for i in range(1i, 10000) {
-            m.insert(i, i + 7);
-            match m.find_copy(&i) {
-                None => panic!(),
-                Some(v) => assert_eq!(v, i + 7)
-            }
-            for j in range(1i, i/100) {
-                match m.find_copy(&j) {
-                    None => panic!(),
-                    Some(v) => assert_eq!(v, j + 7)
-                }
-            }
-        }
-    }
-
-    #[test]
     fn test_eq() {
         let mut m1 = HashMap::new();
         m1.insert(1i, 2i);
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index 28c78ca3a91..b1824db93aa 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -12,7 +12,7 @@
 
 use borrow::BorrowFrom;
 use clone::Clone;
-use cmp::{Eq, Equiv, PartialEq};
+use cmp::{Eq, PartialEq};
 use core::kinds::Sized;
 use default::Default;
 use fmt::Show;
@@ -228,13 +228,6 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
         self.map.shrink_to_fit()
     }
 
-    /// Deprecated: use `contains` and `BorrowFrom`.
-    #[deprecated = "use contains and BorrowFrom"]
-    #[allow(deprecated)]
-    pub fn contains_equiv<Sized? Q: Hash<S> + Equiv<T>>(&self, value: &Q) -> bool {
-      self.map.contains_key_equiv(value)
-    }
-
     /// An iterator visiting all elements in arbitrary order.
     /// Iterator element type is &'a T.
     ///
diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 0d44e6d869a..4be83bfc664 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -314,17 +314,9 @@
 pub use core_collections::{BinaryHeap, Bitv, BitvSet, BTreeMap, BTreeSet};
 pub use core_collections::{DList, RingBuf, VecMap};
 
-/// Deprecated: Moved to collect-rs: https://github.com/Gankro/collect-rs/
-#[deprecated = "Moved to collect-rs: https://github.com/Gankro/collect-rs/"]
-pub use core_collections::EnumSet;
-
 pub use core_collections::{binary_heap, bitv, bitv_set, btree_map, btree_set};
 pub use core_collections::{dlist, ring_buf, vec_map};
 
-/// Deprecated: Moved to collect-rs: https://github.com/Gankro/collect-rs/
-#[deprecated = "Moved to collect-rs: https://github.com/Gankro/collect-rs/"]
-pub use core_collections::enum_set;
-
 pub use self::hash_map::HashMap;
 pub use self::hash_set::HashSet;
 
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index d97f4a7bc34..c56acd38e81 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -89,10 +89,6 @@ impl<R: Reader> BufferedReader<R> {
     ///
     /// Note that any leftover data in the internal buffer is lost.
     pub fn into_inner(self) -> R { self.inner }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> R { self.into_inner() }
 }
 
 impl<R: Reader> Buffer for BufferedReader<R> {
@@ -198,10 +194,6 @@ impl<W: Writer> BufferedWriter<W> {
         self.flush_buf().unwrap();
         self.inner.take().unwrap()
     }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> W { self.into_inner() }
 }
 
 impl<W: Writer> Writer for BufferedWriter<W> {
@@ -262,10 +254,6 @@ impl<W: Writer> LineBufferedWriter<W> {
     ///
     /// The internal buffer is flushed before returning the writer.
     pub fn into_inner(self) -> W { self.inner.into_inner() }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> W { self.into_inner() }
 }
 
 impl<W: Writer> Writer for LineBufferedWriter<W> {
@@ -374,10 +362,6 @@ impl<S: Stream> BufferedStream<S> {
         let InternalBufferedWriter(w) = self.inner.inner;
         w.into_inner()
     }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> S { self.into_inner() }
 }
 
 impl<S: Stream> Buffer for BufferedStream<S> {
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 8c097a65db7..af08eea210e 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -518,7 +518,7 @@ mod bench {
         ({
             use super::u64_from_be_bytes;
 
-            let data = Vec::from_fn($stride*100+$start_index, |i| i as u8);
+            let data = range(0u8, $stride*100+$start_index).collect::<Vec<_>>();
             let mut sum = 0u64;
             $b.iter(|| {
                 let mut i = $start_index;
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 1615541e37d..5c17644a1ac 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -12,8 +12,6 @@
 
 //! Readers and Writers for in-memory buffers
 
-#![allow(deprecated)]
-
 use cmp::min;
 use option::Option::None;
 use result::Result::{Err, Ok};
@@ -70,6 +68,7 @@ pub struct MemWriter {
     buf: Vec<u8>,
 }
 
+#[allow(deprecated)]
 impl MemWriter {
     /// Create a new `MemWriter`.
     #[inline]
@@ -96,10 +95,6 @@ impl MemWriter {
     /// Unwraps this `MemWriter`, returning the underlying buffer
     #[inline]
     pub fn into_inner(self) -> Vec<u8> { self.buf }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
 }
 
 impl Writer for MemWriter {
@@ -155,10 +150,6 @@ impl MemReader {
     /// Unwraps this `MemReader`, returning the underlying buffer
     #[inline]
     pub fn into_inner(self) -> Vec<u8> { self.buf }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
 }
 
 impl Reader for MemReader {
@@ -401,10 +392,11 @@ mod test {
     extern crate "test" as test_crate;
     use prelude::v1::*;
 
-    use super::*;
     use io::{SeekSet, SeekCur, SeekEnd};
     use io;
+    use iter::repeat;
     use self::test_crate::Bencher;
+    use super::*;
 
     #[test]
     fn test_vec_writer() {
@@ -664,7 +656,7 @@ mod test {
     }
 
     fn do_bench_mem_writer(b: &mut Bencher, times: uint, len: uint) {
-        let src: Vec<u8> = Vec::from_elem(len, 5);
+        let src: Vec<u8> = repeat(5).take(len).collect();
 
         b.bytes = (times * len) as u64;
         b.iter(|| {
@@ -673,7 +665,7 @@ mod test {
                 wr.write(src.as_slice()).unwrap();
             }
 
-            let v = wr.unwrap();
+            let v = wr.into_inner();
             assert_eq!(v.len(), times * len);
             assert!(v.iter().all(|x| *x == 5));
         });
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 590231dcd82..ae401a04a96 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -263,7 +263,6 @@ pub use self::timer::Timer;
 pub use self::net::ip::IpAddr;
 pub use self::net::tcp::TcpListener;
 pub use self::net::tcp::TcpStream;
-pub use self::net::udp::UdpStream;
 pub use self::pipe::PipeStream;
 pub use self::process::{Process, Command};
 pub use self::tempfile::TempDir;
@@ -863,23 +862,6 @@ pub trait Reader {
 }
 
 /// A reader which can be converted to a RefReader.
-#[deprecated = "use ByRefReader instead"]
-pub trait AsRefReader {
-    /// Creates a wrapper around a mutable reference to the reader.
-    ///
-    /// This is useful to allow applying adaptors while still
-    /// retaining ownership of the original value.
-    fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self>;
-}
-
-#[allow(deprecated)]
-impl<T: Reader> AsRefReader for T {
-    fn by_ref<'a>(&'a mut self) -> RefReader<'a, T> {
-        RefReader { inner: self }
-    }
-}
-
-/// A reader which can be converted to a RefReader.
 pub trait ByRefReader {
     /// Creates a wrapper around a mutable reference to the reader.
     ///
@@ -1243,24 +1225,6 @@ pub trait Writer {
 }
 
 /// A writer which can be converted to a RefWriter.
-#[deprecated = "use ByRefWriter instead"]
-pub trait AsRefWriter {
-    /// Creates a wrapper around a mutable reference to the writer.
-    ///
-    /// This is useful to allow applying wrappers while still
-    /// retaining ownership of the original value.
-    #[inline]
-    fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self>;
-}
-
-#[allow(deprecated)]
-impl<T: Writer> AsRefWriter for T {
-    fn by_ref<'a>(&'a mut self) -> RefWriter<'a, T> {
-        RefWriter { inner: self }
-    }
-}
-
-/// A writer which can be converted to a RefWriter.
 pub trait ByRefWriter {
     /// Creates a wrapper around a mutable reference to the writer.
     ///
@@ -1847,64 +1811,6 @@ bitflags! {
 
         #[doc = "All possible permissions enabled."]
         const ALL_PERMISSIONS = USER_RWX.bits | GROUP_RWX.bits | OTHER_RWX.bits,
-
-        // Deprecated names
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_READ instead"]
-        const UserRead     = USER_READ.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_WRITE instead"]
-        const UserWrite    = USER_WRITE.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_EXECUTE instead"]
-        const UserExecute  = USER_EXECUTE.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use GROUP_READ instead"]
-        const GroupRead    = GROUP_READ.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use GROUP_WRITE instead"]
-        const GroupWrite   = GROUP_WRITE.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use GROUP_EXECUTE instead"]
-        const GroupExecute = GROUP_EXECUTE.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use OTHER_READ instead"]
-        const OtherRead    = OTHER_READ.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use OTHER_WRITE instead"]
-        const OtherWrite   = OTHER_WRITE.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use OTHER_EXECUTE instead"]
-        const OtherExecute = OTHER_EXECUTE.bits,
-
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_RWX instead"]
-        const UserRWX  = USER_RWX.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use GROUP_RWX instead"]
-        const GroupRWX = GROUP_RWX.bits,
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use OTHER_RWX instead"]
-        const OtherRWX = OTHER_RWX.bits,
-
-        #[doc = "Deprecated: use `USER_FILE` instead."]
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_FILE instead"]
-        const UserFile = USER_FILE.bits,
-
-        #[doc = "Deprecated: use `USER_DIR` instead."]
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_DIR instead"]
-        const UserDir  = USER_DIR.bits,
-        #[doc = "Deprecated: use `USER_EXEC` instead."]
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use USER_EXEC instead"]
-        const UserExec = USER_EXEC.bits,
-
-        #[doc = "Deprecated: use `ALL_PERMISSIONS` instead"]
-        #[allow(non_upper_case_globals)]
-        #[deprecated = "use ALL_PERMISSIONS instead"]
-        const AllPermissions = ALL_PERMISSIONS.bits,
     }
 }
 
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 6c167359966..a4db0d4f5de 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -17,10 +17,8 @@
 
 use clone::Clone;
 use io::net::ip::{SocketAddr, IpAddr, ToSocketAddr};
-use io::{Reader, Writer, IoResult};
-use ops::FnOnce;
+use io::IoResult;
 use option::Option;
-use result::Result::{Ok, Err};
 use sys::udp::UdpSocket as UdpSocketImp;
 use sys_common;
 
@@ -88,21 +86,6 @@ impl UdpSocket {
         super::with_addresses(addr, |addr| self.inner.send_to(buf, addr))
     }
 
-    /// Creates a `UdpStream`, which allows use of the `Reader` and `Writer`
-    /// traits to receive and send data from the same address. This transfers
-    /// ownership of the socket to the stream.
-    ///
-    /// Note that this call does not perform any actual network communication,
-    /// because UDP is a datagram protocol.
-    #[deprecated = "`UdpStream` has been deprecated"]
-    #[allow(deprecated)]
-    pub fn connect(self, other: SocketAddr) -> UdpStream {
-        UdpStream {
-            socket: self,
-            connected_to: other,
-        }
-    }
-
     /// Returns the socket address that this socket was created from.
     pub fn socket_name(&mut self) -> IoResult<SocketAddr> {
         self.inner.socket_name()
@@ -192,59 +175,6 @@ impl sys_common::AsInner<UdpSocketImp> for UdpSocket {
     }
 }
 
-/// A type that allows convenient usage of a UDP stream connected to one
-/// address via the `Reader` and `Writer` traits.
-///
-/// # Note
-///
-/// This structure has been deprecated because `Reader` is a stream-oriented API but UDP
-/// is a packet-oriented protocol. Every `Reader` method will read a whole packet and
-/// throw all superfluous bytes away so that they are no longer available for further
-/// method calls.
-#[deprecated]
-pub struct UdpStream {
-    socket: UdpSocket,
-    connected_to: SocketAddr
-}
-
-impl UdpStream {
-    /// Allows access to the underlying UDP socket owned by this stream. This
-    /// is useful to, for example, use the socket to send data to hosts other
-    /// than the one that this stream is connected to.
-    pub fn as_socket<T, F>(&mut self, f: F) -> T where
-        F: FnOnce(&mut UdpSocket) -> T,
-    {
-        f(&mut self.socket)
-    }
-
-    /// Consumes this UDP stream and returns out the underlying socket.
-    pub fn disconnect(self) -> UdpSocket {
-        self.socket
-    }
-}
-
-impl Reader for UdpStream {
-    /// Returns the next non-empty message from the specified address.
-    fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
-        let peer = self.connected_to;
-        self.as_socket(|sock| {
-            loop {
-                let (nread, src) = try!(sock.recv_from(buf));
-                if nread > 0 && src == peer {
-                    return Ok(nread);
-                }
-            }
-        })
-    }
-}
-
-impl Writer for UdpStream {
-    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
-        let connected_to = self.connected_to;
-        self.as_socket(|sock| sock.send_to(buf, connected_to))
-    }
-}
-
 #[cfg(test)]
 #[allow(experimental)]
 mod test {
@@ -337,91 +267,6 @@ mod test {
         }
     }
 
-    #[test]
-    #[allow(deprecated)]
-    fn stream_smoke_test_ip4() {
-        let server_ip = next_test_ip4();
-        let client_ip = next_test_ip4();
-        let dummy_ip = next_test_ip4();
-        let (tx1, rx1) = channel();
-        let (tx2, rx2) = channel();
-
-        let _t = Thread::spawn(move|| {
-            let send_as = |&:ip, val: &[u8]| {
-                match UdpSocket::bind(ip) {
-                    Ok(client) => {
-                        let client = box client;
-                        let mut stream = client.connect(server_ip);
-                        stream.write(val).unwrap();
-                    }
-                    Err(..) => panic!()
-                }
-            };
-            rx1.recv().unwrap();
-            send_as(dummy_ip, &[98]);
-            send_as(client_ip, &[99]);
-            tx2.send(()).unwrap();
-        });
-
-        match UdpSocket::bind(server_ip) {
-            Ok(server) => {
-                let server = box server;
-                let mut stream = server.connect(client_ip);
-                tx1.send(()).unwrap();
-                let mut buf = [0];
-                match stream.read(&mut buf) {
-                    Ok(nread) => {
-                        assert_eq!(nread, 1);
-                        assert_eq!(buf[0], 99);
-                    }
-                    Err(..) => panic!(),
-                }
-            }
-            Err(..) => panic!()
-        }
-        rx2.recv().unwrap();
-    }
-
-    #[test]
-    #[allow(deprecated)]
-    fn stream_smoke_test_ip6() {
-        let server_ip = next_test_ip6();
-        let client_ip = next_test_ip6();
-        let (tx1, rx1) = channel();
-        let (tx2, rx2) = channel();
-
-        let _t = Thread::spawn(move|| {
-            match UdpSocket::bind(client_ip) {
-                Ok(client) => {
-                    let client = box client;
-                    let mut stream = client.connect(server_ip);
-                    rx1.recv().unwrap();
-                    stream.write(&[99]).unwrap();
-                }
-                Err(..) => panic!()
-            }
-            tx2.send(()).unwrap();
-        });
-
-        match UdpSocket::bind(server_ip) {
-            Ok(server) => {
-                let server = box server;
-                let mut stream = server.connect(client_ip);
-                tx1.send(()).unwrap();
-                let mut buf = [0];
-                match stream.read(&mut buf) {
-                    Ok(nread) => {
-                        assert_eq!(nread, 1);
-                        assert_eq!(buf[0], 99);
-                    }
-                    Err(..) => panic!()
-                }
-            }
-            Err(..) => panic!()
-        }
-        rx2.recv().unwrap();
-    }
-
     pub fn socket_name(addr: SocketAddr) {
         let server = UdpSocket::bind(addr);
 
diff --git a/src/libstd/io/tempfile.rs b/src/libstd/io/tempfile.rs
index 5cf86676651..45e0dd4e8e5 100644
--- a/src/libstd/io/tempfile.rs
+++ b/src/libstd/io/tempfile.rs
@@ -19,7 +19,7 @@ use option::Option::{None, Some};
 use os;
 use path::{Path, GenericPath};
 use result::Result::{Ok, Err};
-use sync::atomic;
+use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
 
 /// A wrapper for a path to temporary directory implementing automatic
 /// scope-based deletion.
@@ -90,14 +90,14 @@ impl TempDir {
             return TempDir::new_in(&abs_tmpdir, suffix);
         }
 
-        static CNT: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
+        static CNT: AtomicUint = ATOMIC_UINT_INIT;
 
         let mut attempts = 0u;
         loop {
             let filename =
                 format!("rs-{}-{}-{}",
                         unsafe { libc::getpid() },
-                        CNT.fetch_add(1, atomic::SeqCst),
+                        CNT.fetch_add(1, Ordering::SeqCst),
                         suffix);
             let p = tmpdir.join(filename);
             match fs::mkdir(&p, io::USER_RWX) {
@@ -129,10 +129,6 @@ impl TempDir {
         tmpdir.path.take().unwrap()
     }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> Path { self.into_inner() }
-
     /// Access the wrapped `std::path::Path` to the temporary directory.
     pub fn path<'a>(&'a self) -> &'a Path {
         self.path.as_ref().unwrap()
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index 2f87abd0ee2..3ce56c907b3 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -17,12 +17,12 @@ use prelude::v1::*;
 use libc;
 use os;
 use std::io::net::ip::*;
-use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Relaxed};
+use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
 
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
     static NEXT_OFFSET: AtomicUint = ATOMIC_UINT_INIT;
-    base_port() + NEXT_OFFSET.fetch_add(1, Relaxed) as u16
+    base_port() + NEXT_OFFSET.fetch_add(1, Ordering::Relaxed) as u16
 }
 
 /// Get a temporary path which could be the location of a unix socket
@@ -34,7 +34,7 @@ pub fn next_test_unix() -> Path {
     let string = format!("rust-test-unix-path-{}-{}-{}",
                          base_port(),
                          unsafe {libc::getpid()},
-                         COUNT.fetch_add(1, Relaxed));
+                         COUNT.fetch_add(1, Ordering::Relaxed));
     if cfg!(unix) {
         os::tmpdir().join(string)
     } else {
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 1381ad17ea2..86fa68d63ac 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -30,10 +30,6 @@ impl<R: Reader> LimitReader<R> {
     /// Consumes the `LimitReader`, returning the underlying `Reader`.
     pub fn into_inner(self) -> R { self.inner }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner"]
-    pub fn unwrap(self) -> R { self.into_inner() }
-
     /// Returns the number of bytes that can be read before the `LimitReader`
     /// will return EOF.
     ///
@@ -219,10 +215,6 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
         let TeeReader { reader, writer } = self;
         (reader, writer)
     }
-
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner"]
-    pub fn unwrap(self) -> (R, W) { self.into_inner() }
 }
 
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 7c8aab2b31d..608ad9882b9 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -226,7 +226,6 @@ pub mod hash;
 
 /* Threads and communication */
 
-pub mod task;
 pub mod thread;
 pub mod sync;
 
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 8f21fb0b8b9..c126eb1d6cf 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -21,12 +21,8 @@
 #[cfg(test)] use ops::{Add, Sub, Mul, Div, Rem};
 #[cfg(test)] use kinds::Copy;
 
-pub use core::num::{Num, div_rem, Zero, zero, One, one};
-pub use core::num::{Unsigned, pow, Bounded};
-pub use core::num::{Primitive, Int, SignedInt, UnsignedInt};
+pub use core::num::{Int, SignedInt, UnsignedInt};
 pub use core::num::{cast, FromPrimitive, NumCast, ToPrimitive};
-pub use core::num::{next_power_of_two, is_power_of_two};
-pub use core::num::{checked_next_power_of_two};
 pub use core::num::{from_int, from_i8, from_i16, from_i32, from_i64};
 pub use core::num::{from_uint, from_u8, from_u16, from_u32, from_u64};
 pub use core::num::{from_f32, from_f64};
@@ -118,11 +114,6 @@ pub trait FloatMath: Float {
 
 // DEPRECATED
 
-#[deprecated = "Use `FloatMath::abs_sub`"]
-pub fn abs_sub<T: FloatMath>(x: T, y: T) -> T {
-    x.abs_sub(y)
-}
-
 /// Helper function for testing numeric operations
 #[cfg(test)]
 pub fn test_num<T>(ten: T, two: T) where
@@ -804,7 +795,7 @@ mod bench {
 
     #[bench]
     fn bench_pow_function(b: &mut Bencher) {
-        let v = Vec::from_fn(1024u, |n| n);
+        let v = range(0, 1024u).collect::<Vec<_>>();
         b.iter(|| {v.iter().fold(0u, |old, new| old.pow(*new));});
     }
 }
diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs
index 46699b78599..7cb6a8ffe07 100644
--- a/src/libstd/num/u16.rs
+++ b/src/libstd/num/u16.rs
@@ -15,6 +15,4 @@
 
 pub use core::u16::{BITS, BYTES, MIN, MAX};
 
-use ops::FnOnce;
-
 uint_module! { u16 }
diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs
index 45ee9251d2f..43b01ddb16b 100644
--- a/src/libstd/num/u32.rs
+++ b/src/libstd/num/u32.rs
@@ -15,6 +15,4 @@
 
 pub use core::u32::{BITS, BYTES, MIN, MAX};
 
-use ops::FnOnce;
-
 uint_module! { u32 }
diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs
index 1d8ff77dac8..79e7f237051 100644
--- a/src/libstd/num/u64.rs
+++ b/src/libstd/num/u64.rs
@@ -15,6 +15,4 @@
 
 pub use core::u64::{BITS, BYTES, MIN, MAX};
 
-use ops::FnOnce;
-
 uint_module! { u64 }
diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs
index 0663ace2e5b..3da2fabe3f2 100644
--- a/src/libstd/num/u8.rs
+++ b/src/libstd/num/u8.rs
@@ -15,6 +15,4 @@
 
 pub use core::u8::{BITS, BYTES, MIN, MAX};
 
-use ops::FnOnce;
-
 uint_module! { u8 }
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index cd000b3098b..0fbc0953b20 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -15,6 +15,4 @@
 
 pub use core::uint::{BITS, BYTES, MIN, MAX};
 
-use ops::FnOnce;
-
 uint_module! { uint }
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index b52e4fda7af..7818f4a0534 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -17,41 +17,14 @@ macro_rules! uint_module { ($T:ty) => (
 
 // String conversion functions and impl num -> str
 
-/// Convert to a string as a byte slice in a given base.
-///
-/// Use in place of x.to_string() when you do not need to store the string permanently
-///
-/// # Examples
-///
-/// ```
-/// #![allow(deprecated)]
-///
-/// std::uint::to_str_bytes(123, 10, |v| {
-///     assert!(v == "123".as_bytes());
-/// });
-/// ```
-#[inline]
-#[deprecated = "just use .to_string(), or a BufWriter with write! if you mustn't allocate"]
-pub fn to_str_bytes<U, F>(n: $T, radix: uint, f: F) -> U where
-    F: FnOnce(&[u8]) -> U,
-{
-    use io::{Writer, Seek};
-    // The radix can be as low as 2, so we need at least 64 characters for a
-    // base 2 number, and then we need another for a possible '-' character.
-    let mut buf = [0u8; 65];
-    let amt = {
-        let mut wr = ::io::BufWriter::new(&mut buf);
-        (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
-        wr.tell().unwrap() as uint
-    };
-    f(buf[..amt])
-}
-
 #[cfg(test)]
 mod tests {
     use prelude::v1::*;
     use num::FromStrRadix;
-    use str::from_str;
+
+    fn from_str<T: ::str::FromStr>(t: &str) -> Option<T> {
+        ::str::FromStr::from_str(t)
+    }
 
     #[test]
     pub fn test_from_str() {
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 771c808ab8a..be8f82349c2 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -54,7 +54,7 @@ use result::Result::{Err, Ok};
 use slice::{AsSlice, SliceExt};
 use str::{Str, StrExt};
 use string::{String, ToString};
-use sync::atomic::{AtomicInt, ATOMIC_INT_INIT, SeqCst};
+use sync::atomic::{AtomicInt, ATOMIC_INT_INIT, Ordering};
 use vec::Vec;
 
 #[cfg(unix)] use c_str::ToCStr;
@@ -606,13 +606,13 @@ static EXIT_STATUS: AtomicInt = ATOMIC_INT_INIT;
 ///
 /// Note that this is not synchronized against modifications of other threads.
 pub fn set_exit_status(code: int) {
-    EXIT_STATUS.store(code, SeqCst)
+    EXIT_STATUS.store(code, Ordering::SeqCst)
 }
 
 /// Fetches the process's current exit code. This defaults to 0 and can change
 /// by calling `set_exit_status`.
 pub fn get_exit_status() -> int {
-    EXIT_STATUS.load(SeqCst)
+    EXIT_STATUS.load(Ordering::SeqCst)
 }
 
 #[cfg(target_os = "macos")]
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 731c3bbe427..bf9ffbffe7d 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -69,9 +69,9 @@ use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
 use str;
-use str::{CowString, MaybeOwned, Str, StrExt};
-use string::String;
-use slice::{AsSlice, SliceExt};
+use str::StrExt;
+use string::{String, CowString};
+use slice::SliceExt;
 use vec::Vec;
 
 /// Typedef for POSIX file paths.
@@ -896,20 +896,6 @@ impl BytesContainer for CString {
     }
 }
 
-#[allow(deprecated)]
-impl<'a> BytesContainer for str::MaybeOwned<'a> {
-    #[inline]
-    fn container_as_bytes<'b>(&'b self) -> &'b [u8] {
-        self.as_slice().as_bytes()
-    }
-    #[inline]
-    fn container_as_str<'b>(&'b self) -> Option<&'b str> {
-        Some(self.as_slice())
-    }
-    #[inline]
-    fn is_str(_: Option<&str::MaybeOwned>) -> bool { true }
-}
-
 impl<'a, Sized? T: BytesContainer> BytesContainer for &'a T {
     #[inline]
     fn container_as_bytes(&self) -> &[u8] {
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 55063f1393f..aa28c8266d1 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -421,7 +421,7 @@ pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R,
 mod test {
     use prelude::v1::*;
     use super::{Rng, thread_rng, random, SeedableRng, StdRng, sample};
-    use iter::order;
+    use iter::{order, repeat};
 
     struct ConstRng { i: u64 }
     impl Rng for ConstRng {
@@ -439,7 +439,7 @@ mod test {
         let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
                        80, 81, 82, 83, 84, 85, 86, 87];
         for &n in lengths.iter() {
-            let mut v = Vec::from_elem(n, 0u8);
+            let mut v = repeat(0u8).take(n).collect::<Vec<_>>();
             r.fill_bytes(v.as_mut_slice());
 
             // use this to get nicer error messages.
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 5caa71b4347..6ae6a238c95 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -93,12 +93,12 @@ mod imp {
                   target_arch = "arm",
                   target_arch = "aarch64")))]
     fn is_getrandom_available() -> bool {
-        use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Relaxed};
+        use sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
 
         static GETRANDOM_CHECKED: AtomicBool = ATOMIC_BOOL_INIT;
         static GETRANDOM_AVAILABLE: AtomicBool = ATOMIC_BOOL_INIT;
 
-        if !GETRANDOM_CHECKED.load(Relaxed) {
+        if !GETRANDOM_CHECKED.load(Ordering::Relaxed) {
             let mut buf: [u8; 0] = [];
             let result = getrandom(&mut buf);
             let available = if result == -1 {
@@ -107,11 +107,11 @@ mod imp {
             } else {
                 true
             };
-            GETRANDOM_AVAILABLE.store(available, Relaxed);
-            GETRANDOM_CHECKED.store(true, Relaxed);
+            GETRANDOM_AVAILABLE.store(available, Ordering::Relaxed);
+            GETRANDOM_CHECKED.store(true, Ordering::Relaxed);
             available
         } else {
-            GETRANDOM_AVAILABLE.load(Relaxed)
+            GETRANDOM_AVAILABLE.load(Ordering::Relaxed)
         }
     }
 
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index ae405e9400b..578239c9cc4 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -15,7 +15,7 @@
 use prelude::v1::*;
 
 use os;
-use sync::atomic;
+use sync::atomic::{mod, Ordering};
 
 pub use sys::backtrace::write;
 
@@ -23,7 +23,7 @@ pub use sys::backtrace::write;
 // whether the magical environment variable is present to see if it's turned on.
 pub fn log_enabled() -> bool {
     static ENABLED: atomic::AtomicInt = atomic::ATOMIC_INT_INIT;
-    match ENABLED.load(atomic::SeqCst) {
+    match ENABLED.load(Ordering::SeqCst) {
         1 => return false,
         2 => return true,
         _ => {}
@@ -33,7 +33,7 @@ pub fn log_enabled() -> bool {
         Some(..) => 2,
         None => 1,
     };
-    ENABLED.store(val, atomic::SeqCst);
+    ENABLED.store(val, Ordering::SeqCst);
     val == 2
 }
 
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index 99f791df474..a48a8edd82f 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -67,7 +67,7 @@ use fmt;
 use intrinsics;
 use libc::c_void;
 use mem;
-use sync::atomic;
+use sync::atomic::{mod, Ordering};
 use sync::{Once, ONCE_INIT};
 
 use rt::libunwind as uw;
@@ -543,11 +543,11 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     // callback. Additionally, CALLBACK_CNT may briefly be higher than
     // MAX_CALLBACKS, so we're sure to clamp it as necessary.
     let callbacks = {
-        let amt = CALLBACK_CNT.load(atomic::SeqCst);
+        let amt = CALLBACK_CNT.load(Ordering::SeqCst);
         CALLBACKS[..cmp::min(amt, MAX_CALLBACKS)]
     };
     for cb in callbacks.iter() {
-        match cb.load(atomic::SeqCst) {
+        match cb.load(Ordering::SeqCst) {
             0 => {}
             n => {
                 let f: Callback = unsafe { mem::transmute(n) };
@@ -584,18 +584,18 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
 /// currently possible to unregister a callback once it has been registered.
 #[experimental]
 pub unsafe fn register(f: Callback) -> bool {
-    match CALLBACK_CNT.fetch_add(1, atomic::SeqCst) {
+    match CALLBACK_CNT.fetch_add(1, Ordering::SeqCst) {
         // The invocation code has knowledge of this window where the count has
         // been incremented, but the callback has not been stored. We're
         // guaranteed that the slot we're storing into is 0.
         n if n < MAX_CALLBACKS => {
-            let prev = CALLBACKS[n].swap(mem::transmute(f), atomic::SeqCst);
+            let prev = CALLBACKS[n].swap(mem::transmute(f), Ordering::SeqCst);
             rtassert!(prev == 0);
             true
         }
         // If we accidentally bumped the count too high, pull it back.
         _ => {
-            CALLBACK_CNT.store(MAX_CALLBACKS, atomic::SeqCst);
+            CALLBACK_CNT.store(MAX_CALLBACKS, Ordering::SeqCst);
             false
         }
     }
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index d6cf35ee3cd..883a01fa318 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -19,7 +19,7 @@ use libc::{self, uintptr_t};
 use os;
 use slice;
 use str;
-use sync::atomic;
+use sync::atomic::{mod, Ordering};
 
 /// Dynamically inquire about whether we're running under V.
 /// You should usually not use this unless your test definitely
@@ -47,7 +47,7 @@ pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool {
 
 pub fn min_stack() -> uint {
     static MIN: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
-    match MIN.load(atomic::SeqCst) {
+    match MIN.load(Ordering::SeqCst) {
         0 => {}
         n => return n - 1,
     }
@@ -55,7 +55,7 @@ pub fn min_stack() -> uint {
     let amt = amt.unwrap_or(2 * 1024 * 1024);
     // 0 is our sentinel value, so ensure that we'll never see 0 after
     // initialization has run
-    MIN.store(amt + 1, atomic::SeqCst);
+    MIN.store(amt + 1, Ordering::SeqCst);
     return amt;
 }
 
diff --git a/src/libstd/sync/atomic.rs b/src/libstd/sync/atomic.rs
deleted file mode 100644
index 3652b45ce97..00000000000
--- a/src/libstd/sync/atomic.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Atomic types
-//!
-//! Atomic types provide primitive shared-memory communication between
-//! threads, and are the building blocks of other concurrent
-//! types.
-//!
-//! This module defines atomic versions of a select number of primitive
-//! types, including `AtomicBool`, `AtomicInt`, `AtomicUint`, and `AtomicOption`.
-//! Atomic types present operations that, when used correctly, synchronize
-//! updates between threads.
-//!
-//! Each method takes an `Ordering` which represents the strength of
-//! the memory barrier for that operation. These orderings are the
-//! same as [C++11 atomic orderings][1].
-//!
-//! [1]: http://gcc.gnu.org/wiki/Atomic/GCCMM/AtomicSync
-//!
-//! Atomic variables are safe to share between threads (they implement `Sync`)
-//! but they do not themselves provide the mechanism for sharing. The most
-//! common way to share an atomic variable is to put it into an `Arc` (an
-//! atomically-reference-counted shared pointer).
-//!
-//! Most atomic types may be stored in static variables, initialized using
-//! the provided static initializers like `INIT_ATOMIC_BOOL`. Atomic statics
-//! are often used for lazy global initialization.
-//!
-//!
-//! # Examples
-//!
-//! A simple spinlock:
-//!
-//! ```
-//! use std::sync::Arc;
-//! use std::sync::atomic::{AtomicUint, SeqCst};
-//! use std::thread::Thread;
-//!
-//! fn main() {
-//!     let spinlock = Arc::new(AtomicUint::new(1));
-//!
-//!     let spinlock_clone = spinlock.clone();
-//!     Thread::spawn(move|| {
-//!         spinlock_clone.store(0, SeqCst);
-//!     }).detach();
-//!
-//!     // Wait for the other task to release the lock
-//!     while spinlock.load(SeqCst) != 0 {}
-//! }
-//! ```
-//!
-//! Transferring a heap object with `AtomicOption`:
-//!
-//! ```
-//! use std::sync::Arc;
-//! use std::sync::atomic::{AtomicOption, SeqCst};
-//! use std::thread::Thread;
-//!
-//! fn main() {
-//!     struct BigObject;
-//!
-//!     let shared_big_object = Arc::new(AtomicOption::empty());
-//!
-//!     let shared_big_object_clone = shared_big_object.clone();
-//!     Thread::spawn(move|| {
-//!         let unwrapped_big_object = shared_big_object_clone.take(SeqCst);
-//!         if unwrapped_big_object.is_some() {
-//!             println!("got a big object from another task");
-//!         } else {
-//!             println!("other task hasn't sent big object yet");
-//!         }
-//!     }).detach();
-//!
-//!     shared_big_object.swap(box BigObject, SeqCst);
-//! }
-//! ```
-//!
-//! Keep a global count of live tasks:
-//!
-//! ```
-//! use std::sync::atomic::{AtomicUint, SeqCst, ATOMIC_UINT_INIT};
-//!
-//! static GLOBAL_TASK_COUNT: AtomicUint = ATOMIC_UINT_INIT;
-//!
-//! let old_task_count = GLOBAL_TASK_COUNT.fetch_add(1, SeqCst);
-//! println!("live tasks: {}", old_task_count + 1);
-//! ```
-
-#![stable]
-
-use alloc::boxed::Box;
-use core::mem;
-use core::prelude::{Send, Drop, None, Option, Some};
-
-pub use core::atomic::{AtomicBool, AtomicInt, AtomicUint, AtomicPtr};
-pub use core::atomic::{INIT_ATOMIC_BOOL, INIT_ATOMIC_INT, INIT_ATOMIC_UINT};
-pub use core::atomic::{ATOMIC_BOOL_INIT, ATOMIC_INT_INIT, ATOMIC_UINT_INIT};
-pub use core::atomic::fence;
-pub use core::atomic::Ordering::{self, Relaxed, Release, Acquire, AcqRel, SeqCst};
-
-/// An atomic, nullable unique pointer
-///
-/// This can be used as the concurrency primitive for operations that transfer
-/// owned heap objects across tasks.
-#[unsafe_no_drop_flag]
-#[deprecated = "no longer used; will eventually be replaced by a higher-level\
-                concept like MVar"]
-pub struct AtomicOption<T> {
-    p: AtomicUint,
-}
-
-#[allow(deprecated)]
-impl<T: Send> AtomicOption<T> {
-    /// Create a new `AtomicOption`
-    pub fn new(p: Box<T>) -> AtomicOption<T> {
-        unsafe { AtomicOption { p: AtomicUint::new(mem::transmute(p)) } }
-    }
-
-    /// Create a new `AtomicOption` that doesn't contain a value
-    pub fn empty() -> AtomicOption<T> { AtomicOption { p: AtomicUint::new(0) } }
-
-    /// Store a value, returning the old value
-    #[inline]
-    pub fn swap(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> {
-        let val = unsafe { mem::transmute(val) };
-
-        match self.p.swap(val, order) {
-            0 => None,
-            n => Some(unsafe { mem::transmute(n) }),
-        }
-    }
-
-    /// Remove the value, leaving the `AtomicOption` empty.
-    #[inline]
-    pub fn take(&self, order: Ordering) -> Option<Box<T>> {
-        unsafe { self.swap(mem::transmute(0u), order) }
-    }
-
-    /// Replace an empty value with a non-empty value.
-    ///
-    /// Succeeds if the option is `None` and returns `None` if so. If
-    /// the option was already `Some`, returns `Some` of the rejected
-    /// value.
-    #[inline]
-    pub fn fill(&self, val: Box<T>, order: Ordering) -> Option<Box<T>> {
-        unsafe {
-            let val = mem::transmute(val);
-            let expected = mem::transmute(0u);
-            let oldval = self.p.compare_and_swap(expected, val, order);
-            if oldval == expected {
-                None
-            } else {
-                Some(mem::transmute(val))
-            }
-        }
-    }
-
-    /// Returns `true` if the `AtomicOption` is empty.
-    ///
-    /// Be careful: The caller must have some external method of ensuring the
-    /// result does not get invalidated by another task after this returns.
-    #[inline]
-    pub fn is_empty(&self, order: Ordering) -> bool {
-        self.p.load(order) as uint == 0
-    }
-}
-
-#[unsafe_destructor]
-impl<T: Send> Drop for AtomicOption<T> {
-    fn drop(&mut self) {
-        let _ = self.take(SeqCst);
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use prelude::v1::*;
-    use super::*;
-
-    #[test]
-    fn option_empty() {
-        let option: AtomicOption<()> = AtomicOption::empty();
-        assert!(option.is_empty(SeqCst));
-    }
-
-    #[test]
-    fn option_swap() {
-        let p = AtomicOption::new(box 1i);
-        let a = box 2i;
-
-        let b = p.swap(a, SeqCst);
-
-        assert!(b == Some(box 1));
-        assert!(p.take(SeqCst) == Some(box 2));
-    }
-
-    #[test]
-    fn option_take() {
-        let p = AtomicOption::new(box 1i);
-
-        assert!(p.take(SeqCst) == Some(box 1));
-        assert!(p.take(SeqCst) == None);
-
-        let p2 = box 2i;
-        p.swap(p2, SeqCst);
-
-        assert!(p.take(SeqCst) == Some(box 2));
-    }
-
-    #[test]
-    fn option_fill() {
-        let p = AtomicOption::new(box 1i);
-        assert!(p.fill(box 2i, SeqCst).is_some()); // should fail; shouldn't leak!
-        assert!(p.take(SeqCst) == Some(box 1));
-
-        assert!(p.fill(box 2i, SeqCst).is_none()); // shouldn't fail
-        assert!(p.take(SeqCst) == Some(box 2));
-    }
-}
diff --git a/src/libstd/sync/condvar.rs b/src/libstd/sync/condvar.rs
index 28c36922ca6..7734f655ed2 100644
--- a/src/libstd/sync/condvar.rs
+++ b/src/libstd/sync/condvar.rs
@@ -10,7 +10,7 @@
 
 use prelude::v1::*;
 
-use sync::atomic::{self, AtomicUint};
+use sync::atomic::{AtomicUint, Ordering, ATOMIC_UINT_INIT};
 use sync::poison::{self, LockResult};
 use sys_common::condvar as sys;
 use sys_common::mutex as sys_mutex;
@@ -88,7 +88,7 @@ unsafe impl Sync for StaticCondvar {}
 #[unstable = "may be merged with Condvar in the future"]
 pub const CONDVAR_INIT: StaticCondvar = StaticCondvar {
     inner: sys::CONDVAR_INIT,
-    mutex: atomic::ATOMIC_UINT_INIT,
+    mutex: ATOMIC_UINT_INIT,
 };
 
 impl Condvar {
@@ -260,7 +260,7 @@ impl StaticCondvar {
 
     fn verify(&self, mutex: &sys_mutex::Mutex) {
         let addr = mutex as *const _ as uint;
-        match self.mutex.compare_and_swap(0, addr, atomic::SeqCst) {
+        match self.mutex.compare_and_swap(0, addr, Ordering::SeqCst) {
             // If we got out 0, then we have successfully bound the mutex to
             // this cvar.
             0 => {}
diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs
index e5245251ea8..4c6adcc04f6 100644
--- a/src/libstd/sync/future.rs
+++ b/src/libstd/sync/future.rs
@@ -65,10 +65,6 @@ impl<A> Future<A> {
         }
     }
 
-    /// Deprecated, use into_inner() instead
-    #[deprecated = "renamed to into_inner()"]
-    pub fn unwrap(self) -> A { self.into_inner() }
-
     pub fn get_ref<'a>(&'a mut self) -> &'a A {
         /*!
         * Executes the future's closure and then returns a reference
diff --git a/src/libstd/sync/mod.rs b/src/libstd/sync/mod.rs
index c09c3b45d3e..6ce278726e9 100644
--- a/src/libstd/sync/mod.rs
+++ b/src/libstd/sync/mod.rs
@@ -18,6 +18,7 @@
 #![experimental]
 
 pub use alloc::arc::{Arc, Weak};
+pub use core::atomic;
 
 pub use self::mutex::{Mutex, MutexGuard, StaticMutex};
 pub use self::mutex::MUTEX_INIT;
@@ -32,7 +33,6 @@ pub use self::poison::{PoisonError, TryLockError, TryLockResult, LockResult};
 pub use self::future::Future;
 pub use self::task_pool::TaskPool;
 
-pub mod atomic;
 pub mod mpsc;
 
 mod barrier;
diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index 8945233dac9..8f85dc6e043 100644
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -48,7 +48,7 @@ use alloc::boxed::Box;
 use core::mem;
 use core::cell::UnsafeCell;
 
-use sync::atomic::{AtomicPtr, Release, Acquire, AcqRel, Relaxed};
+use sync::atomic::{AtomicPtr, Ordering};
 
 /// A result of the `pop` function.
 pub enum PopResult<T> {
@@ -103,8 +103,8 @@ impl<T: Send> Queue<T> {
     pub fn push(&self, t: T) {
         unsafe {
             let n = Node::new(Some(t));
-            let prev = self.head.swap(n, AcqRel);
-            (*prev).next.store(n, Release);
+            let prev = self.head.swap(n, Ordering::AcqRel);
+            (*prev).next.store(n, Ordering::Release);
         }
     }
 
@@ -121,7 +121,7 @@ impl<T: Send> Queue<T> {
     pub fn pop(&self) -> PopResult<T> {
         unsafe {
             let tail = *self.tail.get();
-            let next = (*tail).next.load(Acquire);
+            let next = (*tail).next.load(Ordering::Acquire);
 
             if !next.is_null() {
                 *self.tail.get() = next;
@@ -132,7 +132,7 @@ impl<T: Send> Queue<T> {
                 return Data(ret);
             }
 
-            if self.head.load(Acquire) == tail {Empty} else {Inconsistent}
+            if self.head.load(Ordering::Acquire) == tail {Empty} else {Inconsistent}
         }
     }
 }
@@ -143,7 +143,7 @@ impl<T: Send> Drop for Queue<T> {
         unsafe {
             let mut cur = *self.tail.get();
             while !cur.is_null() {
-                let next = (*cur).next.load(Relaxed);
+                let next = (*cur).next.load(Ordering::Relaxed);
                 let _: Box<Node<T>> = mem::transmute(cur);
                 cur = next;
             }
diff --git a/src/libstd/sync/mpsc/oneshot.rs b/src/libstd/sync/mpsc/oneshot.rs
index 2811f403c6c..5c2331d0f2e 100644
--- a/src/libstd/sync/mpsc/oneshot.rs
+++ b/src/libstd/sync/mpsc/oneshot.rs
@@ -42,7 +42,7 @@ use core::prelude::*;
 use sync::mpsc::Receiver;
 use sync::mpsc::blocking::{self, SignalToken};
 use core::mem;
-use sync::atomic;
+use sync::atomic::{AtomicUint, Ordering};
 
 // Various states you can find a port in.
 const EMPTY: uint = 0;          // initial state: no data, no blocked reciever
@@ -56,7 +56,7 @@ const DISCONNECTED: uint = 2;   // channel is disconnected OR upgraded
 
 pub struct Packet<T> {
     // Internal state of the chan/port pair (stores the blocked task as well)
-    state: atomic::AtomicUint,
+    state: AtomicUint,
     // One-shot data slot location
     data: Option<T>,
     // when used for the second time, a oneshot channel must be upgraded, and
@@ -93,7 +93,7 @@ impl<T: Send> Packet<T> {
         Packet {
             data: None,
             upgrade: NothingSent,
-            state: atomic::AtomicUint::new(EMPTY),
+            state: AtomicUint::new(EMPTY),
         }
     }
 
@@ -107,7 +107,7 @@ impl<T: Send> Packet<T> {
         self.data = Some(t);
         self.upgrade = SendUsed;
 
-        match self.state.swap(DATA, atomic::SeqCst) {
+        match self.state.swap(DATA, Ordering::SeqCst) {
             // Sent the data, no one was waiting
             EMPTY => Ok(()),
 
@@ -141,14 +141,14 @@ impl<T: Send> Packet<T> {
     pub fn recv(&mut self) -> Result<T, Failure<T>> {
         // Attempt to not block the task (it's a little expensive). If it looks
         // like we're not empty, then immediately go through to `try_recv`.
-        if self.state.load(atomic::SeqCst) == EMPTY {
+        if self.state.load(Ordering::SeqCst) == EMPTY {
             let (wait_token, signal_token) = blocking::tokens();
             let ptr = unsafe { signal_token.cast_to_uint() };
 
             // race with senders to enter the blocking state
-            if self.state.compare_and_swap(EMPTY, ptr, atomic::SeqCst) == EMPTY {
+            if self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) == EMPTY {
                 wait_token.wait();
-                debug_assert!(self.state.load(atomic::SeqCst) != EMPTY);
+                debug_assert!(self.state.load(Ordering::SeqCst) != EMPTY);
             } else {
                 // drop the signal token, since we never blocked
                 drop(unsafe { SignalToken::cast_from_uint(ptr) });
@@ -159,7 +159,7 @@ impl<T: Send> Packet<T> {
     }
 
     pub fn try_recv(&mut self) -> Result<T, Failure<T>> {
-        match self.state.load(atomic::SeqCst) {
+        match self.state.load(Ordering::SeqCst) {
             EMPTY => Err(Empty),
 
             // We saw some data on the channel, but the channel can be used
@@ -169,7 +169,7 @@ impl<T: Send> Packet<T> {
             // the state changes under our feet we'd rather just see that state
             // change.
             DATA => {
-                self.state.compare_and_swap(DATA, EMPTY, atomic::SeqCst);
+                self.state.compare_and_swap(DATA, EMPTY, Ordering::SeqCst);
                 match self.data.take() {
                     Some(data) => Ok(data),
                     None => unreachable!(),
@@ -209,7 +209,7 @@ impl<T: Send> Packet<T> {
         };
         self.upgrade = GoUp(up);
 
-        match self.state.swap(DISCONNECTED, atomic::SeqCst) {
+        match self.state.swap(DISCONNECTED, Ordering::SeqCst) {
             // If the channel is empty or has data on it, then we're good to go.
             // Senders will check the data before the upgrade (in case we
             // plastered over the DATA state).
@@ -225,7 +225,7 @@ impl<T: Send> Packet<T> {
     }
 
     pub fn drop_chan(&mut self) {
-        match self.state.swap(DISCONNECTED, atomic::SeqCst) {
+        match self.state.swap(DISCONNECTED, Ordering::SeqCst) {
             DATA | DISCONNECTED | EMPTY => {}
 
             // If someone's waiting, we gotta wake them up
@@ -236,7 +236,7 @@ impl<T: Send> Packet<T> {
     }
 
     pub fn drop_port(&mut self) {
-        match self.state.swap(DISCONNECTED, atomic::SeqCst) {
+        match self.state.swap(DISCONNECTED, Ordering::SeqCst) {
             // An empty channel has nothing to do, and a remotely disconnected
             // channel also has nothing to do b/c we're about to run the drop
             // glue
@@ -259,7 +259,7 @@ impl<T: Send> Packet<T> {
     // If Ok, the value is whether this port has data, if Err, then the upgraded
     // port needs to be checked instead of this one.
     pub fn can_recv(&mut self) -> Result<bool, Receiver<T>> {
-        match self.state.load(atomic::SeqCst) {
+        match self.state.load(Ordering::SeqCst) {
             EMPTY => Ok(false), // Welp, we tried
             DATA => Ok(true),   // we have some un-acquired data
             DISCONNECTED if self.data.is_some() => Ok(true), // we have data
@@ -284,7 +284,7 @@ impl<T: Send> Packet<T> {
     // because there is data, or fail because there is an upgrade pending.
     pub fn start_selection(&mut self, token: SignalToken) -> SelectionResult<T> {
         let ptr = unsafe { token.cast_to_uint() };
-        match self.state.compare_and_swap(EMPTY, ptr, atomic::SeqCst) {
+        match self.state.compare_and_swap(EMPTY, ptr, Ordering::SeqCst) {
             EMPTY => SelSuccess,
             DATA => {
                 drop(unsafe { SignalToken::cast_from_uint(ptr) });
@@ -322,7 +322,7 @@ impl<T: Send> Packet<T> {
     //
     // The return value indicates whether there's data on this port.
     pub fn abort_selection(&mut self) -> Result<bool, Receiver<T>> {
-        let state = match self.state.load(atomic::SeqCst) {
+        let state = match self.state.load(Ordering::SeqCst) {
             // Each of these states means that no further activity will happen
             // with regard to abortion selection
             s @ EMPTY |
@@ -331,7 +331,7 @@ impl<T: Send> Packet<T> {
 
             // If we've got a blocked task, then use an atomic to gain ownership
             // of it (may fail)
-            ptr => self.state.compare_and_swap(ptr, EMPTY, atomic::SeqCst)
+            ptr => self.state.compare_and_swap(ptr, EMPTY, Ordering::SeqCst)
         };
 
         // Now that we've got ownership of our state, figure out what to do
@@ -370,6 +370,6 @@ impl<T: Send> Packet<T> {
 #[unsafe_destructor]
 impl<T: Send> Drop for Packet<T> {
     fn drop(&mut self) {
-        assert_eq!(self.state.load(atomic::SeqCst), DISCONNECTED);
+        assert_eq!(self.state.load(Ordering::SeqCst), DISCONNECTED);
     }
 }
diff --git a/src/libstd/sync/mpsc/shared.rs b/src/libstd/sync/mpsc/shared.rs
index cadac8e6272..4295d116aed 100644
--- a/src/libstd/sync/mpsc/shared.rs
+++ b/src/libstd/sync/mpsc/shared.rs
@@ -25,11 +25,12 @@ use core::prelude::*;
 use core::cmp;
 use core::int;
 
-use sync::{atomic, Mutex, MutexGuard};
-use sync::mpsc::mpsc_queue as mpsc;
+use sync::atomic::{AtomicUint, AtomicInt, AtomicBool, Ordering};
 use sync::mpsc::blocking::{self, SignalToken};
-use sync::mpsc::select::StartResult;
+use sync::mpsc::mpsc_queue as mpsc;
 use sync::mpsc::select::StartResult::*;
+use sync::mpsc::select::StartResult;
+use sync::{Mutex, MutexGuard};
 use thread::Thread;
 
 const DISCONNECTED: int = int::MIN;
@@ -41,17 +42,17 @@ const MAX_STEALS: int = 1 << 20;
 
 pub struct Packet<T> {
     queue: mpsc::Queue<T>,
-    cnt: atomic::AtomicInt, // How many items are on this channel
+    cnt: AtomicInt, // How many items are on this channel
     steals: int, // How many times has a port received without blocking?
-    to_wake: atomic::AtomicUint, // SignalToken for wake up
+    to_wake: AtomicUint, // SignalToken for wake up
 
     // The number of channels which are currently using this packet.
-    channels: atomic::AtomicInt,
+    channels: AtomicInt,
 
     // See the discussion in Port::drop and the channel send methods for what
     // these are used for
-    port_dropped: atomic::AtomicBool,
-    sender_drain: atomic::AtomicInt,
+    port_dropped: AtomicBool,
+    sender_drain: AtomicInt,
 
     // this lock protects various portions of this implementation during
     // select()
@@ -69,12 +70,12 @@ impl<T: Send> Packet<T> {
     pub fn new() -> Packet<T> {
         let p = Packet {
             queue: mpsc::Queue::new(),
-            cnt: atomic::AtomicInt::new(0),
+            cnt: AtomicInt::new(0),
             steals: 0,
-            to_wake: atomic::AtomicUint::new(0),
-            channels: atomic::AtomicInt::new(2),
-            port_dropped: atomic::AtomicBool::new(false),
-            sender_drain: atomic::AtomicInt::new(0),
+            to_wake: AtomicUint::new(0),
+            channels: AtomicInt::new(2),
+            port_dropped: AtomicBool::new(false),
+            sender_drain: AtomicInt::new(0),
             select_lock: Mutex::new(()),
         };
         return p;
@@ -98,10 +99,10 @@ impl<T: Send> Packet<T> {
                            token: Option<SignalToken>,
                            guard: MutexGuard<()>) {
         token.map(|token| {
-            assert_eq!(self.cnt.load(atomic::SeqCst), 0);
-            assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
-            self.to_wake.store(unsafe { token.cast_to_uint() }, atomic::SeqCst);
-            self.cnt.store(-1, atomic::SeqCst);
+            assert_eq!(self.cnt.load(Ordering::SeqCst), 0);
+            assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
+            self.to_wake.store(unsafe { token.cast_to_uint() }, Ordering::SeqCst);
+            self.cnt.store(-1, Ordering::SeqCst);
 
             // This store is a little sketchy. What's happening here is that
             // we're transferring a blocker from a oneshot or stream channel to
@@ -134,7 +135,7 @@ impl<T: Send> Packet<T> {
 
     pub fn send(&mut self, t: T) -> Result<(), T> {
         // See Port::drop for what's going on
-        if self.port_dropped.load(atomic::SeqCst) { return Err(t) }
+        if self.port_dropped.load(Ordering::SeqCst) { return Err(t) }
 
         // Note that the multiple sender case is a little trickier
         // semantically than the single sender case. The logic for
@@ -161,12 +162,12 @@ impl<T: Send> Packet<T> {
         // preflight check serves as the definitive "this will never be
         // received". Once we get beyond this check, we have permanently
         // entered the realm of "this may be received"
-        if self.cnt.load(atomic::SeqCst) < DISCONNECTED + FUDGE {
+        if self.cnt.load(Ordering::SeqCst) < DISCONNECTED + FUDGE {
             return Err(t)
         }
 
         self.queue.push(t);
-        match self.cnt.fetch_add(1, atomic::SeqCst) {
+        match self.cnt.fetch_add(1, Ordering::SeqCst) {
             -1 => {
                 self.take_to_wake().signal();
             }
@@ -183,9 +184,9 @@ impl<T: Send> Packet<T> {
             n if n < DISCONNECTED + FUDGE => {
                 // see the comment in 'try' for a shared channel for why this
                 // window of "not disconnected" is ok.
-                self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                self.cnt.store(DISCONNECTED, Ordering::SeqCst);
 
-                if self.sender_drain.fetch_add(1, atomic::SeqCst) == 0 {
+                if self.sender_drain.fetch_add(1, Ordering::SeqCst) == 0 {
                     loop {
                         // drain the queue, for info on the thread yield see the
                         // discussion in try_recv
@@ -198,7 +199,7 @@ impl<T: Send> Packet<T> {
                         }
                         // maybe we're done, if we're not the last ones
                         // here, then we need to go try again.
-                        if self.sender_drain.fetch_sub(1, atomic::SeqCst) == 1 {
+                        if self.sender_drain.fetch_sub(1, Ordering::SeqCst) == 1 {
                             break
                         }
                     }
@@ -239,15 +240,15 @@ impl<T: Send> Packet<T> {
     // Essentially the exact same thing as the stream decrement function.
     // Returns true if blocking should proceed.
     fn decrement(&mut self, token: SignalToken) -> StartResult {
-        assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+        assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
         let ptr = unsafe { token.cast_to_uint() };
-        self.to_wake.store(ptr, atomic::SeqCst);
+        self.to_wake.store(ptr, Ordering::SeqCst);
 
         let steals = self.steals;
         self.steals = 0;
 
-        match self.cnt.fetch_sub(1 + steals, atomic::SeqCst) {
-            DISCONNECTED => { self.cnt.store(DISCONNECTED, atomic::SeqCst); }
+        match self.cnt.fetch_sub(1 + steals, Ordering::SeqCst) {
+            DISCONNECTED => { self.cnt.store(DISCONNECTED, Ordering::SeqCst); }
             // If we factor in our steals and notice that the channel has no
             // data, we successfully sleep
             n => {
@@ -256,7 +257,7 @@ impl<T: Send> Packet<T> {
             }
         }
 
-        self.to_wake.store(0, atomic::SeqCst);
+        self.to_wake.store(0, Ordering::SeqCst);
         drop(unsafe { SignalToken::cast_from_uint(ptr) });
         Abort
     }
@@ -297,9 +298,9 @@ impl<T: Send> Packet<T> {
             // might decrement steals.
             Some(data) => {
                 if self.steals > MAX_STEALS {
-                    match self.cnt.swap(0, atomic::SeqCst) {
+                    match self.cnt.swap(0, Ordering::SeqCst) {
                         DISCONNECTED => {
-                            self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                            self.cnt.store(DISCONNECTED, Ordering::SeqCst);
                         }
                         n => {
                             let m = cmp::min(n, self.steals);
@@ -316,7 +317,7 @@ impl<T: Send> Packet<T> {
             // See the discussion in the stream implementation for why we try
             // again.
             None => {
-                match self.cnt.load(atomic::SeqCst) {
+                match self.cnt.load(Ordering::SeqCst) {
                     n if n != DISCONNECTED => Err(Empty),
                     _ => {
                         match self.queue.pop() {
@@ -334,20 +335,20 @@ impl<T: Send> Packet<T> {
     // Prepares this shared packet for a channel clone, essentially just bumping
     // a refcount.
     pub fn clone_chan(&mut self) {
-        self.channels.fetch_add(1, atomic::SeqCst);
+        self.channels.fetch_add(1, Ordering::SeqCst);
     }
 
     // Decrement the reference count on a channel. This is called whenever a
     // Chan is dropped and may end up waking up a receiver. It's the receiver's
     // responsibility on the other end to figure out that we've disconnected.
     pub fn drop_chan(&mut self) {
-        match self.channels.fetch_sub(1, atomic::SeqCst) {
+        match self.channels.fetch_sub(1, Ordering::SeqCst) {
             1 => {}
             n if n > 1 => return,
             n => panic!("bad number of channels left {}", n),
         }
 
-        match self.cnt.swap(DISCONNECTED, atomic::SeqCst) {
+        match self.cnt.swap(DISCONNECTED, Ordering::SeqCst) {
             -1 => { self.take_to_wake().signal(); }
             DISCONNECTED => {}
             n => { assert!(n >= 0); }
@@ -357,10 +358,10 @@ impl<T: Send> Packet<T> {
     // See the long discussion inside of stream.rs for why the queue is drained,
     // and why it is done in this fashion.
     pub fn drop_port(&mut self) {
-        self.port_dropped.store(true, atomic::SeqCst);
+        self.port_dropped.store(true, Ordering::SeqCst);
         let mut steals = self.steals;
         while {
-            let cnt = self.cnt.compare_and_swap(steals, DISCONNECTED, atomic::SeqCst);
+            let cnt = self.cnt.compare_and_swap(steals, DISCONNECTED, Ordering::SeqCst);
             cnt != DISCONNECTED && cnt != steals
         } {
             // See the discussion in 'try_recv' for why we yield
@@ -376,8 +377,8 @@ impl<T: Send> Packet<T> {
 
     // Consumes ownership of the 'to_wake' field.
     fn take_to_wake(&mut self) -> SignalToken {
-        let ptr = self.to_wake.load(atomic::SeqCst);
-        self.to_wake.store(0, atomic::SeqCst);
+        let ptr = self.to_wake.load(Ordering::SeqCst);
+        self.to_wake.store(0, Ordering::SeqCst);
         assert!(ptr != 0);
         unsafe { SignalToken::cast_from_uint(ptr) }
     }
@@ -392,15 +393,15 @@ impl<T: Send> Packet<T> {
     // This is different than the stream version because there's no need to peek
     // at the queue, we can just look at the local count.
     pub fn can_recv(&mut self) -> bool {
-        let cnt = self.cnt.load(atomic::SeqCst);
+        let cnt = self.cnt.load(Ordering::SeqCst);
         cnt == DISCONNECTED || cnt - self.steals > 0
     }
 
     // increment the count on the channel (used for selection)
     fn bump(&mut self, amt: int) -> int {
-        match self.cnt.fetch_add(amt, atomic::SeqCst) {
+        match self.cnt.fetch_add(amt, Ordering::SeqCst) {
             DISCONNECTED => {
-                self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                self.cnt.store(DISCONNECTED, Ordering::SeqCst);
                 DISCONNECTED
             }
             n => n
@@ -444,13 +445,13 @@ impl<T: Send> Packet<T> {
         // the channel count and figure out what we should do to make it
         // positive.
         let steals = {
-            let cnt = self.cnt.load(atomic::SeqCst);
+            let cnt = self.cnt.load(Ordering::SeqCst);
             if cnt < 0 && cnt != DISCONNECTED {-cnt} else {0}
         };
         let prev = self.bump(steals + 1);
 
         if prev == DISCONNECTED {
-            assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+            assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
             true
         } else {
             let cur = prev + steals + 1;
@@ -458,7 +459,7 @@ impl<T: Send> Packet<T> {
             if prev < 0 {
                 drop(self.take_to_wake());
             } else {
-                while self.to_wake.load(atomic::SeqCst) != 0 {
+                while self.to_wake.load(Ordering::SeqCst) != 0 {
                     Thread::yield_now();
                 }
             }
@@ -479,8 +480,8 @@ impl<T: Send> Drop for Packet<T> {
         // disconnection, but also a proper fence before the read of
         // `to_wake`, so this assert cannot be removed with also removing
         // the `to_wake` assert.
-        assert_eq!(self.cnt.load(atomic::SeqCst), DISCONNECTED);
-        assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
-        assert_eq!(self.channels.load(atomic::SeqCst), 0);
+        assert_eq!(self.cnt.load(Ordering::SeqCst), DISCONNECTED);
+        assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
+        assert_eq!(self.channels.load(Ordering::SeqCst), 0);
     }
 }
diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs
index 15624601157..e8d6e380be5 100644
--- a/src/libstd/sync/mpsc/spsc_queue.rs
+++ b/src/libstd/sync/mpsc/spsc_queue.rs
@@ -41,7 +41,7 @@ use alloc::boxed::Box;
 use core::mem;
 use core::cell::UnsafeCell;
 
-use sync::atomic::{AtomicPtr, Relaxed, AtomicUint, Acquire, Release};
+use sync::atomic::{AtomicPtr, AtomicUint, Ordering};
 
 // Node within the linked list queue of messages to send
 struct Node<T> {
@@ -109,7 +109,7 @@ impl<T: Send> Queue<T> {
     pub unsafe fn new(bound: uint) -> Queue<T> {
         let n1 = Node::new();
         let n2 = Node::new();
-        (*n1).next.store(n2, Relaxed);
+        (*n1).next.store(n2, Ordering::Relaxed);
         Queue {
             tail: UnsafeCell::new(n2),
             tail_prev: AtomicPtr::new(n1),
@@ -131,8 +131,8 @@ impl<T: Send> Queue<T> {
             let n = self.alloc();
             assert!((*n).value.is_none());
             (*n).value = Some(t);
-            (*n).next.store(0 as *mut Node<T>, Relaxed);
-            (**self.head.get()).next.store(n, Release);
+            (*n).next.store(0 as *mut Node<T>, Ordering::Relaxed);
+            (**self.head.get()).next.store(n, Ordering::Release);
             *self.head.get() = n;
         }
     }
@@ -144,23 +144,23 @@ impl<T: Send> Queue<T> {
         // only one subtracting from the cache).
         if *self.first.get() != *self.tail_copy.get() {
             if self.cache_bound > 0 {
-                let b = self.cache_subtractions.load(Relaxed);
-                self.cache_subtractions.store(b + 1, Relaxed);
+                let b = self.cache_subtractions.load(Ordering::Relaxed);
+                self.cache_subtractions.store(b + 1, Ordering::Relaxed);
             }
             let ret = *self.first.get();
-            *self.first.get() = (*ret).next.load(Relaxed);
+            *self.first.get() = (*ret).next.load(Ordering::Relaxed);
             return ret;
         }
         // If the above fails, then update our copy of the tail and try
         // again.
-        *self.tail_copy.get() = self.tail_prev.load(Acquire);
+        *self.tail_copy.get() = self.tail_prev.load(Ordering::Acquire);
         if *self.first.get() != *self.tail_copy.get() {
             if self.cache_bound > 0 {
-                let b = self.cache_subtractions.load(Relaxed);
-                self.cache_subtractions.store(b + 1, Relaxed);
+                let b = self.cache_subtractions.load(Ordering::Relaxed);
+                self.cache_subtractions.store(b + 1, Ordering::Relaxed);
             }
             let ret = *self.first.get();
-            *self.first.get() = (*ret).next.load(Relaxed);
+            *self.first.get() = (*ret).next.load(Ordering::Relaxed);
             return ret;
         }
         // If all of that fails, then we have to allocate a new node
@@ -177,25 +177,26 @@ impl<T: Send> Queue<T> {
             // tail's next field and see if we can use it. If we do a pop, then
             // the current tail node is a candidate for going into the cache.
             let tail = *self.tail.get();
-            let next = (*tail).next.load(Acquire);
+            let next = (*tail).next.load(Ordering::Acquire);
             if next.is_null() { return None }
             assert!((*next).value.is_some());
             let ret = (*next).value.take();
 
             *self.tail.get() = next;
             if self.cache_bound == 0 {
-                self.tail_prev.store(tail, Release);
+                self.tail_prev.store(tail, Ordering::Release);
             } else {
                 // FIXME: this is dubious with overflow.
-                let additions = self.cache_additions.load(Relaxed);
-                let subtractions = self.cache_subtractions.load(Relaxed);
+                let additions = self.cache_additions.load(Ordering::Relaxed);
+                let subtractions = self.cache_subtractions.load(Ordering::Relaxed);
                 let size = additions - subtractions;
 
                 if size < self.cache_bound {
-                    self.tail_prev.store(tail, Release);
-                    self.cache_additions.store(additions + 1, Relaxed);
+                    self.tail_prev.store(tail, Ordering::Release);
+                    self.cache_additions.store(additions + 1, Ordering::Relaxed);
                 } else {
-                    (*self.tail_prev.load(Relaxed)).next.store(next, Relaxed);
+                    (*self.tail_prev.load(Ordering::Relaxed))
+                          .next.store(next, Ordering::Relaxed);
                     // We have successfully erased all references to 'tail', so
                     // now we can safely drop it.
                     let _: Box<Node<T>> = mem::transmute(tail);
@@ -217,7 +218,7 @@ impl<T: Send> Queue<T> {
         // stripped out.
         unsafe {
             let tail = *self.tail.get();
-            let next = (*tail).next.load(Acquire);
+            let next = (*tail).next.load(Ordering::Acquire);
             if next.is_null() { return None }
             return (*next).value.as_mut();
         }
@@ -230,7 +231,7 @@ impl<T: Send> Drop for Queue<T> {
         unsafe {
             let mut cur = *self.first.get();
             while !cur.is_null() {
-                let next = (*cur).next.load(Relaxed);
+                let next = (*cur).next.load(Ordering::Relaxed);
                 let _n: Box<Node<T>> = mem::transmute(cur);
                 cur = next;
             }
diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs
index c526e6acb8f..bd1e74a3390 100644
--- a/src/libstd/sync/mpsc/stream.rs
+++ b/src/libstd/sync/mpsc/stream.rs
@@ -28,10 +28,10 @@ use core::cmp;
 use core::int;
 use thread::Thread;
 
+use sync::atomic::{AtomicInt, AtomicUint, Ordering, AtomicBool};
+use sync::mpsc::Receiver;
 use sync::mpsc::blocking::{self, SignalToken};
 use sync::mpsc::spsc_queue as spsc;
-use sync::mpsc::Receiver;
-use sync::atomic;
 
 const DISCONNECTED: int = int::MIN;
 #[cfg(test)]
@@ -42,11 +42,11 @@ const MAX_STEALS: int = 1 << 20;
 pub struct Packet<T> {
     queue: spsc::Queue<Message<T>>, // internal queue for all message
 
-    cnt: atomic::AtomicInt, // How many items are on this channel
+    cnt: AtomicInt, // How many items are on this channel
     steals: int, // How many times has a port received without blocking?
-    to_wake: atomic::AtomicUint, // SignalToken for the blocked thread to wake up
+    to_wake: AtomicUint, // SignalToken for the blocked thread to wake up
 
-    port_dropped: atomic::AtomicBool, // flag if the channel has been destroyed.
+    port_dropped: AtomicBool, // flag if the channel has been destroyed.
 }
 
 pub enum Failure<T> {
@@ -79,11 +79,11 @@ impl<T: Send> Packet<T> {
         Packet {
             queue: unsafe { spsc::Queue::new(128) },
 
-            cnt: atomic::AtomicInt::new(0),
+            cnt: AtomicInt::new(0),
             steals: 0,
-            to_wake: atomic::AtomicUint::new(0),
+            to_wake: AtomicUint::new(0),
 
-            port_dropped: atomic::AtomicBool::new(false),
+            port_dropped: AtomicBool::new(false),
         }
     }
 
@@ -91,7 +91,7 @@ impl<T: Send> Packet<T> {
         // If the other port has deterministically gone away, then definitely
         // must return the data back up the stack. Otherwise, the data is
         // considered as being sent.
-        if self.port_dropped.load(atomic::SeqCst) { return Err(t) }
+        if self.port_dropped.load(Ordering::SeqCst) { return Err(t) }
 
         match self.do_send(Data(t)) {
             UpSuccess | UpDisconnected => {},
@@ -103,14 +103,14 @@ impl<T: Send> Packet<T> {
     pub fn upgrade(&mut self, up: Receiver<T>) -> UpgradeResult {
         // If the port has gone away, then there's no need to proceed any
         // further.
-        if self.port_dropped.load(atomic::SeqCst) { return UpDisconnected }
+        if self.port_dropped.load(Ordering::SeqCst) { return UpDisconnected }
 
         self.do_send(GoUp(up))
     }
 
     fn do_send(&mut self, t: Message<T>) -> UpgradeResult {
         self.queue.push(t);
-        match self.cnt.fetch_add(1, atomic::SeqCst) {
+        match self.cnt.fetch_add(1, Ordering::SeqCst) {
             // As described in the mod's doc comment, -1 == wakeup
             -1 => UpWoke(self.take_to_wake()),
             // As as described before, SPSC queues must be >= -2
@@ -124,7 +124,7 @@ impl<T: Send> Packet<T> {
             // will never remove this data. We can only have at most one item to
             // drain (the port drains the rest).
             DISCONNECTED => {
-                self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                self.cnt.store(DISCONNECTED, Ordering::SeqCst);
                 let first = self.queue.pop();
                 let second = self.queue.pop();
                 assert!(second.is_none());
@@ -143,8 +143,8 @@ impl<T: Send> Packet<T> {
 
     // Consumes ownership of the 'to_wake' field.
     fn take_to_wake(&mut self) -> SignalToken {
-        let ptr = self.to_wake.load(atomic::SeqCst);
-        self.to_wake.store(0, atomic::SeqCst);
+        let ptr = self.to_wake.load(Ordering::SeqCst);
+        self.to_wake.store(0, Ordering::SeqCst);
         assert!(ptr != 0);
         unsafe { SignalToken::cast_from_uint(ptr) }
     }
@@ -153,15 +153,15 @@ impl<T: Send> Packet<T> {
     // back if it shouldn't sleep. Note that this is the location where we take
     // steals into account.
     fn decrement(&mut self, token: SignalToken) -> Result<(), SignalToken> {
-        assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+        assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
         let ptr = unsafe { token.cast_to_uint() };
-        self.to_wake.store(ptr, atomic::SeqCst);
+        self.to_wake.store(ptr, Ordering::SeqCst);
 
         let steals = self.steals;
         self.steals = 0;
 
-        match self.cnt.fetch_sub(1 + steals, atomic::SeqCst) {
-            DISCONNECTED => { self.cnt.store(DISCONNECTED, atomic::SeqCst); }
+        match self.cnt.fetch_sub(1 + steals, Ordering::SeqCst) {
+            DISCONNECTED => { self.cnt.store(DISCONNECTED, Ordering::SeqCst); }
             // If we factor in our steals and notice that the channel has no
             // data, we successfully sleep
             n => {
@@ -170,7 +170,7 @@ impl<T: Send> Packet<T> {
             }
         }
 
-        self.to_wake.store(0, atomic::SeqCst);
+        self.to_wake.store(0, Ordering::SeqCst);
         Err(unsafe { SignalToken::cast_from_uint(ptr) })
     }
 
@@ -217,9 +217,9 @@ impl<T: Send> Packet<T> {
             // adding back in whatever we couldn't factor into steals.
             Some(data) => {
                 if self.steals > MAX_STEALS {
-                    match self.cnt.swap(0, atomic::SeqCst) {
+                    match self.cnt.swap(0, Ordering::SeqCst) {
                         DISCONNECTED => {
-                            self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                            self.cnt.store(DISCONNECTED, Ordering::SeqCst);
                         }
                         n => {
                             let m = cmp::min(n, self.steals);
@@ -237,7 +237,7 @@ impl<T: Send> Packet<T> {
             }
 
             None => {
-                match self.cnt.load(atomic::SeqCst) {
+                match self.cnt.load(Ordering::SeqCst) {
                     n if n != DISCONNECTED => Err(Empty),
 
                     // This is a little bit of a tricky case. We failed to pop
@@ -266,7 +266,7 @@ impl<T: Send> Packet<T> {
     pub fn drop_chan(&mut self) {
         // Dropping a channel is pretty simple, we just flag it as disconnected
         // and then wakeup a blocker if there is one.
-        match self.cnt.swap(DISCONNECTED, atomic::SeqCst) {
+        match self.cnt.swap(DISCONNECTED, Ordering::SeqCst) {
             -1 => { self.take_to_wake().signal(); }
             DISCONNECTED => {}
             n => { assert!(n >= 0); }
@@ -293,7 +293,7 @@ impl<T: Send> Packet<T> {
         // sends are gated on this flag, so we're immediately guaranteed that
         // there are a bounded number of active sends that we'll have to deal
         // with.
-        self.port_dropped.store(true, atomic::SeqCst);
+        self.port_dropped.store(true, Ordering::SeqCst);
 
         // Now that we're guaranteed to deal with a bounded number of senders,
         // we need to drain the queue. This draining process happens atomically
@@ -306,7 +306,7 @@ impl<T: Send> Packet<T> {
         let mut steals = self.steals;
         while {
             let cnt = self.cnt.compare_and_swap(
-                            steals, DISCONNECTED, atomic::SeqCst);
+                            steals, DISCONNECTED, Ordering::SeqCst);
             cnt != DISCONNECTED && cnt != steals
         } {
             loop {
@@ -351,9 +351,9 @@ impl<T: Send> Packet<T> {
 
     // increment the count on the channel (used for selection)
     fn bump(&mut self, amt: int) -> int {
-        match self.cnt.fetch_add(amt, atomic::SeqCst) {
+        match self.cnt.fetch_add(amt, Ordering::SeqCst) {
             DISCONNECTED => {
-                self.cnt.store(DISCONNECTED, atomic::SeqCst);
+                self.cnt.store(DISCONNECTED, Ordering::SeqCst);
                 DISCONNECTED
             }
             n => n
@@ -403,7 +403,7 @@ impl<T: Send> Packet<T> {
         // of time until the data is actually sent.
         if was_upgrade {
             assert_eq!(self.steals, 0);
-            assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+            assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
             return Ok(true)
         }
 
@@ -416,7 +416,7 @@ impl<T: Send> Packet<T> {
         // If we were previously disconnected, then we know for sure that there
         // is no task in to_wake, so just keep going
         let has_data = if prev == DISCONNECTED {
-            assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+            assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
             true // there is data, that data is that we're disconnected
         } else {
             let cur = prev + steals + 1;
@@ -439,7 +439,7 @@ impl<T: Send> Packet<T> {
             if prev < 0 {
                 drop(self.take_to_wake());
             } else {
-                while self.to_wake.load(atomic::SeqCst) != 0 {
+                while self.to_wake.load(Ordering::SeqCst) != 0 {
                     Thread::yield_now();
                 }
             }
@@ -478,7 +478,7 @@ impl<T: Send> Drop for Packet<T> {
         // disconnection, but also a proper fence before the read of
         // `to_wake`, so this assert cannot be removed with also removing
         // the `to_wake` assert.
-        assert_eq!(self.cnt.load(atomic::SeqCst), DISCONNECTED);
-        assert_eq!(self.to_wake.load(atomic::SeqCst), 0);
+        assert_eq!(self.cnt.load(Ordering::SeqCst), DISCONNECTED);
+        assert_eq!(self.to_wake.load(Ordering::SeqCst), 0);
     }
 }
diff --git a/src/libstd/sync/mpsc/sync.rs b/src/libstd/sync/mpsc/sync.rs
index 0eee10898bc..6836888e67e 100644
--- a/src/libstd/sync/mpsc/sync.rs
+++ b/src/libstd/sync/mpsc/sync.rs
@@ -41,14 +41,15 @@ use self::Blocker::*;
 use vec::Vec;
 use core::mem;
 
-use sync::{atomic, Mutex, MutexGuard};
+use sync::atomic::{Ordering, AtomicUint};
 use sync::mpsc::blocking::{self, WaitToken, SignalToken};
 use sync::mpsc::select::StartResult::{self, Installed, Abort};
+use sync::{Mutex, MutexGuard};
 
 pub struct Packet<T> {
     /// Only field outside of the mutex. Just done for kicks, but mainly because
     /// the other shared channel already had the code implemented
-    channels: atomic::AtomicUint,
+    channels: AtomicUint,
 
     lock: Mutex<State<T>>,
 }
@@ -137,7 +138,7 @@ fn wakeup<T>(token: SignalToken, guard: MutexGuard<State<T>>) {
 impl<T: Send> Packet<T> {
     pub fn new(cap: uint) -> Packet<T> {
         Packet {
-            channels: atomic::AtomicUint::new(1),
+            channels: AtomicUint::new(1),
             lock: Mutex::new(State {
                 disconnected: false,
                 blocker: NoneBlocked,
@@ -304,12 +305,12 @@ impl<T: Send> Packet<T> {
     // Prepares this shared packet for a channel clone, essentially just bumping
     // a refcount.
     pub fn clone_chan(&self) {
-        self.channels.fetch_add(1, atomic::SeqCst);
+        self.channels.fetch_add(1, Ordering::SeqCst);
     }
 
     pub fn drop_chan(&self) {
         // Only flag the channel as disconnected if we're the last channel
-        match self.channels.fetch_sub(1, atomic::SeqCst) {
+        match self.channels.fetch_sub(1, Ordering::SeqCst) {
             1 => {}
             _ => return
         }
@@ -412,7 +413,7 @@ impl<T: Send> Packet<T> {
 #[unsafe_destructor]
 impl<T: Send> Drop for Packet<T> {
     fn drop(&mut self) {
-        assert_eq!(self.channels.load(atomic::SeqCst), 0);
+        assert_eq!(self.channels.load(Ordering::SeqCst), 0);
         let mut guard = self.lock.lock().unwrap();
         assert!(guard.queue.dequeue().is_none());
         assert!(guard.canceled.is_none());
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index 9e9a17e482f..08e323c9cb4 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -17,7 +17,7 @@ use int;
 use kinds::Sync;
 use mem::drop;
 use ops::FnOnce;
-use sync::atomic;
+use sync::atomic::{AtomicInt, Ordering, ATOMIC_INT_INIT};
 use sync::{StaticMutex, MUTEX_INIT};
 
 /// A synchronization primitive which can be used to run a one-time global
@@ -39,8 +39,8 @@ use sync::{StaticMutex, MUTEX_INIT};
 #[stable]
 pub struct Once {
     mutex: StaticMutex,
-    cnt: atomic::AtomicInt,
-    lock_cnt: atomic::AtomicInt,
+    cnt: AtomicInt,
+    lock_cnt: AtomicInt,
 }
 
 unsafe impl Sync for Once {}
@@ -49,8 +49,8 @@ unsafe impl Sync for Once {}
 #[stable]
 pub const ONCE_INIT: Once = Once {
     mutex: MUTEX_INIT,
-    cnt: atomic::ATOMIC_INT_INIT,
-    lock_cnt: atomic::ATOMIC_INT_INIT,
+    cnt: ATOMIC_INT_INIT,
+    lock_cnt: ATOMIC_INT_INIT,
 };
 
 impl Once {
@@ -66,7 +66,7 @@ impl Once {
     #[stable]
     pub fn call_once<F>(&'static self, f: F) where F: FnOnce() {
         // Optimize common path: load is much cheaper than fetch_add.
-        if self.cnt.load(atomic::SeqCst) < 0 {
+        if self.cnt.load(Ordering::SeqCst) < 0 {
             return
         }
 
@@ -97,11 +97,11 @@ impl Once {
         // calling `call_once` will return immediately before the initialization
         // has completed.
 
-        let prev = self.cnt.fetch_add(1, atomic::SeqCst);
+        let prev = self.cnt.fetch_add(1, Ordering::SeqCst);
         if prev < 0 {
             // Make sure we never overflow, we'll never have int::MIN
             // simultaneous calls to `call_once` to make this value go back to 0
-            self.cnt.store(int::MIN, atomic::SeqCst);
+            self.cnt.store(int::MIN, Ordering::SeqCst);
             return
         }
 
@@ -109,15 +109,15 @@ impl Once {
         // otherwise we run the job and record how many people will try to grab
         // this lock
         let guard = self.mutex.lock();
-        if self.cnt.load(atomic::SeqCst) > 0 {
+        if self.cnt.load(Ordering::SeqCst) > 0 {
             f();
-            let prev = self.cnt.swap(int::MIN, atomic::SeqCst);
-            self.lock_cnt.store(prev, atomic::SeqCst);
+            let prev = self.cnt.swap(int::MIN, Ordering::SeqCst);
+            self.lock_cnt.store(prev, Ordering::SeqCst);
         }
         drop(guard);
 
         // Last one out cleans up after everyone else, no leaks!
-        if self.lock_cnt.fetch_add(-1, atomic::SeqCst) == 1 {
+        if self.lock_cnt.fetch_add(-1, Ordering::SeqCst) == 1 {
             unsafe { self.mutex.destroy() }
         }
     }
diff --git a/src/libstd/sys/common/thread_local.rs b/src/libstd/sys/common/thread_local.rs
index 158fd3a8382..e9af796c674 100644
--- a/src/libstd/sys/common/thread_local.rs
+++ b/src/libstd/sys/common/thread_local.rs
@@ -58,7 +58,7 @@
 
 use prelude::v1::*;
 
-use sync::atomic::{self, AtomicUint};
+use sync::atomic::{self, AtomicUint, Ordering};
 use sync::{Mutex, Once, ONCE_INIT};
 
 use sys::thread_local as imp;
@@ -166,7 +166,7 @@ impl StaticKey {
     /// Note that this does *not* run the user-provided destructor if one was
     /// specified at definition time. Doing so must be done manually.
     pub unsafe fn destroy(&self) {
-        match self.inner.key.swap(0, atomic::SeqCst) {
+        match self.inner.key.swap(0, Ordering::SeqCst) {
             0 => {}
             n => { imp::destroy(n as imp::Key) }
         }
@@ -174,7 +174,7 @@ impl StaticKey {
 
     #[inline]
     unsafe fn key(&self) -> imp::Key {
-        match self.inner.key.load(atomic::Relaxed) {
+        match self.inner.key.load(Ordering::Relaxed) {
             0 => self.lazy_init() as imp::Key,
             n => n as imp::Key
         }
@@ -199,7 +199,7 @@ impl StaticKey {
             key2
         };
         assert!(key != 0);
-        match self.inner.key.compare_and_swap(0, key as uint, atomic::SeqCst) {
+        match self.inner.key.compare_and_swap(0, key as uint, Ordering::SeqCst) {
             // The CAS succeeded, so we've created the actual key
             0 => key as uint,
             // If someone beat us to the punch, use their key instead
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index 690574301d7..181b8fdd0f8 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -20,7 +20,6 @@ use libc::{self, c_int, c_char, c_void};
 use os;
 use path::{BytesContainer};
 use ptr;
-use sync::atomic::{AtomicInt, SeqCst};
 use sys::fs::FileDesc;
 
 use os::TMPBUF_SZ;
diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs
index fcbfb383d3c..9063fbc2ba9 100644
--- a/src/libstd/sys/unix/pipe.rs
+++ b/src/libstd/sys/unix/pipe.rs
@@ -13,7 +13,8 @@ use prelude::v1::*;
 use libc;
 use c_str::CString;
 use mem;
-use sync::{atomic, Arc, Mutex};
+use sync::{Arc, Mutex};
+use sync::atomic::{AtomicBool, Ordering};
 use io::{self, IoResult, IoError};
 
 use sys::{self, timer, retry, c, set_nonblocking, wouldblock};
@@ -242,7 +243,7 @@ impl UnixListener {
                         listener: self,
                         reader: reader,
                         writer: writer,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -260,7 +261,7 @@ struct AcceptorInner {
     listener: UnixListener,
     reader: FileDesc,
     writer: FileDesc,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 impl UnixAcceptor {
@@ -269,7 +270,7 @@ impl UnixAcceptor {
     pub fn accept(&mut self) -> IoResult<UnixStream> {
         let deadline = if self.deadline == 0 {None} else {Some(self.deadline)};
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             unsafe {
                 let mut storage: libc::sockaddr_storage = mem::zeroed();
                 let storagep = &mut storage as *mut libc::sockaddr_storage;
@@ -297,7 +298,7 @@ impl UnixAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let fd = FileDesc::new(self.inner.writer.fd(), false);
         match fd.write(&[0]) {
             Ok(..) => Ok(()),
diff --git a/src/libstd/sys/unix/tcp.rs b/src/libstd/sys/unix/tcp.rs
index 13ccf685fd7..59eebd3f28e 100644
--- a/src/libstd/sys/unix/tcp.rs
+++ b/src/libstd/sys/unix/tcp.rs
@@ -16,7 +16,8 @@ use libc;
 use mem;
 use ptr;
 use super::{last_error, last_net_error, retry, sock_t};
-use sync::{Arc, atomic};
+use sync::Arc;
+use sync::atomic::{AtomicBool, Ordering};
 use sys::fs::FileDesc;
 use sys::{set_nonblocking, wouldblock};
 use sys;
@@ -74,7 +75,7 @@ impl TcpListener {
                         listener: self,
                         reader: reader,
                         writer: writer,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -96,7 +97,7 @@ struct AcceptorInner {
     listener: TcpListener,
     reader: FileDesc,
     writer: FileDesc,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Sync for AcceptorInner {}
@@ -121,7 +122,7 @@ impl TcpAcceptor {
         // self-pipe is never written to unless close_accept() is called.
         let deadline = if self.deadline == 0 {None} else {Some(self.deadline)};
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             match retry(|| unsafe {
                 libc::accept(self.fd(), ptr::null_mut(), ptr::null_mut())
             }) {
@@ -145,7 +146,7 @@ impl TcpAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let fd = FileDesc::new(self.inner.writer.fd(), false);
         match fd.write(&[0]) {
             Ok(..) => Ok(()),
diff --git a/src/libstd/sys/unix/timer.rs b/src/libstd/sys/unix/timer.rs
index 80f93dd2f61..11f29232a92 100644
--- a/src/libstd/sys/unix/timer.rs
+++ b/src/libstd/sys/unix/timer.rs
@@ -54,7 +54,7 @@ use libc;
 use mem;
 use os;
 use ptr;
-use sync::atomic;
+use sync::atomic::{mod, Ordering};
 use sync::mpsc::{channel, Sender, Receiver, TryRecvError};
 use sys::c;
 use sys::fs::FileDesc;
@@ -212,7 +212,7 @@ impl Timer {
         HELPER.boot(|| {}, helper);
 
         static ID: atomic::AtomicUint = atomic::ATOMIC_UINT_INIT;
-        let id = ID.fetch_add(1, atomic::Relaxed);
+        let id = ID.fetch_add(1, Ordering::Relaxed);
         Ok(Timer {
             id: id,
             inner: Some(box Inner {
diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs
index f561e0121b3..1def99a3741 100644
--- a/src/libstd/sys/windows/mutex.rs
+++ b/src/libstd/sys/windows/mutex.rs
@@ -10,7 +10,7 @@
 
 use prelude::v1::*;
 
-use sync::atomic;
+use sync::atomic::{AtomicUint, ATOMIC_UINT_INIT, Ordering};
 use alloc::{self, heap};
 
 use libc::DWORD;
@@ -18,9 +18,9 @@ use sys::sync as ffi;
 
 const SPIN_COUNT: DWORD = 4000;
 
-pub struct Mutex { inner: atomic::AtomicUint }
+pub struct Mutex { inner: AtomicUint }
 
-pub const MUTEX_INIT: Mutex = Mutex { inner: atomic::ATOMIC_UINT_INIT };
+pub const MUTEX_INIT: Mutex = Mutex { inner: ATOMIC_UINT_INIT };
 
 unsafe impl Sync for Mutex {}
 
@@ -32,7 +32,7 @@ pub unsafe fn raw(m: &Mutex) -> ffi::LPCRITICAL_SECTION {
 impl Mutex {
     #[inline]
     pub unsafe fn new() -> Mutex {
-        Mutex { inner: atomic::AtomicUint::new(init_lock() as uint) }
+        Mutex { inner: AtomicUint::new(init_lock() as uint) }
     }
     #[inline]
     pub unsafe fn lock(&self) {
@@ -47,22 +47,22 @@ impl Mutex {
         ffi::LeaveCriticalSection(self.get())
     }
     pub unsafe fn destroy(&self) {
-        let lock = self.inner.swap(0, atomic::SeqCst);
+        let lock = self.inner.swap(0, Ordering::SeqCst);
         if lock != 0 { free_lock(lock as ffi::LPCRITICAL_SECTION) }
     }
 
     unsafe fn get(&self) -> ffi::LPCRITICAL_SECTION {
-        match self.inner.load(atomic::SeqCst) {
+        match self.inner.load(Ordering::SeqCst) {
             0 => {}
             n => return n as ffi::LPCRITICAL_SECTION
         }
         let lock = init_lock();
-        match self.inner.compare_and_swap(0, lock as uint, atomic::SeqCst) {
+        match self.inner.compare_and_swap(0, lock as uint, Ordering::SeqCst) {
             0 => return lock as ffi::LPCRITICAL_SECTION,
             _ => {}
         }
         free_lock(lock);
-        return self.inner.load(atomic::SeqCst) as ffi::LPCRITICAL_SECTION;
+        return self.inner.load(Ordering::SeqCst) as ffi::LPCRITICAL_SECTION;
     }
 }
 
diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs
index 0edae75a9ce..9057515cad2 100644
--- a/src/libstd/sys/windows/pipe.rs
+++ b/src/libstd/sys/windows/pipe.rs
@@ -90,7 +90,8 @@ use libc;
 use c_str::CString;
 use mem;
 use ptr;
-use sync::{atomic, Arc, Mutex};
+use sync::{Arc, Mutex};
+use sync::atomic::{AtomicBool, Ordering};
 use io::{self, IoError, IoResult};
 
 use sys_common::{self, eof};
@@ -126,8 +127,8 @@ impl Drop for Event {
 struct Inner {
     handle: libc::HANDLE,
     lock: Mutex<()>,
-    read_closed: atomic::AtomicBool,
-    write_closed: atomic::AtomicBool,
+    read_closed: AtomicBool,
+    write_closed: AtomicBool,
 }
 
 impl Inner {
@@ -135,8 +136,8 @@ impl Inner {
         Inner {
             handle: handle,
             lock: Mutex::new(()),
-            read_closed: atomic::AtomicBool::new(false),
-            write_closed: atomic::AtomicBool::new(false),
+            read_closed: AtomicBool::new(false),
+            write_closed: AtomicBool::new(false),
         }
     }
 }
@@ -334,11 +335,11 @@ impl UnixStream {
     pub fn handle(&self) -> libc::HANDLE { self.inner.handle }
 
     fn read_closed(&self) -> bool {
-        self.inner.read_closed.load(atomic::SeqCst)
+        self.inner.read_closed.load(Ordering::SeqCst)
     }
 
     fn write_closed(&self) -> bool {
-        self.inner.write_closed.load(atomic::SeqCst)
+        self.inner.write_closed.load(Ordering::SeqCst)
     }
 
     fn cancel_io(&self) -> IoResult<()> {
@@ -517,14 +518,14 @@ impl UnixStream {
         // and 2 with a lock with respect to close_read(), we're guaranteed that
         // no thread will erroneously sit in a read forever.
         let _guard = unsafe { self.inner.lock.lock() };
-        self.inner.read_closed.store(true, atomic::SeqCst);
+        self.inner.read_closed.store(true, Ordering::SeqCst);
         self.cancel_io()
     }
 
     pub fn close_write(&mut self) -> IoResult<()> {
         // see comments in close_read() for why this lock is necessary
         let _guard = unsafe { self.inner.lock.lock() };
-        self.inner.write_closed.store(true, atomic::SeqCst);
+        self.inner.write_closed.store(true, Ordering::SeqCst);
         self.cancel_io()
     }
 
@@ -586,7 +587,7 @@ impl UnixListener {
             deadline: 0,
             inner: Arc::new(AcceptorState {
                 abort: try!(Event::new(true, false)),
-                closed: atomic::AtomicBool::new(false),
+                closed: AtomicBool::new(false),
             }),
         })
     }
@@ -614,7 +615,7 @@ unsafe impl Sync for UnixAcceptor {}
 
 struct AcceptorState {
     abort: Event,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Send for AcceptorState {}
@@ -658,7 +659,7 @@ impl UnixAcceptor {
 
         // If we've had an artificial call to close_accept, be sure to never
         // proceed in accepting new clients in the future
-        if self.inner.closed.load(atomic::SeqCst) { return Err(eof()) }
+        if self.inner.closed.load(Ordering::SeqCst) { return Err(eof()) }
 
         let name = try!(to_utf16(self.listener.name.as_str()));
 
@@ -734,7 +735,7 @@ impl UnixAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let ret = unsafe {
             c::SetEvent(self.inner.abort.handle())
         };
diff --git a/src/libstd/sys/windows/tcp.rs b/src/libstd/sys/windows/tcp.rs
index 1c8ec2a80a7..77139b52efa 100644
--- a/src/libstd/sys/windows/tcp.rs
+++ b/src/libstd/sys/windows/tcp.rs
@@ -15,7 +15,8 @@ use mem;
 use ptr;
 use prelude::v1::*;
 use super::{last_error, last_net_error, retry, sock_t};
-use sync::{Arc, atomic};
+use sync::Arc;
+use sync::atomic::{AtomicBool, Ordering};
 use sys::fs::FileDesc;
 use sys::{self, c, set_nonblocking, wouldblock, timer};
 use sys_common::{self, timeout, eof, net};
@@ -91,7 +92,7 @@ impl TcpListener {
                         listener: self,
                         abort: try!(Event::new()),
                         accept: accept,
-                        closed: atomic::AtomicBool::new(false),
+                        closed: AtomicBool::new(false),
                     }),
                     deadline: 0,
                 })
@@ -122,7 +123,7 @@ struct AcceptorInner {
     listener: TcpListener,
     abort: Event,
     accept: Event,
-    closed: atomic::AtomicBool,
+    closed: AtomicBool,
 }
 
 unsafe impl Send for AcceptorInner {}
@@ -154,7 +155,7 @@ impl TcpAcceptor {
         // stolen, so we do all of this in a loop as well.
         let events = [self.inner.abort.handle(), self.inner.accept.handle()];
 
-        while !self.inner.closed.load(atomic::SeqCst) {
+        while !self.inner.closed.load(Ordering::SeqCst) {
             let ms = if self.deadline == 0 {
                 c::WSA_INFINITE as u64
             } else {
@@ -214,7 +215,7 @@ impl TcpAcceptor {
     }
 
     pub fn close_accept(&mut self) -> IoResult<()> {
-        self.inner.closed.store(true, atomic::SeqCst);
+        self.inner.closed.store(true, Ordering::SeqCst);
         let ret = unsafe { c::WSASetEvent(self.inner.abort.handle()) };
         if ret == libc::TRUE {
             Ok(())
diff --git a/src/libstd/task.rs b/src/libstd/task.rs
deleted file mode 100644
index 0f08108fee5..00000000000
--- a/src/libstd/task.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Deprecated in favor of `thread`.
-
-#![deprecated = "use std::thread instead"]
-
-use any::Any;
-use boxed::Box;
-use thread;
-use kinds::Send;
-use result::Result;
-use ops::FnOnce;
-
-/// Deprecate: use `std::thread::Builder` instead.
-#[deprecated = "use std::thread::Builder instead"]
-pub type TaskBuilder = thread::Builder;
-
-/// Deprecated: use `std::thread::Thread::spawn` and `detach` instead.
-#[deprecated = "use std::thread::Thread::spawn and detach instead"]
-pub fn spawn<F>(f: F) where F: FnOnce(), F: Send {
-    thread::Thread::spawn(f).detach();
-}
-
-/// Deprecated: use `std::thread::Thread::spawn` and `join` instead.
-#[deprecated = "use std::thread::Thread::spawn and join instead"]
-pub fn try<T, F>(f: F) -> Result<T, Box<Any + Send>> where
-    T: Send, F: FnOnce() -> T, F: Send
-{
-    thread::Thread::spawn(f).join()
-}
-
-/// Deprecated: use `std::thread::Thread::yield_now instead`.
-#[deprecated = "use std::thread::Thread::yield_now instead"]
-pub fn deschedule() {
-    thread::Thread::yield_now()
-}
diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs
index 9c8a5fc239c..1d6f49b04a3 100644
--- a/src/libstd/thread.rs
+++ b/src/libstd/thread.rs
@@ -125,7 +125,6 @@
 //! * It can be implemented highly efficiently on many platforms.
 
 use any::Any;
-use borrow::IntoCow;
 use boxed::Box;
 use cell::UnsafeCell;
 use clone::Clone;
@@ -175,12 +174,6 @@ impl Builder {
         self
     }
 
-    /// Deprecated: use `name` instead
-    #[deprecated = "use name instead"]
-    pub fn named<T: IntoCow<'static, String, str>>(self, name: T) -> Builder {
-        self.name(name.into_cow().into_owned())
-    }
-
     /// Set the size of the stack for the new thread.
     pub fn stack_size(mut self, size: uint) -> Builder {
         self.stack_size = Some(size);
diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs
index fc90bffa03c..f40b62182d4 100644
--- a/src/libstd/tuple.rs
+++ b/src/libstd/tuple.rs
@@ -35,17 +35,6 @@
 //!
 //! # Examples
 //!
-//! Using fields:
-//!
-//! ```
-//! #[allow(deprecated)]
-//! # fn main() {
-//! let pair = ("pi", 3.14f64);
-//! assert_eq!(pair.0, "pi");
-//! assert_eq!(pair.1, 3.14f64);
-//! # }
-//! ```
-//!
 //! Using traits implemented for tuples:
 //!
 //! ```