std: Stabilize the prelude module

This commit is an implementation of [RFC 503][rfc] which is a stabilization
story for the prelude. Most of the RFC was directly applied, removing reexports.
Some reexports are kept around, however:

* `range` remains until range syntax has landed to reduce churn.
* `Path` and `GenericPath` remain until path reform lands. This is done to
  prevent many imports of `GenericPath` which will soon be removed.
* All `io` traits remain until I/O reform lands so imports can be rewritten all
  at once to `std::io::prelude::*`.

This is a breaking change because many prelude reexports have been removed, and
the RFC can be consulted for the exact list of removed reexports, as well as to
find the locations of where to import them.

[rfc]: https://github.com/rust-lang/rfcs/blob/master/text/0503-prelude-stabilization.md
[breaking-change]

Closes #20068

1 files changed, 13 insertions, 9 deletions

diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index 4d2fbfc4055..87a02bd4ef5 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -8,10 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
+use prelude::v1::*;
 
 use cell::UnsafeCell;
 use kinds::marker;
+use ops::{Deref, DerefMut};
 use sync::{poison, AsMutexGuard};
 use sys_common::mutex as sys;
 
@@ -36,6 +37,8 @@ use sys_common::mutex as sys;
 /// ```rust
 /// use std::sync::{Arc, Mutex};
 /// use std::thread::Thread;
+/// use std::comm::channel;
+///
 /// const N: uint = 10;
 ///
 /// // Spawn a few threads to increment a shared variable (non-atomically), and
@@ -279,10 +282,11 @@ impl Drop for StaticMutexGuard {
 
 #[cfg(test)]
 mod test {
-    use prelude::*;
+    use prelude::v1::*;
 
-    use thread::Thread;
+    use comm::channel;
     use sync::{Arc, Mutex, StaticMutex, MUTEX_INIT, Condvar};
+    use thread::Thread;
 
     struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
 
@@ -325,9 +329,9 @@ mod test {
         let (tx, rx) = channel();
         for _ in range(0, K) {
             let tx2 = tx.clone();
-            spawn(move|| { inc(); tx2.send(()); });
+            Thread::spawn(move|| { inc(); tx2.send(()); }).detach();
             let tx2 = tx.clone();
-            spawn(move|| { inc(); tx2.send(()); });
+            Thread::spawn(move|| { inc(); tx2.send(()); }).detach();
         }
 
         drop(tx);
@@ -351,7 +355,7 @@ mod test {
         let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));
         let packet2 = Packet(packet.0.clone());
         let (tx, rx) = channel();
-        spawn(move|| {
+        let _t = Thread::spawn(move|| {
             // wait until parent gets in
             rx.recv();
             let &(ref lock, ref cvar) = &*packet2.0;
@@ -376,7 +380,7 @@ mod test {
         let packet2 = Packet(packet.0.clone());
         let (tx, rx) = channel();
 
-        spawn(move|| {
+        let _t = Thread::spawn(move || -> () {
             rx.recv();
             let &(ref lock, ref cvar) = &*packet2.0;
             let _g = lock.lock();
@@ -413,9 +417,9 @@ mod test {
         let arc = Arc::new(Mutex::new(1i));
         let arc2 = Arc::new(Mutex::new(arc));
         let (tx, rx) = channel();
-        spawn(move|| {
+        let _t = Thread::spawn(move|| {
             let lock = arc2.lock();
-            let lock2 = lock.deref().lock();
+            let lock2 = lock.lock();
             assert_eq!(*lock2, 1);
             tx.send(());
         });