Test fixes and rebase conflicts

24 files changed, 93 insertions, 95 deletions

diff --git a/src/test/compile-fail/issue-8460-const.rs b/src/test/compile-fail/issue-8460-const.rs
index 4e44b4dcdce..b6d371e4b11 100644
--- a/src/test/compile-fail/issue-8460-const.rs
+++ b/src/test/compile-fail/issue-8460-const.rs
@@ -12,44 +12,44 @@ use std::{int, i8, i16, i32, i64};
 use std::thread;
 
 fn main() {
-    assert!(thread::spawn(move|| int::MIN / -1).join().is_err());
+    assert!(thread::spawn(move|| { int::MIN / -1; }).join().is_err());
     //~^ ERROR attempted to divide with overflow in a constant expression
-    assert!(thread::spawn(move|| i8::MIN / -1).join().is_err());
+    assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
     //~^ ERROR attempted to divide with overflow in a constant expression
-    assert!(thread::spawn(move|| i16::MIN / -1).join().is_err());
+    assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
     //~^ ERROR attempted to divide with overflow in a constant expression
-    assert!(thread::spawn(move|| i32::MIN / -1).join().is_err());
+    assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
     //~^ ERROR attempted to divide with overflow in a constant expression
-    assert!(thread::spawn(move|| i64::MIN / -1).join().is_err());
+    assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
     //~^ ERROR attempted to divide with overflow in a constant expression
-    assert!(thread::spawn(move|| 1is / 0).join().is_err());
+    assert!(thread::spawn(move|| { 1is / 0; }).join().is_err());
     //~^ ERROR attempted to divide by zero in a constant expression
-    assert!(thread::spawn(move|| 1i8 / 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
     //~^ ERROR attempted to divide by zero in a constant expression
-    assert!(thread::spawn(move|| 1i16 / 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
     //~^ ERROR attempted to divide by zero in a constant expression
-    assert!(thread::spawn(move|| 1i32 / 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
     //~^ ERROR attempted to divide by zero in a constant expression
-    assert!(thread::spawn(move|| 1i64 / 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
     //~^ ERROR attempted to divide by zero in a constant expression
-    assert!(thread::spawn(move|| int::MIN % -1).join().is_err());
+    assert!(thread::spawn(move|| { int::MIN % -1; }).join().is_err());
     //~^ ERROR attempted remainder with overflow in a constant expression
-    assert!(thread::spawn(move|| i8::MIN % -1).join().is_err());
+    assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
     //~^ ERROR attempted remainder with overflow in a constant expression
-    assert!(thread::spawn(move|| i16::MIN % -1).join().is_err());
+    assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
     //~^ ERROR attempted remainder with overflow in a constant expression
-    assert!(thread::spawn(move|| i32::MIN % -1).join().is_err());
+    assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
     //~^ ERROR attempted remainder with overflow in a constant expression
-    assert!(thread::spawn(move|| i64::MIN % -1).join().is_err());
+    assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
     //~^ ERROR attempted remainder with overflow in a constant expression
-    assert!(thread::spawn(move|| 1is % 0).join().is_err());
+    assert!(thread::spawn(move|| { 1is % 0; }).join().is_err());
     //~^ ERROR attempted remainder with a divisor of zero in a constant expression
-    assert!(thread::spawn(move|| 1i8 % 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
     //~^ ERROR attempted remainder with a divisor of zero in a constant expression
-    assert!(thread::spawn(move|| 1i16 % 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
     //~^ ERROR attempted remainder with a divisor of zero in a constant expression
-    assert!(thread::spawn(move|| 1i32 % 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
     //~^ ERROR attempted remainder with a divisor of zero in a constant expression
-    assert!(thread::spawn(move|| 1i64 % 0).join().is_err());
+    assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
     //~^ ERROR attempted remainder with a divisor of zero in a constant expression
 }
diff --git a/src/test/compile-fail/lint-uppercase-variables.rs b/src/test/compile-fail/lint-uppercase-variables.rs
index b68d9dc4645..a4f46cbd187 100644
--- a/src/test/compile-fail/lint-uppercase-variables.rs
+++ b/src/test/compile-fail/lint-uppercase-variables.rs
@@ -13,9 +13,6 @@
 #![allow(dead_code)]
 #![deny(non_snake_case)]
 
-use std::old_io::File;
-use std::old_io::IoError;
-
 mod foo {
     pub enum Foo { Foo }
 }
@@ -36,6 +33,7 @@ fn main() {
         Foo => {}
 //~^ ERROR variable `Foo` should have a snake case name such as `foo`
 //~^^ WARN `Foo` is named the same as one of the variants of the type `foo::Foo`
+//~^^^ WARN unused variable: `Foo`
     }
 
     test(1);
diff --git a/src/test/run-fail/panic-task-name-none.rs b/src/test/run-fail/panic-task-name-none.rs
index 40a881852f5..3a5ac5a1009 100644
--- a/src/test/run-fail/panic-task-name-none.rs
+++ b/src/test/run-fail/panic-task-name-none.rs
@@ -13,9 +13,8 @@
 use std::thread;
 
 fn main() {
-    let r: Result<int,_> = thread::spawn(move|| {
+    let r: Result<(),_> = thread::spawn(move|| {
         panic!("test");
-        1
     }).join();
     assert!(r.is_ok());
 }
diff --git a/src/test/run-fail/panic-task-name-owned.rs b/src/test/run-fail/panic-task-name-owned.rs
index d48d282c9eb..8cab9e05f96 100644
--- a/src/test/run-fail/panic-task-name-owned.rs
+++ b/src/test/run-fail/panic-task-name-owned.rs
@@ -13,9 +13,9 @@
 use std::thread::Builder;
 
 fn main() {
-    let r: Result<int,_> = Builder::new().name("owned name".to_string()).scoped(move|| {
+    let r: () = Builder::new().name("owned name".to_string()).scoped(move|| {
         panic!("test");
-        1
-    }).join();
-    assert!(r.is_ok());
+        ()
+    }).unwrap().join();
+    panic!();
 }
diff --git a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
index edb3d72483b..96ae7e3d336 100644
--- a/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
+++ b/src/test/run-pass/cleanup-rvalue-temp-during-incomplete-alloc.rs
@@ -27,7 +27,7 @@
 #![allow(unknown_features)]
 #![feature(box_syntax)]
 
-use std::thread::Thread;
+use std::thread;
 
 enum Conzabble {
     Bickwick(Foo)
@@ -48,5 +48,5 @@ pub fn fails() {
 }
 
 pub fn main() {
-    Thread::scoped(fails).join();
+    thread::spawn(fails).join();
 }
diff --git a/src/test/run-pass/issue-12684.rs b/src/test/run-pass/issue-12684.rs
index 38731b8c8da..e66b5d21e17 100644
--- a/src/test/run-pass/issue-12684.rs
+++ b/src/test/run-pass/issue-12684.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 use std::time::Duration;
-use std::thread::Thread;
+use std::thread;
 
 fn main() {
-    Thread::scoped(move|| customtask()).join().ok().unwrap();
+    thread::spawn(move|| customtask()).join().ok().unwrap();
 }
 
 fn customtask() {
diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs
index ca40b2fe4c7..9448e605937 100644
--- a/src/test/run-pass/issue-16560.rs
+++ b/src/test/run-pass/issue-16560.rs
@@ -10,7 +10,7 @@
 
 #![feature(unboxed_closures)]
 
-use std::thread::Thread;
+use std::thread;
 use std::mem;
 
 fn main() {
@@ -20,7 +20,7 @@ fn main() {
     // Check that both closures are capturing by value
     assert_eq!(1, mem::size_of_val(&closure));
 
-    Thread::scoped(move|| {
+    thread::spawn(move|| {
         let ok = closure;
     }).join().ok().unwrap();
 }
diff --git a/src/test/run-pass/issue-16671.rs b/src/test/run-pass/issue-16671.rs
index 124b0205fae..0e42f2593f2 100644
--- a/src/test/run-pass/issue-16671.rs
+++ b/src/test/run-pass/issue-16671.rs
@@ -18,11 +18,11 @@
 // A var moved into a proc, that has a mutable loan path should
 // not trigger a misleading unused_mut warning.
 
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() {
     let mut stdin = std::old_io::stdin();
-    Thread::spawn(move|| {
+    thread::spawn(move|| {
         let _ = stdin.read_to_end();
     });
 }
diff --git a/src/test/run-pass/issue-4446.rs b/src/test/run-pass/issue-4446.rs
index ec4cd02e9fd..b40a726a2c3 100644
--- a/src/test/run-pass/issue-4446.rs
+++ b/src/test/run-pass/issue-4446.rs
@@ -10,14 +10,14 @@
 
 use std::old_io::println;
 use std::sync::mpsc::channel;
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() {
     let (tx, rx) = channel();
 
     tx.send("hello, world").unwrap();
 
-    Thread::scoped(move|| {
+    thread::spawn(move|| {
         println(rx.recv().unwrap());
     }).join().ok().unwrap();
 }
diff --git a/src/test/run-pass/issue-4448.rs b/src/test/run-pass/issue-4448.rs
index a19bfca721a..ef30f9182ba 100644
--- a/src/test/run-pass/issue-4448.rs
+++ b/src/test/run-pass/issue-4448.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 use std::sync::mpsc::channel;
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() {
     let (tx, rx) = channel::<&'static str>();
 
-    let t = Thread::scoped(move|| {
+    let t = thread::spawn(move|| {
         assert_eq!(rx.recv().unwrap(), "hello, world");
     });
 
diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs
index 4b9ed44c7cd..72a1ec436f3 100644
--- a/src/test/run-pass/issue-8460.rs
+++ b/src/test/run-pass/issue-8460.rs
@@ -9,31 +9,31 @@
 // except according to those terms.
 
 use std::num::Int;
-use std::thread::Thread;
+use std::thread;
 
 // Avoid using constants, which would trigger compile-time errors.
 fn min_val<T: Int>() -> T { Int::min_value() }
 fn zero<T: Int>() -> T { Int::zero() }
 
 fn main() {
-    assert!(Thread::scoped(move|| min_val::<isize>() / -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i8>() / -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i16>() / -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i32>() / -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i64>() / -1).join().is_err());
-    assert!(Thread::scoped(move|| 1is / zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i8 / zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i16 / zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i32 / zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i64 / zero()).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<isize>() % -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i8>() % -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i16>() % -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i32>() % -1).join().is_err());
-    assert!(Thread::scoped(move|| min_val::<i64>() % -1).join().is_err());
-    assert!(Thread::scoped(move|| 1is % zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i8 % zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i16 % zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i32 % zero()).join().is_err());
-    assert!(Thread::scoped(move|| 1i64 % zero()).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<isize>() / -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i8>() / -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i16>() / -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i32>() / -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i64>() / -1; }).join().is_err());
+    assert!(thread::spawn(move|| { 1is / zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i8 / zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i16 / zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i32 / zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i64 / zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<isize>() % -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i8>() % -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i16>() % -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i32>() % -1; }).join().is_err());
+    assert!(thread::spawn(move|| { min_val::<i64>() % -1; }).join().is_err());
+    assert!(thread::spawn(move|| { 1is % zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i8 % zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i16 % zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i32 % zero(); }).join().is_err());
+    assert!(thread::spawn(move|| { 1i64 % zero(); }).join().is_err());
 }
diff --git a/src/test/run-pass/logging-only-prints-once.rs b/src/test/run-pass/logging-only-prints-once.rs
index 644efe20ded..b03c4b5ff47 100644
--- a/src/test/run-pass/logging-only-prints-once.rs
+++ b/src/test/run-pass/logging-only-prints-once.rs
@@ -13,7 +13,7 @@
 
 use std::cell::Cell;
 use std::fmt;
-use std::thread::Thread;
+use std::thread;
 
 struct Foo(Cell<int>);
 
@@ -27,7 +27,7 @@ impl fmt::Debug for Foo {
 }
 
 pub fn main() {
-    Thread::scoped(move|| {
+    thread::spawn(move|| {
         let mut f = Foo(Cell::new(0));
         println!("{:?}", f);
         let Foo(ref mut f) = f;
diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs
index c90c6ce87f0..5ce32e4fe2c 100644
--- a/src/test/run-pass/no-landing-pads.rs
+++ b/src/test/run-pass/no-landing-pads.rs
@@ -10,7 +10,7 @@
 
 // compile-flags: -Z no-landing-pads
 
-use std::thread::Thread;
+use std::thread;
 
 static mut HIT: bool = false;
 
@@ -23,7 +23,7 @@ impl Drop for A {
 }
 
 fn main() {
-    Thread::scoped(move|| -> () {
+    thread::spawn(move|| -> () {
         let _a = A;
         panic!();
     }).join().err().unwrap();
diff --git a/src/test/run-pass/panic-in-dtor-drops-fields.rs b/src/test/run-pass/panic-in-dtor-drops-fields.rs
index 3cc01b967ce..6da15b97aca 100644
--- a/src/test/run-pass/panic-in-dtor-drops-fields.rs
+++ b/src/test/run-pass/panic-in-dtor-drops-fields.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::thread::Thread;
+use std::thread;
 
 static mut dropped: bool = false;
 
@@ -33,7 +33,7 @@ impl Drop for B {
 }
 
 pub fn main() {
-    let ret = Thread::scoped(move|| {
+    let ret = thread::spawn(move|| {
         let _a = A { b: B { foo: 3 } };
     }).join();
     assert!(ret.is_err());
diff --git a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
index 6c9707103b9..523b7528103 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -11,7 +11,7 @@
 #![allow(unknown_features)]
 #![feature(box_syntax)]
 
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() { test05(); }
 
@@ -25,7 +25,7 @@ fn test05() {
         println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
-    Thread::scoped(move|| {
+    thread::spawn(move|| {
         test05_start(fn_to_send);
     }).join().ok().unwrap();
 }
diff --git a/src/test/run-pass/sepcomp-unwind.rs b/src/test/run-pass/sepcomp-unwind.rs
index f68dea04a08..21c5a6fc83a 100644
--- a/src/test/run-pass/sepcomp-unwind.rs
+++ b/src/test/run-pass/sepcomp-unwind.rs
@@ -19,7 +19,7 @@
 // In any case, this test should let us know if enabling parallel codegen ever
 // breaks unwinding.
 
-use std::thread::Thread;
+use std::thread;
 
 fn pad() -> uint { 0 }
 
@@ -36,5 +36,5 @@ mod b {
 }
 
 fn main() {
-    Thread::scoped(move|| { ::b::g() }).join().err().unwrap();
+    thread::spawn(move|| { ::b::g() }).join().err().unwrap();
 }
diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs
index b2e3d83ca9b..639ffd56002 100644
--- a/src/test/run-pass/slice-panic-1.rs
+++ b/src/test/run-pass/slice-panic-1.rs
@@ -10,7 +10,7 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-use std::thread::Thread;
+use std::thread;
 
 struct Foo;
 
@@ -26,6 +26,6 @@ fn foo() {
 }
 
 fn main() {
-    let _ = Thread::scoped(move|| foo()).join();
+    let _ = thread::spawn(move|| foo()).join();
     unsafe { assert!(DTOR_COUNT == 2); }
 }
diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs
index dea45e63ab0..4a2038175d2 100644
--- a/src/test/run-pass/slice-panic-2.rs
+++ b/src/test/run-pass/slice-panic-2.rs
@@ -10,7 +10,7 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-use std::thread::Thread;
+use std::thread;
 
 struct Foo;
 
@@ -30,6 +30,6 @@ fn foo() {
 }
 
 fn main() {
-    let _ = Thread::scoped(move|| foo()).join();
+    let _ = thread::spawn(move|| foo()).join();
     unsafe { assert!(DTOR_COUNT == 2); }
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index eaad2abe8f7..bf2f03b3e6d 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -14,7 +14,7 @@
   Arnold.
  */
 
-use std::thread::Thread;
+use std::thread;
 use std::sync::mpsc::{channel, Sender};
 
 type ctx = Sender<int>;
@@ -25,6 +25,6 @@ fn iotask(_tx: &ctx, ip: String) {
 
 pub fn main() {
     let (tx, _rx) = channel::<int>();
-    let t = Thread::scoped(move|| iotask(&tx, "localhost".to_string()) );
+    let t = thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
     t.join().ok().unwrap();
 }
diff --git a/src/test/run-pass/spawn.rs b/src/test/run-pass/spawn.rs
index 8f937afa6b9..90b47f4986b 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() {
-    Thread::scoped(move|| child(10)).join().ok().unwrap();
+    thread::spawn(move|| child(10)).join().ok().unwrap();
 }
 
 fn child(i: int) { println!("{}", i); assert!((i == 10)); }
diff --git a/src/test/run-pass/spawn2.rs b/src/test/run-pass/spawn2.rs
index 75104a4ddef..91edb5fd9c1 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::thread::Thread;
+use std::thread;
 
 pub fn main() {
-    let t = Thread::scoped(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
+    let t = thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
     t.join().ok().unwrap();
 }
 
diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs
index 5994b24dfdc..1c263b19dd1 100644
--- a/src/test/run-pass/task-stderr.rs
+++ b/src/test/run-pass/task-stderr.rs
@@ -20,9 +20,10 @@ fn main() {
     let mut reader = ChanReader::new(rx);
     let stderr = ChanWriter::new(tx);
 
-    let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).scoped(move|| -> () {
+    let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>)
+                                    .spawn(move|| -> () {
         panic!("Hello, world!")
-    }).join();
+    }).unwrap().join();
     assert!(res.is_err());
 
     let output = reader.read_to_string().unwrap();
diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs
index 4df1ff14810..053df3a57f3 100644
--- a/src/test/run-pass/tempfile.rs
+++ b/src/test/run-pass/tempfile.rs
@@ -23,7 +23,7 @@ use std::old_io::{fs, TempDir};
 use std::old_io;
 use std::os;
 use std::sync::mpsc::channel;
-use std::thread::Thread;
+use std::thread;
 
 fn test_tempdir() {
     let path = {
@@ -42,7 +42,7 @@ fn test_rm_tempdir() {
         tx.send(tmp.path().clone()).unwrap();
         panic!("panic to unwind past `tmp`");
     };
-    let _ = Thread::scoped(f).join();
+    thread::spawn(f).join();
     let path = rx.recv().unwrap();
     assert!(!path.exists());
 
@@ -52,7 +52,7 @@ fn test_rm_tempdir() {
         let _tmp = tmp;
         panic!("panic to unwind past `tmp`");
     };
-    let _ = Thread::scoped(f).join();
+    thread::spawn(f).join();
     assert!(!path.exists());
 
     let path;
@@ -61,7 +61,7 @@ fn test_rm_tempdir() {
             TempDir::new("test_rm_tempdir").unwrap()
         };
         // FIXME(#16640) `: TempDir` annotation shouldn't be necessary
-        let tmp: TempDir = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
+        let tmp: TempDir = thread::scoped(f).join();
         path = tmp.path().clone();
         assert!(path.exists());
     }
@@ -85,7 +85,7 @@ fn test_rm_tempdir_close() {
         tmp.close();
         panic!("panic when unwinding past `tmp`");
     };
-    let _ = Thread::scoped(f).join();
+    thread::spawn(f).join();
     let path = rx.recv().unwrap();
     assert!(!path.exists());
 
@@ -96,7 +96,7 @@ fn test_rm_tempdir_close() {
         tmp.close();
         panic!("panic when unwinding past `tmp`");
     };
-    let _ = Thread::scoped(f).join();
+    thread::spawn(f).join();
     assert!(!path.exists());
 
     let path;
@@ -105,7 +105,7 @@ fn test_rm_tempdir_close() {
             TempDir::new("test_rm_tempdir").unwrap()
         };
         // FIXME(#16640) `: TempDir` annotation shouldn't be necessary
-        let tmp: TempDir = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
+        let tmp: TempDir = thread::scoped(f).join();
         path = tmp.path().clone();
         assert!(path.exists());
         tmp.close();
@@ -179,7 +179,7 @@ pub fn test_rmdir_recursive_ok() {
 }
 
 pub fn dont_double_panic() {
-    let r: Result<(), _> = Thread::scoped(move|| {
+    let r: Result<(), _> = thread::spawn(move|| {
         let tmpdir = TempDir::new("test").unwrap();
         // Remove the temporary directory so that TempDir sees
         // an error on drop
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index 185edb02cca..bef9efa9eb6 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -12,7 +12,7 @@
 // Issue #787
 // Don't try to clean up uninitialized locals
 
-use std::thread::Thread;
+use std::thread;
 
 fn test_break() { loop { let _x: Box<int> = break; } }
 
@@ -22,13 +22,13 @@ fn test_ret() { let _x: Box<int> = return; }
 
 fn test_panic() {
     fn f() { let _x: Box<int> = panic!(); }
-    Thread::scoped(move|| f() ).join().err().unwrap();
+    thread::spawn(move|| f() ).join().err().unwrap();
 }
 
 fn test_panic_indirect() {
     fn f() -> ! { panic!(); }
     fn g() { let _x: Box<int> = f(); }
-    Thread::scoped(move|| g() ).join().err().unwrap();
+    thread::spawn(move|| g() ).join().err().unwrap();
 }
 
 pub fn main() {