auto merge of #20677 : alexcrichton/rust/rollup, r=alexcrichton

117 files changed, 564 insertions, 591 deletions

diff --git a/src/test/run-pass/associated-types-impl-redirect.rs b/src/test/run-pass/associated-types-impl-redirect.rs
index 388a2d73447..d9d11c95adb 100644
--- a/src/test/run-pass/associated-types-impl-redirect.rs
+++ b/src/test/run-pass/associated-types-impl-redirect.rs
@@ -19,7 +19,7 @@
 #![feature(lang_items, unboxed_closures)]
 #![no_implicit_prelude]
 
-use std::kinds::Sized;
+use std::marker::Sized;
 use std::option::Option::{None, Some, self};
 
 trait Iterator {
diff --git a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
index abbe250b627..4152321cab8 100644
--- a/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
+++ b/src/test/run-pass/associated-types-where-clause-impl-ambiguity.rs
@@ -19,7 +19,7 @@
 #![feature(lang_items, unboxed_closures)]
 #![no_implicit_prelude]
 
-use std::kinds::Sized;
+use std::marker::Sized;
 use std::option::Option::{None, Some, self};
 
 trait Iterator {
diff --git a/src/test/run-pass/auto-encode.rs b/src/test/run-pass/auto-encode.rs
index 24df95ffd3c..9b030de9983 100644
--- a/src/test/run-pass/auto-encode.rs
+++ b/src/test/run-pass/auto-encode.rs
@@ -35,7 +35,7 @@ fn test_rbml<'a, 'b, A:
     let mut rbml_w = EBwriter::Encoder::new(&mut wr);
     a1.encode(&mut rbml_w);
 
-    let d: serialize::rbml::Doc<'a> = EBDoc::new(wr[]);
+    let d: serialize::rbml::Doc<'a> = EBDoc::new(&wr[]);
     let mut decoder: EBReader::Decoder<'a> = EBreader::Decoder::new(d);
     let a2: A = Decodable::decode(&mut decoder);
     assert!(*a1 == a2);
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index dac8945b6e8..c586ff2c93a 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -32,9 +32,9 @@ pub fn main() {
     add_int(&mut *ints, 44);
 
     iter_ints(&*ints, |i| {
-        println!("int = {}", *i);
+        println!("int = {:?}", *i);
         true
     });
 
-    println!("ints={}", ints);
+    println!("ints={:?}", ints);
 }
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 86d7b72f4ff..9c7913dc0b0 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -51,7 +51,7 @@ fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
     }
 }
 
-impl fmt::Show for cat {
+impl fmt::String for cat {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.name)
     }
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 440b7afa984..526819940d0 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
@@ -45,5 +45,5 @@ pub fn fails() {
 }
 
 pub fn main() {
-    Thread::spawn(fails).join();
+    Thread::scoped(fails).join();
 }
diff --git a/src/test/run-pass/conditional-debug-macro-off.rs b/src/test/run-pass/conditional-debug-macro-off.rs
index e3bdbeb1692..b5a5f57d07a 100644
--- a/src/test/run-pass/conditional-debug-macro-off.rs
+++ b/src/test/run-pass/conditional-debug-macro-off.rs
@@ -16,5 +16,5 @@ extern crate log;
 
 pub fn main() {
     // only panics if println! evaluates its argument.
-    debug!("{}", { if true { panic!() } });
+    debug!("{:?}", { if true { panic!() } });
 }
diff --git a/src/test/run-pass/conditional-debug-macro-on.rs b/src/test/run-pass/conditional-debug-macro-on.rs
index 0591828bb13..b335e20f91d 100644
--- a/src/test/run-pass/conditional-debug-macro-on.rs
+++ b/src/test/run-pass/conditional-debug-macro-on.rs
@@ -13,7 +13,7 @@
 pub fn main() {
     // exits early if println! evaluates its arguments, otherwise it
     // will hit the panic.
-    println!("{}", { if true { return; } });
+    println!("{:?}", { if true { return; } });
 
     panic!();
 }
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index 35783ea5899..84acd3c4ecd 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -11,7 +11,7 @@
 #![allow(dead_code)]
 #![allow(unused_unsafe)]
 
-use std::kinds::Sync;
+use std::marker::Sync;
 
 struct Foo {
     a: uint,
diff --git a/src/test/run-pass/const-polymorphic-paths.rs b/src/test/run-pass/const-polymorphic-paths.rs
index 25c1464adfa..28b346c9ed4 100644
--- a/src/test/run-pass/const-polymorphic-paths.rs
+++ b/src/test/run-pass/const-polymorphic-paths.rs
@@ -29,7 +29,7 @@ fn odd(x: uint) -> bool { x % 2 == 1 }
 fn dummy_rng() -> DummyRng { DummyRng::new_unseeded() }
 
 macro_rules! tests {
-    ($($expr:expr: $ty:ty /($($test:expr),*);)+) => (pub fn main() {$({
+    ($($expr:expr, $ty:ty, ($($test:expr),*);)+) => (pub fn main() {$({
         const C: $ty = $expr;
         static S: $ty = $expr;
         assert!(eq(C($($test),*), $expr($($test),*)));
@@ -40,45 +40,44 @@ macro_rules! tests {
 
 tests! {
     // Free function.
-    id: fn(int) -> int /(5);
-    id::<int>: fn(int) -> int /(5);
+    id, fn(int) -> int, (5);
+    id::<int>, fn(int) -> int, (5);
 
     // Enum variant constructor.
-    Some: fn(int) -> Option<int> /(5);
-    Some::<int>: fn(int) -> Option<int> /(5);
+    Some, fn(int) -> Option<int>, (5);
+    Some::<int>, fn(int) -> Option<int>, (5);
 
     // Tuple struct constructor.
-    Newt: fn(int) -> Newt<int> /(5);
-    Newt::<int>: fn(int) -> Newt<int> /(5);
+    Newt, fn(int) -> Newt<int>, (5);
+    Newt::<int>, fn(int) -> Newt<int>, (5);
 
     // Inherent static methods.
-    Vec::new: fn() -> Vec<()> /();
-    Vec::<()>::new: fn() -> Vec<()> /();
-    Vec::with_capacity: fn(uint) -> Vec<()> /(5);
-    Vec::<()>::with_capacity: fn(uint) -> Vec<()> /(5);
-    Bitv::from_fn: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd);
-    Bitv::from_fn::<fn(uint) -> bool>: fn(uint, fn(uint) -> bool) -> Bitv /(5, odd);
+    Vec::new, fn() -> Vec<()>, ();
+    Vec::<()>::new, fn() -> Vec<()>, ();
+    Vec::with_capacity, fn(uint) -> Vec<()>, (5);
+    Vec::<()>::with_capacity, fn(uint) -> Vec<()>, (5);
+    Bitv::from_fn, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd);
+    Bitv::from_fn::<fn(uint) -> bool>, fn(uint, fn(uint) -> bool) -> Bitv, (5, odd);
 
     // Inherent non-static method.
-    Vec::map_in_place: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
-        /(vec![b'f', b'o', b'o'], u8_as_i8);
-    Vec::map_in_place::<i8, fn(u8) -> i8>: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
-        /(vec![b'f', b'o', b'o'], u8_as_i8);
+    Vec::map_in_place, fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>, (vec![b'f', b'o', b'o'], u8_as_i8);
+    Vec::map_in_place::<i8, fn(u8) -> i8>, fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>,
+        (vec![b'f', b'o', b'o'], u8_as_i8);
     // FIXME these break with "type parameter might not appear here pointing at `<u8>`.
     // Vec::<u8>::map_in_place: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
-    //     /(vec![b'f', b'o', b'o'], u8_as_i8);
+    //    , (vec![b'f', b'o', b'o'], u8_as_i8);
     // Vec::<u8>::map_in_place::<i8, fn(u8) -> i8>: fn(Vec<u8>, fn(u8) -> i8) -> Vec<i8>
-    //     /(vec![b'f', b'o', b'o'], u8_as_i8);
+    //    , (vec![b'f', b'o', b'o'], u8_as_i8);
 
     // Trait static methods.
     // FIXME qualified path expressions aka UFCS i.e. <T as Trait>::method.
-    Default::default: fn() -> int /();
-    Rand::rand: fn(&mut DummyRng) -> int /(&mut dummy_rng());
-    Rand::rand::<DummyRng>: fn(&mut DummyRng) -> int /(&mut dummy_rng());
+    Default::default, fn() -> int, ();
+    Rand::rand, fn(&mut DummyRng) -> int, (&mut dummy_rng());
+    Rand::rand::<DummyRng>, fn(&mut DummyRng) -> int, (&mut dummy_rng());
 
     // Trait non-static methods.
-    Clone::clone: fn(&int) -> int /(&5);
-    FromIterator::from_iter: fn(OptionIter<int>) -> Vec<int> /(Some(5).into_iter());
-    FromIterator::from_iter::<OptionIter<int>>: fn(OptionIter<int>) -> Vec<int>
-        /(Some(5).into_iter());
+    Clone::clone, fn(&int) -> int, (&5);
+    FromIterator::from_iter, fn(OptionIter<int>) -> Vec<int>, (Some(5).into_iter());
+    FromIterator::from_iter::<OptionIter<int>>, fn(OptionIter<int>) -> Vec<int>
+       , (Some(5).into_iter());
 }
diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs
index 3298976de6c..eeb044e5604 100644
--- a/src/test/run-pass/core-run-destroy.rs
+++ b/src/test/run-pass/core-run-destroy.rs
@@ -90,7 +90,7 @@ pub fn test_destroy_actually_kills(force: bool) {
             _ = rx2.recv() => unsafe { libc::exit(1) },
             _ = rx1.recv() => {}
         }
-    }).detach();
+    });
     match p.wait().unwrap() {
         ExitStatus(..) => panic!("expected a signal"),
         ExitSignal(..) => tx.send(()).unwrap(),
diff --git a/src/test/run-pass/deriving-encodable-decodable.rs b/src/test/run-pass/deriving-encodable-decodable.rs
index 2466d0adf7b..01814e8eab7 100644
--- a/src/test/run-pass/deriving-encodable-decodable.rs
+++ b/src/test/run-pass/deriving-encodable-decodable.rs
@@ -59,7 +59,7 @@ fn roundtrip<'a, T: Rand + Eq + Encodable<Encoder<'a>> +
     let mut w = Vec::new();
     let mut e = Encoder::new(&mut w);
     obj.encode(&mut e);
-    let doc = rbml::Doc::new(@w[]);
+    let doc = rbml::Doc::new(&w[]);
     let mut dec = Decoder::new(doc);
     let obj2 = Decodable::decode(&mut dec);
     assert!(obj == obj2);
diff --git a/src/test/run-pass/deriving-in-fn.rs b/src/test/run-pass/deriving-in-fn.rs
index d191bad10ea..cd79f84b7cb 100644
--- a/src/test/run-pass/deriving-in-fn.rs
+++ b/src/test/run-pass/deriving-in-fn.rs
@@ -15,5 +15,5 @@ pub fn main() {
     }
 
     let f = Foo { foo: 10 };
-    format!("{}", f);
+    format!("{:?}", f);
 }
diff --git a/src/test/run-pass/deriving-show-2.rs b/src/test/run-pass/deriving-show-2.rs
index 58faab7bfbe..8465f521e43 100644
--- a/src/test/run-pass/deriving-show-2.rs
+++ b/src/test/run-pass/deriving-show-2.rs
@@ -38,16 +38,25 @@ impl fmt::Show for Custom {
     }
 }
 
+trait ToShow {
+    fn to_show(&self) -> String;
+}
+
+impl<T: fmt::Show> ToShow for T {
+    fn to_show(&self) -> String {
+        format!("{:?}", self)
+    }
+}
+
 pub fn main() {
-    assert_eq!(B::B1.to_string(), "B1".to_string());
-    assert_eq!(B::B2.to_string(), "B2".to_string());
-    assert_eq!(C::C1(3).to_string(), "C1(3)".to_string());
-    assert_eq!(C::C2(B::B2).to_string(), "C2(B2)".to_string());
-    assert_eq!(D::D1{ a: 2 }.to_string(), "D1 { a: 2 }".to_string());
-    assert_eq!(E.to_string(), "E".to_string());
-    assert_eq!(F(3).to_string(), "F(3)".to_string());
-    assert_eq!(G(3, 4).to_string(), "G(3, 4)".to_string());
-    assert_eq!(G(3, 4).to_string(), "G(3, 4)".to_string());
-    assert_eq!(I{ a: 2, b: 4 }.to_string(), "I { a: 2, b: 4 }".to_string());
-    assert_eq!(J(Custom).to_string(), "J(yay)".to_string());
+    assert_eq!(B::B1.to_show(), "B1".to_string());
+    assert_eq!(B::B2.to_show(), "B2".to_string());
+    assert_eq!(C::C1(3).to_show(), "C1(3i)".to_string());
+    assert_eq!(C::C2(B::B2).to_show(), "C2(B2)".to_string());
+    assert_eq!(D::D1{ a: 2 }.to_show(), "D1 { a: 2i }".to_string());
+    assert_eq!(E.to_show(), "E".to_string());
+    assert_eq!(F(3).to_show(), "F(3i)".to_string());
+    assert_eq!(G(3, 4).to_show(), "G(3i, 4i)".to_string());
+    assert_eq!(I{ a: 2, b: 4 }.to_show(), "I { a: 2i, b: 4i }".to_string());
+    assert_eq!(J(Custom).to_show(), "J(yay)".to_string());
 }
diff --git a/src/test/run-pass/deriving-show.rs b/src/test/run-pass/deriving-show.rs
index e8086b8b7c6..99c73dd94a6 100644
--- a/src/test/run-pass/deriving-show.rs
+++ b/src/test/run-pass/deriving-show.rs
@@ -26,15 +26,15 @@ enum Enum {
 
 macro_rules! t {
     ($x:expr, $expected:expr) => {
-        assert_eq!(format!("{}", $x), $expected.to_string())
+        assert_eq!(format!("{:?}", $x), $expected.to_string())
     }
 }
 
 pub fn main() {
     t!(Unit, "Unit");
-    t!(Tuple(1, 2), "Tuple(1, 2)");
-    t!(Struct { x: 1, y: 2 }, "Struct { x: 1, y: 2 }");
+    t!(Tuple(1, 2), "Tuple(1i, 2u)");
+    t!(Struct { x: 1, y: 2 }, "Struct { x: 1i, y: 2u }");
     t!(Enum::Nullary, "Nullary");
-    t!(Enum::Variant(1, 2), "Variant(1, 2)");
-    t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1, y: 2 }");
+    t!(Enum::Variant(1, 2), "Variant(1i, 2u)");
+    t!(Enum::StructVariant { x: 1, y: 2 }, "StructVariant { x: 1i, y: 2u }");
 }
diff --git a/src/test/run-pass/dst-index.rs b/src/test/run-pass/dst-index.rs
index d1823359af1..dfb28fc9344 100644
--- a/src/test/run-pass/dst-index.rs
+++ b/src/test/run-pass/dst-index.rs
@@ -30,12 +30,13 @@ impl Index<uint> for T {
     type Output = Show + 'static;
 
     fn index<'a>(&'a self, idx: &uint) -> &'a (Show + 'static) {
-        static x: uint = 42;
-        &x
+        static X: uint = 42;
+        &X as &(Show + 'static)
     }
 }
 
 fn main() {
     assert_eq!(&S[0], "hello");
-    assert_eq!(format!("{}", &T[0]).as_slice(), "42");
+    &T[0];
+    // let x = &x as &Show;
 }
diff --git a/src/test/run-pass/enum-discrim-width-stuff.rs b/src/test/run-pass/enum-discrim-width-stuff.rs
index 07941eca224..73559af79de 100644
--- a/src/test/run-pass/enum-discrim-width-stuff.rs
+++ b/src/test/run-pass/enum-discrim-width-stuff.rs
@@ -23,8 +23,8 @@ macro_rules! check {
                 assert_eq!(size_of::<E>(), size_of::<$t>());
                 assert_eq!(E::V as $t, $v as $t);
                 assert_eq!(C as $t, $v as $t);
-                assert_eq!(format!("{}", E::V), "V".to_string());
-                assert_eq!(format!("{}", C), "V".to_string());
+                assert_eq!(format!("{:?}", E::V), "V".to_string());
+                assert_eq!(format!("{:?}", C), "V".to_string());
             }
         }
         $m::check();
diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs
index ce3e447350d..c1df9d53ad4 100644
--- a/src/test/run-pass/foreign-call-no-runtime.rs
+++ b/src/test/run-pass/foreign-call-no-runtime.rs
@@ -21,7 +21,7 @@ extern {
 
 pub fn main() {
     unsafe {
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             let i = &100i;
             rust_dbg_call(callback, mem::transmute(i));
         }).join();
diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs
index 14843b30e1c..a08cd33362f 100644
--- a/src/test/run-pass/fsu-moves-and-copies.rs
+++ b/src/test/run-pass/fsu-moves-and-copies.rs
@@ -11,7 +11,7 @@
 // Issue 4691: Ensure that functional-struct-updates operates
 // correctly and moves rather than copy when appropriate.
 
-use std::kinds::marker::NoCopy as NP;
+use std::marker::NoCopy as NP;
 
 struct ncint { np: NP, v: int }
 fn ncint(v: int) -> ncint { ncint { np: NP, v: v } }
diff --git a/src/test/run-pass/functional-struct-upd.rs b/src/test/run-pass/functional-struct-upd.rs
index e2297661d65..5f2ebc6cbed 100644
--- a/src/test/run-pass/functional-struct-upd.rs
+++ b/src/test/run-pass/functional-struct-upd.rs
@@ -17,5 +17,5 @@ struct Foo {
 pub fn main() {
     let a = Foo { x: 1, y: 2 };
     let c = Foo { x: 4, .. a};
-    println!("{}", c);
+    println!("{:?}", c);
 }
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index 3bcce538871..f83698edc90 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -1,4 +1,3 @@
-
 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
@@ -37,7 +36,7 @@ mod map_reduce {
         for i in inputs.iter() {
             let ctrl = ctrl.clone();
             let i = i.clone();
-            Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) ).detach();
+            Thread::spawn(move|| map_task(ctrl.clone(), i.clone()) );
         }
     }
 
diff --git a/src/test/run-pass/hrtb-opt-in-copy.rs b/src/test/run-pass/hrtb-opt-in-copy.rs
index 0616a7b21b5..8eaf8427bfd 100644
--- a/src/test/run-pass/hrtb-opt-in-copy.rs
+++ b/src/test/run-pass/hrtb-opt-in-copy.rs
@@ -18,7 +18,7 @@
 
 #![allow(dead_code)]
 
-use std::kinds::marker;
+use std::marker;
 
 #[derive(Copy)]
 struct Foo<T> { x: T }
diff --git a/src/test/run-pass/html-literals.rs b/src/test/run-pass/html-literals.rs
index fbaeb1753f4..23970af9576 100644
--- a/src/test/run-pass/html-literals.rs
+++ b/src/test/run-pass/html-literals.rs
@@ -10,6 +10,7 @@
 
 // A test of the macro system. Can we do HTML literals?
 
+// ignore-test FIXME #20673
 
 /*
 
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index d38b0ea2747..8b0d7c18fb1 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -30,7 +30,7 @@ impl fmt::UpperHex for B {
         f.write_str("adios")
     }
 }
-impl fmt::Show for C {
+impl fmt::String for C {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.pad_integral(true, "☃", "123")
     }
@@ -58,9 +58,12 @@ pub fn main() {
     t!(format!("{}", true), "true");
     t!(format!("{}", '☃'), "☃");
     t!(format!("{}", 10i), "10");
-    t!(format!("{}", 10i), "10");
     t!(format!("{}", 10u), "10");
-    t!(format!("{:?}", true), "true");
+    t!(format!("{:?}", '☃'), "'\\u{2603}'");
+    t!(format!("{:?}", 10i), "10i");
+    t!(format!("{:?}", 10u), "10u");
+    t!(format!("{:?}", "true"), "\"true\"");
+    t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
     t!(format!("{:o}", 10u), "12");
     t!(format!("{:x}", 10u), "a");
     t!(format!("{:X}", 10u), "A");
@@ -79,8 +82,10 @@ pub fn main() {
     t!(format!("{}", 5i + 5i), "10");
     t!(format!("{:#4}", C), "☃123");
 
-    let a: &fmt::Show = &1i;
-    t!(format!("{}", a), "1");
+    // FIXME(#20676)
+    // let a: &fmt::Show = &1i;
+    // t!(format!("{:?}", a), "1i");
+
 
     // Formatting strings and their arguments
     t!(format!("{}", "a"), "a");
diff --git a/src/test/run-pass/issue-10396.rs b/src/test/run-pass/issue-10396.rs
index ea311e6e32c..308783f0d4b 100644
--- a/src/test/run-pass/issue-10396.rs
+++ b/src/test/run-pass/issue-10396.rs
@@ -15,7 +15,7 @@ enum Foo<'s> {
 
 fn f(arr: &[&Foo]) {
     for &f in arr.iter() {
-        println!("{}", f);
+        println!("{:?}", f);
     }
 }
 
diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs
index 8a6e300bd15..b06799444f4 100644
--- a/src/test/run-pass/issue-10626.rs
+++ b/src/test/run-pass/issue-10626.rs
@@ -30,5 +30,5 @@ pub fn main () {
 
     let mut p = process::Command::new(args[0].as_slice());
     p.arg("child").stdout(process::Ignored).stderr(process::Ignored);
-    println!("{}", p.spawn().unwrap().wait());
+    println!("{:?}", p.spawn().unwrap().wait());
 }
diff --git a/src/test/run-pass/issue-11267.rs b/src/test/run-pass/issue-11267.rs
index f08805fe49c..6fb2c532e0c 100644
--- a/src/test/run-pass/issue-11267.rs
+++ b/src/test/run-pass/issue-11267.rs
@@ -20,7 +20,7 @@ impl T<int> for Empty {
 }
 
 fn do_something_with(a : &mut T<int>) {
-    println!("{}", a.next())
+    println!("{:?}", a.next())
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/issue-12684.rs b/src/test/run-pass/issue-12684.rs
index 856fbbd00b2..a6a4d21e8f2 100644
--- a/src/test/run-pass/issue-12684.rs
+++ b/src/test/run-pass/issue-12684.rs
@@ -12,7 +12,7 @@ use std::time::Duration;
 use std::thread::Thread;
 
 fn main() {
-    Thread::spawn(move|| customtask()).join().ok().unwrap();
+    Thread::scoped(move|| customtask()).join().ok().unwrap();
 }
 
 fn customtask() {
diff --git a/src/test/run-pass/issue-12744.rs b/src/test/run-pass/issue-12744.rs
index 1182cf5b29f..a91dbd2b716 100644
--- a/src/test/run-pass/issue-12744.rs
+++ b/src/test/run-pass/issue-12744.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     fn test() -> Box<std::any::Any + 'static> { box 1i }
-    println!("{}", test())
+    println!("{:?}", test())
 }
diff --git a/src/test/run-pass/issue-13434.rs b/src/test/run-pass/issue-13434.rs
index e5fd17e2dfe..35e487539fa 100644
--- a/src/test/run-pass/issue-13434.rs
+++ b/src/test/run-pass/issue-13434.rs
@@ -26,5 +26,5 @@ fn do_stuff<R: Repro>(r: R) -> String {
 }
 
 pub fn main() {
-  assert_eq!("MyStruct".to_string(), do_stuff(|: s: MyStruct| format!("{}", s)));
+  assert_eq!("MyStruct".to_string(), do_stuff(|: s: MyStruct| format!("{:?}", s)));
 }
diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs
index b9339c1cc0d..bef0ff5fc2c 100644
--- a/src/test/run-pass/issue-13494.rs
+++ b/src/test/run-pass/issue-13494.rs
@@ -22,7 +22,7 @@ fn helper(rx: Receiver<Sender<()>>) {
 
 fn main() {
     let (tx, rx) = channel();
-    let _t = Thread::spawn(move|| { helper(rx) }).detach();
+    let _t = Thread::spawn(move|| { helper(rx) });
     let (snd, rcv) = channel::<int>();
     for _ in range(1i, 100000i) {
         snd.send(1i).unwrap();
diff --git a/src/test/run-pass/issue-15730.rs b/src/test/run-pass/issue-15730.rs
index a1a5922e150..4e1aa454a88 100644
--- a/src/test/run-pass/issue-15730.rs
+++ b/src/test/run-pass/issue-15730.rs
@@ -12,5 +12,5 @@
 
 fn main() {
     let mut array = [1, 2, 3];
-    let pie_slice = array[1..2];
+    let pie_slice = &array[1..2];
 }
diff --git a/src/test/run-pass/issue-16560.rs b/src/test/run-pass/issue-16560.rs
index b2b819a1103..6b03a499f15 100644
--- a/src/test/run-pass/issue-16560.rs
+++ b/src/test/run-pass/issue-16560.rs
@@ -20,7 +20,7 @@ fn main() {
     // Check that both closures are capturing by value
     assert_eq!(1, mem::size_of_val(&closure));
 
-    Thread::spawn(move|| {
+    Thread::scoped(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 99758f9f777..e25b3e8e89c 100644
--- a/src/test/run-pass/issue-16671.rs
+++ b/src/test/run-pass/issue-16671.rs
@@ -24,5 +24,5 @@ pub fn main() {
     let mut stdin = std::io::stdin();
     Thread::spawn(move|| {
         let _ = stdin.read_to_end();
-    }).detach();
+    });
 }
diff --git a/src/test/run-pass/issue-1696.rs b/src/test/run-pass/issue-1696.rs
index e69738d4caa..40e112d6fbf 100644
--- a/src/test/run-pass/issue-1696.rs
+++ b/src/test/run-pass/issue-1696.rs
@@ -15,5 +15,5 @@ use std::collections::HashMap;
 pub fn main() {
     let mut m = HashMap::new();
     m.insert(b"foo".to_vec(), b"bar".to_vec());
-    println!("{}", m);
+    println!("{:?}", m);
 }
diff --git a/src/test/run-pass/issue-17503.rs b/src/test/run-pass/issue-17503.rs
index 986879e8e46..8acda175006 100644
--- a/src/test/run-pass/issue-17503.rs
+++ b/src/test/run-pass/issue-17503.rs
@@ -15,7 +15,7 @@ fn main() {
     let ss: &&[int] = &s;
     let sss: &&&[int] = &ss;
 
-    println!("{}", s[..3]);
-    println!("{}", ss[3..]);
-    println!("{}", sss[2..4]);
+    println!("{}", &s[0..3]);
+    println!("{}", &ss[3..]);
+    println!("{}", &sss[2..4]);
 }
diff --git a/src/test/run-pass/issue-17718-static-unsafe-interior.rs b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
index 0851f0e367b..cdd03244df1 100644
--- a/src/test/run-pass/issue-17718-static-unsafe-interior.rs
+++ b/src/test/run-pass/issue-17718-static-unsafe-interior.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::kinds::marker;
+use std::marker;
 use std::cell::UnsafeCell;
 
 struct MyUnsafePack<T>(UnsafeCell<T>);
diff --git a/src/test/run-pass/issue-19135.rs b/src/test/run-pass/issue-19135.rs
index b9d0a9a2988..c90880ff120 100644
--- a/src/test/run-pass/issue-19135.rs
+++ b/src/test/run-pass/issue-19135.rs
@@ -14,7 +14,7 @@
 struct LifetimeStruct<'a>;
 
 fn main() {
-    takes_hrtb_closure(|&mut: lts| println!("{}", lts));
+    takes_hrtb_closure(|&mut: lts| println!("{:?}", lts));
 }
 
 fn takes_hrtb_closure<F: for<'a>FnMut(LifetimeStruct<'a>)>(mut f: F) {
diff --git a/src/test/run-pass/issue-19358.rs b/src/test/run-pass/issue-19358.rs
index 86687fccd61..36093482175 100644
--- a/src/test/run-pass/issue-19358.rs
+++ b/src/test/run-pass/issue-19358.rs
@@ -25,5 +25,5 @@ impl Trait for int {}
 fn main() {
     let a = Foo { foo: 12i };
     let b = Bar { bar: 12i };
-    println!("{} {}", a, b);
+    println!("{:?} {:?}", a, b);
 }
diff --git a/src/test/run-pass/issue-20644.rs b/src/test/run-pass/issue-20644.rs
new file mode 100644
index 00000000000..4a57ed56594
--- /dev/null
+++ b/src/test/run-pass/issue-20644.rs
@@ -0,0 +1,35 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// A reduced version of the rustbook ice. The problem this encountered
+// had to do with trans ignoring binders.
+
+#![feature(slicing_syntax)]
+#![feature(associated_types)]
+#![feature(macro_rules)]
+
+use std::iter;
+use std::os;
+use std::io::File;
+
+#[allow(unused)]
+pub fn parse_summary<R: Reader>(_: R, _: &Path) {
+     let path_from_root = Path::new("");
+     Path::new(iter::repeat("../")
+               .take(path_from_root.components().count() - 1)
+               .collect::<String>());
+ }
+
+fn main() {
+    let cwd = os::getcwd().unwrap();
+    let src = cwd.clone();
+    let summary = File::open(&src.join("SUMMARY.md"));
+    let _ = parse_summary(summary, &src);
+}
diff --git a/src/test/run-pass/issue-2190-1.rs b/src/test/run-pass/issue-2190-1.rs
index 4bbbe978192..810bf385d7e 100644
--- a/src/test/run-pass/issue-2190-1.rs
+++ b/src/test/run-pass/issue-2190-1.rs
@@ -14,7 +14,7 @@ use std::thunk::Thunk;
 static generations: uint = 1024+256+128+49;
 
 fn spawn(f: Thunk) {
-    Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(())).detach()
+    Builder::new().stack_size(32 * 1024).spawn(move|| f.invoke(()));
 }
 
 fn child_no(x: uint) -> Thunk {
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index f4146063409..3ca3e0592e7 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -23,7 +23,7 @@ pub mod pipes {
     use std::mem::{replace, swap};
     use std::mem;
     use std::thread::Thread;
-    use std::kinds::Send;
+    use std::marker::Send;
 
     pub struct Stuff<T> {
         state: state,
diff --git a/src/test/run-pass/issue-3109.rs b/src/test/run-pass/issue-3109.rs
index 86913c0e8d4..dc22ebce804 100644
--- a/src/test/run-pass/issue-3109.rs
+++ b/src/test/run-pass/issue-3109.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    println!("{}", ("hi there!", "you"));
+    println!("{:?}", ("hi there!", "you"));
 }
diff --git a/src/test/run-pass/issue-3556.rs b/src/test/run-pass/issue-3556.rs
index e004c24da13..3448273e144 100644
--- a/src/test/run-pass/issue-3556.rs
+++ b/src/test/run-pass/issue-3556.rs
@@ -43,6 +43,6 @@ pub fn main()
                     "foo".to_string(),
                     "foo".to_string(), "foo".to_string(), "foo".to_string(),
                     "foo".to_string());
-    let v = format!("{}", u);    // this is the line that causes the seg fault
+    let v = format!("{:?}", u);    // this is the line that causes the seg fault
     assert!(v.len() > 0);
 }
diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs
index 2568d94fcbf..633832f424c 100644
--- a/src/test/run-pass/issue-3559.rs
+++ b/src/test/run-pass/issue-3559.rs
@@ -24,6 +24,6 @@ pub fn main() {
     let mut table = HashMap::new();
     table.insert("one".to_string(), 1i);
     table.insert("two".to_string(), 2i);
-    assert!(check_strs(table.to_string().as_slice(), "{one: 1, two: 2}") ||
-            check_strs(table.to_string().as_slice(), "{two: 2, one: 1}"));
+    assert!(check_strs(format!("{:?}", table).as_slice(), "HashMap {\"one\": 1i, \"two\": 2i}") ||
+            check_strs(format!("{:?}", table).as_slice(), "HashMap {\"two\": 2i, \"one\": 1i}"));
 }
diff --git a/src/test/run-pass/issue-3563-3.rs b/src/test/run-pass/issue-3563-3.rs
index a3903128b65..3fe6e02dcef 100644
--- a/src/test/run-pass/issue-3563-3.rs
+++ b/src/test/run-pass/issue-3563-3.rs
@@ -104,7 +104,7 @@ impl AsciiArt {
 
 // Allows AsciiArt to be converted to a string using the libcore ToString trait.
 // Note that the %s fmt! specifier will not call this automatically.
-impl fmt::Show for AsciiArt {
+impl fmt::String for AsciiArt {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Convert each line into a string.
         let lines = self.lines.iter()
diff --git a/src/test/run-pass/issue-3743.rs b/src/test/run-pass/issue-3743.rs
index 43852fb3324..382ea0c5758 100644
--- a/src/test/run-pass/issue-3743.rs
+++ b/src/test/run-pass/issue-3743.rs
@@ -30,17 +30,23 @@ impl Vec2 {
 }
 
 // Right-hand-side operator visitor pattern
-trait RhsOfVec2Mul<Result> { fn mul_vec2_by(&self, lhs: &Vec2) -> Result; }
+trait RhsOfVec2Mul {
+    type Result;
+
+    fn mul_vec2_by(&self, lhs: &Vec2) -> Self::Result;
+}
 
 // Vec2's implementation of Mul "from the other side" using the above trait
-impl<Res, Rhs: RhsOfVec2Mul<Res>> Mul<Rhs> for Vec2 {
+impl<Res, Rhs: RhsOfVec2Mul<Result=Res>> Mul<Rhs> for Vec2 {
     type Output = Res;
 
     fn mul(self, rhs: Rhs) -> Res { rhs.mul_vec2_by(&self) }
 }
 
 // Implementation of 'f64 as right-hand-side of Vec2::Mul'
-impl RhsOfVec2Mul<Vec2> for f64 {
+impl RhsOfVec2Mul for f64 {
+    type Result = Vec2;
+
     fn mul_vec2_by(&self, lhs: &Vec2) -> Vec2 { lhs.vmul(*self) }
 }
 
diff --git a/src/test/run-pass/issue-3794.rs b/src/test/run-pass/issue-3794.rs
index 4508bc5771c..926b53cf92c 100644
--- a/src/test/run-pass/issue-3794.rs
+++ b/src/test/run-pass/issue-3794.rs
@@ -19,7 +19,7 @@ struct S {
 
 impl T for S {
     fn print(&self) {
-        println!("{}", self);
+        println!("{:?}", self);
     }
 }
 
diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs
index 10add853ee7..5ed9729c142 100644
--- a/src/test/run-pass/issue-3888-2.rs
+++ b/src/test/run-pass/issue-3888-2.rs
@@ -11,7 +11,7 @@
 #![feature(slicing_syntax)]
 
 fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
-    v[1..5]
+    &v[1..5]
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-4252.rs b/src/test/run-pass/issue-4252.rs
index 6ed35e6bc23..3606aff05ff 100644
--- a/src/test/run-pass/issue-4252.rs
+++ b/src/test/run-pass/issue-4252.rs
@@ -13,7 +13,7 @@
 trait X {
     fn call<T: std::fmt::Show>(&self, x: &T);
     fn default_method<T: std::fmt::Show>(&self, x: &T) {
-        println!("X::default_method {}", x);
+        println!("X::default_method {:?}", x);
     }
 }
 
@@ -27,7 +27,7 @@ struct Z<T> {
 
 impl X for Y {
     fn call<T: std::fmt::Show>(&self, x: &T) {
-        println!("X::call {} {}", self, x);
+        println!("X::call {:?} {:?}", self, x);
     }
 }
 
diff --git a/src/test/run-pass/issue-4446.rs b/src/test/run-pass/issue-4446.rs
index 30e1a14ecff..9c00348ad6a 100644
--- a/src/test/run-pass/issue-4446.rs
+++ b/src/test/run-pass/issue-4446.rs
@@ -17,7 +17,7 @@ pub fn main() {
 
     tx.send("hello, world").unwrap();
 
-    Thread::spawn(move|| {
+    Thread::scoped(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 7e53722726f..a19bfca721a 100644
--- a/src/test/run-pass/issue-4448.rs
+++ b/src/test/run-pass/issue-4448.rs
@@ -14,7 +14,7 @@ use std::thread::Thread;
 pub fn main() {
     let (tx, rx) = channel::<&'static str>();
 
-    let t = Thread::spawn(move|| {
+    let t = Thread::scoped(move|| {
         assert_eq!(rx.recv().unwrap(), "hello, world");
     });
 
diff --git a/src/test/run-pass/issue-4464.rs b/src/test/run-pass/issue-4464.rs
index f2c1a715b51..2581069d29b 100644
--- a/src/test/run-pass/issue-4464.rs
+++ b/src/test/run-pass/issue-4464.rs
@@ -10,6 +10,6 @@
 
 #![feature(slicing_syntax)]
 
-fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { v[i..j] }
+fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-7563.rs b/src/test/run-pass/issue-7563.rs
index 4d217fbf335..734d131ffdf 100644
--- a/src/test/run-pass/issue-7563.rs
+++ b/src/test/run-pass/issue-7563.rs
@@ -31,6 +31,6 @@ pub fn main() {
     let sa = A { a: 100 };
     let sb = B { b: 200, pa: &sa };
 
-    println!("sa is {}", sa);
-    println!("sb is {}", sb);
+    println!("sa is {:?}", sa);
+    println!("sb is {:?}", sb);
 }
diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs
index 3d5e32972e7..3ea6d5d4f2f 100644
--- a/src/test/run-pass/issue-8460.rs
+++ b/src/test/run-pass/issue-8460.rs
@@ -12,24 +12,24 @@ use std::{int, i8, i16, i32, i64};
 use std::thread::Thread;
 
 fn main() {
-    assert!(Thread::spawn(move|| int::MIN / -1).join().is_err());
-    assert!(Thread::spawn(move|| i8::MIN / -1).join().is_err());
-    assert!(Thread::spawn(move|| i16::MIN / -1).join().is_err());
-    assert!(Thread::spawn(move|| i32::MIN / -1).join().is_err());
-    assert!(Thread::spawn(move|| i64::MIN / -1).join().is_err());
-    assert!(Thread::spawn(move|| 1i / 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i8 / 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i16 / 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i32 / 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i64 / 0).join().is_err());
-    assert!(Thread::spawn(move|| int::MIN % -1).join().is_err());
-    assert!(Thread::spawn(move|| i8::MIN % -1).join().is_err());
-    assert!(Thread::spawn(move|| i16::MIN % -1).join().is_err());
-    assert!(Thread::spawn(move|| i32::MIN % -1).join().is_err());
-    assert!(Thread::spawn(move|| i64::MIN % -1).join().is_err());
-    assert!(Thread::spawn(move|| 1i % 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i8 % 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i16 % 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i32 % 0).join().is_err());
-    assert!(Thread::spawn(move|| 1i64 % 0).join().is_err());
+    assert!(Thread::scoped(move|| int::MIN / -1).join().is_err());
+    assert!(Thread::scoped(move|| i8::MIN / -1).join().is_err());
+    assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err());
+    assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err());
+    assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err());
+    assert!(Thread::scoped(move|| 1i / 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i8 / 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i16 / 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i32 / 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i64 / 0).join().is_err());
+    assert!(Thread::scoped(move|| int::MIN % -1).join().is_err());
+    assert!(Thread::scoped(move|| i8::MIN % -1).join().is_err());
+    assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err());
+    assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err());
+    assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err());
+    assert!(Thread::scoped(move|| 1i % 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i8 % 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i16 % 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i32 % 0).join().is_err());
+    assert!(Thread::scoped(move|| 1i64 % 0).join().is_err());
 }
diff --git a/src/test/run-pass/issue-8827.rs b/src/test/run-pass/issue-8827.rs
index 39695a8339f..d8b7490124f 100644
--- a/src/test/run-pass/issue-8827.rs
+++ b/src/test/run-pass/issue-8827.rs
@@ -26,7 +26,7 @@ fn periodical(n: int) -> Receiver<bool> {
                 Err(..) => break
             }
         }
-    }).detach();
+    });
     return port;
 }
 
@@ -41,7 +41,7 @@ fn integers() -> Receiver<int> {
             }
             i = i + 1;
         }
-    }).detach();
+    });
     return port;
 }
 
@@ -58,4 +58,3 @@ fn main() {
         }
     }
 }
-
diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index 305f984f98e..0ca63d52bd8 100644
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -11,18 +11,18 @@
 #![feature(slicing_syntax)]
 
 fn assert_repr_eq<T: std::fmt::Show>(obj : T, expected : String) {
-    assert_eq!(expected, format!("{}", obj));
+    assert_eq!(expected, format!("{:?}", obj));
 }
 
 pub fn main() {
     let abc = [1i, 2, 3];
     let tf = [true, false];
     let x  = [(), ()];
-    let slice = x[0..1];
+    let slice = &x[0..1];
 
-    assert_repr_eq(abc[], "[1, 2, 3]".to_string());
-    assert_repr_eq(tf[], "[true, false]".to_string());
-    assert_repr_eq(x[], "[(), ()]".to_string());
+    assert_repr_eq(&abc[], "[1i, 2i, 3i]".to_string());
+    assert_repr_eq(&tf[], "[true, false]".to_string());
+    assert_repr_eq(&x[], "[(), ()]".to_string());
     assert_repr_eq(slice, "[()]".to_string());
-    assert_repr_eq(x[], "[(), ()]".to_string());
+    assert_repr_eq(&x[], "[(), ()]".to_string());
 }
diff --git a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
index bffa86a2c62..7fb2390b84b 100644
--- a/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
+++ b/src/test/run-pass/log-knows-the-names-of-variants-in-std.rs
@@ -15,19 +15,19 @@ enum foo {
 }
 
 fn check_log<T: std::fmt::Show>(exp: String, v: T) {
-    assert_eq!(exp, format!("{}", v));
+    assert_eq!(exp, format!("{:?}", v));
 }
 
 pub fn main() {
     let mut x = Some(foo::a(22u));
-    let exp = "Some(a(22))".to_string();
-    let act = format!("{}", x);
+    let exp = "Some(a(22u))".to_string();
+    let act = format!("{:?}", x);
     assert_eq!(act, exp);
     check_log(exp, x);
 
     x = None;
     let exp = "None".to_string();
-    let act = format!("{}", x);
+    let act = format!("{:?}", x);
     assert_eq!(act, exp);
     check_log(exp, x);
 }
diff --git a/src/test/run-pass/log-knows-the-names-of-variants.rs b/src/test/run-pass/log-knows-the-names-of-variants.rs
index e40723ab1b6..45fd2098dc4 100644
--- a/src/test/run-pass/log-knows-the-names-of-variants.rs
+++ b/src/test/run-pass/log-knows-the-names-of-variants.rs
@@ -21,7 +21,7 @@ enum bar {
 }
 
 pub fn main() {
-    assert_eq!("a(22)".to_string(), format!("{}", foo::a(22u)));
-    assert_eq!("c".to_string(), format!("{}", foo::c));
-    assert_eq!("d".to_string(), format!("{}", bar::d));
+    assert_eq!("a(22u)".to_string(), format!("{:?}", foo::a(22u)));
+    assert_eq!("c".to_string(), format!("{:?}", foo::c));
+    assert_eq!("d".to_string(), format!("{:?}", bar::d));
 }
diff --git a/src/test/run-pass/log-poly.rs b/src/test/run-pass/log-poly.rs
index 163efcb1a2b..a6a99d6fc92 100644
--- a/src/test/run-pass/log-poly.rs
+++ b/src/test/run-pass/log-poly.rs
@@ -14,8 +14,8 @@ enum Numbers {
 }
 
 pub fn main() {
-    println!("{}", 1i);
-    println!("{}", 2.0f64);
-    println!("{}", Numbers::Three);
-    println!("{}", vec!(4i));
+    println!("{:?}", 1i);
+    println!("{:?}", 2.0f64);
+    println!("{:?}", Numbers::Three);
+    println!("{:?}", vec!(4i));
 }
diff --git a/src/test/run-pass/logging-only-prints-once.rs b/src/test/run-pass/logging-only-prints-once.rs
index 509afff3d13..a72cfad2cb8 100644
--- a/src/test/run-pass/logging-only-prints-once.rs
+++ b/src/test/run-pass/logging-only-prints-once.rs
@@ -27,9 +27,9 @@ impl fmt::Show for Foo {
 }
 
 pub fn main() {
-    Thread::spawn(move|| {
+    Thread::scoped(move|| {
         let mut f = Foo(Cell::new(0));
-        println!("{}", f);
+        println!("{:?}", f);
         let Foo(ref mut f) = f;
         assert!(f.get() == 1);
     }).join().ok().unwrap();
diff --git a/src/test/run-pass/macro-with-braces-in-expr-position.rs b/src/test/run-pass/macro-with-braces-in-expr-position.rs
index 93bb9557604..cb52ba74bbd 100644
--- a/src/test/run-pass/macro-with-braces-in-expr-position.rs
+++ b/src/test/run-pass/macro-with-braces-in-expr-position.rs
@@ -14,7 +14,7 @@ macro_rules! expr { ($e: expr) => { $e } }
 
 macro_rules! spawn {
     ($($code: tt)*) => {
-        expr!(Thread::spawn(move|| {$($code)*}).detach())
+        expr!(Thread::spawn(move|| {$($code)*}))
     }
 }
 
diff --git a/src/test/run-pass/method-recursive-blanket-impl.rs b/src/test/run-pass/method-recursive-blanket-impl.rs
index e81244d4bea..338bd89ab5c 100644
--- a/src/test/run-pass/method-recursive-blanket-impl.rs
+++ b/src/test/run-pass/method-recursive-blanket-impl.rs
@@ -13,7 +13,7 @@
 // know not to stop at the blanket, we have to recursively evaluate
 // the `T:Foo` bound.
 
-use std::kinds::Sized;
+use std::marker::Sized;
 
 // Note: this must be generic for the problem to show up
 trait Foo<A> {
diff --git a/src/test/run-pass/new-impl-syntax.rs b/src/test/run-pass/new-impl-syntax.rs
index 8532b5f51dc..84d2083cedd 100644
--- a/src/test/run-pass/new-impl-syntax.rs
+++ b/src/test/run-pass/new-impl-syntax.rs
@@ -17,7 +17,7 @@ struct Thingy {
 
 impl fmt::Show for Thingy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{{ x: {}, y: {} }}", self.x, self.y)
+        write!(f, "{{ x: {:?}, y: {:?} }}", self.x, self.y)
     }
 }
 
@@ -27,11 +27,11 @@ struct PolymorphicThingy<T> {
 
 impl<T:fmt::Show> fmt::Show for PolymorphicThingy<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.x)
+        write!(f, "{:?}", self.x)
     }
 }
 
 pub fn main() {
-    println!("{}", Thingy { x: 1, y: 2 }.to_string());
-    println!("{}", PolymorphicThingy { x: Thingy { x: 1, y: 2 } }.to_string());
+    println!("{:?}", Thingy { x: 1, y: 2 });
+    println!("{:?}", PolymorphicThingy { x: Thingy { x: 1, y: 2 } });
 }
diff --git a/src/test/run-pass/no-landing-pads.rs b/src/test/run-pass/no-landing-pads.rs
index 6b1553cd9f6..64e78c3483b 100644
--- a/src/test/run-pass/no-landing-pads.rs
+++ b/src/test/run-pass/no-landing-pads.rs
@@ -23,7 +23,7 @@ impl Drop for A {
 }
 
 fn main() {
-    Thread::spawn(move|| -> () {
+    Thread::scoped(move|| -> () {
         let _a = A;
         panic!();
     }).join().unwrap_err();
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index 9b9a7f68995..0293c4e36ac 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -35,10 +35,10 @@ impl<T> E<T> {
 }
 
 macro_rules! check_option {
-    ($e:expr: $T:ty) => {{
-        check_option!($e: $T, |ptr| assert!(*ptr == $e));
+    ($e:expr, $T:ty) => {{
+        check_option!($e, $T, |ptr| assert!(*ptr == $e));
     }};
-    ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
+    ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
         assert!(option::Option::None::<$T>.is_none());
         let e = $e;
         let s_ = option::Option::Some::<$T>(e);
@@ -48,10 +48,10 @@ macro_rules! check_option {
 }
 
 macro_rules! check_fancy {
-    ($e:expr: $T:ty) => {{
-        check_fancy!($e: $T, |ptr| assert!(*ptr == $e));
+    ($e:expr, $T:ty) => {{
+        check_fancy!($e, $T, |ptr| assert!(*ptr == $e));
     }};
-    ($e:expr: $T:ty, |$v:ident| $chk:expr) => {{
+    ($e:expr, $T:ty, |$v:ident| $chk:expr) => {{
         assert!(E::Nothing::<$T>((), ((), ()), [23i8; 0]).is_none());
         let e = $e;
         let t_ = E::Thing::<$T>(23, e);
@@ -71,12 +71,12 @@ macro_rules! check_type {
 }
 
 pub fn main() {
-    check_type!(&17: &int);
-    check_type!(box 18: Box<int>);
-    check_type!("foo".to_string(): String);
-    check_type!(vec!(20, 22): Vec<int> );
+    check_type!(&17, &int);
+    check_type!(box 18, Box<int>);
+    check_type!("foo".to_string(), String);
+    check_type!(vec!(20, 22), Vec<int> );
     let mint: uint = unsafe { mem::transmute(main) };
-    check_type!(main: fn(), |pthing| {
+    check_type!(main, fn(), |pthing| {
         assert!(mint == unsafe { mem::transmute(*pthing) })
     });
 }
diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
index 7aac2d705a8..ce6604df49b 100644
--- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs
+++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
@@ -37,11 +37,13 @@ fn main() {
     let args = os::args();
     let args = args.as_slice();
     if args.len() > 1 && args[1].as_slice() == "recurse" {
-        let _t = Thread::spawn(recurse);
+        let _t = Thread::scoped(recurse);
     } else {
         let recurse = Command::new(args[0].as_slice()).arg("recurse").output().unwrap();
         assert!(!recurse.status.success());
         let error = String::from_utf8_lossy(recurse.error.as_slice());
+        println!("wut");
+        println!("`{}`", error);
         assert!(error.as_slice().contains("has overflowed its stack"));
     }
 }
diff --git a/src/test/run-pass/overloaded-index-assoc-list.rs b/src/test/run-pass/overloaded-index-assoc-list.rs
index aac0b5e06d0..2e044227eb1 100644
--- a/src/test/run-pass/overloaded-index-assoc-list.rs
+++ b/src/test/run-pass/overloaded-index-assoc-list.rs
@@ -37,7 +37,7 @@ impl<K: PartialEq + std::fmt::Show, V:Clone> Index<K> for AssociationList<K,V> {
                 return &pair.value
             }
         }
-        panic!("No value found for key: {}", index);
+        panic!("No value found for key: {:?}", index);
     }
 }
 
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 5c692bf8801..3cc01b967ce 100644
--- a/src/test/run-pass/panic-in-dtor-drops-fields.rs
+++ b/src/test/run-pass/panic-in-dtor-drops-fields.rs
@@ -33,10 +33,9 @@ impl Drop for B {
 }
 
 pub fn main() {
-    let ret = Thread::spawn(move|| {
+    let ret = Thread::scoped(move|| {
         let _a = A { b: B { foo: 3 } };
     }).join();
     assert!(ret.is_err());
     unsafe { assert!(dropped); }
 }
-
diff --git a/src/test/run-pass/plugin-args-1.rs b/src/test/run-pass/plugin-args-1.rs
deleted file mode 100644
index 5a91f603f96..00000000000
--- a/src/test/run-pass/plugin-args-1.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin]
-extern crate plugin_args;
-
-fn main() {
-    assert_eq!(plugin_args!(), "#[plugin]");
-}
diff --git a/src/test/run-pass/plugin-args-2.rs b/src/test/run-pass/plugin-args-2.rs
deleted file mode 100644
index d0ac22a5290..00000000000
--- a/src/test/run-pass/plugin-args-2.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin()]
-extern crate plugin_args;
-
-fn main() {
-    assert_eq!(plugin_args!(), "#[plugin()]");
-}
diff --git a/src/test/run-pass/plugin-args-3.rs b/src/test/run-pass/plugin-args-3.rs
deleted file mode 100644
index 7cac8ac57e5..00000000000
--- a/src/test/run-pass/plugin-args-3.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin(hello(there), how(are="you"))]
-extern crate plugin_args;
-
-fn main() {
-    assert_eq!(plugin_args!(), "#[plugin(hello(there), how(are = \"you\"))]");
-}
diff --git a/src/test/run-pass/plugin-args-4.rs b/src/test/run-pass/plugin-args-4.rs
deleted file mode 100644
index 8563c8c178f..00000000000
--- a/src/test/run-pass/plugin-args-4.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// aux-build:plugin_args.rs
-// ignore-stage1
-
-#![feature(plugin)]
-
-#[no_link]
-#[plugin="foobar"]
-extern crate plugin_args;
-
-fn main() {
-    assert_eq!(plugin_args!(), "#[plugin = \"foobar\"]");
-}
diff --git a/src/test/run-pass/rec-align-u32.rs b/src/test/run-pass/rec-align-u32.rs
index e165b34f680..5b91d5e930f 100644
--- a/src/test/run-pass/rec-align-u32.rs
+++ b/src/test/run-pass/rec-align-u32.rs
@@ -53,11 +53,11 @@ pub fn main() {
         let x = Outer {c8: 22u8, t: Inner {c64: 44u32}};
 
         // Send it through the shape code
-        let y = format!("{}", x);
+        let y = format!("{:?}", x);
 
-        println!("align inner = {}", rusti::min_align_of::<Inner>());
-        println!("size outer = {}", mem::size_of::<Outer>());
-        println!("y = {}", y);
+        println!("align inner = {:?}", rusti::min_align_of::<Inner>());
+        println!("size outer = {:?}", mem::size_of::<Outer>());
+        println!("y = {:?}", y);
 
         // per clang/gcc the alignment of `inner` is 4 on x86.
         assert_eq!(rusti::min_align_of::<Inner>(), m::align());
@@ -66,6 +66,6 @@ pub fn main() {
         // because `inner`s alignment was 4.
         assert_eq!(mem::size_of::<Outer>(), m::size());
 
-        assert_eq!(y, "Outer { c8: 22, t: Inner { c64: 44 } }".to_string());
+        assert_eq!(y, "Outer { c8: 22u8, t: Inner { c64: 44u32 } }".to_string());
     }
 }
diff --git a/src/test/run-pass/rec-align-u64.rs b/src/test/run-pass/rec-align-u64.rs
index c3cec77a646..27941542d00 100644
--- a/src/test/run-pass/rec-align-u64.rs
+++ b/src/test/run-pass/rec-align-u64.rs
@@ -82,11 +82,11 @@ pub fn main() {
     unsafe {
         let x = Outer {c8: 22u8, t: Inner {c64: 44u64}};
 
-        let y = format!("{}", x);
+        let y = format!("{:?}", x);
 
-        println!("align inner = {}", rusti::min_align_of::<Inner>());
-        println!("size outer = {}", mem::size_of::<Outer>());
-        println!("y = {}", y);
+        println!("align inner = {:?}", rusti::min_align_of::<Inner>());
+        println!("size outer = {:?}", mem::size_of::<Outer>());
+        println!("y = {:?}", y);
 
         // per clang/gcc the alignment of `Inner` is 4 on x86.
         assert_eq!(rusti::min_align_of::<Inner>(), m::m::align());
@@ -95,6 +95,6 @@ pub fn main() {
         // because `Inner`s alignment was 4.
         assert_eq!(mem::size_of::<Outer>(), m::m::size());
 
-        assert_eq!(y, "Outer { c8: 22, t: Inner { c64: 44 } }".to_string());
+        assert_eq!(y, "Outer { c8: 22u8, t: Inner { c64: 44u64 } }".to_string());
     }
 }
diff --git a/src/test/run-pass/regions-infer-bivariance.rs b/src/test/run-pass/regions-infer-bivariance.rs
index 8b9d6af1017..a3288e2e1b9 100644
--- a/src/test/run-pass/regions-infer-bivariance.rs
+++ b/src/test/run-pass/regions-infer-bivariance.rs
@@ -11,7 +11,7 @@
 // Test that a type whose lifetime parameters is never used is
 // inferred to be bivariant.
 
-use std::kinds::marker;
+use std::marker;
 
 struct Bivariant<'a>;
 
diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index 0781822cb74..e854a732632 100644
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -16,8 +16,8 @@ pub fn main() {
 
     print!("[");
     for xi in x.iter() {
-        print!("{}, ", (*xi)[]);
+        print!("{}, ", &xi[]);
     }
     println!("]");
-    println!("{}", y[]);
+    println!("{}", &y[]);
 }
diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs
index a67b24f8b1e..57f72b23adf 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -37,7 +37,7 @@ pub fn main() {
         let a = r(i);
         let b = (a, 10i);
         let (c, _d) = b;
-        println!("{}", c);
+        println!("{:?}", c);
     }
     assert_eq!(i.get(), 1);
 }
diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs
index 6f807fc3499..d6c25672cdb 100644
--- a/src/test/run-pass/running-with-no-runtime.rs
+++ b/src/test/run-pass/running-with-no-runtime.rs
@@ -57,7 +57,7 @@ fn start(argc: int, argv: *const *const u8) -> int {
 
 fn pass(output: ProcessOutput) {
     if !output.status.success() {
-        println!("{}", str::from_utf8(output.output.as_slice()));
-        println!("{}", str::from_utf8(output.error.as_slice()));
+        println!("{:?}", str::from_utf8(output.output.as_slice()));
+        println!("{:?}", str::from_utf8(output.error.as_slice()));
     }
 }
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 3ed835dc5bd..a6e4716c3b8 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -22,7 +22,7 @@ fn test05() {
         println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
-    Thread::spawn(move|| {
+    Thread::scoped(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 246957a4f46..b8bb3b4e7f8 100644
--- a/src/test/run-pass/sepcomp-unwind.rs
+++ b/src/test/run-pass/sepcomp-unwind.rs
@@ -36,5 +36,5 @@ mod b {
 }
 
 fn main() {
-    Thread::spawn(move|| { ::b::g() }).join().unwrap_err();
+    Thread::scoped(move|| { ::b::g() }).join().unwrap_err();
 }
diff --git a/src/test/run-pass/show-boxed-slice.rs b/src/test/run-pass/show-boxed-slice.rs
index 2273c399c9a..e0d005a485b 100644
--- a/src/test/run-pass/show-boxed-slice.rs
+++ b/src/test/run-pass/show-boxed-slice.rs
@@ -12,5 +12,5 @@
 struct Foo(Box<[u8]>);
 
 pub fn main() {
-    println!("{}", Foo(box [0, 1, 2]));
+    println!("{:?}", Foo(box [0, 1, 2]));
 }
diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs
index f03b4609637..05f318b53c2 100644
--- a/src/test/run-pass/slice-2.rs
+++ b/src/test/run-pass/slice-2.rs
@@ -15,57 +15,57 @@
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
-    assert!(x[] == cmp);
+    assert!(&x[] == cmp);
     let cmp: &[int] = &[3, 4, 5];
-    assert!(x[2..] == cmp);
+    assert!(&x[2..] == cmp);
     let cmp: &[int] = &[1, 2, 3];
-    assert!(x[..3] == cmp);
+    assert!(&x[0..3] == cmp);
     let cmp: &[int] = &[2, 3, 4];
-    assert!(x[1..4] == cmp);
+    assert!(&x[1..4] == cmp);
 
     let x: Vec<int> = vec![1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
-    assert!(x[] == cmp);
+    assert!(&x[] == cmp);
     let cmp: &[int] = &[3, 4, 5];
-    assert!(x[2..] == cmp);
+    assert!(&x[2..] == cmp);
     let cmp: &[int] = &[1, 2, 3];
-    assert!(x[..3] == cmp);
+    assert!(&x[0..3] == cmp);
     let cmp: &[int] = &[2, 3, 4];
-    assert!(x[1..4] == cmp);
+    assert!(&x[1..4] == cmp);
 
     let x: &mut [int] = &mut [1, 2, 3, 4, 5];
     {
         let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
-        assert!(x[mut] == cmp);
+        assert!(&mut x[] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [3, 4, 5];
-        assert!(x[mut 2..] == cmp);
+        assert!(&mut x[2..] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [1, 2, 3];
-        assert!(x[mut ..3] == cmp);
+        assert!(&mut x[..3] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [2, 3, 4];
-        assert!(x[mut 1..4] == cmp);
+        assert!(&mut x[1..4] == cmp);
     }
 
     let mut x: Vec<int> = vec![1, 2, 3, 4, 5];
     {
         let cmp: &mut [int] = &mut [1, 2, 3, 4, 5];
-        assert!(x[mut] == cmp);
+        assert!(&mut x[] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [3, 4, 5];
-        assert!(x[mut 2..] == cmp);
+        assert!(&mut x[2..] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [1, 2, 3];
-        assert!(x[mut ..3] == cmp);
+        assert!(&mut x[..3] == cmp);
     }
     {
         let cmp: &mut [int] = &mut [2, 3, 4];
-        assert!(x[mut 1..4] == cmp);
+        assert!(&mut x[1..4] == cmp);
     }
 }
diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs
index 13f2971871b..8b9a3f10a60 100644
--- a/src/test/run-pass/slice-panic-1.rs
+++ b/src/test/run-pass/slice-panic-1.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test that is a slicing expr[..] fails, the correct cleanups happen.
+// Test that if a slicing expr[..] fails, the correct cleanups happen.
 
 #![feature(slicing_syntax)]
 
@@ -24,10 +24,10 @@ impl Drop for Foo {
 
 fn foo() {
     let x: &[_] = &[Foo, Foo];
-    x[3..4];
+    &x[3..4];
 }
 
 fn main() {
-    let _ = Thread::spawn(move|| foo()).join();
+    let _ = Thread::scoped(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 ccbb33d7768..94a0530bffb 100644
--- a/src/test/run-pass/slice-panic-2.rs
+++ b/src/test/run-pass/slice-panic-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test that is a slicing expr[..] fails, the correct cleanups happen.
+// Test that if a slicing expr[..] fails, the correct cleanups happen.
 
 #![feature(slicing_syntax)]
 
@@ -28,10 +28,10 @@ fn bar() -> uint {
 
 fn foo() {
     let x: &[_] = &[Foo, Foo];
-    x[3..bar()];
+    &x[3..bar()];
 }
 
 fn main() {
-    let _ = Thread::spawn(move|| foo()).join();
+    let _ = Thread::scoped(move|| foo()).join();
     unsafe { assert!(DTOR_COUNT == 2); }
 }
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index f863c4d330f..fca7daeb07d 100644
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -11,61 +11,84 @@
 // Test slicing sugar.
 
 #![feature(slicing_syntax)]
+#![feature(associated_types)]
 
 extern crate core;
-use core::ops::{Slice,SliceMut};
+use core::ops::{Index, Range, RangeTo, RangeFrom, FullRange};
 
 static mut COUNT: uint = 0;
 
 struct Foo;
 
-impl Slice<Foo, Foo> for Foo {
-    fn as_slice_<'a>(&'a self) -> &'a Foo {
+impl Index<Range<Foo>> for Foo {
+    type Output = Foo;
+    fn index(&self, index: &Range<Foo>) -> &Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_from_or_fail<'a>(&'a self, _from: &Foo) -> &'a Foo {
+}
+impl Index<RangeTo<Foo>> for Foo {
+    type Output = Foo;
+    fn index(&self, index: &RangeTo<Foo>) -> &Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_to_or_fail<'a>(&'a self, _to: &Foo) -> &'a Foo {
+}
+impl Index<RangeFrom<Foo>> for Foo {
+    type Output = Foo;
+    fn index(&self, index: &RangeFrom<Foo>) -> &Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_or_fail<'a>(&'a self, _from: &Foo, _to: &Foo) -> &'a Foo {
+}
+impl Index<FullRange> for Foo {
+    type Output = Foo;
+    fn index(&self, _index: &FullRange) -> &Foo {
         unsafe { COUNT += 1; }
         self
     }
 }
 
-impl SliceMut<Foo, Foo> for Foo {
-    fn as_mut_slice_<'a>(&'a mut self) -> &'a mut Foo {
+impl IndexMut<Range<Foo>> for Foo {
+    type Output = Foo;
+    fn index_mut(&mut self, index: &Range<Foo>) -> &mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_from_or_fail_mut<'a>(&'a mut self, _from: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<RangeTo<Foo>> for Foo {
+    type Output = Foo;
+    fn index_mut(&mut self, index: &RangeTo<Foo>) -> &mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_to_or_fail_mut<'a>(&'a mut self, _to: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<RangeFrom<Foo>> for Foo {
+    type Output = Foo;
+    fn index_mut(&mut self, index: &RangeFrom<Foo>) -> &mut Foo {
         unsafe { COUNT += 1; }
         self
     }
-    fn slice_or_fail_mut<'a>(&'a mut self, _from: &Foo, _to: &Foo) -> &'a mut Foo {
+}
+impl IndexMut<FullRange> for Foo {
+    type Output = Foo;
+    fn index_mut(&mut self, _index: &FullRange) -> &mut Foo {
         unsafe { COUNT += 1; }
         self
     }
 }
+
+
 fn main() {
     let mut x = Foo;
-    x[];
-    x[Foo..];
-    x[..Foo];
-    x[Foo..Foo];
-    x[mut];
-    x[mut Foo..];
-    x[mut ..Foo];
-    x[mut Foo..Foo];
+    &x[];
+    &x[Foo..];
+    &x[..Foo];
+    &x[Foo..Foo];
+    &mut x[];
+    &mut x[Foo..];
+    &mut x[..Foo];
+    &mut x[Foo..Foo];
     unsafe {
         assert!(COUNT == 8);
     }
diff --git a/src/test/run-pass/small-enums-with-fields.rs b/src/test/run-pass/small-enums-with-fields.rs
index 46daa659430..c793deaae2b 100644
--- a/src/test/run-pass/small-enums-with-fields.rs
+++ b/src/test/run-pass/small-enums-with-fields.rs
@@ -20,8 +20,8 @@ macro_rules! check {
             static S: $t = $e;
             let v: $t = $e;
             assert_eq!(S, v);
-            assert_eq!(format!("{}", v).as_slice(), $s);
-            assert_eq!(format!("{}", S).as_slice(), $s);
+            assert_eq!(format!("{:?}", v).as_slice(), $s);
+            assert_eq!(format!("{:?}", S).as_slice(), $s);
         });*
     }}
 }
@@ -29,14 +29,14 @@ macro_rules! check {
 pub fn main() {
     check!(Option<u8>, 2,
            None, "None",
-           Some(129u8), "Some(129)");
+           Some(129u8), "Some(129u8)");
     check!(Option<i16>, 4,
            None, "None",
-           Some(-20000i16), "Some(-20000)");
+           Some(-20000i16), "Some(-20000i16)");
     check!(Either<u8, i8>, 2,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-32i8), "Right(-32)");
+           Either::Left(132u8), "Left(132u8)",
+           Either::Right(-32i8), "Right(-32i8)");
     check!(Either<u8, i16>, 4,
-           Either::Left(132u8), "Left(132)",
-           Either::Right(-20000i16), "Right(-20000)");
+           Either::Left(132u8), "Left(132u8)",
+           Either::Right(-20000i16), "Right(-20000i16)");
 }
diff --git a/src/test/run-pass/spawn-types.rs b/src/test/run-pass/spawn-types.rs
index bb9de7cecc9..eaad2abe8f7 100644
--- a/src/test/run-pass/spawn-types.rs
+++ b/src/test/run-pass/spawn-types.rs
@@ -25,6 +25,6 @@ fn iotask(_tx: &ctx, ip: String) {
 
 pub fn main() {
     let (tx, _rx) = channel::<int>();
-    let t = Thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
+    let t = Thread::scoped(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 820dd49142a..8f937afa6b9 100644
--- a/src/test/run-pass/spawn.rs
+++ b/src/test/run-pass/spawn.rs
@@ -11,7 +11,7 @@
 use std::thread::Thread;
 
 pub fn main() {
-    Thread::spawn(move|| child(10)).join().ok().unwrap();
+    Thread::scoped(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 50c2d79132e..75104a4ddef 100644
--- a/src/test/run-pass/spawn2.rs
+++ b/src/test/run-pass/spawn2.rs
@@ -11,7 +11,7 @@
 use std::thread::Thread;
 
 pub fn main() {
-    let t = Thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
+    let t = Thread::scoped(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
     t.join().ok().unwrap();
 }
 
diff --git a/src/test/run-pass/spawning-with-debug.rs b/src/test/run-pass/spawning-with-debug.rs
index ea594977f90..858b7a83c62 100644
--- a/src/test/run-pass/spawning-with-debug.rs
+++ b/src/test/run-pass/spawning-with-debug.rs
@@ -17,5 +17,5 @@ use std::thread::Builder;
 
 pub fn main() {
     let mut t = Builder::new();
-    t.spawn(move|| ()).detach();
+    t.spawn(move|| ());
 }
diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs
index 2757439828d..7cba4533c7f 100644
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -12,208 +12,208 @@ extern crate libc;
 
 pub fn main() {
   let f = 1u as *const libc::FILE;
-  println!("{}", f as int);
-  println!("{}", f as uint);
-  println!("{}", f as i8);
-  println!("{}", f as i16);
-  println!("{}", f as i32);
-  println!("{}", f as i64);
-  println!("{}", f as u8);
-  println!("{}", f as u16);
-  println!("{}", f as u32);
-  println!("{}", f as u64);
-
-  println!("{}", 1 as int);
-  println!("{}", 1 as uint);
-  println!("{}", 1 as *const libc::FILE);
-  println!("{}", 1 as i8);
-  println!("{}", 1 as i16);
-  println!("{}", 1 as i32);
-  println!("{}", 1 as i64);
-  println!("{}", 1 as u8);
-  println!("{}", 1 as u16);
-  println!("{}", 1 as u32);
-  println!("{}", 1 as u64);
-  println!("{}", 1i as f32);
-  println!("{}", 1i as f64);
-
-  println!("{}", 1u as int);
-  println!("{}", 1u as uint);
-  println!("{}", 1u as *const libc::FILE);
-  println!("{}", 1u as i8);
-  println!("{}", 1u as i16);
-  println!("{}", 1u as i32);
-  println!("{}", 1u as i64);
-  println!("{}", 1u as u8);
-  println!("{}", 1u as u16);
-  println!("{}", 1u as u32);
-  println!("{}", 1u as u64);
-  println!("{}", 1u as f32);
-  println!("{}", 1u as f64);
-
-  println!("{}", 1i8 as int);
-  println!("{}", 1i8 as uint);
-  println!("{}", 1i8 as *const libc::FILE);
-  println!("{}", 1i8 as i8);
-  println!("{}", 1i8 as i16);
-  println!("{}", 1i8 as i32);
-  println!("{}", 1i8 as i64);
-  println!("{}", 1i8 as u8);
-  println!("{}", 1i8 as u16);
-  println!("{}", 1i8 as u32);
-  println!("{}", 1i8 as u64);
-  println!("{}", 1i8 as f32);
-  println!("{}", 1i8 as f64);
-
-  println!("{}", 1u8 as int);
-  println!("{}", 1u8 as uint);
-  println!("{}", 1u8 as *const libc::FILE);
-  println!("{}", 1u8 as i8);
-  println!("{}", 1u8 as i16);
-  println!("{}", 1u8 as i32);
-  println!("{}", 1u8 as i64);
-  println!("{}", 1u8 as u8);
-  println!("{}", 1u8 as u16);
-  println!("{}", 1u8 as u32);
-  println!("{}", 1u8 as u64);
-  println!("{}", 1u8 as f32);
-  println!("{}", 1u8 as f64);
-
-  println!("{}", 1i16 as int);
-  println!("{}", 1i16 as uint);
-  println!("{}", 1i16 as *const libc::FILE);
-  println!("{}", 1i16 as i8);
-  println!("{}", 1i16 as i16);
-  println!("{}", 1i16 as i32);
-  println!("{}", 1i16 as i64);
-  println!("{}", 1i16 as u8);
-  println!("{}", 1i16 as u16);
-  println!("{}", 1i16 as u32);
-  println!("{}", 1i16 as u64);
-  println!("{}", 1i16 as f32);
-  println!("{}", 1i16 as f64);
-
-  println!("{}", 1u16 as int);
-  println!("{}", 1u16 as uint);
-  println!("{}", 1u16 as *const libc::FILE);
-  println!("{}", 1u16 as i8);
-  println!("{}", 1u16 as i16);
-  println!("{}", 1u16 as i32);
-  println!("{}", 1u16 as i64);
-  println!("{}", 1u16 as u8);
-  println!("{}", 1u16 as u16);
-  println!("{}", 1u16 as u32);
-  println!("{}", 1u16 as u64);
-  println!("{}", 1u16 as f32);
-  println!("{}", 1u16 as f64);
-
-  println!("{}", 1i32 as int);
-  println!("{}", 1i32 as uint);
-  println!("{}", 1i32 as *const libc::FILE);
-  println!("{}", 1i32 as i8);
-  println!("{}", 1i32 as i16);
-  println!("{}", 1i32 as i32);
-  println!("{}", 1i32 as i64);
-  println!("{}", 1i32 as u8);
-  println!("{}", 1i32 as u16);
-  println!("{}", 1i32 as u32);
-  println!("{}", 1i32 as u64);
-  println!("{}", 1i32 as f32);
-  println!("{}", 1i32 as f64);
-
-  println!("{}", 1u32 as int);
-  println!("{}", 1u32 as uint);
-  println!("{}", 1u32 as *const libc::FILE);
-  println!("{}", 1u32 as i8);
-  println!("{}", 1u32 as i16);
-  println!("{}", 1u32 as i32);
-  println!("{}", 1u32 as i64);
-  println!("{}", 1u32 as u8);
-  println!("{}", 1u32 as u16);
-  println!("{}", 1u32 as u32);
-  println!("{}", 1u32 as u64);
-  println!("{}", 1u32 as f32);
-  println!("{}", 1u32 as f64);
-
-  println!("{}", 1i64 as int);
-  println!("{}", 1i64 as uint);
-  println!("{}", 1i64 as *const libc::FILE);
-  println!("{}", 1i64 as i8);
-  println!("{}", 1i64 as i16);
-  println!("{}", 1i64 as i32);
-  println!("{}", 1i64 as i64);
-  println!("{}", 1i64 as u8);
-  println!("{}", 1i64 as u16);
-  println!("{}", 1i64 as u32);
-  println!("{}", 1i64 as u64);
-  println!("{}", 1i64 as f32);
-  println!("{}", 1i64 as f64);
-
-  println!("{}", 1u64 as int);
-  println!("{}", 1u64 as uint);
-  println!("{}", 1u64 as *const libc::FILE);
-  println!("{}", 1u64 as i8);
-  println!("{}", 1u64 as i16);
-  println!("{}", 1u64 as i32);
-  println!("{}", 1u64 as i64);
-  println!("{}", 1u64 as u8);
-  println!("{}", 1u64 as u16);
-  println!("{}", 1u64 as u32);
-  println!("{}", 1u64 as u64);
-  println!("{}", 1u64 as f32);
-  println!("{}", 1u64 as f64);
-
-  println!("{}", 1u64 as int);
-  println!("{}", 1u64 as uint);
-  println!("{}", 1u64 as *const libc::FILE);
-  println!("{}", 1u64 as i8);
-  println!("{}", 1u64 as i16);
-  println!("{}", 1u64 as i32);
-  println!("{}", 1u64 as i64);
-  println!("{}", 1u64 as u8);
-  println!("{}", 1u64 as u16);
-  println!("{}", 1u64 as u32);
-  println!("{}", 1u64 as u64);
-  println!("{}", 1u64 as f32);
-  println!("{}", 1u64 as f64);
-
-  println!("{}", true as int);
-  println!("{}", true as uint);
-  println!("{}", true as *const libc::FILE);
-  println!("{}", true as i8);
-  println!("{}", true as i16);
-  println!("{}", true as i32);
-  println!("{}", true as i64);
-  println!("{}", true as u8);
-  println!("{}", true as u16);
-  println!("{}", true as u32);
-  println!("{}", true as u64);
-  println!("{}", true as f32);
-  println!("{}", true as f64);
-
-  println!("{}", 1f32 as int);
-  println!("{}", 1f32 as uint);
-  println!("{}", 1f32 as i8);
-  println!("{}", 1f32 as i16);
-  println!("{}", 1f32 as i32);
-  println!("{}", 1f32 as i64);
-  println!("{}", 1f32 as u8);
-  println!("{}", 1f32 as u16);
-  println!("{}", 1f32 as u32);
-  println!("{}", 1f32 as u64);
-  println!("{}", 1f32 as f32);
-  println!("{}", 1f32 as f64);
-
-  println!("{}", 1f64 as int);
-  println!("{}", 1f64 as uint);
-  println!("{}", 1f64 as i8);
-  println!("{}", 1f64 as i16);
-  println!("{}", 1f64 as i32);
-  println!("{}", 1f64 as i64);
-  println!("{}", 1f64 as u8);
-  println!("{}", 1f64 as u16);
-  println!("{}", 1f64 as u32);
-  println!("{}", 1f64 as u64);
-  println!("{}", 1f64 as f32);
-  println!("{}", 1f64 as f64);
+  println!("{:?}", f as int);
+  println!("{:?}", f as uint);
+  println!("{:?}", f as i8);
+  println!("{:?}", f as i16);
+  println!("{:?}", f as i32);
+  println!("{:?}", f as i64);
+  println!("{:?}", f as u8);
+  println!("{:?}", f as u16);
+  println!("{:?}", f as u32);
+  println!("{:?}", f as u64);
+
+  println!("{:?}", 1 as int);
+  println!("{:?}", 1 as uint);
+  println!("{:?}", 1 as *const libc::FILE);
+  println!("{:?}", 1 as i8);
+  println!("{:?}", 1 as i16);
+  println!("{:?}", 1 as i32);
+  println!("{:?}", 1 as i64);
+  println!("{:?}", 1 as u8);
+  println!("{:?}", 1 as u16);
+  println!("{:?}", 1 as u32);
+  println!("{:?}", 1 as u64);
+  println!("{:?}", 1i as f32);
+  println!("{:?}", 1i as f64);
+
+  println!("{:?}", 1u as int);
+  println!("{:?}", 1u as uint);
+  println!("{:?}", 1u as *const libc::FILE);
+  println!("{:?}", 1u as i8);
+  println!("{:?}", 1u as i16);
+  println!("{:?}", 1u as i32);
+  println!("{:?}", 1u as i64);
+  println!("{:?}", 1u as u8);
+  println!("{:?}", 1u as u16);
+  println!("{:?}", 1u as u32);
+  println!("{:?}", 1u as u64);
+  println!("{:?}", 1u as f32);
+  println!("{:?}", 1u as f64);
+
+  println!("{:?}", 1i8 as int);
+  println!("{:?}", 1i8 as uint);
+  println!("{:?}", 1i8 as *const libc::FILE);
+  println!("{:?}", 1i8 as i8);
+  println!("{:?}", 1i8 as i16);
+  println!("{:?}", 1i8 as i32);
+  println!("{:?}", 1i8 as i64);
+  println!("{:?}", 1i8 as u8);
+  println!("{:?}", 1i8 as u16);
+  println!("{:?}", 1i8 as u32);
+  println!("{:?}", 1i8 as u64);
+  println!("{:?}", 1i8 as f32);
+  println!("{:?}", 1i8 as f64);
+
+  println!("{:?}", 1u8 as int);
+  println!("{:?}", 1u8 as uint);
+  println!("{:?}", 1u8 as *const libc::FILE);
+  println!("{:?}", 1u8 as i8);
+  println!("{:?}", 1u8 as i16);
+  println!("{:?}", 1u8 as i32);
+  println!("{:?}", 1u8 as i64);
+  println!("{:?}", 1u8 as u8);
+  println!("{:?}", 1u8 as u16);
+  println!("{:?}", 1u8 as u32);
+  println!("{:?}", 1u8 as u64);
+  println!("{:?}", 1u8 as f32);
+  println!("{:?}", 1u8 as f64);
+
+  println!("{:?}", 1i16 as int);
+  println!("{:?}", 1i16 as uint);
+  println!("{:?}", 1i16 as *const libc::FILE);
+  println!("{:?}", 1i16 as i8);
+  println!("{:?}", 1i16 as i16);
+  println!("{:?}", 1i16 as i32);
+  println!("{:?}", 1i16 as i64);
+  println!("{:?}", 1i16 as u8);
+  println!("{:?}", 1i16 as u16);
+  println!("{:?}", 1i16 as u32);
+  println!("{:?}", 1i16 as u64);
+  println!("{:?}", 1i16 as f32);
+  println!("{:?}", 1i16 as f64);
+
+  println!("{:?}", 1u16 as int);
+  println!("{:?}", 1u16 as uint);
+  println!("{:?}", 1u16 as *const libc::FILE);
+  println!("{:?}", 1u16 as i8);
+  println!("{:?}", 1u16 as i16);
+  println!("{:?}", 1u16 as i32);
+  println!("{:?}", 1u16 as i64);
+  println!("{:?}", 1u16 as u8);
+  println!("{:?}", 1u16 as u16);
+  println!("{:?}", 1u16 as u32);
+  println!("{:?}", 1u16 as u64);
+  println!("{:?}", 1u16 as f32);
+  println!("{:?}", 1u16 as f64);
+
+  println!("{:?}", 1i32 as int);
+  println!("{:?}", 1i32 as uint);
+  println!("{:?}", 1i32 as *const libc::FILE);
+  println!("{:?}", 1i32 as i8);
+  println!("{:?}", 1i32 as i16);
+  println!("{:?}", 1i32 as i32);
+  println!("{:?}", 1i32 as i64);
+  println!("{:?}", 1i32 as u8);
+  println!("{:?}", 1i32 as u16);
+  println!("{:?}", 1i32 as u32);
+  println!("{:?}", 1i32 as u64);
+  println!("{:?}", 1i32 as f32);
+  println!("{:?}", 1i32 as f64);
+
+  println!("{:?}", 1u32 as int);
+  println!("{:?}", 1u32 as uint);
+  println!("{:?}", 1u32 as *const libc::FILE);
+  println!("{:?}", 1u32 as i8);
+  println!("{:?}", 1u32 as i16);
+  println!("{:?}", 1u32 as i32);
+  println!("{:?}", 1u32 as i64);
+  println!("{:?}", 1u32 as u8);
+  println!("{:?}", 1u32 as u16);
+  println!("{:?}", 1u32 as u32);
+  println!("{:?}", 1u32 as u64);
+  println!("{:?}", 1u32 as f32);
+  println!("{:?}", 1u32 as f64);
+
+  println!("{:?}", 1i64 as int);
+  println!("{:?}", 1i64 as uint);
+  println!("{:?}", 1i64 as *const libc::FILE);
+  println!("{:?}", 1i64 as i8);
+  println!("{:?}", 1i64 as i16);
+  println!("{:?}", 1i64 as i32);
+  println!("{:?}", 1i64 as i64);
+  println!("{:?}", 1i64 as u8);
+  println!("{:?}", 1i64 as u16);
+  println!("{:?}", 1i64 as u32);
+  println!("{:?}", 1i64 as u64);
+  println!("{:?}", 1i64 as f32);
+  println!("{:?}", 1i64 as f64);
+
+  println!("{:?}", 1u64 as int);
+  println!("{:?}", 1u64 as uint);
+  println!("{:?}", 1u64 as *const libc::FILE);
+  println!("{:?}", 1u64 as i8);
+  println!("{:?}", 1u64 as i16);
+  println!("{:?}", 1u64 as i32);
+  println!("{:?}", 1u64 as i64);
+  println!("{:?}", 1u64 as u8);
+  println!("{:?}", 1u64 as u16);
+  println!("{:?}", 1u64 as u32);
+  println!("{:?}", 1u64 as u64);
+  println!("{:?}", 1u64 as f32);
+  println!("{:?}", 1u64 as f64);
+
+  println!("{:?}", 1u64 as int);
+  println!("{:?}", 1u64 as uint);
+  println!("{:?}", 1u64 as *const libc::FILE);
+  println!("{:?}", 1u64 as i8);
+  println!("{:?}", 1u64 as i16);
+  println!("{:?}", 1u64 as i32);
+  println!("{:?}", 1u64 as i64);
+  println!("{:?}", 1u64 as u8);
+  println!("{:?}", 1u64 as u16);
+  println!("{:?}", 1u64 as u32);
+  println!("{:?}", 1u64 as u64);
+  println!("{:?}", 1u64 as f32);
+  println!("{:?}", 1u64 as f64);
+
+  println!("{:?}", true as int);
+  println!("{:?}", true as uint);
+  println!("{:?}", true as *const libc::FILE);
+  println!("{:?}", true as i8);
+  println!("{:?}", true as i16);
+  println!("{:?}", true as i32);
+  println!("{:?}", true as i64);
+  println!("{:?}", true as u8);
+  println!("{:?}", true as u16);
+  println!("{:?}", true as u32);
+  println!("{:?}", true as u64);
+  println!("{:?}", true as f32);
+  println!("{:?}", true as f64);
+
+  println!("{:?}", 1f32 as int);
+  println!("{:?}", 1f32 as uint);
+  println!("{:?}", 1f32 as i8);
+  println!("{:?}", 1f32 as i16);
+  println!("{:?}", 1f32 as i32);
+  println!("{:?}", 1f32 as i64);
+  println!("{:?}", 1f32 as u8);
+  println!("{:?}", 1f32 as u16);
+  println!("{:?}", 1f32 as u32);
+  println!("{:?}", 1f32 as u64);
+  println!("{:?}", 1f32 as f32);
+  println!("{:?}", 1f32 as f64);
+
+  println!("{:?}", 1f64 as int);
+  println!("{:?}", 1f64 as uint);
+  println!("{:?}", 1f64 as i8);
+  println!("{:?}", 1f64 as i16);
+  println!("{:?}", 1f64 as i32);
+  println!("{:?}", 1f64 as i64);
+  println!("{:?}", 1f64 as u8);
+  println!("{:?}", 1f64 as u16);
+  println!("{:?}", 1f64 as u32);
+  println!("{:?}", 1f64 as u64);
+  println!("{:?}", 1f64 as f32);
+  println!("{:?}", 1f64 as f64);
 }
diff --git a/src/test/run-pass/syntax-trait-polarity.rs b/src/test/run-pass/syntax-trait-polarity.rs
index 021cfedf06f..a91e5da1537 100644
--- a/src/test/run-pass/syntax-trait-polarity.rs
+++ b/src/test/run-pass/syntax-trait-polarity.rs
@@ -10,7 +10,7 @@
 
 #![feature(optin_builtin_traits)]
 
-use std::kinds::Send;
+use std::marker::Send;
 
 struct TestType;
 
diff --git a/src/test/run-pass/tag-align-shape.rs b/src/test/run-pass/tag-align-shape.rs
index 8438a5ff47f..b88357252d8 100644
--- a/src/test/run-pass/tag-align-shape.rs
+++ b/src/test/run-pass/tag-align-shape.rs
@@ -21,7 +21,7 @@ struct t_rec {
 
 pub fn main() {
     let x = t_rec {c8: 22u8, t: a_tag::a_tag_var(44u64)};
-    let y = format!("{}", x);
-    println!("y = {}", y);
-    assert_eq!(y, "t_rec { c8: 22, t: a_tag_var(44) }".to_string());
+    let y = format!("{:?}", x);
+    println!("y = {:?}", y);
+    assert_eq!(y, "t_rec { c8: 22u8, t: a_tag_var(44u64) }".to_string());
 }
diff --git a/src/test/run-pass/tag-disr-val-shape.rs b/src/test/run-pass/tag-disr-val-shape.rs
index 1155a619a60..049e4bb9a38 100644
--- a/src/test/run-pass/tag-disr-val-shape.rs
+++ b/src/test/run-pass/tag-disr-val-shape.rs
@@ -18,9 +18,9 @@ enum color {
 }
 
 pub fn main() {
-    let act = format!("{}", color::red);
+    let act = format!("{:?}", color::red);
     println!("{}", act);
     assert_eq!("red".to_string(), act);
-    assert_eq!("green".to_string(), format!("{}", color::green));
-    assert_eq!("white".to_string(), format!("{}", color::white));
+    assert_eq!("green".to_string(), format!("{:?}", color::green));
+    assert_eq!("white".to_string(), format!("{:?}", color::white));
 }
diff --git a/src/test/run-pass/task-comm-1.rs b/src/test/run-pass/task-comm-1.rs
index 966bb6aa735..180f6e09ba9 100644
--- a/src/test/run-pass/task-comm-1.rs
+++ b/src/test/run-pass/task-comm-1.rs
@@ -15,6 +15,6 @@ pub fn main() { test00(); }
 fn start() { println!("Started / Finished task."); }
 
 fn test00() {
-    let _ = Thread::spawn(move|| start() ).join();
+    let _ = Thread::scoped(move|| start() ).join();
     println!("Completing.");
 }
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index 561c9e91553..da080408ad1 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -16,7 +16,7 @@ fn start(_task_number: int) { println!("Started / Finished task."); }
 
 fn test00() {
     let i: int = 0;
-    let mut result = Thread::spawn(move|| {
+    let mut result = Thread::scoped(move|| {
         start(i)
     });
 
diff --git a/src/test/run-pass/task-comm-13.rs b/src/test/run-pass/task-comm-13.rs
index 50667d375a1..429c6ce9fb3 100644
--- a/src/test/run-pass/task-comm-13.rs
+++ b/src/test/run-pass/task-comm-13.rs
@@ -19,6 +19,6 @@ fn start(tx: &Sender<int>, start: int, number_of_messages: int) {
 pub fn main() {
     println!("Check that we don't deadlock.");
     let (tx, rx) = channel();
-    let _ = Thread::spawn(move|| { start(&tx, 0, 10) }).join();
+    let _ = Thread::scoped(move|| { start(&tx, 0, 10) }).join();
     println!("Joined task");
 }
diff --git a/src/test/run-pass/task-comm-14.rs b/src/test/run-pass/task-comm-14.rs
index 82e4bd8f6d2..0735e3996ee 100644
--- a/src/test/run-pass/task-comm-14.rs
+++ b/src/test/run-pass/task-comm-14.rs
@@ -19,7 +19,7 @@ pub fn main() {
     while (i > 0) {
         println!("{}", i);
         let tx = tx.clone();
-        Thread::spawn({let i = i; move|| { child(i, &tx) }}).detach();
+        Thread::spawn({let i = i; move|| { child(i, &tx) }});
         i = i - 1;
     }
 
diff --git a/src/test/run-pass/task-comm-17.rs b/src/test/run-pass/task-comm-17.rs
index e9f7cdf96a8..9db5465f7e9 100644
--- a/src/test/run-pass/task-comm-17.rs
+++ b/src/test/run-pass/task-comm-17.rs
@@ -18,5 +18,5 @@ fn f() {
 }
 
 pub fn main() {
-    let _t = Thread::spawn(move|| f() ).join();
+    let _t = Thread::scoped(move|| f() ).join();
 }
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index a002a597481..306cc0ffcef 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -40,7 +40,7 @@ fn test00() {
     let mut results = Vec::new();
     while i < number_of_tasks {
         let tx = tx.clone();
-        results.push(Thread::spawn({
+        results.push(Thread::scoped({
             let i = i;
             move|| {
                 test00_start(&tx, i, number_of_messages)
diff --git a/src/test/run-pass/task-comm-9.rs b/src/test/run-pass/task-comm-9.rs
index d9faf6ee4e4..6d8de4a6a53 100644
--- a/src/test/run-pass/task-comm-9.rs
+++ b/src/test/run-pass/task-comm-9.rs
@@ -24,7 +24,7 @@ fn test00() {
     let (tx, rx) = channel();
     let number_of_messages: int = 10;
 
-    let result = Thread::spawn(move|| {
+    let result = Thread::scoped(move|| {
         test00_start(&tx, number_of_messages);
     });
 
diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs
index a7eabe0edb3..7ff5960375c 100644
--- a/src/test/run-pass/task-stderr.rs
+++ b/src/test/run-pass/task-stderr.rs
@@ -17,7 +17,7 @@ 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>).spawn(move|| -> () {
+    let res = thread::Builder::new().stderr(box stderr as Box<Writer + Send>).scoped(move|| -> () {
         panic!("Hello, world!")
     }).join();
     assert!(res.is_err());
diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs
index 3e6158ca821..cd3cb872fd3 100644
--- a/src/test/run-pass/tcp-accept-stress.rs
+++ b/src/test/run-pass/tcp-accept-stress.rs
@@ -52,7 +52,7 @@ fn test() {
                 }
             }
             srv_tx.send(());
-        }).detach();
+        });
     }
 
     for _ in range(0, N) {
@@ -62,7 +62,7 @@ fn test() {
                 let _s = TcpStream::connect(addr).unwrap();
             }
             cli_tx.send(());
-        }).detach();
+        });
     }
     drop((cli_tx, srv_tx));
 
diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs
index 7d226aa9420..0109d64ad53 100644
--- a/src/test/run-pass/tcp-stress.rs
+++ b/src/test/run-pass/tcp-stress.rs
@@ -29,7 +29,7 @@ fn main() {
         timer::sleep(Duration::milliseconds(30 * 1000));
         println!("timed out!");
         unsafe { libc::exit(1) }
-    }).detach();
+    });
 
     let (tx, rx) = channel();
     Thread::spawn(move || -> () {
@@ -47,7 +47,7 @@ fn main() {
             stream.read_byte();
             stream.write(&[2]);
         }
-    }).detach();
+    });
     let addr = rx.recv().unwrap();
 
     let (tx, rx) = channel();
@@ -64,7 +64,7 @@ fn main() {
                 Err(e) => debug!("{}", e)
             }
             tx.send(()).unwrap();
-        }).detach();
+        });
     }
 
     // Wait for all clients to exit, but don't wait for the server to exit. The
diff --git a/src/test/run-pass/tempfile.rs b/src/test/run-pass/tempfile.rs
index bf108ecd676..b931bd9609c 100644
--- a/src/test/run-pass/tempfile.rs
+++ b/src/test/run-pass/tempfile.rs
@@ -42,7 +42,7 @@ fn test_rm_tempdir() {
         tx.send(tmp.path().clone()).unwrap();
         panic!("panic to unwind past `tmp`");
     };
-    let _ = Thread::spawn(f).join();
+    let _ = Thread::scoped(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::spawn(f).join();
+    let _ = Thread::scoped(f).join();
     assert!(!path.exists());
 
     let path;
@@ -60,7 +60,7 @@ fn test_rm_tempdir() {
         let f = move|:| {
             TempDir::new("test_rm_tempdir").unwrap()
         };
-        let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+        let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
         path = tmp.path().clone();
         assert!(path.exists());
     }
@@ -84,7 +84,7 @@ fn test_rm_tempdir_close() {
         tmp.close();
         panic!("panic when unwinding past `tmp`");
     };
-    let _ = Thread::spawn(f).join();
+    let _ = Thread::scoped(f).join();
     let path = rx.recv().unwrap();
     assert!(!path.exists());
 
@@ -95,7 +95,7 @@ fn test_rm_tempdir_close() {
         tmp.close();
         panic!("panic when unwinding past `tmp`");
     };
-    let _ = Thread::spawn(f).join();
+    let _ = Thread::scoped(f).join();
     assert!(!path.exists());
 
     let path;
@@ -103,7 +103,7 @@ fn test_rm_tempdir_close() {
         let f = move|:| {
             TempDir::new("test_rm_tempdir").unwrap()
         };
-        let tmp = Thread::spawn(f).join().ok().expect("test_rm_tmdir");
+        let tmp = Thread::scoped(f).join().ok().expect("test_rm_tmdir");
         path = tmp.path().clone();
         assert!(path.exists());
         tmp.close();
@@ -177,7 +177,7 @@ pub fn test_rmdir_recursive_ok() {
 }
 
 pub fn dont_double_panic() {
-    let r: Result<(), _> = Thread::spawn(move|| {
+    let r: Result<(), _> = Thread::scoped(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 4270ecc7450..bfd1f5f4a74 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -22,13 +22,13 @@ fn test_ret() { let _x: Box<int> = return; }
 
 fn test_panic() {
     fn f() { let _x: Box<int> = panic!(); }
-    Thread::spawn(move|| f() ).join().err().unwrap();
+    Thread::scoped(move|| f() ).join().err().unwrap();
 }
 
 fn test_panic_indirect() {
     fn f() -> ! { panic!(); }
     fn g() { let _x: Box<int> = f(); }
-    Thread::spawn(move|| g() ).join().err().unwrap();
+    Thread::scoped(move|| g() ).join().err().unwrap();
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index 02817a285dd..c47ca0db2a1 100644
--- a/src/test/run-pass/threads.rs
+++ b/src/test/run-pass/threads.rs
@@ -13,7 +13,7 @@ use std::thread::Thread;
 pub fn main() {
     let mut i = 10;
     while i > 0 {
-        Thread::spawn({let i = i; move|| child(i)}).detach();
+        Thread::spawn({let i = i; move|| child(i)});
         i = i - 1;
     }
     println!("main thread exiting");
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index 6bece8265c0..df8efb42e30 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -19,5 +19,5 @@ pub fn main() {
     let (tx, rx) = channel();
     tx.send(42i);
     let r = rx.recv();
-    println!("{}", r);
+    println!("{:?}", r);
 }
diff --git a/src/test/run-pass/tuple-struct-construct.rs b/src/test/run-pass/tuple-struct-construct.rs
index 5bf152f2976..d7a78dbc411 100644
--- a/src/test/run-pass/tuple-struct-construct.rs
+++ b/src/test/run-pass/tuple-struct-construct.rs
@@ -13,5 +13,5 @@ struct Foo(int, int);
 
 pub fn main() {
     let x = Foo(1, 2);
-    println!("{}", x);
+    println!("{:?}", x);
 }
diff --git a/src/test/run-pass/tydesc-name.rs b/src/test/run-pass/tydesc-name.rs
index 4f473755cb6..e3b148ac92d 100644
--- a/src/test/run-pass/tydesc-name.rs
+++ b/src/test/run-pass/tydesc-name.rs
@@ -17,7 +17,7 @@ struct Foo<T> {
 
 pub fn main() {
     unsafe {
-        assert_eq!((*get_tydesc::<int>()).name, "int");
-        assert_eq!((*get_tydesc::<Foo<uint>>()).name, "Foo<uint>");
+        assert_eq!((*get_tydesc::<int>()).name, "isize");
+        assert_eq!((*get_tydesc::<Foo<uint>>()).name, "Foo<usize>");
     }
 }
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index bd4143348b8..bb3019ede4b 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -23,7 +23,7 @@ pub fn main() {
         let tx = tx.clone();
         Thread::spawn(move|| {
             child(&tx, i)
-        }).detach();
+        });
         expected += i;
     }
 
diff --git a/src/test/run-pass/unit-like-struct-drop-run.rs b/src/test/run-pass/unit-like-struct-drop-run.rs
index 9aeb5b10cf5..4c866503282 100644
--- a/src/test/run-pass/unit-like-struct-drop-run.rs
+++ b/src/test/run-pass/unit-like-struct-drop-run.rs
@@ -22,7 +22,7 @@ impl Drop for Foo {
 }
 
 pub fn main() {
-    let x = Thread::spawn(move|| {
+    let x = Thread::scoped(move|| {
         let _b = Foo;
     }).join();
 
diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs
index bdd62995e0a..29bf82a81d6 100644
--- a/src/test/run-pass/vector-sort-panic-safe.rs
+++ b/src/test/run-pass/vector-sort-panic-safe.rs
@@ -77,7 +77,7 @@ pub fn main() {
 
                 let v = main.clone();
 
-                let _ = Thread::spawn(move|| {
+                let _ = Thread::scoped(move|| {
                     let mut v = v;
                     let mut panic_countdown = panic_countdown;
                     v.as_mut_slice().sort_by(|a, b| {
diff --git a/src/test/run-pass/where-clauses-not-parameter.rs b/src/test/run-pass/where-clauses-not-parameter.rs
deleted file mode 100644
index bc5fc388ca1..00000000000
--- a/src/test/run-pass/where-clauses-not-parameter.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn equal<T>(_: &T, _: &T) -> bool where int : Eq {
-    true
-}
-
-fn main() {
-    equal(&0i, &0i);
-}
diff --git a/src/test/run-pass/yield.rs b/src/test/run-pass/yield.rs
index 9a96b483f2c..9ad6dd9d2b1 100644
--- a/src/test/run-pass/yield.rs
+++ b/src/test/run-pass/yield.rs
@@ -11,7 +11,7 @@
 use std::thread::Thread;
 
 pub fn main() {
-    let mut result = Thread::spawn(child);
+    let mut result = Thread::scoped(child);
     println!("1");
     Thread::yield_now();
     println!("2");
diff --git a/src/test/run-pass/yield1.rs b/src/test/run-pass/yield1.rs
index 13119e5d909..3d3a36021da 100644
--- a/src/test/run-pass/yield1.rs
+++ b/src/test/run-pass/yield1.rs
@@ -11,7 +11,7 @@
 use std::thread::Thread;
 
 pub fn main() {
-    let mut result = Thread::spawn(child);
+    let mut result = Thread::scoped(child);
     println!("1");
     Thread::yield_now();
     result.join();