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.

8 files changed, 46 insertions, 43 deletions

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(())