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

@@ -39,9 +39,9 @@ fn parent() {
     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();

src/test/run-pass/init-large-type.rs

@@ -26,7 +26,7 @@ const SIZE: usize = 1024 * 1024;
 
 fn main() {
     // do the test in a new thread to avoid (spurious?) stack overflows
-    let _ = thread::scoped(|| {
+    thread::spawn(|| {
         let _memory: [u8; SIZE] = unsafe { init() };
     }).join();
 }

src/test/run-pass/issue-13494.rs

@@ -26,7 +26,7 @@ fn helper(rx: Receiver<Sender<()>>) {
 
 fn main() {
     let (tx, rx) = channel();
-    let _t = thread::scoped(move|| { helper(rx) });
+    let t = thread::spawn(move|| { helper(rx) });
     let (snd, rcv) = channel::<isize>();
     for _ in 1..100000 {
         snd.send(1).unwrap();
@@ -38,4 +38,5 @@ fn main() {
         }
     }
     drop(tx);
+    t.join();
 }

src/test/run-pass/issue-20454.rs

@@ -13,11 +13,11 @@
 use std::thread;
 
 fn _foo() {
-    let _t = thread::scoped(move || { // no need for -> ()
+    thread::spawn(move || { // no need for -> ()
         loop {
             println!("hello");
         }
-    });
+    }).join();
 }
 
 fn main() {}

src/test/run-pass/issue-3609.rs

@@ -23,7 +23,7 @@ enum Msg
 }
 
 fn foo(name: String, samples_chan: Sender<Msg>) {
-    let _t = thread::scoped(move|| {
+    thread::spawn(move|| {
         let mut samples_chan = samples_chan;
 
         // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
@@ -34,7 +34,7 @@ fn foo(name: String, samples_chan: Sender<Msg>) {
         });
 
         samples_chan.send(Msg::GetSamples(name.clone(), callback));
-    });
+    }).join();
 }
 
 pub fn main() {}

src/test/run-pass/issue-9396.rs

@@ -19,7 +19,7 @@ use std::time::Duration;
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _t = thread::scoped(move||{
+    let t = thread::spawn(move||{
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(10));
         tx.send(()).unwrap();
@@ -31,4 +31,5 @@ pub fn main() {
             Err(TryRecvError::Disconnected) => unreachable!()
         }
     }
+    t.join();
 }

src/test/run-pass/ivec-tag.rs

@@ -23,9 +23,10 @@ fn producer(tx: &Sender<Vec<u8>>) {
 
 pub fn main() {
     let (tx, rx) = channel::<Vec<u8>>();
-    let _prod = thread::scoped(move|| {
+    let prod = thread::spawn(move|| {
         producer(&tx)
     });
 
     let _data: Vec<u8> = rx.recv().unwrap();
+    prod.join();
 }

src/test/run-pass/kindck-implicit-close-over-mut-var.rs

@@ -18,36 +18,39 @@ fn foo() {
     // Here, i is *copied* into the proc (heap closure).
     // Requires allocation.  The proc's copy is not mutable.
     let mut i = 0;
-    let _t = thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         user(i);
         println!("spawned {}", i)
     });
     i += 1;
-    println!("original {}", i)
+    println!("original {}", i);
+    t.join();
 }
 
 fn bar() {
     // Here, the original i has not been moved, only copied, so is still
     // mutable outside of the proc.
     let mut i = 0;
     while i < 10 {
-        let _t = thread::scoped(move|| {
+        let t = thread::spawn(move|| {
             user(i);
         });
         i += 1;
+        t.join();
     }
 }
 
 fn car() {
     // Here, i must be shadowed in the proc to be mutable.
     let mut i = 0;
     while i < 10 {
-        let _t = thread::scoped(move|| {
+        let t = thread::spawn(move|| {
             let mut i = i;
             i += 1;
             user(i);
         });
         i += 1;
+        t.join();
     }
 }
 

src/test/run-pass/moves-based-on-type-capture-clause.rs

@@ -14,7 +14,7 @@ use std::thread;
 
 pub fn main() {
     let x = "Hello world!".to_string();
-    let _t = thread::scoped(move|| {
+    thread::spawn(move|| {
         println!("{}", x);
-    });
+    }).join();
 }

src/test/run-pass/out-of-stack-new-thread-no-split.rs

@@ -37,7 +37,7 @@ fn recurse() {
 fn main() {
     let args: Vec<String> = env::args().collect();
     if args.len() > 1 && args[1] == "recurse" {
-        let _t = thread::scoped(recurse);
+        thread::spawn(recurse).join();
     } else {
         let recurse = Command::new(&args[0]).arg("recurse").output().unwrap();
         assert!(!recurse.status.success());

src/test/run-pass/rust-log-filter.rs

@@ -41,7 +41,7 @@ impl log::Logger for ChannelLogger {
 pub fn main() {
     let (logger, rx) = ChannelLogger::new();
 
-    let _t = thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         log::set_logger(logger);
 
         info!("foo");
@@ -54,4 +54,6 @@ pub fn main() {
     assert_eq!(rx.recv().unwrap(), "foo bar");
     assert_eq!(rx.recv().unwrap(), "bar foo");
     assert!(rx.recv().is_err());
+
+    t.join();
 }

src/test/run-pass/send-is-not-static-par-for.rs

@@ -10,7 +10,7 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(core, std_misc)]
+#![feature(core, std_misc, scoped)]
 use std::thread;
 use std::sync::Mutex;
 
@@ -25,7 +25,6 @@ fn par_for<I, F>(iter: I, f: F)
             f(elem)
         })
     }).collect();
-
 }
 
 fn sum(x: &[i32]) {

src/test/run-pass/send-resource.rs

@@ -32,12 +32,14 @@ fn test(f: isize) -> test {
 pub fn main() {
     let (tx, rx) = channel();
 
-    let _t = thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         let (tx2, rx2) = channel();
         tx.send(tx2).unwrap();
 
         let _r = rx2.recv().unwrap();
     });
 
     rx.recv().unwrap().send(test(42)).unwrap();
+
+    t.join();
 }

src/test/run-pass/spawn-fn.rs

@@ -16,13 +16,16 @@ fn x(s: String, n: isize) {
 }
 
 pub fn main() {
-    let _t = thread::scoped(|| x("hello from first spawned fn".to_string(), 65) );
-    let _t = thread::scoped(|| x("hello from second spawned fn".to_string(), 66) );
-    let _t = thread::scoped(|| x("hello from third spawned fn".to_string(), 67) );
+    let t1 = thread::spawn(|| x("hello from first spawned fn".to_string(), 65) );
+    let t2 = thread::spawn(|| x("hello from second spawned fn".to_string(), 66) );
+    let t3 = thread::spawn(|| x("hello from third spawned fn".to_string(), 67) );
     let mut i = 30;
     while i > 0 {
         i = i - 1;
         println!("parent sleeping");
         thread::yield_now();
     }
+    t1.join();
+    t2.join();
+    t3.join();
 }

src/test/run-pass/task-comm-0.rs

@@ -26,12 +26,13 @@ fn test05_start(tx : &Sender<isize>) {
 
 fn test05() {
     let (tx, rx) = channel();
-    let _t = thread::scoped(move|| { test05_start(&tx) });
+    let t = thread::spawn(move|| { test05_start(&tx) });
     let mut value: isize = rx.recv().unwrap();
     println!("{}", value);
     value = rx.recv().unwrap();
     println!("{}", value);
     value = rx.recv().unwrap();
     println!("{}", value);
     assert_eq!(value, 30);
+    t.join();
 }

src/test/run-pass/task-comm-1.rs

@@ -17,6 +17,6 @@ pub fn main() { test00(); }
 fn start() { println!("Started / Finished task."); }
 
 fn test00() {
-    let _ = thread::scoped(move|| start() ).join();
+    thread::spawn(move|| start() ).join();
     println!("Completing.");
 }

src/test/run-pass/task-comm-10.rs

@@ -29,10 +29,12 @@ fn start(tx: &Sender<Sender<String>>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _child = thread::scoped(move|| { start(&tx) });
+    let child = thread::spawn(move|| { start(&tx) });
 
     let mut c = rx.recv().unwrap();
     c.send("A".to_string()).unwrap();
     c.send("B".to_string()).unwrap();
     thread::yield_now();
+
+    child.join();
 }

src/test/run-pass/task-comm-11.rs

@@ -22,8 +22,9 @@ fn start(tx: &Sender<Sender<isize>>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _child = thread::scoped(move|| {
+    let child = thread::spawn(move|| {
         start(&tx)
     });
     let _tx = rx.recv().unwrap();
+    child.join();
 }

src/test/run-pass/task-comm-12.rs

@@ -18,7 +18,7 @@ fn start(_task_number: isize) { println!("Started / Finished task."); }
 
 fn test00() {
     let i: isize = 0;
-    let mut result = thread::scoped(move|| {
+    let mut result = thread::spawn(move|| {
         start(i)
     });
 

src/test/run-pass/task-comm-13.rs

@@ -21,6 +21,6 @@ fn start(tx: &Sender<isize>, start: isize, number_of_messages: isize) {
 pub fn main() {
     println!("Check that we don't deadlock.");
     let (tx, rx) = channel();
-    let _t = thread::scoped(move|| { start(&tx, 0, 10) }).join();
+    let _ = thread::spawn(move|| { start(&tx, 0, 10) }).join();
     println!("Joined task");
 }

src/test/run-pass/task-comm-14.rs

@@ -21,7 +21,7 @@ pub fn main() {
     while (i > 0) {
         println!("{}", i);
         let tx = tx.clone();
-        thread::scoped({let i = i; move|| { child(i, &tx) }});
+        thread::spawn({let i = i; move|| { child(i, &tx) }});
         i = i - 1;
     }
 

src/test/run-pass/task-comm-15.rs

@@ -29,8 +29,9 @@ pub fn main() {
     // the child's point of view the receiver may die. We should
     // drop messages on the floor in this case, and not crash!
     let (tx, rx) = channel();
-    let _t = thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         start(&tx, 10)
     });
     rx.recv();
+    t.join();
 }