Fallout: move from scoped to spawn

Author: aturon

src/librustdoc/lib.rs

@@ -130,10 +130,10 @@ struct Output {
 
 pub fn main() {
     const STACK_SIZE: usize = 32000000; // 32MB
-    let res = std::thread::Builder::new().stack_size(STACK_SIZE).scoped(move || {
+    let res = std::thread::Builder::new().stack_size(STACK_SIZE).spawn(move || {
         let s = env::args().collect::<Vec<_>>();
         main_args(&s)
-    }).unwrap().join();
+    }).unwrap().join().unwrap();
     env::set_exit_status(res as i32);
 }
 

src/test/run-fail/panic-task-name-owned.rs

@@ -13,9 +13,9 @@
 use std::thread::Builder;
 
 fn main() {
-    let r: () = Builder::new().name("owned name".to_string()).scoped(move|| {
+    let r: () = Builder::new().name("owned name".to_string()).spawn(move|| {
         panic!("test");
         ()
-    }).unwrap().join();
+    }).unwrap().join().unwrap();
     panic!();
 }

src/test/run-fail/rt-set-exit-status-panic2.rs

@@ -37,7 +37,7 @@ fn r(x:isize) -> r {
 
 fn main() {
     error!("whatever");
-    let _t = thread::scoped(move|| {
+    let _t = thread::spawn(move|| {
       let _i = r(5);
     });
     panic!();

src/test/run-pass/atomic-print.rs

@@ -27,7 +27,7 @@ fn main(){
     if env::args().count() == 2 {
         let barrier = sync::Arc::new(sync::Barrier::new(2));
         let tbarrier = barrier.clone();
-        let t = thread::scoped(||{
+        let t = thread::spawn(move || {
             tbarrier.wait();
             do_print(1);
         });

src/test/run-pass/capturing-logging.rs

@@ -36,12 +36,13 @@ impl Logger for MyWriter {
 fn main() {
     let (tx, rx) = channel();
     let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
-    let _t = thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         set_logger(box MyWriter(w) as Box<Logger+Send>);
         debug!("debug");
         info!("info");
     });
     let s = r.read_to_string().unwrap();
     assert!(s.contains("info"));
     assert!(!s.contains("debug"));
+    t.join();
 }

src/test/run-pass/clone-with-exterior.rs

@@ -23,8 +23,8 @@ struct Pair {
 pub fn main() {
     let z: Box<_> = box Pair { a : 10, b : 12};
 
-    let _t = thread::scoped(move|| {
+    thread::spawn(move|| {
         assert_eq!(z.a, 10);
         assert_eq!(z.b, 12);
-    });
+    }).join();
 }

src/test/run-pass/comm.rs

@@ -15,11 +15,12 @@ use std::sync::mpsc::{channel, Sender};
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _t = thread::scoped(move|| { child(&tx) });
+    let t = thread::spawn(move|| { child(&tx) });
     let y = rx.recv().unwrap();
     println!("received");
     println!("{}", y);
     assert_eq!(y, 10);
+    t.join();
 }
 
 fn child(c: &Sender<isize>) {

src/test/run-pass/extern-call-deep2.rs

@@ -42,7 +42,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t {
 pub fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    thread::scoped(move|| {
+    thread::spawn(move|| {
         let result = count(1000);
         println!("result = {}", result);
         assert_eq!(result, 1000);

src/test/run-pass/extern-call-scrub.rs

@@ -46,9 +46,9 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t {
 pub fn main() {
     // Make sure we're on a task with small Rust stacks (main currently
     // has a large stack)
-    let _t = thread::scoped(move|| {
+    thread::spawn(move|| {
         let result = count(12);
         println!("result = {}", result);
         assert_eq!(result, 2048);
-    });
+    }).join();
 }

src/test/run-pass/fds-are-cloexec.rs

@@ -34,22 +34,19 @@ fn main() {
 
 fn parent() {
     let file = File::open("Makefile").unwrap();
-    let _dir = fs::read_dir("/").unwrap();
     let tcp1 = TcpListener::bind("127.0.0.1:0").unwrap();
-    assert_eq!(tcp1.as_raw_fd(), file.as_raw_fd() + 2);
     let tcp2 = tcp1.try_clone().unwrap();
     let addr = tcp1.local_addr().unwrap();
-    let t = thread::scoped(|| TcpStream::connect(addr).unwrap());
+    let t = thread::spawn(move || TcpStream::connect(addr).unwrap());
     let tcp3 = tcp1.accept().unwrap().0;
-    let tcp4 = t.join();
+    let tcp4 = t.join().unwrap();
     let tcp5 = tcp3.try_clone().unwrap();
     let tcp6 = tcp4.try_clone().unwrap();
     let udp1 = UdpSocket::bind("127.0.0.1:0").unwrap();
     let udp2 = udp1.try_clone().unwrap();
 
     let status = Command::new(env::args().next().unwrap())
                         .arg(file.as_raw_fd().to_string())
-                        .arg((file.as_raw_fd() + 1).to_string())
                         .arg(tcp1.as_raw_fd().to_string())
                         .arg(tcp2.as_raw_fd().to_string())
                         .arg(tcp3.as_raw_fd().to_string())