std: Second pass stabilization for comm

This commit is a second pass stabilization for the `std::comm` module,
performing the following actions:

* The entire `std::comm` module was moved under `std::sync::mpsc`. This movement
  reflects that channels are just yet another synchronization primitive, and
  they don't necessarily deserve a special place outside of the other
  concurrency primitives that the standard library offers.
* The `send` and `recv` methods have all been removed.
* The `send_opt` and `recv_opt` methods have been renamed to `send` and `recv`.
  This means that all send/receive operations return a `Result` now indicating
  whether the operation was successful or not.
* The error type of `send` is now a `SendError` to implement a custom error
  message and allow for `unwrap()`. The error type contains an `into_inner`
  method to extract the value.
* The error type of `recv` is now `RecvError` for the same reasons as `send`.
* The `TryRecvError` and `TrySendError` types have had public reexports removed
  of their variants and the variant names have been tweaked with enum
  namespacing rules.
* The `Messages` iterator is renamed to `Iter`

This functionality is now all `#[stable]`:

* `Sender`
* `SyncSender`
* `Receiver`
* `std::sync::mpsc`
* `channel`
* `sync_channel`
* `Iter`
* `Sender::send`
* `Sender::clone`
* `SyncSender::send`
* `SyncSender::try_send`
* `SyncSender::clone`
* `Receiver::recv`
* `Receiver::try_recv`
* `Receiver::iter`
* `SendError`
* `RecvError`
* `TrySendError::{mod, Full, Disconnected}`
* `TryRecvError::{mod, Empty, Disconnected}`
* `SendError::into_inner`
* `TrySendError::into_inner`

This is a breaking change due to the modification of where this module is
located, as well as the changing of the semantics of `send` and `recv`. Most
programs just need to rename imports of `std::comm` to `std::sync::mpsc` and
add calls to `unwrap` after a send or a receive operation.

[breaking-change]

Author: alexcrichton

src/etc/licenseck.py

@@ -38,8 +38,8 @@
     "rt/isaac/randport.cpp", # public domain
     "rt/isaac/rand.h", # public domain
     "rt/isaac/standard.h", # public domain
-    "libstd/comm/mpsc_queue.rs", # BSD
-    "libstd/comm/spsc_queue.rs", # BSD
+    "libstd/sync/mpsc/mpsc_queue.rs", # BSD
+    "libstd/sync/mpsc/spsc_queue.rs", # BSD
     "test/bench/shootout-binarytrees.rs", # BSD
     "test/bench/shootout-chameneos-redux.rs", # BSD
     "test/bench/shootout-fannkuch-redux.rs", # BSD

src/liballoc/arc.rs

@@ -592,7 +592,7 @@ impl<T: Default + Sync + Send> Default for Arc<T> {
 #[allow(experimental)]
 mod tests {
     use std::clone::Clone;
-    use std::comm::channel;
+    use std::sync::mpsc::channel;
     use std::mem::drop;
     use std::ops::Drop;
     use std::option::Option;
@@ -628,11 +628,11 @@ mod tests {
         let (tx, rx) = channel();
 
         task::spawn(move || {
-            let arc_v: Arc<Vec<int>> = rx.recv();
+            let arc_v: Arc<Vec<int>> = rx.recv().unwrap();
             assert_eq!((*arc_v)[3], 4);
         });
 
-        tx.send(arc_v.clone());
+        tx.send(arc_v.clone()).unwrap();
 
         assert_eq!((*arc_v)[2], 3);
         assert_eq!((*arc_v)[4], 5);

src/libcollections/bit.rs

@@ -2452,7 +2452,7 @@ mod tests {
 
 #[cfg(test)]
 mod bitv_bench {
-    use std::prelude::*;
+    use std::prelude::v1::*;
     use std::rand;
     use std::rand::Rng;
     use std::u32;
@@ -2947,7 +2947,7 @@ mod bitv_set_test {
 
 #[cfg(test)]
 mod bitv_set_bench {
-    use std::prelude::*;
+    use std::prelude::v1::*;
     use std::rand;
     use std::rand::Rng;
     use std::u32;

src/librustc_driver/lib.rs

@@ -55,10 +55,10 @@ use rustc::DIAGNOSTICS;
 
 use std::any::AnyRefExt;
 use std::cmp::Ordering::Equal;
-use std::comm::channel;
 use std::io;
 use std::iter::repeat;
 use std::os;
+use std::sync::mpsc::channel;
 use std::thread;
 
 use rustc::session::early_error;

src/librustc_trans/back/write.rs

@@ -23,14 +23,14 @@ use syntax::diagnostic;
 use syntax::diagnostic::{Emitter, Handler, Level, mk_handler};
 
 use std::c_str::{ToCStr, CString};
-use std::comm::channel;
 use std::io::Command;
 use std::io::fs;
 use std::iter::Unfold;
 use std::ptr;
 use std::str;
 use std::mem;
 use std::sync::{Arc, Mutex};
+use std::sync::mpsc::channel;
 use std::thread;
 use libc::{c_uint, c_int, c_void};
 
@@ -929,13 +929,13 @@ fn run_work_multithreaded(sess: &Session,
                 }
             }
 
-            tx.take().unwrap().send(());
+            tx.take().unwrap().send(()).unwrap();
         }).detach();
     }
 
     let mut panicked = false;
     for rx in futures.into_iter() {
-        match rx.recv_opt() {
+        match rx.recv() {
             Ok(()) => {},
             Err(_) => {
                 panicked = true;

src/librustc_trans/save/mod.rs

@@ -1203,8 +1203,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                         let glob_map = &self.analysis.glob_map;
                         let glob_map = glob_map.as_ref().unwrap();
                         if glob_map.contains_key(&id) {
-                            let names = glob_map.index(&id);
-                            for n in names.iter() {
+                            for n in glob_map[id].iter() {
                                 if name_string.len() > 0 {
                                     name_string.push_str(", ");
                                 }

src/librustdoc/test.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::cell::RefCell;
-use std::comm::channel;
+use std::sync::mpsc::channel;
 use std::dynamic_lib::DynamicLibrary;
 use std::io::{Command, TempDir};
 use std::io;

src/libstd/bitflags.rs

@@ -273,7 +273,6 @@ macro_rules! bitflags {
 mod tests {
     use hash;
     use option::Option::{Some, None};
-    use ops::{BitOr, BitAnd, BitXor, Sub, Not};
 
     bitflags! {
         #[doc = "> The first principle is that you must not fool yourself — and"]

src/libstd/c_str.rs

@@ -621,7 +621,7 @@ mod tests {
     #[test]
     fn test_unwrap() {
         let c_str = "hello".to_c_str();
-        unsafe { libc::free(c_str.unwrap() as *mut libc::c_void) }
+        unsafe { libc::free(c_str.into_inner() as *mut libc::c_void) }
     }
 
     #[test]

src/libstd/c_vec.rs

@@ -228,7 +228,7 @@ mod tests {
             let cv = CVec::new_with_dtor(1 as *mut int,
                                          0,
                                          move|:| panic!("Don't run this destructor!"));
-            let p = cv.unwrap();
+            let p = cv.into_inner();
             assert_eq!(p, 1 as *mut int);
         }
     }

src/libstd/collections/hash/map.rs

@@ -1485,6 +1485,7 @@ mod test_map {
 
     struct KindaIntLike(int);
 
+    #[allow(deprecated)]
     impl Equiv<int> for KindaIntLike {
         fn equiv(&self, other: &int) -> bool {
             let KindaIntLike(this) = *self;
@@ -1812,7 +1813,7 @@ mod test_map {
     }
 
     #[test]
-    #[allow(experimental)]
+    #[allow(deprecated)]
     fn test_pop_equiv() {
         let mut m = HashMap::new();
         m.insert(1i, 2i);

src/libstd/io/buffered.rs

@@ -533,7 +533,7 @@ mod test {
         w.write(&[0, 1]).unwrap();
         let a: &[_] = &[];
         assert_eq!(a, w.get_ref()[]);
-        let w = w.unwrap();
+        let w = w.into_inner();
         let a: &[_] = &[0, 1];
         assert_eq!(a, w[]);
     }

src/libstd/io/comm_adapters.rs

@@ -10,7 +10,7 @@
 
 use clone::Clone;
 use cmp;
-use comm::{Sender, Receiver};
+use sync::mpsc::{Sender, Receiver};
 use io;
 use option::Option::{None, Some};
 use result::Result::{Ok, Err};
@@ -23,7 +23,7 @@ use vec::Vec;
 /// # Example
 ///
 /// ```
-/// use std::comm::channel;
+/// use std::sync::mpsc::channel;
 /// use std::io::ChanReader;
 ///
 /// let (tx, rx) = channel();
@@ -59,11 +59,11 @@ impl Buffer for ChanReader {
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos >= self.buf.len() {
             self.pos = 0;
-            match self.rx.recv_opt() {
+            match self.rx.recv() {
                 Ok(bytes) => {
                     self.buf = bytes;
                 },
-                Err(()) => {
+                Err(..) => {
                     self.closed = true;
                     self.buf = Vec::new();
                 }
@@ -115,7 +115,7 @@ impl Reader for ChanReader {
 ///
 /// ```
 /// # #![allow(unused_must_use)]
-/// use std::comm::channel;
+/// use std::sync::mpsc::channel;
 /// use std::io::ChanWriter;
 ///
 /// let (tx, rx) = channel();
@@ -143,7 +143,7 @@ impl Clone for ChanWriter {
 
 impl Writer for ChanWriter {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
-        self.tx.send_opt(buf.to_vec()).map_err(|_| {
+        self.tx.send(buf.to_vec()).map_err(|_| {
             io::IoError {
                 kind: io::BrokenPipe,
                 desc: "Pipe closed",
@@ -158,7 +158,7 @@ impl Writer for ChanWriter {
 mod test {
     use prelude::v1::*;
 
-    use comm::channel;
+    use sync::mpsc::channel;
     use super::*;
     use io;
     use thread::Thread;
@@ -167,11 +167,11 @@ mod test {
     fn test_rx_reader() {
         let (tx, rx) = channel();
         Thread::spawn(move|| {
-          tx.send(vec![1u8, 2u8]);
-          tx.send(vec![]);
-          tx.send(vec![3u8, 4u8]);
-          tx.send(vec![5u8, 6u8]);
-          tx.send(vec![7u8, 8u8]);
+          tx.send(vec![1u8, 2u8]).unwrap();
+          tx.send(vec![]).unwrap();
+          tx.send(vec![3u8, 4u8]).unwrap();
+          tx.send(vec![5u8, 6u8]).unwrap();
+          tx.send(vec![7u8, 8u8]).unwrap();
         }).detach();
 
         let mut reader = ChanReader::new(rx);
@@ -209,12 +209,12 @@ mod test {
     fn test_rx_buffer() {
         let (tx, rx) = channel();
         Thread::spawn(move|| {
-          tx.send(b"he".to_vec());
-          tx.send(b"llo wo".to_vec());
-          tx.send(b"".to_vec());
-          tx.send(b"rld\nhow ".to_vec());
-          tx.send(b"are you?".to_vec());
-          tx.send(b"".to_vec());
+          tx.send(b"he".to_vec()).unwrap();
+          tx.send(b"llo wo".to_vec()).unwrap();
+          tx.send(b"".to_vec()).unwrap();
+          tx.send(b"rld\nhow ".to_vec()).unwrap();
+          tx.send(b"are you?".to_vec()).unwrap();
+          tx.send(b"".to_vec()).unwrap();
         }).detach();
 
         let mut reader = ChanReader::new(rx);
@@ -234,7 +234,7 @@ mod test {
         writer.write_be_u32(42).unwrap();
 
         let wanted = vec![0u8, 0u8, 0u8, 42u8];
-        let got = match Thread::spawn(move|| { rx.recv() }).join() {
+        let got = match Thread::spawn(move|| { rx.recv().unwrap() }).join() {
             Ok(got) => got,
             Err(_) => panic!(),
         };

src/libstd/io/mem.rs

@@ -402,8 +402,8 @@ mod test {
     use prelude::v1::*;
 
     use super::*;
-    use io::*;
     use io;
+    use io::{SeekSet, SeekCur, SeekEnd};
     use self::test_crate::Bencher;
 
     #[test]