Rollup test fixes and rebase conflicts

Author: alexcrichton

src/doc/reference.md

@@ -3177,7 +3177,6 @@ then the expression completes.
 Some examples of call expressions:
 
 ```
-# use std::str::from_str;
 # fn add(x: int, y: int) -> int { 0 }
 
 let x: int = add(1, 2);

src/liballoc/boxed.rs

@@ -113,39 +113,20 @@ impl<S: hash::Writer, Sized? T: Hash<S>> Hash<S> for Box<T> {
     }
 }
 
-#[cfg(not(stage0))]
-impl Box<Any> {
-    pub fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
-        if self.is::<T>() {
-            unsafe {
-                // Get the raw representation of the trait object
-                let to: TraitObject =
-                    mem::transmute::<Box<Any>, TraitObject>(self);
-
-                // Extract the data pointer
-                Ok(mem::transmute(to.data))
-            }
-        } else {
-            Err(self)
-        }
-    }
-}
-
 /// Extension methods for an owning `Any` trait object.
 #[unstable = "post-DST and coherence changes, this will not be a trait but \
               rather a direct `impl` on `Box<Any>`"]
-#[cfg(stage0)]
 pub trait BoxAny {
     /// Returns the boxed value if it is of type `T`, or
     /// `Err(Self)` if it isn't.
     #[stable]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Self>;
 }
 
-#[stable]
-#[cfg(stage0)]
 impl BoxAny for Box<Any> {
     #[inline]
+    #[unstable = "method may be renamed with respect to other downcasting \
+                  methods"]
     fn downcast<T: 'static>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {

src/libcollections/bit.rs

@@ -92,7 +92,7 @@ use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
 use core::iter::{mod, FromIterator};
 use core::num::Int;
 use core::ops::Index;
-use core::slice::{Iter, IterMut};
+use core::slice;
 use core::{u8, u32, uint};
 use bitv_set; //so meta
 

src/libcore/option.rs

@@ -723,8 +723,6 @@ impl<T: Default> Option<T> {
     /// `None` on error.
     ///
     /// ```
-    /// use std::str::from_str;
-    ///
     /// let good_year_from_input = "1909";
     /// let bad_year_from_input = "190blarg";
     /// let good_year = good_year_from_input.parse().unwrap_or_default();

src/libcore/result.rs

@@ -449,7 +449,6 @@ impl<T, E> Result<T, E> {
     ///
     /// ```
     /// use std::io::IoResult;
-    /// use std::str::from_str;
     ///
     /// let mut buffer = &mut b"1\n2\n3\n4\n";
     ///

src/librustc_trans/back/write.rs

@@ -23,7 +23,6 @@ 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;

src/libserialize/json.rs

@@ -402,7 +402,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result {
 }
 
 fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result {
-    let mut buf = [0, .. 4];
+    let mut buf = [0; 4];
     let n = v.encode_utf8(&mut buf).unwrap();
     let buf = unsafe { str::from_utf8_unchecked(buf[0..n]) };
     escape_str(writer, buf)

src/libstd/io/mod.rs

@@ -1918,7 +1918,7 @@ impl fmt::Show for FilePermission {
 #[cfg(test)]
 mod tests {
     use self::BadReaderBehavior::*;
-    use super::{IoResult, Reader, MemReader, NoProgress, InvalidInput};
+    use super::{IoResult, MemReader, NoProgress, InvalidInput};
     use prelude::v1::*;
     use uint;
 

src/libstd/io/timer.rs

@@ -225,8 +225,6 @@ fn in_ms_u64(d: Duration) -> u64 {
 
 #[cfg(test)]
 mod test {
-    use prelude::v1::*;
-
     use super::Timer;
     use thread::Thread;
     use time::Duration;

src/libstd/path/windows.rs

@@ -1119,10 +1119,6 @@ fn prefix_len(p: Option<PathPrefix>) -> uint {
 
 #[cfg(test)]
 mod tests {
-    use prelude::v1::Option::{mod, Some, None};
-    use prelude::v1::{Vec, Clone, AsSlice, SliceExt, CloneSliceExt, IteratorExt};
-    use prelude::v1::{DoubleEndedIteratorExt, Str, ToString, GenericPath};
-
     use super::PathPrefix::*;
     use super::parse_prefix;
     use super::*;

src/libstd/sync/condvar.rs

@@ -307,7 +307,7 @@ mod tests {
         static C: StaticCondvar = CONDVAR_INIT;
         static M: StaticMutex = MUTEX_INIT;
 
-        let mut g = M.lock().unwrap();
+        let g = M.lock().unwrap();
         let _t = Thread::spawn(move|| {
             let _g = M.lock().unwrap();
             C.notify_one();
@@ -386,6 +386,6 @@ mod tests {
         g = C.wait(g).unwrap();
         drop(g);
 
-        C.wait(M2.lock().unwrap()).unwrap();
+        let _ = C.wait(M2.lock().unwrap()).unwrap();
     }
 }

src/libstd/sync/mpsc/select.rs

@@ -337,7 +337,6 @@ mod test {
     use prelude::v1::*;
 
     use thread::Thread;
-    use super::*;
     use sync::mpsc::*;
 
     // Don't use the libstd version so we can pull in the right Select structure

src/libstd/sync/mutex.rs

@@ -447,7 +447,7 @@ mod test {
     fn test_mutex_arc_poison() {
         let arc = Arc::new(Mutex::new(1i));
         let arc2 = arc.clone();
-        Thread::spawn(move|| {
+        let _ = Thread::spawn(move|| {
             let lock = arc2.lock().unwrap();
             assert_eq!(*lock, 2);
         }).join();

src/libstd/sys/common/helper_thread.rs

@@ -23,7 +23,6 @@
 use prelude::v1::*;
 
 use cell::UnsafeCell;
-use comm::{channel, Sender, Receiver};
 use mem;
 use rt;
 use sync::{StaticMutex, StaticCondvar};

src/libstd/sys/unix/pipe.rs

@@ -10,8 +10,6 @@
 
 use prelude::v1::*;
 
-use prelude::*;
-
 use libc;
 use c_str::CString;
 use mem;

src/libstd/sys/windows/mod.rs

@@ -24,13 +24,12 @@ use num;
 use mem;
 use io::{mod, IoResult, IoError};
 use sync::{Once, ONCE_INIT};
-use comm::Sender;
 
 macro_rules! helper_init { (static $name:ident: Helper<$m:ty>) => (
     static $name: Helper<$m> = Helper {
         lock: ::sync::MUTEX_INIT,
         cond: ::sync::CONDVAR_INIT,
-        chan: ::cell::UnsafeCell { value: 0 as *mut Sender<$m> },
+        chan: ::cell::UnsafeCell { value: 0 as *mut ::sync::mpsc::Sender<$m> },
         signal: ::cell::UnsafeCell { value: 0 },
         initialized: ::cell::UnsafeCell { value: false },
         shutdown: ::cell::UnsafeCell { value: false },

src/libstd/sys/windows/timer.rs

@@ -25,10 +25,9 @@ use prelude::v1::*;
 
 use libc;
 use ptr;
-use comm;
 
-use comm::{channel, Sender, Receiver};
 use io::IoResult;
+use sync::mpsc::{channel, Sender, Receiver, TryRecvError};
 use sys::c;
 use sys::fs::FileDesc;
 use sys_common::helper_thread::Helper;
@@ -72,7 +71,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>, _: ()) {
                         chans.push((c, one));
                     }
                     Ok(RemoveTimer(obj, c)) => {
-                        c.send(());
+                        c.send(()).unwrap();
                         match objs.iter().position(|&o| o == obj) {
                             Some(i) => {
                                 drop(objs.remove(i));
@@ -81,7 +80,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>, _: ()) {
                             None => {}
                         }
                     }
-                    Err(comm::Disconnected) => {
+                    Err(TryRecvError::Disconnected) => {
                         assert_eq!(objs.len(), 1);
                         assert_eq!(chans.len(), 0);
                         break 'outer;
@@ -133,7 +132,7 @@ impl Timer {
 
         let (tx, rx) = channel();
         HELPER.send(RemoveTimer(self.obj, tx));
-        rx.recv();
+        rx.recv().unwrap();
 
         self.on_worker = false;
     }

src/libstd/thread.rs

@@ -443,8 +443,8 @@ mod test {
     use prelude::v1::*;
 
     use any::{Any, AnyRefExt};
-    use boxed::BoxAny;
     use sync::mpsc::{channel, Sender};
+    use boxed::BoxAny;
     use result;
     use std::io::{ChanReader, ChanWriter};
     use super::{Thread, Builder};

src/test/bench/msgsend-pipes-shared.rs

@@ -18,8 +18,7 @@
 // different scalability characteristics compared to the select
 // version.
 
-use std::comm::{channel, Sender, Receiver};
-use std::comm;
+use std::sync::mpsc::{channel, Sender, Receiver};
 use std::os;
 use std::str::from_str;
 use std::thread::Thread;
@@ -38,8 +37,8 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
     let mut count = 0u;
     let mut done = false;
     while !done {
-        match requests.recv_opt() {
-          Ok(request::get_count) => { responses.send(count.clone()); }
+        match requests.recv() {
+          Ok(request::get_count) => { responses.send(count.clone()).unwrap(); }
           Ok(request::bytes(b)) => {
             //println!("server: received {} bytes", b);
             count += b;
@@ -48,7 +47,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
           _ => { }
         }
     }
-    responses.send(count);
+    responses.send(count).unwrap();
     //println!("server exiting");
 }
 
@@ -69,7 +68,7 @@ fn run(args: &[String]) {
             worker_results.push(Thread::spawn(move|| {
                 for _ in range(0u, size / workers) {
                     //println!("worker {}: sending {} bytes", i, num_bytes);
-                    to_child.send(request::bytes(num_bytes));
+                    to_child.send(request::bytes(num_bytes)).unwrap();
                 }
                 //println!("worker {} exiting", i);
             }));
@@ -83,9 +82,9 @@ fn run(args: &[String]) {
         }
 
         //println!("sending stop message");
-        to_child.send(request::stop);
+        to_child.send(request::stop).unwrap();
         move_out(to_child);
-        result = Some(from_child.recv());
+        result = Some(from_child.recv().unwrap());
     });
     let result = result.unwrap();
     print!("Count is {}\n", result);

src/test/bench/msgsend-pipes.rs

@@ -14,9 +14,8 @@
 //
 // I *think* it's the same, more or less.
 
-use std::comm::{channel, Sender, Receiver};
+use std::sync::mpsc::{channel, Sender, Receiver};
 use std::os;
-use std::str::from_str;
 use std::thread::Thread;
 use std::time::Duration;
 use std::uint;
@@ -33,7 +32,7 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
     let mut count: uint = 0;
     let mut done = false;
     while !done {
-        match requests.recv_opt() {
+        match requests.recv() {
           Ok(request::get_count) => { responses.send(count.clone()); }
           Ok(request::bytes(b)) => {
             //println!("server: received {} bytes", b);
@@ -50,8 +49,8 @@ fn server(requests: &Receiver<request>, responses: &Sender<uint>) {
 fn run(args: &[String]) {
     let (to_parent, from_child) = channel();
 
-    let size = from_str::<uint>(args[1].as_slice()).unwrap();
-    let workers = from_str::<uint>(args[2].as_slice()).unwrap();
+    let size = args[1].parse::<uint>().unwrap();
+    let workers = args[2].parse::<uint>().unwrap();
     let num_bytes = 100;
     let mut result = None;
     let mut to_parent = Some(to_parent);
@@ -93,7 +92,7 @@ fn run(args: &[String]) {
         //println!("sending stop message");
         //to_child.send(stop);
         //move_out(to_child);
-        result = Some(from_child.recv());
+        result = Some(from_child.recv().unwrap());
     });
     let result = result.unwrap();
     print!("Count is {}\n", result);

src/test/bench/rt-messaging-ping-pong.rs

@@ -17,7 +17,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::comm::channel;
+use std::sync::mpsc::channel;
 use std::os;
 use std::str::from_str;
 use std::thread::Thread;

src/test/bench/rt-parfib.rs

@@ -8,9 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::comm::channel;
+use std::sync::mpsc::channel;
 use std::os;
-use std::str::from_str;
 use std::thread::Thread;
 use std::uint;
 
@@ -28,15 +27,15 @@ fn parfib(n: uint) -> uint {
         tx.send(parfib(n-1));
     }).detach();
     let m2 = parfib(n-2);
-    return (rx.recv() + m2);
+    return (rx.recv().unwrap() + m2);
 }
 
 fn main() {
 
     let args = os::args();
     let args = args.as_slice();
     let n = if args.len() == 2 {
-        from_str::<uint>(args[1].as_slice()).unwrap()
+        args[1].parse::<uint>().unwrap()
     } else {
         10
     };

src/test/bench/shootout-binarytrees.rs

@@ -75,7 +75,7 @@ fn main() {
     } else if args.len() <= 1u {
         8
     } else {
-        from_str(args[1].as_slice()).unwrap()
+        args[1].parse().unwrap()
     };
     let min_depth = 4;
     let max_depth = if min_depth + 2 > n {min_depth + 2} else {n};