diff --git a/configure b/configure
index ea9320c901b6d..61c737e0fd3af 100755
--- a/configure
+++ b/configure
@@ -599,6 +599,18 @@ then
 fi
 putvar CFG_RELEASE_CHANNEL
 
+# A magic value that allows the compiler to use unstable features
+# during the bootstrap even when doing so would normally be an error
+# because of feature staging or because the build turns on
+# warnings-as-errors and unstable features default to warnings.  The
+# build has to match this key in an env var. Meant to be a mild
+# deterrent from users just turning on unstable features on the stable
+# channel.
+# Basing CFG_BOOTSTRAP_KEY on CFG_BOOTSTRAP_KEY lets it get picked up
+# during a Makefile reconfig.
+CFG_BOOTSTRAP_KEY="${CFG_BOOTSTRAP_KEY-`date +%N`}"
+putvar CFG_BOOTSTRAP_KEY
+
 step_msg "looking for build programs"
 
 probe_need CFG_PERL        perl
diff --git a/mk/main.mk b/mk/main.mk
index a97e68af59b38..99aecc34be973 100644
--- a/mk/main.mk
+++ b/mk/main.mk
@@ -25,11 +25,13 @@ ifeq ($(CFG_RELEASE_CHANNEL),stable)
 CFG_RELEASE=$(CFG_RELEASE_NUM)
 # This is the string used in dist artifact file names, e.g. "0.12.0", "nightly"
 CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)
+CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),beta)
 # The beta channel is temporarily called 'alpha'
 CFG_RELEASE=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE)
 CFG_PACKAGE_VERS=$(CFG_RELEASE_NUM)-alpha$(CFG_BETA_CYCLE)
+CFG_DISABLE_UNSTABLE_FEATURES=1
 endif
 ifeq ($(CFG_RELEASE_CHANNEL),nightly)
 CFG_RELEASE=$(CFG_RELEASE_NUM)-nightly
@@ -121,11 +123,9 @@ CFG_JEMALLOC_FLAGS += $(JEMALLOC_FLAGS)
 
 ifdef CFG_DISABLE_DEBUG
   CFG_RUSTC_FLAGS += --cfg ndebug
-  CFG_GCCISH_CFLAGS += -DRUST_NDEBUG
 else
   $(info cfg: enabling more debugging (CFG_ENABLE_DEBUG))
   CFG_RUSTC_FLAGS += --cfg debug
-  CFG_GCCISH_CFLAGS += -DRUST_DEBUG
 endif
 
 ifdef SAVE_TEMPS
@@ -319,11 +319,20 @@ export CFG_VERSION_WIN
 export CFG_RELEASE
 export CFG_PACKAGE_NAME
 export CFG_BUILD
+export CFG_RELEASE_CHANNEL
 export CFG_LLVM_ROOT
 export CFG_PREFIX
 export CFG_LIBDIR
 export CFG_LIBDIR_RELATIVE
 export CFG_DISABLE_INJECT_STD_VERSION
+ifdef CFG_DISABLE_UNSTABLE_FEATURES
+CFG_INFO := $(info cfg: disabling unstable features (CFG_DISABLE_UNSTABLE_FEATURES))
+# Turn on feature-staging
+export CFG_DISABLE_UNSTABLE_FEATURES
+endif
+# Subvert unstable feature lints to do the self-build
+export CFG_BOOTSTRAP_KEY
+export RUSTC_BOOTSTRAP_KEY:=$(CFG_BOOTSTRAP_KEY)
 
 ######################################################################
 # Per-stage targets and runner
diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs
index e2420b0a22024..9a5665e683934 100644
--- a/src/compiletest/compiletest.rs
+++ b/src/compiletest/compiletest.rs
@@ -9,7 +9,9 @@
 // except according to those terms.
 
 #![crate_type = "bin"]
+#![allow(unknown_features)]
 #![feature(slicing_syntax, unboxed_closures)]
+#![feature(box_syntax)]
 
 #![deny(warnings)]
 
diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index f8e2ba4828f38..5de93c5202922 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -908,8 +908,7 @@ fn check_error_patterns(props: &TestProps,
     }
     if done { return; }
 
-    let missing_patterns =
-        props.error_patterns.index(&(next_err_idx..));
+    let missing_patterns = &props.error_patterns[next_err_idx..];
     if missing_patterns.len() == 1u {
         fatal_proc_rec(format!("error pattern '{}' not found!",
                               missing_patterns[0]).as_slice(),
diff --git a/src/doc/footer.inc b/src/doc/footer.inc
index 4e7d60586f23d..f32f2fd443f8e 100644
--- a/src/doc/footer.inc
+++ b/src/doc/footer.inc
@@ -1,5 +1,5 @@
 <footer><p>
-Copyright &copy; 2011-2014 The Rust Project Developers. Licensed under the
+Copyright &copy; 2011-2015 The Rust Project Developers. Licensed under the
 <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>
 or the <a href="http://opensource.org/licenses/MIT">MIT license</a>, at your option.
 </p><p>
diff --git a/src/doc/guide-error-handling.md b/src/doc/guide-error-handling.md
index d241e77f810c7..98b46511f0458 100644
--- a/src/doc/guide-error-handling.md
+++ b/src/doc/guide-error-handling.md
@@ -147,10 +147,10 @@ for all but the most trivial of situations.
 Here's an example of using `Result`:
 
 ```rust
-#[deriving(Show)]
+#[derive(Show)]
 enum Version { Version1, Version2 }
 
-#[deriving(Show)]
+#[derive(Show)]
 enum ParseError { InvalidHeaderLength, InvalidVersion }
 
 fn parse_version(header: &[u8]) -> Result<Version, ParseError> {
diff --git a/src/doc/guide-ffi.md b/src/doc/guide-ffi.md
index 7ee1c1a7032a5..1f12c05f37e34 100644
--- a/src/doc/guide-ffi.md
+++ b/src/doc/guide-ffi.md
@@ -262,6 +262,7 @@ referenced Rust object.
 Rust code:
 
 ~~~~no_run
+# use std::boxed::Box;
 
 #[repr(C)]
 struct RustObject {
@@ -286,7 +287,7 @@ extern {
 
 fn main() {
     // Create the object that will be referenced in the callback
-    let mut rust_object = box RustObject { a: 5 };
+    let mut rust_object = Box::new(RustObject { a: 5 });
 
     unsafe {
         register_callback(&mut *rust_object, callback);
diff --git a/src/doc/guide-ownership.md b/src/doc/guide-ownership.md
index 414a874082eef..3db4da73f932e 100644
--- a/src/doc/guide-ownership.md
+++ b/src/doc/guide-ownership.md
@@ -81,27 +81,29 @@ therefore deallocates the memory for you. Here's the equivalent example in
 Rust:
 
 ```rust
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 }
 ```
 
-The `box` keyword creates a `Box<T>` (specifically `Box<int>` in this case) by
-allocating a small segment of memory on the heap with enough space to fit an
-`int`. But where in the code is the box deallocated? We said before that we
-must have a deallocation for each allocation. Rust handles this for you. It
+The `Box::new` function creates a `Box<T>` (specifically `Box<int>` in this
+case) by allocating a small segment of memory on the heap with enough space to
+fit an `int`. But where in the code is the box deallocated? We said before that
+we must have a deallocation for each allocation. Rust handles this for you. It
 knows that our handle, `x`, is the owning reference to our box. Rust knows that
 `x` will go out of scope at the end of the block, and so it inserts a call to
 deallocate the memory at the end of the scope. Because the compiler does this
-for us, it's impossible to forget. We always have exactly one deallocation paired
-with each of our allocations.
+for us, it's impossible to forget. We always have exactly one deallocation
+  paired with each of our allocations.
 
 This is pretty straightforward, but what happens when we want to pass our box
 to a function? Let's look at some code:
 
 ```rust
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     add_one(x);
 }
@@ -115,8 +117,9 @@ This code works, but it's not ideal. For example, let's add one more line of
 code, where we print out the value of `x`:
 
 ```{rust,ignore}
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     add_one(x);
 
@@ -148,8 +151,9 @@ To fix this, we can have `add_one` give ownership back when it's done with the
 box:
 
 ```rust
+# use std::boxed::Box;
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     let y = add_one(x);
 
@@ -458,7 +462,7 @@ lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust
 will do three things to determine what those lifetimes should be.
 
 When talking about lifetime elision, we use the term 'input lifetime' and
-'output lifetime'. An 'input liftime' is a lifetime associated with a parameter
+'output lifetime'. An 'input lifetime' is a lifetime associated with a parameter
 of a function, and an 'output lifetime' is a lifetime associated with the return
 value of a function. For example, this function has an input lifetime:
 
diff --git a/src/doc/guide-pointers.md b/src/doc/guide-pointers.md
index 14e33ab0f74a9..4c35fae3ecc51 100644
--- a/src/doc/guide-pointers.md
+++ b/src/doc/guide-pointers.md
@@ -455,12 +455,13 @@ fn rc_succ(x: Rc<int>) -> int { *x + 1 }
 Note that the caller of your function will have to modify their calls slightly:
 
 ```{rust}
+# use std::boxed::Box;
 use std::rc::Rc;
 
 fn succ(x: &int) -> int { *x + 1 }
 
 let ref_x = &5i;
-let box_x = box 5i;
+let box_x = Box::new(5i);
 let rc_x  = Rc::new(5i);
 
 succ(ref_x);
@@ -477,24 +478,17 @@ those contents.
 heap allocation in Rust. Creating a box looks like this:
 
 ```{rust}
-let x = box(std::boxed::HEAP) 5i;
+# use std::boxed::Box;
+let x = Box::new(5i);
 ```
 
-`box` is a keyword that does 'placement new,' which we'll talk about in a bit.
-`box` will be useful for creating a number of heap-allocated types, but is not
-quite finished yet. In the meantime, `box`'s type defaults to
-`std::boxed::HEAP`, and so you can leave it off:
-
-```{rust}
-let x = box 5i;
-```
-
-As you might assume from the `HEAP`, boxes are heap allocated. They are
-deallocated automatically by Rust when they go out of scope:
+Boxes are heap allocated and they are deallocated automatically by Rust when
+they go out of scope:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     // stuff happens
 
@@ -513,8 +507,9 @@ You don't need to fully grok the theory of affine types or regions to grok
 boxes, though. As a rough approximation, you can treat this Rust code:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     // stuff happens
 }
@@ -553,12 +548,13 @@ for more detail on how lifetimes work.
 Using boxes and references together is very common. For example:
 
 ```{rust}
+# use std::boxed::Box;
 fn add_one(x: &int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x));
 }
@@ -570,12 +566,13 @@ function, and since it's only reading the value, allows it.
 We can borrow `x` multiple times, as long as it's not simultaneous:
 
 ```{rust}
+# use std::boxed::Box;
 fn add_one(x: &int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x));
     println!("{}", add_one(&*x));
@@ -586,12 +583,13 @@ fn main() {
 Or as long as it's not a mutable borrow. This will error:
 
 ```{rust,ignore}
+# use std::boxed::Box;
 fn add_one(x: &mut int) -> int {
     *x + 1
 }
 
 fn main() {
-    let x = box 5i;
+    let x = Box::new(5i);
 
     println!("{}", add_one(&*x)); // error: cannot borrow immutable dereference
                                   // of `&`-pointer as mutable
@@ -612,14 +610,15 @@ Sometimes, you need a recursive data structure. The simplest is known as a
 
 
 ```{rust}
-#[deriving(Show)]
+# use std::boxed::Box;
+#[derive(Show)]
 enum List<T> {
     Cons(T, Box<List<T>>),
     Nil,
 }
 
 fn main() {
-    let list: List<int> = List::Cons(1, box List::Cons(2, box List::Cons(3, box List::Nil)));
+    let list: List<int> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Cons(3, Box::new(List::Nil))))));
     println!("{:?}", list);
 }
 ```
@@ -627,7 +626,7 @@ fn main() {
 This prints:
 
 ```text
-Cons(1, box Cons(2, box Cons(3, box Nil)))
+Cons(1, Box(Cons(2, Box(Cons(3, Box(Nil))))))
 ```
 
 The reference to another `List` inside of the `Cons` enum variant must be a box,
@@ -667,6 +666,7 @@ In many languages with pointers, you'd return a pointer from a function
 so as to avoid copying a large data structure. For example:
 
 ```{rust}
+# use std::boxed::Box;
 struct BigStruct {
     one: int,
     two: int,
@@ -675,15 +675,15 @@ struct BigStruct {
 }
 
 fn foo(x: Box<BigStruct>) -> Box<BigStruct> {
-    return box *x;
+    return Box::new(*x);
 }
 
 fn main() {
-    let x = box BigStruct {
+    let x = Box::new(BigStruct {
         one: 1,
         two: 2,
         one_hundred: 100,
-    };
+    });
 
     let y = foo(x);
 }
@@ -695,6 +695,7 @@ than the hundred `int`s that make up the `BigStruct`.
 This is an antipattern in Rust. Instead, write this:
 
 ```{rust}
+# use std::boxed::Box;
 struct BigStruct {
     one: int,
     two: int,
@@ -707,13 +708,13 @@ fn foo(x: Box<BigStruct>) -> BigStruct {
 }
 
 fn main() {
-    let x = box BigStruct {
+    let x = Box::new(BigStruct {
         one: 1,
         two: 2,
         one_hundred: 100,
-    };
+    });
 
-    let y = box foo(x);
+    let y = Box::new(foo(x));
 }
 ```
 
diff --git a/src/doc/guide-unsafe.md b/src/doc/guide-unsafe.md
index 11bc0bc30f20e..25ca07ad74fe8 100644
--- a/src/doc/guide-unsafe.md
+++ b/src/doc/guide-unsafe.md
@@ -197,6 +197,7 @@ extern crate libc;
 use libc::{c_void, size_t, malloc, free};
 use std::mem;
 use std::ptr;
+# use std::boxed::Box;
 
 // Define a wrapper around the handle returned by the foreign code.
 // Unique<T> has the same semantics as Box<T>
@@ -265,7 +266,7 @@ impl<T: Send> Drop for Unique<T> {
 // A comparison between the built-in `Box` and this reimplementation
 fn main() {
     {
-        let mut x = box 5i;
+        let mut x = Box::new(5i);
         *x = 10;
     } // `x` is freed here
 
@@ -653,7 +654,7 @@ sugar for dynamic allocations via `malloc` and `free`:
 
 ```
 #![no_std]
-#![feature(lang_items)]
+#![feature(lang_items, box_syntax)]
 
 extern crate libc;
 
diff --git a/src/doc/guide.md b/src/doc/guide.md
index f736ef821fa37..5ab3063033fc2 100644
--- a/src/doc/guide.md
+++ b/src/doc/guide.md
@@ -3802,18 +3802,19 @@ enum List {             // error: illegal recursive enum type
 
 But the compiler complains that the type is recursive, that is, it could be
 arbitrarily large. To remedy this, Rust provides a fixed-size container called
-a **box** that can hold any type. You can box up any value with the `box`
-keyword. Our boxed List gets the type `Box<List>` (more on the notation when we
+a **Box** that can hold any type. You can box up any value with the `Box::new`
+function. Our boxed List gets the type `Box<List>` (more on the notation when we
 get to generics):
 
 ```{rust}
+# use std::boxed::Box;
 enum List {
     Node(u32, Box<List>),
     Nil
 }
 
 fn main() {
-    let list = List::Node(0, box List::Node(1, box List::Nil));
+    let list = List::Node(0, Box::new(List::Node(1, Box::new(List::Nil))));
 }
 ```
 
@@ -3826,8 +3827,9 @@ just like regular references. This (rather silly) example dynamically allocates
 an integer `5` and makes `x` a pointer to it:
 
 ```{rust}
+# use std::boxed::Box;
 {
-    let x = box 5;
+    let x = Box::new(5);
     println!("{}", *x);     // Prints 5
 }
 ```
@@ -3858,7 +3860,8 @@ Boxes are the sole owner of their contents, so you cannot take a mutable
 reference to them and then use the original box:
 
 ```{rust,ignore}
-let mut x = box 5;
+# use std::boxed::Box;
+let mut x = Box::new(5);
 let y = &mut x;
 
 *x; // you might expect 5, but this is actually an error
@@ -3879,7 +3882,8 @@ As long as `y` is borrowing the contents, we cannot use `x`. After `y` is
 done borrowing the value, we can use it again. This works fine:
 
 ```{rust}
-let mut x = box 5;
+# use std::boxed::Box;
+let mut x = Box::new(5);
 
 {
     let y = &mut x;
diff --git a/src/doc/intro.md b/src/doc/intro.md
index fbc96a577a41a..ffe33f41bc733 100644
--- a/src/doc/intro.md
+++ b/src/doc/intro.md
@@ -542,7 +542,7 @@ use std::thread::Thread;
 fn main() {
     let vec = vec![1i, 2, 3];
 
-    for i in range(1u, 3) {
+    for i in range(0u, 3) {
         Thread::spawn(move || {
             println!("{}", vec[i]);
         }).detach();
@@ -558,7 +558,7 @@ a vector:
 ```{rust}
 let vec = vec![1i, 2, 3];
 
-for i in range(1u, vec.len()) {
+for i in range(0u, vec.len()) {
      println!("{}", vec[i]);
 }
 ```
diff --git a/src/doc/reference.md b/src/doc/reference.md
index febd5f883d14d..804b6b9f63cf0 100644
--- a/src/doc/reference.md
+++ b/src/doc/reference.md
@@ -1588,10 +1588,11 @@ pointer values (pointing to a type for which an implementation of the given
 trait is in scope) to pointers to the trait name, used as a type.
 
 ```
+# use std::boxed::Box;
 # trait Shape { }
 # impl Shape for int { }
 # let mycircle = 0i;
-let myshape: Box<Shape> = box mycircle as Box<Shape>;
+let myshape: Box<Shape> = Box::new(mycircle) as Box<Shape>;
 ```
 
 The resulting value is a box containing the value that was cast, along with
@@ -1646,12 +1647,13 @@ fn radius_times_area<T: Circle>(c: T) -> f64 {
 Likewise, supertrait methods may also be called on trait objects.
 
 ```{.ignore}
+# use std::boxed::Box;
 # trait Shape { fn area(&self) -> f64; }
 # trait Circle : Shape { fn radius(&self) -> f64; }
 # impl Shape for int { fn area(&self) -> f64 { 0.0 } }
 # impl Circle for int { fn radius(&self) -> f64 { 0.0 } }
 # let mycircle = 0;
-let mycircle = box mycircle as Box<Circle>;
+let mycircle = Box::new(mycircle) as Box<Circle>;
 let nonsense = mycircle.radius() * mycircle.area();
 ```
 
@@ -3376,14 +3378,17 @@ stands for a *single* data field, whereas a wildcard `..` stands for *all* the
 fields of a particular variant. For example:
 
 ```
+#![feature(box_syntax)]
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+fn main() {
+    let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
 
-match x {
-    List::Cons(_, box List::Nil) => panic!("singleton list"),
-    List::Cons(..)               => return,
-    List::Nil                    => panic!("empty list")
+    match x {
+        List::Cons(_, box List::Nil) => panic!("singleton list"),
+        List::Cons(..)               => return,
+        List::Nil                    => panic!("empty list")
+    }
 }
 ```
 
@@ -3436,25 +3441,28 @@ the inside of the match.
 An example of a `match` expression:
 
 ```
+#![feature(box_syntax)]
 # fn process_pair(a: int, b: int) { }
 # fn process_ten() { }
 
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 
-let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
+fn main() {
+    let x: List<int> = List::Cons(10, box List::Cons(11, box List::Nil));
 
-match x {
-    List::Cons(a, box List::Cons(b, _)) => {
-        process_pair(a, b);
-    }
-    List::Cons(10, _) => {
-        process_ten();
-    }
-    List::Nil => {
-        return;
-    }
-    _ => {
-        panic!();
+    match x {
+        List::Cons(a, box List::Cons(b, _)) => {
+            process_pair(a, b);
+        }
+        List::Cons(10, _) => {
+            process_ten();
+        }
+        List::Nil => {
+            return;
+        }
+        _ => {
+            panic!();
+        }
     }
 }
 ```
@@ -3468,6 +3476,8 @@ Subpatterns can also be bound to variables by the use of the syntax `variable @
 subpattern`. For example:
 
 ```
+#![feature(box_syntax)]
+
 enum List { Nil, Cons(uint, Box<List>) }
 
 fn is_sorted(list: &List) -> bool {
@@ -3781,12 +3791,13 @@ enclosing `enum` or `struct` type itself. Such recursion has restrictions:
 An example of a *recursive* type and its use:
 
 ```
+# use std::boxed::Box;
 enum List<T> {
-  Nil,
-  Cons(T, Box<List<T>>)
+    Nil,
+    Cons(T, Box<List<T>>)
 }
 
-let a: List<int> = List::Cons(7, box List::Cons(13, box List::Nil));
+let a: List<int> = List::Cons(7, Box::new(List::Cons(13, Box::new(List::Nil))));
 ```
 
 ### Pointer types
@@ -3893,6 +3904,7 @@ implementation of `R`, and the pointer value of `E`.
 An example of an object type:
 
 ```
+# use std::boxed::Box;
 trait Printable {
   fn stringify(&self) -> String;
 }
@@ -3906,7 +3918,7 @@ fn print(a: Box<Printable>) {
 }
 
 fn main() {
-   print(box 10i as Box<Printable>);
+   print(Box::new(10i) as Box<Printable>);
 }
 ```
 
@@ -4100,7 +4112,8 @@ the type of a box is `std::owned::Box<T>`.
 An example of a box type and value:
 
 ```
-let x: Box<int> = box 10;
+# use std::boxed::Box;
+let x: Box<int> = Box::new(10);
 ```
 
 Box values exist in 1:1 correspondence with their heap allocation, copying a
@@ -4109,7 +4122,8 @@ copy of a box to move ownership of the value. After a value has been moved,
 the source location cannot be used unless it is reinitialized.
 
 ```
-let x: Box<int> = box 10;
+# use std::boxed::Box;
+let x: Box<int> = Box::new(10);
 let y = x;
 // attempting to use `x` will result in an error here
 ```
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 5d47602b5e15c..48136bc1d96e2 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -67,21 +67,20 @@
 //! }
 //! ```
 
+use core::prelude::*;
+
 use core::atomic;
 use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
 use core::borrow::BorrowFrom;
-use core::clone::Clone;
 use core::fmt::{self, Show};
-use core::cmp::{Eq, Ord, PartialEq, PartialOrd, Ordering};
+use core::cmp::{Ordering};
 use core::default::Default;
-use core::marker::{Sync, Send};
-use core::mem::{min_align_of, size_of, drop};
+use core::mem::{min_align_of, size_of};
 use core::mem;
 use core::nonzero::NonZero;
-use core::ops::{Drop, Deref};
-use core::option::Option;
-use core::option::Option::{Some, None};
-use core::ptr::{self, PtrExt};
+use core::ops::Deref;
+use core::ptr;
+use core::hash::{Hash, Hasher};
 use heap::deallocate;
 
 /// An atomically reference counted wrapper for shared state.
@@ -585,12 +584,25 @@ impl<T: fmt::Show> fmt::Show for Arc<T> {
     }
 }
 
+#[stable]
+impl<T: fmt::String> fmt::String for Arc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::String::fmt(&**self, f)
+    }
+}
+
 #[stable]
 impl<T: Default + Sync + Send> Default for Arc<T> {
     #[stable]
     fn default() -> Arc<T> { Arc::new(Default::default()) }
 }
 
+impl<H: Hasher, T: Hash<H>> Hash<H> for Arc<T> {
+    fn hash(&self, state: &mut H) {
+        (**self).hash(state)
+    }
+}
+
 #[cfg(test)]
 #[allow(experimental)]
 mod tests {
diff --git a/src/liballoc/boxed.rs b/src/liballoc/boxed.rs
index d46f18abf97b4..97b198164ebd8 100644
--- a/src/liballoc/boxed.rs
+++ b/src/liballoc/boxed.rs
@@ -1,4 +1,4 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -33,12 +33,15 @@ use core::ops::{Deref, DerefMut};
 /// The following two examples are equivalent:
 ///
 /// ```rust
+/// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
+/// fn main() {
 /// # struct Bar;
 /// # impl Bar { fn new(_a: int) { } }
-/// let foo = box(HEAP) Bar::new(2);
-/// let foo = box Bar::new(2);
+///     let foo = box(HEAP) Bar::new(2);
+///     let foo = box Bar::new(2);
+/// }
 /// ```
 #[lang = "exchange_heap"]
 #[experimental = "may be renamed; uncertain about custom allocator design"]
@@ -49,6 +52,14 @@ pub static HEAP: () = ();
 #[stable]
 pub struct Box<T>(Unique<T>);
 
+impl<T> Box<T> {
+    /// Moves `x` into a freshly allocated box on the global exchange heap.
+    #[stable]
+    pub fn new(x: T) -> Box<T> {
+        box x
+    }
+}
+
 #[stable]
 impl<T: Default> Default for Box<T> {
     #[stable]
@@ -102,16 +113,24 @@ impl<T: ?Sized + Ord> Ord for Box<T> {
     fn cmp(&self, other: &Box<T>) -> Ordering {
         Ord::cmp(&**self, &**other)
     }
-
-#[stable]}
+}
+#[stable]
 impl<T: ?Sized + Eq> Eq for Box<T> {}
 
+#[cfg(stage0)]
 impl<S: hash::Writer, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
         (**self).hash(state);
     }
 }
+#[cfg(not(stage0))]
+impl<S: hash::Hasher, T: ?Sized + Hash<S>> Hash<S> for Box<T> {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
+    }
+}
 
 /// Extension methods for an owning `Any` trait object.
 #[unstable = "post-DST and coherence changes, this will not be a trait but \
@@ -149,6 +168,7 @@ impl<T: ?Sized + fmt::Show> fmt::Show for Box<T> {
     }
 }
 
+#[stable]
 impl<T: ?Sized + fmt::String> fmt::String for Box<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(&**self, f)
@@ -177,27 +197,27 @@ impl<T: ?Sized> DerefMut for Box<T> {
 mod test {
     #[test]
     fn test_owned_clone() {
-        let a = box 5i;
+        let a = Box::new(5i);
         let b: Box<int> = a.clone();
         assert!(a == b);
     }
 
     #[test]
     fn any_move() {
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
+        let a = Box::new(8u) as Box<Any>;
+        let b = Box::new(Test) as Box<Any>;
 
         match a.downcast::<uint>() {
-            Ok(a) => { assert!(a == box 8u); }
+            Ok(a) => { assert!(a == Box::new(8u)); }
             Err(..) => panic!()
         }
         match b.downcast::<Test>() {
-            Ok(a) => { assert!(a == box Test); }
+            Ok(a) => { assert!(a == Box::new(Test)); }
             Err(..) => panic!()
         }
 
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
+        let a = Box::new(8u) as Box<Any>;
+        let b = Box::new(Test) as Box<Any>;
 
         assert!(a.downcast::<Box<Test>>().is_err());
         assert!(b.downcast::<Box<uint>>().is_err());
@@ -205,8 +225,8 @@ mod test {
 
     #[test]
     fn test_show() {
-        let a = box 8u as Box<Any>;
-        let b = box Test as Box<Any>;
+        let a = Box::new(8u) as Box<Any>;
+        let b = Box::new(Test) as Box<Any>;
         let a_str = a.to_str();
         let b_str = b.to_str();
         assert_eq!(a_str, "Box<Any>");
@@ -223,6 +243,6 @@ mod test {
     #[test]
     fn deref() {
         fn homura<T: Deref<Target=i32>>(_: T) { }
-        homura(box 765i32);
+        homura(Box::new(765i32));
     }
 }
diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
index c57435cdc8c0c..02933c763efe5 100644
--- a/src/liballoc/heap.rs
+++ b/src/liballoc/heap.rs
@@ -115,16 +115,20 @@ unsafe fn exchange_free(ptr: *mut u8, old_size: uint, align: uint) {
 // The minimum alignment guaranteed by the architecture. This value is used to
 // add fast paths for low alignment values. In practice, the alignment is a
 // constant at the call site and the branch will be optimized out.
-#[cfg(any(target_arch = "arm",
-          target_arch = "mips",
-          target_arch = "mipsel"))]
+#[cfg(all(not(feature = "external_funcs"),
+          not(feature = "external_crate"),
+          any(target_arch = "arm",
+              target_arch = "mips",
+              target_arch = "mipsel")))]
 const MIN_ALIGN: uint = 8;
-#[cfg(any(target_arch = "x86",
-          target_arch = "x86_64",
-          target_arch = "aarch64"))]
+#[cfg(all(not(feature = "external_funcs"),
+          not(feature = "external_crate"),
+          any(target_arch = "x86",
+              target_arch = "x86_64",
+              target_arch = "aarch64")))]
 const MIN_ALIGN: uint = 16;
 
-#[cfg(external_funcs)]
+#[cfg(feature = "external_funcs")]
 mod imp {
     extern {
         fn rust_allocate(size: uint, align: uint) -> *mut u8;
@@ -142,14 +146,13 @@ mod imp {
     }
 
     #[inline]
-    pub unsafe fn reallocate_inplace(ptr: *mut u8, old_size: uint, size: uint,
-                                     align: uint) -> uint {
-        rust_reallocate_inplace(ptr, old_size, size, align)
+    pub unsafe fn deallocate(ptr: *mut u8, old_size: uint, align: uint) {
+        rust_deallocate(ptr, old_size, align)
     }
 
     #[inline]
-    pub unsafe fn deallocate(ptr: *mut u8, old_size: uint, align: uint) {
-        rust_deallocate(ptr, old_size, align)
+    pub unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 {
+        rust_reallocate(ptr, old_size, size, align)
     }
 
     #[inline]
@@ -169,14 +172,16 @@ mod imp {
     }
 }
 
-#[cfg(external_crate)]
+#[cfg(feature = "external_crate")]
 mod imp {
     extern crate external;
     pub use self::external::{allocate, deallocate, reallocate_inplace, reallocate};
     pub use self::external::{usable_size, stats_print};
 }
 
-#[cfg(all(not(external_funcs), not(external_crate), jemalloc))]
+#[cfg(all(not(feature = "external_funcs"),
+          not(feature = "external_crate"),
+          jemalloc))]
 mod imp {
     use core::option::Option;
     use core::option::Option::None;
@@ -253,7 +258,10 @@ mod imp {
     }
 }
 
-#[cfg(all(not(external_funcs), not(external_crate), not(jemalloc), unix))]
+#[cfg(all(not(feature = "external_funcs"),
+          not(feature = "external_crate"),
+          not(jemalloc),
+          unix))]
 mod imp {
     use core::cmp;
     use core::ptr;
@@ -314,7 +322,10 @@ mod imp {
     pub fn stats_print() {}
 }
 
-#[cfg(all(not(external_funcs), not(external_crate), not(jemalloc), windows))]
+#[cfg(all(not(feature = "external_funcs"),
+          not(feature = "external_crate"),
+          not(jemalloc),
+          windows))]
 mod imp {
     use libc::{c_void, size_t};
     use libc;
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index ba6e89cdd768e..0bb8ba669ec25 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -58,6 +58,7 @@
 
 #![crate_name = "alloc"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
@@ -66,9 +67,12 @@
 #![no_std]
 #![allow(unknown_features)]
 #![feature(lang_items, unsafe_destructor)]
+#![feature(box_syntax)]
 
 #[macro_use]
 extern crate core;
+
+#[cfg(all(not(feature = "external_funcs"), not(feature = "external_crate")))]
 extern crate libc;
 
 // Allow testing this library
diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs
index 67b2542771012..27b3f03002fb9 100644
--- a/src/liballoc/rc.rs
+++ b/src/liballoc/rc.rs
@@ -10,23 +10,26 @@
 
 //! Thread-local reference-counted boxes (the `Rc<T>` type).
 //!
-//! The `Rc<T>` type provides shared ownership of an immutable value. Destruction is deterministic,
-//! and will occur as soon as the last owner is gone. It is marked as non-sendable because it
-//! avoids the overhead of atomic reference counting.
+//! The `Rc<T>` type provides shared ownership of an immutable value.
+//! Destruction is deterministic, and will occur as soon as the last owner is
+//! gone. It is marked as non-sendable because it avoids the overhead of atomic
+//! reference counting.
 //!
-//! The `downgrade` method can be used to create a non-owning `Weak<T>` pointer to the box. A
-//! `Weak<T>` pointer can be upgraded to an `Rc<T>` pointer, but will return `None` if the value
-//! has already been dropped.
+//! The `downgrade` method can be used to create a non-owning `Weak<T>` pointer
+//! to the box. A `Weak<T>` pointer can be upgraded to an `Rc<T>` pointer, but
+//! will return `None` if the value has already been dropped.
 //!
-//! For example, a tree with parent pointers can be represented by putting the nodes behind strong
-//! `Rc<T>` pointers, and then storing the parent pointers as `Weak<T>` pointers.
+//! For example, a tree with parent pointers can be represented by putting the
+//! nodes behind strong `Rc<T>` pointers, and then storing the parent pointers
+//! as `Weak<T>` pointers.
 //!
 //! # Examples
 //!
-//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`.  We want to have our
-//! `Gadget`s point to their `Owner`. We can't do this with unique ownership, because more than one
-//! gadget may belong to the same `Owner`. `Rc<T>` allows us to share an `Owner` between multiple
-//! `Gadget`s, and have the `Owner` remain allocated as long as any `Gadget` points at it.
+//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`.
+//! We want to have our `Gadget`s point to their `Owner`. We can't do this with
+//! unique ownership, because more than one gadget may belong to the same
+//! `Owner`. `Rc<T>` allows us to share an `Owner` between multiple `Gadget`s,
+//! and have the `Owner` remain allocated as long as any `Gadget` points at it.
 //!
 //! ```rust
 //! use std::rc::Rc;
@@ -597,12 +600,20 @@ impl<T: Ord> Ord for Rc<T> {
 }
 
 // FIXME (#18248) Make `T` `Sized?`
+#[cfg(stage0)]
 impl<S: hash::Writer, T: Hash<S>> Hash<S> for Rc<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
         (**self).hash(state);
     }
 }
+#[cfg(not(stage0))]
+impl<S: hash::Hasher, T: Hash<S>> Hash<S> for Rc<T> {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
+    }
+}
 
 #[experimental = "Show is experimental."]
 impl<T: fmt::Show> fmt::Show for Rc<T> {
@@ -611,6 +622,13 @@ impl<T: fmt::Show> fmt::Show for Rc<T> {
     }
 }
 
+#[stable]
+impl<T: fmt::String> fmt::String for Rc<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::String::fmt(&**self, f)
+    }
+}
+
 /// A weak version of `Rc<T>`.
 ///
 /// Weak references do not count when determining if the inner value should be dropped.
diff --git a/src/libarena/lib.rs b/src/libarena/lib.rs
index 423c16bfee8e8..f208ff9dc0517 100644
--- a/src/libarena/lib.rs
+++ b/src/libarena/lib.rs
@@ -21,14 +21,17 @@
 
 #![crate_name = "arena"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(unsafe_destructor)]
 #![feature(unboxed_closures)]
+#![feature(box_syntax)]
 #![allow(missing_docs)]
 
 extern crate alloc;
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index 2154d06377a19..e922feff02bd2 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -330,7 +330,7 @@ impl Bitv {
 
         if extra_bytes > 0 {
             let mut last_word = 0u32;
-            for (i, &byte) in bytes.index(&((complete_words*4)..)).iter().enumerate() {
+            for (i, &byte) in bytes[(complete_words*4)..].iter().enumerate() {
                 last_word |= (reverse_bits(byte) as u32) << (i * 8);
             }
             bitv.storage.push(last_word);
@@ -982,7 +982,7 @@ impl fmt::Show for Bitv {
 }
 
 #[stable]
-impl<S: hash::Writer> hash::Hash<S> for Bitv {
+impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Bitv {
     fn hash(&self, state: &mut S) {
         self.nbits.hash(state);
         for elem in self.blocks() {
@@ -1742,7 +1742,7 @@ impl fmt::Show for BitvSet {
     }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for BitvSet {
+impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for BitvSet {
     fn hash(&self, state: &mut S) {
         for pos in self.iter() {
             pos.hash(state);
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index 4e44779810b29..3e1533dd35f59 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -23,7 +23,9 @@ use core::borrow::BorrowFrom;
 use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt::Show;
-use core::hash::{Writer, Hash};
+use core::hash::{Hash, Hasher};
+#[cfg(stage0)]
+use core::hash::Writer;
 use core::iter::{Map, FromIterator};
 use core::ops::{Index, IndexMut};
 use core::{iter, fmt, mem};
@@ -820,6 +822,7 @@ impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
 }
 
 #[stable]
+#[cfg(stage0)]
 impl<S: Writer, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
     fn hash(&self, state: &mut S) {
         for elt in self.iter() {
@@ -827,6 +830,15 @@ impl<S: Writer, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
         }
     }
 }
+#[stable]
+#[cfg(not(stage0))]
+impl<S: Hasher, K: Hash<S>, V: Hash<S>> Hash<S> for BTreeMap<K, V> {
+    fn hash(&self, state: &mut S) {
+        for elt in self.iter() {
+            elt.hash(state);
+        }
+    }
+}
 
 #[stable]
 impl<K: Ord, V> Default for BTreeMap<K, V> {
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
index 25df4a3cc2a6f..812cff6fab722 100644
--- a/src/libcollections/btree/set.rs
+++ b/src/libcollections/btree/set.rs
@@ -678,7 +678,7 @@ mod test {
     use prelude::*;
 
     use super::BTreeSet;
-    use std::hash;
+    use std::hash::{self, SipHasher};
 
     #[test]
     fn test_clone_eq() {
@@ -703,7 +703,7 @@ mod test {
       y.insert(2);
       y.insert(1);
 
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
     }
 
     struct Counter<'a, 'b> {
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 63ea9f7cb4322..0b426f6016cb8 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -27,7 +27,7 @@ use alloc::boxed::Box;
 use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
-use core::hash::{Writer, Hash};
+use core::hash::{Writer, Hasher, Hash};
 use core::iter::{self, FromIterator};
 use core::mem;
 use core::ptr;
@@ -675,7 +675,7 @@ impl<A: fmt::Show> fmt::Show for DList<A> {
 }
 
 #[stable]
-impl<S: Writer, A: Hash<S>> Hash<S> for DList<A> {
+impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for DList<A> {
     fn hash(&self, state: &mut S) {
         self.len().hash(state);
         for elt in self.iter() {
@@ -688,7 +688,7 @@ impl<S: Writer, A: Hash<S>> Hash<S> for DList<A> {
 mod tests {
     use prelude::*;
     use std::rand;
-    use std::hash;
+    use std::hash::{self, SipHasher};
     use std::thread::Thread;
     use test::Bencher;
     use test;
@@ -951,7 +951,7 @@ mod tests {
       let mut x = DList::new();
       let mut y = DList::new();
 
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
 
       x.push_back(1i);
       x.push_back(2);
@@ -961,7 +961,7 @@ mod tests {
       y.push_front(2);
       y.push_front(1);
 
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
     }
 
     #[test]
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index 6eab36d8844df..7692c1558a70f 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -15,6 +15,7 @@
 
 #![crate_name = "collections"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
@@ -23,8 +24,9 @@
 
 #![allow(unknown_features)]
 #![feature(unsafe_destructor, slicing_syntax)]
-#![feature(old_impl_check)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
+#![feature(old_impl_check)]
 #![no_std]
 
 #[macro_use]
@@ -101,8 +103,6 @@ mod std {
     pub use core::option;   // necessary for panic!()
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;  // deriving(Copy)
     pub use core::hash;     // deriving(Hash)
 }
diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs
index 68e2482964dbb..0ff869d618316 100644
--- a/src/libcollections/macros.rs
+++ b/src/libcollections/macros.rs
@@ -10,9 +10,10 @@
 
 /// Creates a `Vec` containing the arguments.
 #[macro_export]
+#[stable]
 macro_rules! vec {
     ($($x:expr),*) => ({
-        let xs: $crate::boxed::Box<[_]> = box [$($x),*];
+        let xs: $crate::boxed::Box<[_]> = $crate::boxed::Box::new([$($x),*]);
         $crate::slice::SliceExt::into_vec(xs)
     });
     ($($x:expr,)*) => (vec![$($x),*])
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index 42c17136a0882..c3d2267586837 100644
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -27,7 +27,7 @@ use core::ops::{Index, IndexMut};
 use core::ptr;
 use core::raw::Slice as RawSlice;
 
-use std::hash::{Writer, Hash};
+use std::hash::{Writer, Hash, Hasher};
 use std::cmp;
 
 use alloc::heap;
@@ -556,7 +556,7 @@ impl<T> RingBuf<T> {
             let buf = self.buffer_as_slice();
             if contiguous {
                 let (empty, buf) = buf.split_at(0);
-                (buf.index(&(self.tail..self.head)), empty)
+                (&buf[self.tail..self.head], empty)
             } else {
                 let (mid, right) = buf.split_at(self.tail);
                 let (left, _) = mid.split_at(self.head);
@@ -1562,7 +1562,7 @@ impl<A: Ord> Ord for RingBuf<A> {
 }
 
 #[stable]
-impl<S: Writer, A: Hash<S>> Hash<S> for RingBuf<A> {
+impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> {
     fn hash(&self, state: &mut S) {
         self.len().hash(state);
         for elt in self.iter() {
@@ -1631,7 +1631,7 @@ mod tests {
     use prelude::*;
     use core::iter;
     use std::fmt::Show;
-    use std::hash;
+    use std::hash::{self, SipHasher};
     use test::Bencher;
     use test;
 
@@ -2283,7 +2283,7 @@ mod tests {
       y.push_back(2);
       y.push_back(3);
 
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y));
     }
 
     #[test]
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 61309f0cc0fe8..cb3fbd461cdf6 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -55,7 +55,7 @@
 //! #![feature(slicing_syntax)]
 //! fn main() {
 //!     let numbers = [0i, 1i, 2i];
-//!     let last_numbers = numbers.index(&(1..3));
+//!     let last_numbers = &numbers[1..3];
 //!     // last_numbers is now &[1i, 2i]
 //! }
 //! ```
@@ -98,7 +98,7 @@ use core::iter::{range, range_step, MultiplicativeIterator};
 use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
-use core::ops::{FnMut, FullRange, Index, IndexMut};
+use core::ops::{FnMut, FullRange};
 use core::option::Option::{self, Some, None};
 use core::ptr::PtrExt;
 use core::ptr;
@@ -245,7 +245,7 @@ pub trait SliceExt {
     /// ```rust
     /// let v = &[1i, 2, 3, 4];
     /// for win in v.windows(2) {
-    ///     println!("{}", win);
+    ///     println!("{:?}", win);
     /// }
     /// ```
     #[stable]
@@ -268,7 +268,7 @@ pub trait SliceExt {
     /// ```rust
     /// let v = &[1i, 2, 3, 4, 5];
     /// for win in v.chunks(2) {
-    ///     println!("{}", win);
+    ///     println!("{:?}", win);
     /// }
     /// ```
     #[stable]
@@ -554,7 +554,7 @@ pub trait SliceExt {
     /// let mut perms = v.permutations();
     ///
     /// for p in perms {
-    ///   println!("{}", p);
+    ///   println!("{:?}", p);
     /// }
     /// ```
     ///
@@ -1065,12 +1065,12 @@ impl ElementSwaps {
 
 #[unstable = "trait is unstable"]
 impl<T> BorrowFrom<Vec<T>> for [T] {
-    fn borrow_from(owned: &Vec<T>) -> &[T] { owned.index(&FullRange) }
+    fn borrow_from(owned: &Vec<T>) -> &[T] { &owned[] }
 }
 
 #[unstable = "trait is unstable"]
 impl<T> BorrowFromMut<Vec<T>> for [T] {
-    fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { owned.index_mut(&FullRange) }
+    fn borrow_from_mut(owned: &mut Vec<T>) -> &mut [T] { &mut owned[] }
 }
 
 #[unstable = "trait is unstable"]
@@ -1400,7 +1400,6 @@ mod tests {
     use core::prelude::{Ord, FullRange};
     use core::default::Default;
     use core::mem;
-    use core::ops::Index;
     use std::iter::RandomAccessIterator;
     use std::rand::{Rng, thread_rng};
     use std::rc::Rc;
@@ -1611,7 +1610,7 @@ mod tests {
 
         // Test on stack.
         let vec_stack: &[_] = &[1i, 2, 3];
-        let v_b = vec_stack.index(&(1u..3u)).to_vec();
+        let v_b = vec_stack[1u..3u].to_vec();
         assert_eq!(v_b.len(), 2u);
         let v_b = v_b.as_slice();
         assert_eq!(v_b[0], 2);
@@ -1619,7 +1618,7 @@ mod tests {
 
         // Test `Box<[T]>`
         let vec_unique = vec![1i, 2, 3, 4, 5, 6];
-        let v_d = vec_unique.index(&(1u..6u)).to_vec();
+        let v_d = vec_unique[1u..6u].to_vec();
         assert_eq!(v_d.len(), 5u);
         let v_d = v_d.as_slice();
         assert_eq!(v_d[0], 2);
@@ -1632,21 +1631,21 @@ mod tests {
     #[test]
     fn test_slice_from() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(vec.index(&(0..)), vec);
+        assert_eq!(&vec[0..], vec);
         let b: &[int] = &[3, 4];
-        assert_eq!(vec.index(&(2..)), b);
+        assert_eq!(&vec[2..], b);
         let b: &[int] = &[];
-        assert_eq!(vec.index(&(4..)), b);
+        assert_eq!(&vec[4..], b);
     }
 
     #[test]
     fn test_slice_to() {
         let vec: &[int] = &[1, 2, 3, 4];
-        assert_eq!(vec.index(&(0..4)), vec);
+        assert_eq!(&vec[0..4], vec);
         let b: &[int] = &[1, 2];
-        assert_eq!(vec.index(&(0..2)), b);
+        assert_eq!(&vec[0..2], b);
         let b: &[int] = &[];
-        assert_eq!(vec.index(&(0..0)), b);
+        assert_eq!(&vec[0..0], b);
     }
 
 
@@ -2572,7 +2571,7 @@ mod tests {
         }
         assert_eq!(cnt, 3);
 
-        for f in v.index(&(1..3)).iter() {
+        for f in v[1..3].iter() {
             assert!(*f == Foo);
             cnt += 1;
         }
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 09d140067f451..ccf654ac0a048 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -386,7 +386,7 @@ macro_rules! utf8_acc_cont_byte {
 
 #[unstable = "trait is unstable"]
 impl BorrowFrom<String> for str {
-    fn borrow_from(owned: &String) -> &str { owned.index(&FullRange) }
+    fn borrow_from(owned: &String) -> &str { &owned[] }
 }
 
 #[unstable = "trait is unstable"]
@@ -464,7 +464,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[unstable = "this functionality may be moved to libunicode"]
     fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
         Decompositions {
-            iter: self.index(&FullRange).chars(),
+            iter: self[].chars(),
             buffer: Vec::new(),
             sorted: false,
             kind: Canonical
@@ -477,7 +477,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[unstable = "this functionality may be moved to libunicode"]
     fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
         Decompositions {
-            iter: self.index(&FullRange).chars(),
+            iter: self[].chars(),
             buffer: Vec::new(),
             sorted: false,
             kind: Compatible
@@ -525,7 +525,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn contains(&self, pat: &str) -> bool {
-        core_str::StrExt::contains(self.index(&FullRange), pat)
+        core_str::StrExt::contains(&self[], pat)
     }
 
     /// Returns true if a string contains a char pattern.
@@ -541,7 +541,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "might get removed in favour of a more generic contains()"]
     fn contains_char<P: CharEq>(&self, pat: P) -> bool {
-        core_str::StrExt::contains_char(self.index(&FullRange), pat)
+        core_str::StrExt::contains_char(&self[], pat)
     }
 
     /// An iterator over the characters of `self`. Note, this iterates
@@ -555,7 +555,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn chars(&self) -> Chars {
-        core_str::StrExt::chars(self.index(&FullRange))
+        core_str::StrExt::chars(&self[])
     }
 
     /// An iterator over the bytes of `self`
@@ -568,13 +568,13 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn bytes(&self) -> Bytes {
-        core_str::StrExt::bytes(self.index(&FullRange))
+        core_str::StrExt::bytes(&self[])
     }
 
     /// An iterator over the characters of `self` and their byte offsets.
     #[stable]
     fn char_indices(&self) -> CharIndices {
-        core_str::StrExt::char_indices(self.index(&FullRange))
+        core_str::StrExt::char_indices(&self[])
     }
 
     /// An iterator over substrings of `self`, separated by characters
@@ -597,7 +597,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn split<P: CharEq>(&self, pat: P) -> Split<P> {
-        core_str::StrExt::split(self.index(&FullRange), pat)
+        core_str::StrExt::split(&self[], pat)
     }
 
     /// An iterator over substrings of `self`, separated by characters
@@ -624,7 +624,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> {
-        core_str::StrExt::splitn(self.index(&FullRange), count, pat)
+        core_str::StrExt::splitn(&self[], count, pat)
     }
 
     /// An iterator over substrings of `self`, separated by characters
@@ -653,7 +653,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "might get removed"]
     fn split_terminator<P: CharEq>(&self, pat: P) -> SplitTerminator<P> {
-        core_str::StrExt::split_terminator(self.index(&FullRange), pat)
+        core_str::StrExt::split_terminator(&self[], pat)
     }
 
     /// An iterator over substrings of `self`, separated by characters
@@ -674,7 +674,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> {
-        core_str::StrExt::rsplitn(self.index(&FullRange), count, pat)
+        core_str::StrExt::rsplitn(&self[], count, pat)
     }
 
     /// An iterator over the start and end indices of the disjoint
@@ -699,7 +699,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "might have its iterator type changed"]
     fn match_indices<'a>(&'a self, pat: &'a str) -> MatchIndices<'a> {
-        core_str::StrExt::match_indices(self.index(&FullRange), pat)
+        core_str::StrExt::match_indices(&self[], pat)
     }
 
     /// An iterator over the substrings of `self` separated by the pattern `sep`.
@@ -715,7 +715,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "might get removed in the future in favor of a more generic split()"]
     fn split_str<'a>(&'a self, pat: &'a str) -> SplitStr<'a> {
-        core_str::StrExt::split_str(self.index(&FullRange), pat)
+        core_str::StrExt::split_str(&self[], pat)
     }
 
     /// An iterator over the lines of a string (subsequences separated
@@ -731,7 +731,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn lines(&self) -> Lines {
-        core_str::StrExt::lines(self.index(&FullRange))
+        core_str::StrExt::lines(&self[])
     }
 
     /// An iterator over the lines of a string, separated by either
@@ -747,7 +747,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn lines_any(&self) -> LinesAny {
-        core_str::StrExt::lines_any(self.index(&FullRange))
+        core_str::StrExt::lines_any(&self[])
     }
 
     /// Returns a slice of the given string from the byte range
@@ -782,7 +782,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "use slice notation [a..b] instead"]
     fn slice(&self, begin: uint, end: uint) -> &str {
-        core_str::StrExt::slice(self.index(&FullRange), begin, end)
+        core_str::StrExt::slice(&self[], begin, end)
     }
 
     /// Returns a slice of the string from `begin` to its end.
@@ -795,7 +795,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// See also `slice`, `slice_to` and `slice_chars`.
     #[unstable = "use slice notation [a..] instead"]
     fn slice_from(&self, begin: uint) -> &str {
-        core_str::StrExt::slice_from(self.index(&FullRange), begin)
+        core_str::StrExt::slice_from(&self[], begin)
     }
 
     /// Returns a slice of the string from the beginning to byte
@@ -809,7 +809,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// See also `slice`, `slice_from` and `slice_chars`.
     #[unstable = "use slice notation [0..a] instead"]
     fn slice_to(&self, end: uint) -> &str {
-        core_str::StrExt::slice_to(self.index(&FullRange), end)
+        core_str::StrExt::slice_to(&self[], end)
     }
 
     /// Returns a slice of the string from the character range
@@ -837,7 +837,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "may have yet to prove its worth"]
     fn slice_chars(&self, begin: uint, end: uint) -> &str {
-        core_str::StrExt::slice_chars(self.index(&FullRange), begin, end)
+        core_str::StrExt::slice_chars(&self[], begin, end)
     }
 
     /// Takes a bytewise (not UTF-8) slice from a string.
@@ -848,7 +848,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// the entire slice as well.
     #[stable]
     unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
-        core_str::StrExt::slice_unchecked(self.index(&FullRange), begin, end)
+        core_str::StrExt::slice_unchecked(&self[], begin, end)
     }
 
     /// Returns true if the pattern `pat` is a prefix of the string.
@@ -860,7 +860,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn starts_with(&self, pat: &str) -> bool {
-        core_str::StrExt::starts_with(self.index(&FullRange), pat)
+        core_str::StrExt::starts_with(&self[], pat)
     }
 
     /// Returns true if the pattern `pat` is a suffix of the string.
@@ -872,7 +872,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn ends_with(&self, pat: &str) -> bool {
-        core_str::StrExt::ends_with(self.index(&FullRange), pat)
+        core_str::StrExt::ends_with(&self[], pat)
     }
 
     /// Returns a string with all pre- and suffixes that match
@@ -892,7 +892,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn trim_matches<P: CharEq>(&self, pat: P) -> &str {
-        core_str::StrExt::trim_matches(self.index(&FullRange), pat)
+        core_str::StrExt::trim_matches(&self[], pat)
     }
 
     /// Returns a string with all prefixes that match
@@ -912,7 +912,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn trim_left_matches<P: CharEq>(&self, pat: P) -> &str {
-        core_str::StrExt::trim_left_matches(self.index(&FullRange), pat)
+        core_str::StrExt::trim_left_matches(&self[], pat)
     }
 
     /// Returns a string with all suffixes that match
@@ -932,7 +932,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn trim_right_matches<P: CharEq>(&self, pat: P) -> &str {
-        core_str::StrExt::trim_right_matches(self.index(&FullRange), pat)
+        core_str::StrExt::trim_right_matches(&self[], pat)
     }
 
     /// Check that `index`-th byte lies at the start and/or end of a
@@ -960,7 +960,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "naming is uncertain with container conventions"]
     fn is_char_boundary(&self, index: uint) -> bool {
-        core_str::StrExt::is_char_boundary(self.index(&FullRange), index)
+        core_str::StrExt::is_char_boundary(&self[], index)
     }
 
     /// Pluck a character out of a string and return the index of the next
@@ -1018,7 +1018,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
     #[unstable = "naming is uncertain with container conventions"]
     fn char_range_at(&self, start: uint) -> CharRange {
-        core_str::StrExt::char_range_at(self.index(&FullRange), start)
+        core_str::StrExt::char_range_at(&self[], start)
     }
 
     /// Given a byte position and a str, return the previous char and its position.
@@ -1033,7 +1033,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// If `i` is not an index following a valid UTF-8 character.
     #[unstable = "naming is uncertain with container conventions"]
     fn char_range_at_reverse(&self, start: uint) -> CharRange {
-        core_str::StrExt::char_range_at_reverse(self.index(&FullRange), start)
+        core_str::StrExt::char_range_at_reverse(&self[], start)
     }
 
     /// Plucks the character starting at the `i`th byte of a string.
@@ -1053,7 +1053,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
     #[unstable = "naming is uncertain with container conventions"]
     fn char_at(&self, i: uint) -> char {
-        core_str::StrExt::char_at(self.index(&FullRange), i)
+        core_str::StrExt::char_at(&self[], i)
     }
 
     /// Plucks the character ending at the `i`th byte of a string.
@@ -1064,7 +1064,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// If `i` is not an index following a valid UTF-8 character.
     #[unstable = "naming is uncertain with container conventions"]
     fn char_at_reverse(&self, i: uint) -> char {
-        core_str::StrExt::char_at_reverse(self.index(&FullRange), i)
+        core_str::StrExt::char_at_reverse(&self[], i)
     }
 
     /// Work with the byte buffer of a string as a byte slice.
@@ -1076,7 +1076,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn as_bytes(&self) -> &[u8] {
-        core_str::StrExt::as_bytes(self.index(&FullRange))
+        core_str::StrExt::as_bytes(&self[])
     }
 
     /// Returns the byte index of the first character of `self` that
@@ -1104,7 +1104,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
-        core_str::StrExt::find(self.index(&FullRange), pat)
+        core_str::StrExt::find(&self[], pat)
     }
 
     /// Returns the byte index of the last character of `self` that
@@ -1132,7 +1132,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
-        core_str::StrExt::rfind(self.index(&FullRange), pat)
+        core_str::StrExt::rfind(&self[], pat)
     }
 
     /// Returns the byte index of the first matching substring
@@ -1156,7 +1156,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "might get removed in favor of a more generic find in the future"]
     fn find_str(&self, needle: &str) -> Option<uint> {
-        core_str::StrExt::find_str(self.index(&FullRange), needle)
+        core_str::StrExt::find_str(&self[], needle)
     }
 
     /// Retrieves the first character from a string slice and returns
@@ -1179,7 +1179,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "awaiting conventions about shifting and slices"]
     fn slice_shift_char(&self) -> Option<(char, &str)> {
-        core_str::StrExt::slice_shift_char(self.index(&FullRange))
+        core_str::StrExt::slice_shift_char(&self[])
     }
 
     /// Returns the byte offset of an inner slice relative to an enclosing outer slice.
@@ -1198,7 +1198,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "awaiting convention about comparability of arbitrary slices"]
     fn subslice_offset(&self, inner: &str) -> uint {
-        core_str::StrExt::subslice_offset(self.index(&FullRange), inner)
+        core_str::StrExt::subslice_offset(&self[], inner)
     }
 
     /// Return an unsafe pointer to the strings buffer.
@@ -1209,13 +1209,13 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[stable]
     #[inline]
     fn as_ptr(&self) -> *const u8 {
-        core_str::StrExt::as_ptr(self.index(&FullRange))
+        core_str::StrExt::as_ptr(&self[])
     }
 
     /// Return an iterator of `u16` over the string encoded as UTF-16.
     #[unstable = "this functionality may only be provided by libunicode"]
     fn utf16_units(&self) -> Utf16Units {
-        Utf16Units { encoder: Utf16Encoder::new(self.index(&FullRange).chars()) }
+        Utf16Units { encoder: Utf16Encoder::new(self[].chars()) }
     }
 
     /// Return the number of bytes in this string
@@ -1229,7 +1229,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[stable]
     #[inline]
     fn len(&self) -> uint {
-        core_str::StrExt::len(self.index(&FullRange))
+        core_str::StrExt::len(&self[])
     }
 
     /// Returns true if this slice contains no bytes
@@ -1242,7 +1242,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[inline]
     #[stable]
     fn is_empty(&self) -> bool {
-        core_str::StrExt::is_empty(self.index(&FullRange))
+        core_str::StrExt::is_empty(&self[])
     }
 
     /// Parse this string into the specified type.
@@ -1256,7 +1256,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     #[inline]
     #[unstable = "this method was just created"]
     fn parse<F: FromStr>(&self) -> Option<F> {
-        core_str::StrExt::parse(self.index(&FullRange))
+        core_str::StrExt::parse(&self[])
     }
 
     /// Returns an iterator over the
@@ -1280,7 +1280,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "this functionality may only be provided by libunicode"]
     fn graphemes(&self, is_extended: bool) -> Graphemes {
-        UnicodeStr::graphemes(self.index(&FullRange), is_extended)
+        UnicodeStr::graphemes(&self[], is_extended)
     }
 
     /// Returns an iterator over the grapheme clusters of self and their byte offsets.
@@ -1295,7 +1295,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[unstable = "this functionality may only be provided by libunicode"]
     fn grapheme_indices(&self, is_extended: bool) -> GraphemeIndices {
-        UnicodeStr::grapheme_indices(self.index(&FullRange), is_extended)
+        UnicodeStr::grapheme_indices(&self[], is_extended)
     }
 
     /// An iterator over the words of a string (subsequences separated
@@ -1311,7 +1311,7 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// ```
     #[stable]
     fn words(&self) -> Words {
-        UnicodeStr::words(self.index(&FullRange))
+        UnicodeStr::words(&self[])
     }
 
     /// Returns a string's displayed width in columns, treating control
@@ -1325,25 +1325,25 @@ pub trait StrExt: Index<FullRange, Output = str> {
     /// `is_cjk` = `false`) if the locale is unknown.
     #[unstable = "this functionality may only be provided by libunicode"]
     fn width(&self, is_cjk: bool) -> uint {
-        UnicodeStr::width(self.index(&FullRange), is_cjk)
+        UnicodeStr::width(&self[], is_cjk)
     }
 
     /// Returns a string with leading and trailing whitespace removed.
     #[stable]
     fn trim(&self) -> &str {
-        UnicodeStr::trim(self.index(&FullRange))
+        UnicodeStr::trim(&self[])
     }
 
     /// Returns a string with leading whitespace removed.
     #[stable]
     fn trim_left(&self) -> &str {
-        UnicodeStr::trim_left(self.index(&FullRange))
+        UnicodeStr::trim_left(&self[])
     }
 
     /// Returns a string with trailing whitespace removed.
     #[stable]
     fn trim_right(&self) -> &str {
-        UnicodeStr::trim_right(self.index(&FullRange))
+        UnicodeStr::trim_right(&self[])
     }
 }
 
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 59418f50e3c7d..1bb0be05b1e82 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -168,7 +168,7 @@ impl String {
 
         if i > 0 {
             unsafe {
-                res.as_mut_vec().push_all(v.index(&(0..i)))
+                res.as_mut_vec().push_all(&v[0..i])
             };
         }
 
@@ -185,7 +185,7 @@ impl String {
             macro_rules! error { () => ({
                 unsafe {
                     if subseqidx != i_ {
-                        res.as_mut_vec().push_all(v.index(&(subseqidx..i_)));
+                        res.as_mut_vec().push_all(&v[subseqidx..i_]);
                     }
                     subseqidx = i;
                     res.as_mut_vec().push_all(REPLACEMENT);
@@ -254,7 +254,7 @@ impl String {
         }
         if subseqidx < total {
             unsafe {
-                res.as_mut_vec().push_all(v.index(&(subseqidx..total)))
+                res.as_mut_vec().push_all(&v[subseqidx..total])
             };
         }
         Cow::Owned(res)
@@ -681,6 +681,7 @@ impl fmt::Show for FromUtf8Error {
     }
 }
 
+#[stable]
 impl fmt::String for FromUtf8Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(&self.error, f)
@@ -693,6 +694,7 @@ impl fmt::Show for FromUtf16Error {
     }
 }
 
+#[stable]
 impl fmt::String for FromUtf16Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt("invalid utf-16: lone surrogate found", f)
@@ -805,7 +807,7 @@ impl Default for String {
     }
 }
 
-#[experimental = "waiting on fmt stabilization"]
+#[stable]
 impl fmt::String for String {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(&**self, f)
@@ -820,12 +822,21 @@ impl fmt::Show for String {
 }
 
 #[experimental = "waiting on Hash stabilization"]
+#[cfg(stage0)]
 impl<H: hash::Writer> hash::Hash<H> for String {
     #[inline]
     fn hash(&self, hasher: &mut H) {
         (**self).hash(hasher)
     }
 }
+#[experimental = "waiting on Hash stabilization"]
+#[cfg(not(stage0))]
+impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for String {
+    #[inline]
+    fn hash(&self, hasher: &mut H) {
+        (**self).hash(hasher)
+    }
+}
 
 #[unstable = "recent addition, needs more experience"]
 impl<'a> Add<&'a str> for String {
@@ -841,21 +852,21 @@ impl ops::Index<ops::Range<uint>> for String {
     type Output = str;
     #[inline]
     fn index(&self, index: &ops::Range<uint>) -> &str {
-        &self.index(&FullRange)[*index]
+        &self[][*index]
     }
 }
 impl ops::Index<ops::RangeTo<uint>> for String {
     type Output = str;
     #[inline]
     fn index(&self, index: &ops::RangeTo<uint>) -> &str {
-        &self.index(&FullRange)[*index]
+        &self[][*index]
     }
 }
 impl ops::Index<ops::RangeFrom<uint>> for String {
     type Output = str;
     #[inline]
     fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
-        &self.index(&FullRange)[*index]
+        &self[][*index]
     }
 }
 impl ops::Index<ops::FullRange> for String {
@@ -871,7 +882,7 @@ impl ops::Deref for String {
     type Target = str;
 
     fn deref<'a>(&'a self) -> &'a str {
-        unsafe { mem::transmute(self.vec.index(&FullRange)) }
+        unsafe { mem::transmute(&self.vec[]) }
     }
 }
 
@@ -921,18 +932,6 @@ pub trait ToString {
     fn to_string(&self) -> String;
 }
 
-#[cfg(stage0)]
-impl<T: fmt::Show> ToString for T {
-    fn to_string(&self) -> String {
-        use core::fmt::Writer;
-        let mut buf = String::new();
-        let _ = buf.write_fmt(format_args!("{}", self));
-        buf.shrink_to_fit();
-        buf
-    }
-}
-
-#[cfg(not(stage0))]
 impl<T: fmt::String> ToString for T {
     fn to_string(&self) -> String {
         use core::fmt::Writer;
@@ -1277,18 +1276,17 @@ mod tests {
         assert_eq!(2u8.to_string(), "2");
         assert_eq!(true.to_string(), "true");
         assert_eq!(false.to_string(), "false");
-        assert_eq!(().to_string(), "()");
         assert_eq!(("hi".to_string()).to_string(), "hi");
     }
 
     #[test]
     fn test_vectors() {
         let x: Vec<int> = vec![];
-        assert_eq!(x.to_string(), "[]");
-        assert_eq!((vec![1i]).to_string(), "[1]");
-        assert_eq!((vec![1i, 2, 3]).to_string(), "[1, 2, 3]");
-        assert!((vec![vec![], vec![1i], vec![1i, 1]]).to_string() ==
-               "[[], [1], [1, 1]]");
+        assert_eq!(format!("{:?}", x), "[]");
+        assert_eq!(format!("{:?}", vec![1i]), "[1i]");
+        assert_eq!(format!("{:?}", vec![1i, 2, 3]), "[1i, 2i, 3i]");
+        assert!(format!("{:?}", vec![vec![], vec![1i], vec![1i, 1]]) ==
+               "[[], [1i], [1i, 1i]]");
     }
 
     #[test]
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 5fc3fafac9e22..d9344d130b23c 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -1178,17 +1178,25 @@ impl<T:Clone> Clone for Vec<T> {
 
         // self.len <= other.len due to the truncate above, so the
         // slice here is always in-bounds.
-        let slice = other.index(&(self.len()..));
+        let slice = &other[self.len()..];
         self.push_all(slice);
     }
 }
 
+#[cfg(stage0)]
 impl<S: hash::Writer, T: Hash<S>> Hash<S> for Vec<T> {
     #[inline]
     fn hash(&self, state: &mut S) {
         self.as_slice().hash(state);
     }
 }
+#[cfg(not(stage0))]
+impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
+    #[inline]
+    fn hash(&self, state: &mut S) {
+        self.as_slice().hash(state);
+    }
+}
 
 #[experimental = "waiting on Index stability"]
 impl<T> Index<uint> for Vec<T> {
@@ -1454,22 +1462,6 @@ impl<T: fmt::Show> fmt::Show for Vec<T> {
     }
 }
 
-#[cfg(stage0)]
-#[experimental = "waiting on Show stability"]
-impl<T: fmt::Show> fmt::String for Vec<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_slice(), f)
-    }
-}
-
-#[cfg(not(stage0))]
-#[experimental = "waiting on Show stability"]
-impl<T: fmt::String> fmt::String for Vec<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_slice(), f)
-    }
-}
-
 impl<'a> fmt::Writer for Vec<u8> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         self.push_all(s.as_bytes());
@@ -2039,7 +2031,7 @@ mod tests {
         v.push(());
         assert_eq!(v.iter_mut().count(), 4);
 
-        for &() in v.iter_mut() {}
+        for &mut () in v.iter_mut() {}
         unsafe { v.set_len(0); }
         assert_eq!(v.iter_mut().count(), 0);
     }
diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
index 4399a6fec2274..d4ce266d3e211 100644
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@@ -18,7 +18,7 @@ use core::prelude::*;
 use core::cmp::Ordering;
 use core::default::Default;
 use core::fmt;
-use core::hash::{Hash, Writer};
+use core::hash::{Hash, Writer, Hasher};
 use core::iter::{Enumerate, FilterMap, Map, FromIterator};
 use core::iter;
 use core::mem::replace;
@@ -85,7 +85,7 @@ impl<V:Clone> Clone for VecMap<V> {
     }
 }
 
-impl<S: Writer, V: Hash<S>> Hash<S> for VecMap<V> {
+impl<S: Writer + Hasher, V: Hash<S>> Hash<S> for VecMap<V> {
     fn hash(&self, state: &mut S) {
         // In order to not traverse the `VecMap` twice, count the elements
         // during iteration.
@@ -712,7 +712,7 @@ impl<V> DoubleEndedIterator for IntoIter<V> {
 #[cfg(test)]
 mod test_map {
     use prelude::*;
-    use core::hash::hash;
+    use core::hash::{hash, SipHasher};
 
     use super::VecMap;
 
@@ -1004,7 +1004,7 @@ mod test_map {
         let mut x = VecMap::new();
         let mut y = VecMap::new();
 
-        assert!(hash(&x) == hash(&y));
+        assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
         x.insert(1, 'a');
         x.insert(2, 'b');
         x.insert(3, 'c');
@@ -1013,12 +1013,12 @@ mod test_map {
         y.insert(2, 'b');
         y.insert(1, 'a');
 
-        assert!(hash(&x) == hash(&y));
+        assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
 
         x.insert(1000, 'd');
         x.remove(&1000);
 
-        assert!(hash(&x) == hash(&y));
+        assert!(hash::<_, SipHasher>(&x) == hash::<_, SipHasher>(&y));
     }
 
     #[test]
diff --git a/src/libcore/array.rs b/src/libcore/array.rs
index 05db9e11760e3..0cea0b3d88e14 100644
--- a/src/libcore/array.rs
+++ b/src/libcore/array.rs
@@ -18,7 +18,7 @@ use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
 use fmt;
 use marker::Copy;
-use ops::{Deref, FullRange, Index};
+use ops::{Deref, FullRange};
 use option::Option;
 
 // macro for implementing n-ary tuple functions and operations
@@ -35,7 +35,7 @@ macro_rules! array_impls {
             #[unstable = "waiting for Show to stabilize"]
             impl<T:fmt::Show> fmt::Show for [T; $N] {
                 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    fmt::Show::fmt(&self.index(&FullRange), f)
+                    fmt::Show::fmt(&&self[], f)
                 }
             }
 
@@ -43,11 +43,11 @@ macro_rules! array_impls {
             impl<A, B> PartialEq<[B; $N]> for [A; $N] where A: PartialEq<B> {
                 #[inline]
                 fn eq(&self, other: &[B; $N]) -> bool {
-                    self.index(&FullRange) == other.index(&FullRange)
+                    &self[] == &other[]
                 }
                 #[inline]
                 fn ne(&self, other: &[B; $N]) -> bool {
-                    self.index(&FullRange) != other.index(&FullRange)
+                    &self[] != &other[]
                 }
             }
 
@@ -58,11 +58,11 @@ macro_rules! array_impls {
             {
                 #[inline(always)]
                 fn eq(&self, other: &Rhs) -> bool {
-                    PartialEq::eq(self.index(&FullRange), &**other)
+                    PartialEq::eq(&self[], &**other)
                 }
                 #[inline(always)]
                 fn ne(&self, other: &Rhs) -> bool {
-                    PartialEq::ne(self.index(&FullRange), &**other)
+                    PartialEq::ne(&self[], &**other)
                 }
             }
 
@@ -73,11 +73,11 @@ macro_rules! array_impls {
             {
                 #[inline(always)]
                 fn eq(&self, other: &[B; $N]) -> bool {
-                    PartialEq::eq(&**self, other.index(&FullRange))
+                    PartialEq::eq(&**self, &other[])
                 }
                 #[inline(always)]
                 fn ne(&self, other: &[B; $N]) -> bool {
-                    PartialEq::ne(&**self, other.index(&FullRange))
+                    PartialEq::ne(&**self, &other[])
                 }
             }
 
@@ -88,23 +88,23 @@ macro_rules! array_impls {
             impl<T:PartialOrd> PartialOrd for [T; $N] {
                 #[inline]
                 fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> {
-                    PartialOrd::partial_cmp(&self.index(&FullRange), &other.index(&FullRange))
+                    PartialOrd::partial_cmp(&&self[], &&other[])
                 }
                 #[inline]
                 fn lt(&self, other: &[T; $N]) -> bool {
-                    PartialOrd::lt(&self.index(&FullRange), &other.index(&FullRange))
+                    PartialOrd::lt(&&self[], &&other[])
                 }
                 #[inline]
                 fn le(&self, other: &[T; $N]) -> bool {
-                    PartialOrd::le(&self.index(&FullRange), &other.index(&FullRange))
+                    PartialOrd::le(&&self[], &&other[])
                 }
                 #[inline]
                 fn ge(&self, other: &[T; $N]) -> bool {
-                    PartialOrd::ge(&self.index(&FullRange), &other.index(&FullRange))
+                    PartialOrd::ge(&&self[], &&other[])
                 }
                 #[inline]
                 fn gt(&self, other: &[T; $N]) -> bool {
-                    PartialOrd::gt(&self.index(&FullRange), &other.index(&FullRange))
+                    PartialOrd::gt(&&self[], &&other[])
                 }
             }
 
@@ -112,7 +112,7 @@ macro_rules! array_impls {
             impl<T:Ord> Ord for [T; $N] {
                 #[inline]
                 fn cmp(&self, other: &[T; $N]) -> Ordering {
-                    Ord::cmp(&self.index(&FullRange), &other.index(&FullRange))
+                    Ord::cmp(&&self[], &&other[])
                 }
             }
         )+
diff --git a/src/libcore/borrow.rs b/src/libcore/borrow.rs
index 3163135542296..4363a0a444113 100644
--- a/src/libcore/borrow.rs
+++ b/src/libcore/borrow.rs
@@ -133,7 +133,7 @@ impl<T> ToOwned<T> for T where T: Clone {
 ///     }
 /// }
 /// ```
-//#[deriving(Show)] NOTE(stage0): uncomment after snapshot
+#[derive(Show)]
 pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
     /// Borrowed data.
     Borrowed(&'a B),
@@ -142,16 +142,6 @@ pub enum Cow<'a, T, B: ?Sized + 'a> where B: ToOwned<T> {
     Owned(T)
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
-impl<'a, T, B: ?Sized> fmt::Show for Cow<'a, T, B> where
-    B: fmt::String + ToOwned<T>,
-    T: fmt::String
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 #[stable]
 impl<'a, T, B: ?Sized> Clone for Cow<'a, T, B> where B: ToOwned<T> {
     fn clone(&self) -> Cow<'a, T, B> {
@@ -248,6 +238,7 @@ impl<'a, T, B: ?Sized> PartialOrd for Cow<'a, T, B> where B: PartialOrd + ToOwne
     }
 }
 
+#[stable]
 impl<'a, T, B: ?Sized> fmt::String for Cow<'a, T, B> where
     B: fmt::String + ToOwned<T>,
     T: fmt::String,
diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs
index d833b8fed7779..0ffcb014c2877 100644
--- a/src/libcore/fmt/float.rs
+++ b/src/libcore/fmt/float.rs
@@ -20,7 +20,7 @@ use fmt;
 use iter::{IteratorExt, range};
 use num::{cast, Float, ToPrimitive};
 use num::FpCategory as Fp;
-use ops::{FnOnce, Index};
+use ops::FnOnce;
 use result::Result::Ok;
 use slice::{self, SliceExt};
 use str::{self, StrExt};
@@ -332,5 +332,5 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
         }
     }
 
-    f(unsafe { str::from_utf8_unchecked(buf.index(&(0..end))) })
+    f(unsafe { str::from_utf8_unchecked(&buf[0..end]) })
 }
diff --git a/src/libcore/fmt/mod.rs b/src/libcore/fmt/mod.rs
index f9027f19068e4..69df413a88c0d 100644
--- a/src/libcore/fmt/mod.rs
+++ b/src/libcore/fmt/mod.rs
@@ -21,7 +21,7 @@ use mem;
 use option::Option;
 use option::Option::{Some, None};
 use result::Result::Ok;
-use ops::{Deref, FnOnce, Index};
+use ops::{Deref, FnOnce};
 use result;
 use slice::SliceExt;
 use slice;
@@ -219,6 +219,7 @@ impl<'a> Show for Arguments<'a> {
     }
 }
 
+#[stable]
 impl<'a> String for Arguments<'a> {
     fn fmt(&self, fmt: &mut Formatter) -> Result {
         write(fmt.buf, *self)
@@ -424,7 +425,7 @@ impl<'a> Formatter<'a> {
             for c in sign.into_iter() {
                 let mut b = [0; 4];
                 let n = c.encode_utf8(&mut b).unwrap_or(0);
-                let b = unsafe { str::from_utf8_unchecked(b.index(&(0..n))) };
+                let b = unsafe { str::from_utf8_unchecked(&b[0..n]) };
                 try!(f.buf.write_str(b));
             }
             if prefixed { f.buf.write_str(prefix) }
@@ -532,7 +533,7 @@ impl<'a> Formatter<'a> {
 
         let mut fill = [0u8; 4];
         let len = self.fill.encode_utf8(&mut fill).unwrap_or(0);
-        let fill = unsafe { str::from_utf8_unchecked(fill.index(&(..len))) };
+        let fill = unsafe { str::from_utf8_unchecked(&fill[..len]) };
 
         for _ in range(0, pre_pad) {
             try!(self.buf.write_str(fill));
@@ -627,22 +628,13 @@ impl Show for bool {
     }
 }
 
+#[stable]
 impl String for bool {
     fn fmt(&self, f: &mut Formatter) -> Result {
         String::fmt(if *self { "true" } else { "false" }, f)
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl Show for str {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        String::fmt(self, f)
-    }
-}
-
-#[cfg(not(stage0))]
-//NOTE(stage0): remove cfg after snapshot
 impl Show for str {
     fn fmt(&self, f: &mut Formatter) -> Result {
         try!(write!(f, "\""));
@@ -653,22 +645,13 @@ impl Show for str {
     }
 }
 
+#[stable]
 impl String for str {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.pad(self)
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl Show for char {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        String::fmt(self, f)
-    }
-}
-
-#[cfg(not(stage0))]
-//NOTE(stage0): remove cfg after snapshot
 impl Show for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
         use char::CharExt;
@@ -680,11 +663,12 @@ impl Show for char {
     }
 }
 
+#[stable]
 impl String for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
         let mut utf8 = [0u8; 4];
         let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
-        let s: &str = unsafe { mem::transmute(utf8.index(&(0..amt))) };
+        let s: &str = unsafe { mem::transmute(&utf8[0..amt]) };
         String::fmt(s, f)
     }
 }
@@ -725,6 +709,7 @@ macro_rules! floating { ($ty:ident) => {
         }
     }
 
+    #[stable]
     impl String for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
             use num::Float;
@@ -796,15 +781,9 @@ floating! { f64 }
 impl<T> Show for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
 }
-impl<T> String for *const T {
-    fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
-}
 impl<T> Show for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
 }
-impl<T> String for *mut T {
-    fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }
-}
 
 macro_rules! peel {
     ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
@@ -863,61 +842,12 @@ impl<T: Show> Show for [T] {
     }
 }
 
-#[cfg(stage0)]
-impl<T: Show> String for [T] {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "["));
-        }
-        let mut is_first = true;
-        for x in self.iter() {
-            if is_first {
-                is_first = false;
-            } else {
-                try!(write!(f, ", "));
-            }
-            try!(write!(f, "{}", *x))
-        }
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "]"));
-        }
-        Ok(())
-    }
-}
-#[cfg(not(stage0))]
-impl<T: String> String for [T] {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "["));
-        }
-        let mut is_first = true;
-        for x in self.iter() {
-            if is_first {
-                is_first = false;
-            } else {
-                try!(write!(f, ", "));
-            }
-            try!(write!(f, "{}", *x))
-        }
-        if f.flags & (1 << (rt::FlagAlternate as uint)) == 0 {
-            try!(write!(f, "]"));
-        }
-        Ok(())
-    }
-}
-
 impl Show for () {
     fn fmt(&self, f: &mut Formatter) -> Result {
         f.pad("()")
     }
 }
 
-impl String for () {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        f.pad("()")
-    }
-}
-
 impl<T: Copy + Show> Show for Cell<T> {
     fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "Cell {{ value: {:?} }}", self.get())
@@ -946,6 +876,7 @@ impl<'b, T: Show> Show for RefMut<'b, T> {
     }
 }
 
+#[stable]
 impl String for Utf8Error {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match *self {
diff --git a/src/libcore/fmt/num.rs b/src/libcore/fmt/num.rs
index 17149aed3dbab..1df6f8452258b 100644
--- a/src/libcore/fmt/num.rs
+++ b/src/libcore/fmt/num.rs
@@ -16,7 +16,6 @@
 
 use fmt;
 use iter::IteratorExt;
-use ops::Index;
 use num::{Int, cast};
 use slice::SliceExt;
 use str;
@@ -62,7 +61,7 @@ trait GenericRadix {
                 if x == zero { break };                   // No more digits left to accumulate.
             }
         }
-        let buf = unsafe { str::from_utf8_unchecked(buf.index(&(curr..))) };
+        let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };
         f.pad_integral(is_positive, self.prefix(), buf)
     }
 }
@@ -155,14 +154,6 @@ pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
 
 macro_rules! radix_fmt {
     ($T:ty as $U:ty, $fmt:ident, $S:expr) => {
-        #[cfg(stage0)]
-        impl fmt::Show for RadixFmt<$T, Radix> {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::String::fmt(self, f)
-            }
-        }
-
-        #[cfg(not(stage0))]
         impl fmt::Show for RadixFmt<$T, Radix> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 try!(fmt::String::fmt(self, f));
@@ -188,14 +179,6 @@ macro_rules! int_base {
 
 macro_rules! show {
     ($T:ident with $S:expr) => {
-        #[cfg(stage0)]
-        impl fmt::Show for $T {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::String::fmt(self, f)
-            }
-        }
-
-        #[cfg(not(stage0))]
         impl fmt::Show for $T {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 try!(fmt::String::fmt(self, f));
diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs
index d8b9cf9594d6a..a82ea009e1361 100644
--- a/src/libcore/hash/mod.rs
+++ b/src/libcore/hash/mod.rs
@@ -16,8 +16,7 @@
 //! # Examples
 //!
 //! ```rust
-//! use std::hash;
-//! use std::hash::Hash;
+//! use std::hash::{hash, Hash, SipHasher};
 //!
 //! #[derive(Hash)]
 //! struct Person {
@@ -29,16 +28,14 @@
 //! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 };
 //! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 };
 //!
-//! assert!(hash::hash(&person1) != hash::hash(&person2));
+//! assert!(hash::<_, SipHasher>(&person1) != hash::<_, SipHasher>(&person2));
 //! ```
 //!
 //! If you need more control over how a value is hashed, you need to implement
 //! the trait `Hash`:
 //!
 //! ```rust
-//! use std::hash;
-//! use std::hash::Hash;
-//! use std::hash::sip::SipState;
+//! use std::hash::{hash, Hash, Hasher, Writer, SipHasher};
 //!
 //! struct Person {
 //!     id: uint,
@@ -46,8 +43,8 @@
 //!     phone: u64,
 //! }
 //!
-//! impl Hash for Person {
-//!     fn hash(&self, state: &mut SipState) {
+//! impl<H: Hasher + Writer> Hash<H> for Person {
+//!     fn hash(&self, state: &mut H) {
 //!         self.id.hash(state);
 //!         self.phone.hash(state);
 //!     }
@@ -56,186 +53,382 @@
 //! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 };
 //! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 };
 //!
-//! assert!(hash::hash(&person1) == hash::hash(&person2));
+//! assert_eq!(hash::<_, SipHasher>(&person1), hash::<_, SipHasher>(&person2));
 //! ```
 
-#![allow(unused_must_use)]
+#![unstable = "module was recently redesigned"]
 
-use prelude::*;
+use default::Default;
 
-use borrow::{Cow, ToOwned};
-use intrinsics::TypeId;
-use mem;
-use num::Int;
+pub use self::sip::SipHasher;
 
-/// Reexport the `sip::hash` function as our default hasher.
-pub use self::sip::hash as hash;
+mod sip;
 
-pub mod sip;
+/// A hashable type.
+///
+/// The `H` type parameter is an abstract hash state that is used by the `Hash`
+/// to compute the hash. Specific implementations of this trait may specialize
+/// for particular instances of `H` in order to be able to optimize the hashing
+/// behavior.
+#[cfg(stage0)]
+pub trait Hash<H> {
+    /// Feeds this value into the state given, updating the hasher as necessary.
+    fn hash(&self, state: &mut H);
+}
 
-/// A hashable type. The `S` type parameter is an abstract hash state that is
-/// used by the `Hash` to compute the hash. It defaults to
-/// `std::hash::sip::SipState`.
-pub trait Hash<S = sip::SipState> {
-    /// Computes the hash of a value.
-    fn hash(&self, state: &mut S);
+/// A hashable type.
+///
+/// The `H` type parameter is an abstract hash state that is used by the `Hash`
+/// to compute the hash. Specific implementations of this trait may specialize
+/// for particular instances of `H` in order to be able to optimize the hashing
+/// behavior.
+#[cfg(not(stage0))]
+pub trait Hash<H: Hasher> {
+    /// Feeds this value into the state given, updating the hasher as necessary.
+    fn hash(&self, state: &mut H);
 }
 
-/// A trait that computes a hash for a value. The main users of this trait are
-/// containers like `HashMap`, which need a generic way hash multiple types.
-pub trait Hasher<S> {
-    /// Compute the hash of a value.
-    fn hash<T: ?Sized + Hash<S>>(&self, value: &T) -> u64;
+/// A trait which represents the ability to hash an arbitrary stream of bytes.
+pub trait Hasher {
+    /// Result type of one run of hashing generated by this hasher.
+    type Output;
+
+    /// Resets this hasher back to its initial state (as if it were just
+    /// created).
+    fn reset(&mut self);
+
+    /// Completes a round of hashing, producing the output hash generated.
+    fn finish(&self) -> Self::Output;
 }
 
+/// A common bound on the `Hasher` parameter to `Hash` implementations in order
+/// to generically hash an aggregate.
+#[experimental = "this trait will likely be replaced by io::Writer"]
 #[allow(missing_docs)]
 pub trait Writer {
     fn write(&mut self, bytes: &[u8]);
 }
 
+/// Hash a value with the default SipHasher algorithm (two initial keys of 0).
+///
+/// The specified value will be hashed with this hasher and then the resulting
+/// hash will be returned.
+pub fn hash<T: Hash<H>, H: Hasher + Default>(value: &T) -> H::Output {
+    let mut h: H = Default::default();
+    value.hash(&mut h);
+    h.finish()
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
-macro_rules! impl_hash {
-    ($ty:ident, $uty:ident) => {
-        impl<S: Writer> Hash<S> for $ty {
-            #[inline]
-            fn hash(&self, state: &mut S) {
-                let a: [u8; ::$ty::BYTES] = unsafe {
-                    mem::transmute((*self as $uty).to_le() as $ty)
-                };
-                state.write(a.as_slice())
+#[cfg(stage0)]
+mod impls {
+    use prelude::*;
+
+    use borrow::{Cow, ToOwned};
+    use intrinsics::TypeId;
+    use mem;
+    use super::{Hash, Writer};
+    use num::Int;
+
+    macro_rules! impl_hash {
+        ($ty:ident, $uty:ident) => {
+            impl<S: Writer> Hash<S> for $ty {
+                #[inline]
+                fn hash(&self, state: &mut S) {
+                    let a: [u8; ::$ty::BYTES] = unsafe {
+                        mem::transmute((*self as $uty).to_le() as $ty)
+                    };
+                    state.write(a.as_slice())
+                }
             }
         }
     }
-}
 
-impl_hash! { u8, u8 }
-impl_hash! { u16, u16 }
-impl_hash! { u32, u32 }
-impl_hash! { u64, u64 }
-impl_hash! { uint, uint }
-impl_hash! { i8, u8 }
-impl_hash! { i16, u16 }
-impl_hash! { i32, u32 }
-impl_hash! { i64, u64 }
-impl_hash! { int, uint }
-
-impl<S: Writer> Hash<S> for bool {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (*self as u8).hash(state);
+    impl_hash! { u8, u8 }
+    impl_hash! { u16, u16 }
+    impl_hash! { u32, u32 }
+    impl_hash! { u64, u64 }
+    impl_hash! { uint, uint }
+    impl_hash! { i8, u8 }
+    impl_hash! { i16, u16 }
+    impl_hash! { i32, u32 }
+    impl_hash! { i64, u64 }
+    impl_hash! { int, uint }
+
+    impl<S: Writer> Hash<S> for bool {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (*self as u8).hash(state);
+        }
     }
-}
 
-impl<S: Writer> Hash<S> for char {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (*self as u32).hash(state);
+    impl<S: Writer> Hash<S> for char {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (*self as u32).hash(state);
+        }
     }
-}
 
-impl<S: Writer> Hash<S> for str {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        state.write(self.as_bytes());
-        0xffu8.hash(state)
+    impl<S: Writer> Hash<S> for str {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            state.write(self.as_bytes());
+            0xffu8.hash(state)
+        }
     }
-}
 
-macro_rules! impl_hash_tuple {
-    () => (
-        impl<S: Writer> Hash<S> for () {
-            #[inline]
-            fn hash(&self, state: &mut S) {
-                state.write(&[]);
+    macro_rules! impl_hash_tuple {
+        () => (
+            impl<S> Hash<S> for () {
+                #[inline]
+                fn hash(&self, _state: &mut S) {}
             }
-        }
-    );
-
-    ( $($name:ident)+) => (
-        impl<S: Writer, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
-            #[inline]
-            #[allow(non_snake_case)]
-            fn hash(&self, state: &mut S) {
-                match *self {
-                    ($(ref $name,)*) => {
-                        $(
-                            $name.hash(state);
-                        )*
+        );
+
+        ( $($name:ident)+) => (
+            impl<S, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
+                #[inline]
+                #[allow(non_snake_case)]
+                fn hash(&self, state: &mut S) {
+                    match *self {
+                        ($(ref $name,)*) => {
+                            $(
+                                $name.hash(state);
+                            )*
+                        }
                     }
                 }
             }
+        );
+    }
+
+    impl_hash_tuple! {}
+    impl_hash_tuple! { A }
+    impl_hash_tuple! { A B }
+    impl_hash_tuple! { A B C }
+    impl_hash_tuple! { A B C D }
+    impl_hash_tuple! { A B C D E }
+    impl_hash_tuple! { A B C D E F }
+    impl_hash_tuple! { A B C D E F G }
+    impl_hash_tuple! { A B C D E F G H }
+    impl_hash_tuple! { A B C D E F G H I }
+    impl_hash_tuple! { A B C D E F G H I J }
+    impl_hash_tuple! { A B C D E F G H I J K }
+    impl_hash_tuple! { A B C D E F G H I J K L }
+
+    impl<S: Writer, T: Hash<S>> Hash<S> for [T] {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            self.len().hash(state);
+            for elt in self.iter() {
+                elt.hash(state);
+            }
         }
-    );
-}
+    }
+
 
-impl_hash_tuple! {}
-impl_hash_tuple! { A }
-impl_hash_tuple! { A B }
-impl_hash_tuple! { A B C }
-impl_hash_tuple! { A B C D }
-impl_hash_tuple! { A B C D E }
-impl_hash_tuple! { A B C D E F }
-impl_hash_tuple! { A B C D E F G }
-impl_hash_tuple! { A B C D E F G H }
-impl_hash_tuple! { A B C D E F G H I }
-impl_hash_tuple! { A B C D E F G H I J }
-impl_hash_tuple! { A B C D E F G H I J K }
-impl_hash_tuple! { A B C D E F G H I J K L }
-
-impl<S: Writer, T: Hash<S>> Hash<S> for [T] {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        self.len().hash(state);
-        for elt in self.iter() {
-            elt.hash(state);
+    impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (**self).hash(state);
         }
     }
-}
 
+    impl<'a, S, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (**self).hash(state);
+        }
+    }
 
-impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a T {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (**self).hash(state);
+    impl<S: Writer, T> Hash<S> for *const T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            // NB: raw-pointer Hash does _not_ dereference
+            // to the target; it just gives you the pointer-bytes.
+            (*self as uint).hash(state);
+        }
     }
-}
 
-impl<'a, S: Writer, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        (**self).hash(state);
+    impl<S: Writer, T> Hash<S> for *mut T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            // NB: raw-pointer Hash does _not_ dereference
+            // to the target; it just gives you the pointer-bytes.
+            (*self as uint).hash(state);
+        }
     }
-}
 
-impl<S: Writer, T> Hash<S> for *const T {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        // NB: raw-pointer Hash does _not_ dereference
-        // to the target; it just gives you the pointer-bytes.
-        (*self as uint).hash(state);
+    impl<S: Writer> Hash<S> for TypeId {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            self.hash().hash(state)
+        }
     }
-}
 
-impl<S: Writer, T> Hash<S> for *mut T {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        // NB: raw-pointer Hash does _not_ dereference
-        // to the target; it just gives you the pointer-bytes.
-        (*self as uint).hash(state);
+    impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B>
+        where B: Hash<S> + ToOwned<T>
+    {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            Hash::hash(&**self, state)
+        }
     }
 }
 
-impl<S: Writer> Hash<S> for TypeId {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        self.hash().hash(state)
+#[cfg(not(stage0))]
+mod impls {
+    use prelude::*;
+
+    use borrow::{Cow, ToOwned};
+    use intrinsics::TypeId;
+    use mem;
+    use super::{Hash, Writer, Hasher};
+    use num::Int;
+
+    macro_rules! impl_hash {
+        ($ty:ident, $uty:ident) => {
+            impl<S: Writer + Hasher> Hash<S> for $ty {
+                #[inline]
+                fn hash(&self, state: &mut S) {
+                    let a: [u8; ::$ty::BYTES] = unsafe {
+                        mem::transmute((*self as $uty).to_le() as $ty)
+                    };
+                    state.write(a.as_slice())
+                }
+            }
+        }
+    }
+
+    impl_hash! { u8, u8 }
+    impl_hash! { u16, u16 }
+    impl_hash! { u32, u32 }
+    impl_hash! { u64, u64 }
+    impl_hash! { uint, uint }
+    impl_hash! { i8, u8 }
+    impl_hash! { i16, u16 }
+    impl_hash! { i32, u32 }
+    impl_hash! { i64, u64 }
+    impl_hash! { int, uint }
+
+    impl<S: Writer + Hasher> Hash<S> for bool {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (*self as u8).hash(state);
+        }
+    }
+
+    impl<S: Writer + Hasher> Hash<S> for char {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (*self as u32).hash(state);
+        }
+    }
+
+    impl<S: Writer + Hasher> Hash<S> for str {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            state.write(self.as_bytes());
+            0xffu8.hash(state)
+        }
+    }
+
+    macro_rules! impl_hash_tuple {
+        () => (
+            impl<S: Hasher> Hash<S> for () {
+                #[inline]
+                fn hash(&self, _state: &mut S) {}
+            }
+        );
+
+        ( $($name:ident)+) => (
+            impl<S: Hasher, $($name: Hash<S>),*> Hash<S> for ($($name,)*) {
+                #[inline]
+                #[allow(non_snake_case)]
+                fn hash(&self, state: &mut S) {
+                    match *self {
+                        ($(ref $name,)*) => {
+                            $(
+                                $name.hash(state);
+                            )*
+                        }
+                    }
+                }
+            }
+        );
+    }
+
+    impl_hash_tuple! {}
+    impl_hash_tuple! { A }
+    impl_hash_tuple! { A B }
+    impl_hash_tuple! { A B C }
+    impl_hash_tuple! { A B C D }
+    impl_hash_tuple! { A B C D E }
+    impl_hash_tuple! { A B C D E F }
+    impl_hash_tuple! { A B C D E F G }
+    impl_hash_tuple! { A B C D E F G H }
+    impl_hash_tuple! { A B C D E F G H I }
+    impl_hash_tuple! { A B C D E F G H I J }
+    impl_hash_tuple! { A B C D E F G H I J K }
+    impl_hash_tuple! { A B C D E F G H I J K L }
+
+    impl<S: Writer + Hasher, T: Hash<S>> Hash<S> for [T] {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            self.len().hash(state);
+            for elt in self.iter() {
+                elt.hash(state);
+            }
+        }
+    }
+
+
+    impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (**self).hash(state);
+        }
+    }
+
+    impl<'a, S: Hasher, T: ?Sized + Hash<S>> Hash<S> for &'a mut T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            (**self).hash(state);
+        }
     }
-}
 
-impl<'a, T, B: ?Sized, S> Hash<S> for Cow<'a, T, B> where B: Hash<S> + ToOwned<T> {
-    #[inline]
-    fn hash(&self, state: &mut S) {
-        Hash::hash(&**self, state)
+    impl<S: Writer + Hasher, T> Hash<S> for *const T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            // NB: raw-pointer Hash does _not_ dereference
+            // to the target; it just gives you the pointer-bytes.
+            (*self as uint).hash(state);
+        }
+    }
+
+    impl<S: Writer + Hasher, T> Hash<S> for *mut T {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            // NB: raw-pointer Hash does _not_ dereference
+            // to the target; it just gives you the pointer-bytes.
+            (*self as uint).hash(state);
+        }
+    }
+
+    impl<S: Writer + Hasher> Hash<S> for TypeId {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            self.hash().hash(state)
+        }
+    }
+
+    impl<'a, T, B: ?Sized, S: Hasher> Hash<S> for Cow<'a, T, B>
+        where B: Hash<S> + ToOwned<T>
+    {
+        #[inline]
+        fn hash(&self, state: &mut S) {
+            Hash::hash(&**self, state)
+        }
     }
 }
diff --git a/src/libcore/hash/sip.rs b/src/libcore/hash/sip.rs
index c4d45e9c2c804..c20fb8457d26e 100644
--- a/src/libcore/hash/sip.rs
+++ b/src/libcore/hash/sip.rs
@@ -11,27 +11,27 @@
 // ignore-lexer-test FIXME #15883
 
 //! An implementation of SipHash 2-4.
-//!
-//! See: http://131002.net/siphash/
-//!
-//! Consider this as a main "general-purpose" hash for all hashtables: it
-//! runs at good speed (competitive with spooky and city) and permits
-//! strong _keyed_ hashing. Key your hashtables from a strong RNG,
-//! such as `rand::Rng`.
-//!
-//! Although the SipHash algorithm is considered to be cryptographically
-//! strong, this implementation has not been reviewed for such purposes.
-//! As such, all cryptographic uses of this implementation are strongly
-//! discouraged.
 
 use prelude::*;
 use default::Default;
 
-use super::{Hash, Hasher, Writer};
-
-/// `SipState` computes a SipHash 2-4 hash over a stream of bytes.
-#[derive(Copy)]
-pub struct SipState {
+use super::{Hasher, Writer};
+
+/// An implementation of SipHash 2-4.
+///
+/// See: http://131002.net/siphash/
+///
+/// Consider this as a main "general-purpose" hash for all hashtables: it
+/// runs at good speed (competitive with spooky and city) and permits
+/// strong _keyed_ hashing. Key your hashtables from a strong RNG,
+/// such as `rand::Rng`.
+///
+/// Although the SipHash algorithm is considered to be cryptographically
+/// strong, this implementation has not been reviewed for such purposes.
+/// As such, all cryptographic uses of this implementation are strongly
+/// discouraged.
+#[allow(missing_copy_implementations)]
+pub struct SipHasher {
     k0: u64,
     k1: u64,
     length: uint, // how many bytes we've processed
@@ -86,17 +86,17 @@ macro_rules! compress {
     })
 }
 
-impl SipState {
-    /// Creates a `SipState` that is keyed off the provided keys.
+impl SipHasher {
+    /// Creates a new `SipHasher` with the two initial keys set to 0.
     #[inline]
-    pub fn new() -> SipState {
-        SipState::new_with_keys(0, 0)
+    pub fn new() -> SipHasher {
+        SipHasher::new_with_keys(0, 0)
     }
 
-    /// Creates a `SipState` that is keyed off the provided keys.
+    /// Creates a `SipHasher` that is keyed off the provided keys.
     #[inline]
-    pub fn new_with_keys(key0: u64, key1: u64) -> SipState {
-        let mut state = SipState {
+    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher {
+        let mut state = SipHasher {
             k0: key0,
             k1: key1,
             length: 0,
@@ -111,43 +111,12 @@ impl SipState {
         state
     }
 
-    /// Resets the state to its initial state.
-    #[inline]
-    pub fn reset(&mut self) {
-        self.length = 0;
-        self.v0 = self.k0 ^ 0x736f6d6570736575;
-        self.v1 = self.k1 ^ 0x646f72616e646f6d;
-        self.v2 = self.k0 ^ 0x6c7967656e657261;
-        self.v3 = self.k1 ^ 0x7465646279746573;
-        self.ntail = 0;
-    }
-
     /// Returns the computed hash.
-    #[inline]
-    pub fn result(&self) -> u64 {
-        let mut v0 = self.v0;
-        let mut v1 = self.v1;
-        let mut v2 = self.v2;
-        let mut v3 = self.v3;
-
-        let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
-
-        v3 ^= b;
-        compress!(v0, v1, v2, v3);
-        compress!(v0, v1, v2, v3);
-        v0 ^= b;
-
-        v2 ^= 0xff;
-        compress!(v0, v1, v2, v3);
-        compress!(v0, v1, v2, v3);
-        compress!(v0, v1, v2, v3);
-        compress!(v0, v1, v2, v3);
-
-        v0 ^ v1 ^ v2 ^ v3
-    }
+    #[deprecated = "renamed to finish"]
+    pub fn result(&self) -> u64 { self.finish() }
 }
 
-impl Writer for SipState {
+impl Writer for SipHasher {
     #[inline]
     fn write(&mut self, msg: &[u8]) {
         let length = msg.len();
@@ -195,355 +164,60 @@ impl Writer for SipState {
     }
 }
 
-#[stable]
-impl Clone for SipState {
-    #[inline]
-    fn clone(&self) -> SipState {
-        *self
-    }
-}
+impl Hasher for SipHasher {
+    type Output = u64;
 
-#[stable]
-impl Default for SipState {
-    #[inline]
-    #[stable]
-    fn default() -> SipState {
-        SipState::new()
+    fn reset(&mut self) {
+        self.length = 0;
+        self.v0 = self.k0 ^ 0x736f6d6570736575;
+        self.v1 = self.k1 ^ 0x646f72616e646f6d;
+        self.v2 = self.k0 ^ 0x6c7967656e657261;
+        self.v3 = self.k1 ^ 0x7465646279746573;
+        self.ntail = 0;
     }
-}
 
-/// `SipHasher` computes the SipHash algorithm from a stream of bytes.
-#[derive(Clone)]
-#[allow(missing_copy_implementations)]
-pub struct SipHasher {
-    k0: u64,
-    k1: u64,
-}
+    fn finish(&self) -> u64 {
+        let mut v0 = self.v0;
+        let mut v1 = self.v1;
+        let mut v2 = self.v2;
+        let mut v3 = self.v3;
 
-impl SipHasher {
-    /// Creates a `Sip`.
-    #[inline]
-    pub fn new() -> SipHasher {
-        SipHasher::new_with_keys(0, 0)
-    }
+        let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;
 
-    /// Creates a `Sip` that is keyed off the provided keys.
-    #[inline]
-    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher {
-        SipHasher {
-            k0: key0,
-            k1: key1,
-        }
+        v3 ^= b;
+        compress!(v0, v1, v2, v3);
+        compress!(v0, v1, v2, v3);
+        v0 ^= b;
+
+        v2 ^= 0xff;
+        compress!(v0, v1, v2, v3);
+        compress!(v0, v1, v2, v3);
+        compress!(v0, v1, v2, v3);
+        compress!(v0, v1, v2, v3);
+
+        v0 ^ v1 ^ v2 ^ v3
     }
 }
 
-impl Hasher<SipState> for SipHasher {
+impl Clone for SipHasher {
     #[inline]
-    fn hash<T: ?Sized + Hash<SipState>>(&self, value: &T) -> u64 {
-        let mut state = SipState::new_with_keys(self.k0, self.k1);
-        value.hash(&mut state);
-        state.result()
+    fn clone(&self) -> SipHasher {
+        SipHasher {
+            k0: self.k0,
+            k1: self.k1,
+            length: self.length,
+            v0: self.v0,
+            v1: self.v1,
+            v2: self.v2,
+            v3: self.v3,
+            tail: self.tail,
+            ntail: self.ntail,
+        }
     }
 }
 
 impl Default for SipHasher {
-    #[inline]
     fn default() -> SipHasher {
         SipHasher::new()
     }
 }
-
-/// Hashes a value using the SipHash algorithm.
-#[inline]
-pub fn hash<T: ?Sized + Hash<SipState>>(value: &T) -> u64 {
-    let mut state = SipState::new();
-    value.hash(&mut state);
-    state.result()
-}
-
-/// Hashes a value with the SipHash algorithm with the provided keys.
-#[inline]
-pub fn hash_with_keys<T: ?Sized + Hash<SipState>>(k0: u64, k1: u64, value: &T) -> u64 {
-    let mut state = SipState::new_with_keys(k0, k1);
-    value.hash(&mut state);
-    state.result()
-}
-
-#[cfg(test)]
-mod tests {
-    use test::Bencher;
-    use prelude::*;
-    use std::fmt;
-
-    use super::super::{Hash, Writer};
-    use super::{SipState, hash, hash_with_keys};
-
-    // Hash just the bytes of the slice, without length prefix
-    struct Bytes<'a>(&'a [u8]);
-
-    impl<'a, S: Writer> Hash<S> for Bytes<'a> {
-        #[allow(unused_must_use)]
-        fn hash(&self, state: &mut S) {
-            let Bytes(v) = *self;
-            state.write(v);
-        }
-    }
-
-    #[test]
-    #[allow(unused_must_use)]
-    fn test_siphash() {
-        let vecs : [[u8; 8]; 64] = [
-            [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ],
-            [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ],
-            [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ],
-            [ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, ],
-            [ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, ],
-            [ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, ],
-            [ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, ],
-            [ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, ],
-            [ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, ],
-            [ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, ],
-            [ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, ],
-            [ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, ],
-            [ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, ],
-            [ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, ],
-            [ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, ],
-            [ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, ],
-            [ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, ],
-            [ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, ],
-            [ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, ],
-            [ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, ],
-            [ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, ],
-            [ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, ],
-            [ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, ],
-            [ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, ],
-            [ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, ],
-            [ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, ],
-            [ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, ],
-            [ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, ],
-            [ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, ],
-            [ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, ],
-            [ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, ],
-            [ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, ],
-            [ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, ],
-            [ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, ],
-            [ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, ],
-            [ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, ],
-            [ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, ],
-            [ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, ],
-            [ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, ],
-            [ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, ],
-            [ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, ],
-            [ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, ],
-            [ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, ],
-            [ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, ],
-            [ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, ],
-            [ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, ],
-            [ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, ],
-            [ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, ],
-            [ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, ],
-            [ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, ],
-            [ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, ],
-            [ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, ],
-            [ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, ],
-            [ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, ],
-            [ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, ],
-            [ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, ],
-            [ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, ],
-            [ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, ],
-            [ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, ],
-            [ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, ],
-            [ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, ],
-            [ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, ],
-            [ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, ],
-            [ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, ]
-        ];
-
-        let k0 = 0x_07_06_05_04_03_02_01_00_u64;
-        let k1 = 0x_0f_0e_0d_0c_0b_0a_09_08_u64;
-        let mut buf = Vec::new();
-        let mut t = 0;
-        let mut state_inc = SipState::new_with_keys(k0, k1);
-        let mut state_full = SipState::new_with_keys(k0, k1);
-
-        fn to_hex_str(r: &[u8; 8]) -> String {
-            let mut s = String::new();
-            for b in r.iter() {
-                s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());
-            }
-            s
-        }
-
-        fn result_bytes(h: u64) -> Vec<u8> {
-            vec![(h >> 0) as u8,
-              (h >> 8) as u8,
-              (h >> 16) as u8,
-              (h >> 24) as u8,
-              (h >> 32) as u8,
-              (h >> 40) as u8,
-              (h >> 48) as u8,
-              (h >> 56) as u8,
-            ]
-        }
-
-        fn result_str(h: u64) -> String {
-            let r = result_bytes(h);
-            let mut s = String::new();
-            for b in r.iter() {
-                s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());
-            }
-            s
-        }
-
-        while t < 64 {
-            debug!("siphash test {}: {}", t, buf);
-            let vec = u8to64_le!(vecs[t], 0);
-            let out = hash_with_keys(k0, k1, &Bytes(buf.as_slice()));
-            debug!("got {}, expected {}", out, vec);
-            assert_eq!(vec, out);
-
-            state_full.reset();
-            state_full.write(buf.as_slice());
-            let f = result_str(state_full.result());
-            let i = result_str(state_inc.result());
-            let v = to_hex_str(&vecs[t]);
-            debug!("{}: ({}) => inc={} full={}", t, v, i, f);
-
-            assert_eq!(f, i);
-            assert_eq!(f, v);
-
-            buf.push(t as u8);
-            state_inc.write(&[t as u8]);
-
-            t += 1;
-        }
-    }
-
-    #[test] #[cfg(target_arch = "aarch64")]
-    fn test_hash_uint() {
-        let val = 0xdeadbeef_deadbeef_u64;
-        assert_eq!(hash(&(val as u64)), hash(&(val as uint)));
-        assert!(hash(&(val as u32)) != hash(&(val as uint)));
-    }
-    #[test] #[cfg(target_arch = "arm")]
-    fn test_hash_uint() {
-        let val = 0xdeadbeef_deadbeef_u64;
-        assert!(hash(&(val as u64)) != hash(&(val as uint)));
-        assert_eq!(hash(&(val as u32)), hash(&(val as uint)));
-    }
-    #[test] #[cfg(target_arch = "x86_64")]
-    fn test_hash_uint() {
-        let val = 0xdeadbeef_deadbeef_u64;
-        assert_eq!(hash(&(val as u64)), hash(&(val as uint)));
-        assert!(hash(&(val as u32)) != hash(&(val as uint)));
-    }
-    #[test] #[cfg(target_arch = "x86")]
-    fn test_hash_uint() {
-        let val = 0xdeadbeef_deadbeef_u64;
-        assert!(hash(&(val as u64)) != hash(&(val as uint)));
-        assert_eq!(hash(&(val as u32)), hash(&(val as uint)));
-    }
-
-    #[test]
-    fn test_hash_idempotent() {
-        let val64 = 0xdeadbeef_deadbeef_u64;
-        assert_eq!(hash(&val64), hash(&val64));
-        let val32 = 0xdeadbeef_u32;
-        assert_eq!(hash(&val32), hash(&val32));
-    }
-
-    #[test]
-    fn test_hash_no_bytes_dropped_64() {
-        let val = 0xdeadbeef_deadbeef_u64;
-
-        assert!(hash(&val) != hash(&zero_byte(val, 0)));
-        assert!(hash(&val) != hash(&zero_byte(val, 1)));
-        assert!(hash(&val) != hash(&zero_byte(val, 2)));
-        assert!(hash(&val) != hash(&zero_byte(val, 3)));
-        assert!(hash(&val) != hash(&zero_byte(val, 4)));
-        assert!(hash(&val) != hash(&zero_byte(val, 5)));
-        assert!(hash(&val) != hash(&zero_byte(val, 6)));
-        assert!(hash(&val) != hash(&zero_byte(val, 7)));
-
-        fn zero_byte(val: u64, byte: uint) -> u64 {
-            assert!(byte < 8);
-            val & !(0xff << (byte * 8))
-        }
-    }
-
-    #[test]
-    fn test_hash_no_bytes_dropped_32() {
-        let val = 0xdeadbeef_u32;
-
-        assert!(hash(&val) != hash(&zero_byte(val, 0)));
-        assert!(hash(&val) != hash(&zero_byte(val, 1)));
-        assert!(hash(&val) != hash(&zero_byte(val, 2)));
-        assert!(hash(&val) != hash(&zero_byte(val, 3)));
-
-        fn zero_byte(val: u32, byte: uint) -> u32 {
-            assert!(byte < 4);
-            val & !(0xff << (byte * 8))
-        }
-    }
-
-    #[test]
-    fn test_hash_no_concat_alias() {
-        let s = ("aa", "bb");
-        let t = ("aabb", "");
-        let u = ("a", "abb");
-
-        assert!(s != t && t != u);
-        assert!(hash(&s) != hash(&t) && hash(&s) != hash(&u));
-
-        let v: (&[u8], &[u8], &[u8]) = (&[1u8], &[0u8, 0], &[0u8]);
-        let w: (&[u8], &[u8], &[u8]) = (&[1u8, 0, 0, 0], &[], &[]);
-
-        assert!(v != w);
-        assert!(hash(&v) != hash(&w));
-    }
-
-    #[bench]
-    fn bench_str_under_8_bytes(b: &mut Bencher) {
-        let s = "foo";
-        b.iter(|| {
-            assert_eq!(hash(&s), 16262950014981195938);
-        })
-    }
-
-    #[bench]
-    fn bench_str_of_8_bytes(b: &mut Bencher) {
-        let s = "foobar78";
-        b.iter(|| {
-            assert_eq!(hash(&s), 4898293253460910787);
-        })
-    }
-
-    #[bench]
-    fn bench_str_over_8_bytes(b: &mut Bencher) {
-        let s = "foobarbaz0";
-        b.iter(|| {
-            assert_eq!(hash(&s), 10581415515220175264);
-        })
-    }
-
-    #[bench]
-    fn bench_long_str(b: &mut Bencher) {
-        let s = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor \
-incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \
-exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute \
-irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla \
-pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui \
-officia deserunt mollit anim id est laborum.";
-        b.iter(|| {
-            assert_eq!(hash(&s), 17717065544121360093);
-        })
-    }
-
-    #[bench]
-    fn bench_u64(b: &mut Bencher) {
-        let u = 16262950014981195938u64;
-        b.iter(|| {
-            assert_eq!(hash(&u), 5254097107239593357);
-        })
-    }
-}
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index 822416a387e63..c8b3616a4042e 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -42,6 +42,9 @@
 #![experimental]
 #![allow(missing_docs)]
 
+#[cfg(not(stage0))]
+use marker::Sized;
+
 pub type GlueFn = extern "Rust" fn(*const i8);
 
 #[lang="ty_desc"]
@@ -200,6 +203,10 @@ extern "rust-intrinsic" {
     /// Gets an identifier which is globally unique to the specified type. This
     /// function will return the same value for a type regardless of whichever
     /// crate it is invoked in.
+    #[cfg(not(stage0))]
+    pub fn type_id<T: ?Sized + 'static>() -> TypeId;
+
+    #[cfg(stage0)]
     pub fn type_id<T: 'static>() -> TypeId;
 
     /// Create a value initialized to zero.
@@ -551,8 +558,15 @@ pub struct TypeId {
 
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been instantiated with
+    #[cfg(not(stage0))]
+    pub fn of<T: ?Sized + 'static>() -> TypeId {
+        unsafe { type_id::<T>() }
+    }
+
+    #[cfg(stage0)]
     pub fn of<T: 'static>() -> TypeId {
         unsafe { type_id::<T>() }
     }
+
     pub fn hash(&self) -> u64 { self.t }
 }
diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs
index d30cfc405a1ff..273a51665ce8a 100644
--- a/src/libcore/iter.rs
+++ b/src/libcore/iter.rs
@@ -2344,7 +2344,7 @@ impl<A, I, F> RandomAccessIterator for Inspect<A, I, F> where
 ///
 /// // This iterator will yield up to the last Fibonacci number before the max value of `u32`.
 /// // You can simply change `u32` to `u64` in this line if you want higher values than that.
-/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&(ref mut x2, ref mut x1)| {
+/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)), |&mut (ref mut x2, ref mut x1)| {
 ///     // Attempt to get the next Fibonacci number
 ///     // `x1` will be `None` if previously overflowed.
 ///     let next = match (*x2, *x1) {
@@ -2749,9 +2749,9 @@ macro_rules! step_impl_no_between {
 }
 
 step_impl!(uint u8 u16 u32 int i8 i16 i32);
-#[cfg(target_word_size = "64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 step_impl!(u64 i64);
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 step_impl_no_between!(u64 i64);
 
 
@@ -2804,7 +2804,7 @@ pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
         T: Clone,
         F: FnMut(T) -> T,
     {
-        let &(ref mut f, ref mut val, ref mut first) = st;
+        let &mut (ref mut f, ref mut val, ref mut first) = st;
         if *first {
             *first = false;
         } else {
diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs
index a7e3b61b0d42b..af5aba53bf478 100644
--- a/src/libcore/lib.rs
+++ b/src/libcore/lib.rs
@@ -49,6 +49,7 @@
 
 #![crate_name = "core"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
@@ -57,6 +58,7 @@
 
 #![no_std]
 #![allow(unknown_features, raw_pointer_derive)]
+#![cfg_attr(stage0, allow(unused_attributes))]
 #![feature(intrinsics, lang_items)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
 #![feature(unboxed_closures)]
@@ -78,12 +80,14 @@ mod int_macros;
 mod uint_macros;
 
 #[path = "num/int.rs"]  pub mod int;
+#[path = "num/isize.rs"]  pub mod isize;
 #[path = "num/i8.rs"]   pub mod i8;
 #[path = "num/i16.rs"]  pub mod i16;
 #[path = "num/i32.rs"]  pub mod i32;
 #[path = "num/i64.rs"]  pub mod i64;
 
 #[path = "num/uint.rs"] pub mod uint;
+#[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]   pub mod u8;
 #[path = "num/u16.rs"]  pub mod u16;
 #[path = "num/u32.rs"]  pub mod u32;
@@ -146,8 +150,6 @@ mod core {
 mod std {
     pub use clone;
     pub use cmp;
-    #[cfg(stage0)]
-    pub use marker as kinds;
     pub use marker;
     pub use option;
     pub use fmt;
diff --git a/src/libcore/num/int.rs b/src/libcore/num/int.rs
index 91c5e4163f9e5..065763a0d8ed4 100644
--- a/src/libcore/num/int.rs
+++ b/src/libcore/num/int.rs
@@ -8,10 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized signed integers (`int` type)
+//! Deprecated: replaced by `isize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "int")]
+#![deprecated = "replaced by isize"]
 
-#[cfg(target_word_size = "32")] int_module! { int, 32 }
-#[cfg(target_word_size = "64")] int_module! { int, 64 }
+#[cfg(stage0)] #[cfg(target_word_size = "32")] int_module! { int, 32 }
+#[cfg(stage0)] #[cfg(target_word_size = "64")] int_module! { int, 64 }
+
+#[cfg(not(stage0))] #[cfg(target_pointer_width = "32")] int_module! { int, 32 }
+#[cfg(not(stage0))] #[cfg(target_pointer_width = "64")] int_module! { int, 64 }
diff --git a/src/libcore/num/isize.rs b/src/libcore/num/isize.rs
new file mode 100644
index 0000000000000..c1cf3c6213148
--- /dev/null
+++ b/src/libcore/num/isize.rs
@@ -0,0 +1,25 @@
+// Copyright 2012-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.
+
+//! Operations and constants for pointer-sized signed integers (`isize` type)
+//!
+//! This type was recently added to replace `int`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "isize")]
+
+#[cfg(any(all(stage0, target_word_size = "32"),
+          all(not(stage0), target_pointer_width = "32")))]
+int_module! { isize, 32 }
+#[cfg(any(all(stage0, target_word_size = "64"),
+          all(not(stage0), target_pointer_width = "64")))]
+int_module! { isize, 64 }
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 490d8111f463a..91fed8a31bd40 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -24,7 +24,7 @@ use iter::IteratorExt;
 use marker::Copy;
 use mem::size_of;
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
-use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr, Index};
+use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::Option;
 use option::Option::{Some, None};
 use str::{FromStr, StrExt};
@@ -496,7 +496,7 @@ uint_impl! { u64 = u64, 64,
     intrinsics::u64_sub_with_overflow,
     intrinsics::u64_mul_with_overflow }
 
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 uint_impl! { uint = u32, 32,
     intrinsics::ctpop32,
     intrinsics::ctlz32,
@@ -506,7 +506,7 @@ uint_impl! { uint = u32, 32,
     intrinsics::u32_sub_with_overflow,
     intrinsics::u32_mul_with_overflow }
 
-#[cfg(target_word_size = "64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 uint_impl! { uint = u64, 64,
     intrinsics::ctpop64,
     intrinsics::ctlz64,
@@ -601,13 +601,13 @@ int_impl! { i64 = i64, u64, 64,
     intrinsics::i64_sub_with_overflow,
     intrinsics::i64_mul_with_overflow }
 
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 int_impl! { int = i32, u32, 32,
     intrinsics::i32_add_with_overflow,
     intrinsics::i32_sub_with_overflow,
     intrinsics::i32_mul_with_overflow }
 
-#[cfg(target_word_size = "64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 int_impl! { int = i64, u64, 64,
     intrinsics::i64_add_with_overflow,
     intrinsics::i64_sub_with_overflow,
@@ -1577,7 +1577,7 @@ macro_rules! from_str_radix_float_impl {
                         };
 
                         // Parse the exponent as decimal integer
-                        let src = src.index(&(offset..));
+                        let src = &src[offset..];
                         let (is_positive, exp) = match src.slice_shift_char() {
                             Some(('-', src)) => (false, src.parse::<uint>()),
                             Some(('+', src)) => (true,  src.parse::<uint>()),
diff --git a/src/libcore/num/uint.rs b/src/libcore/num/uint.rs
index 35739f68da969..7931890ca5efb 100644
--- a/src/libcore/num/uint.rs
+++ b/src/libcore/num/uint.rs
@@ -8,9 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized unsigned integers (`uint` type)
+//! Deprecated: replaced by `usize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "uint")]
+#![deprecated = "replaced by usize"]
 
 uint_module! { uint, int, ::int::BITS }
diff --git a/src/libcore/num/usize.rs b/src/libcore/num/usize.rs
new file mode 100644
index 0000000000000..5eebcd51a7765
--- /dev/null
+++ b/src/libcore/num/usize.rs
@@ -0,0 +1,20 @@
+// Copyright 2012-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.
+
+//! Operations and constants for pointer-sized unsigned integers (`usize` type)
+//!
+//! This type was recently added to replace `uint`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "usize")]
+
+uint_module! { usize, isize, ::isize::BITS }
diff --git a/src/libcore/ops.rs b/src/libcore/ops.rs
index 4debab91739c1..ab956587d8248 100644
--- a/src/libcore/ops.rs
+++ b/src/libcore/ops.rs
@@ -65,6 +65,7 @@ use clone::Clone;
 use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
 use marker::Sized;
 use option::Option::{self, Some, None};
+use fmt;
 
 /// The `Drop` trait is used to run some code when a value goes out of scope. This
 /// is sometimes called a 'destructor'.
@@ -847,13 +848,20 @@ pub trait IndexMut<Index: ?Sized> {
 }
 
 /// An unbounded range.
-#[derive(Copy)]
+#[derive(Copy, PartialEq, Eq)]
 #[lang="full_range"]
 #[unstable = "API still in development"]
 pub struct FullRange;
 
+#[unstable = "API still in development"]
+impl fmt::Show for FullRange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Show::fmt("..", fmt)
+    }
+}
+
 /// A (half-open) range which is bounded at both ends.
-#[derive(Copy)]
+#[derive(Copy, PartialEq, Eq)]
 #[lang="range"]
 #[unstable = "API still in development"]
 pub struct Range<Idx> {
@@ -904,8 +912,15 @@ impl<Idx: Clone + Step> DoubleEndedIterator for Range<Idx> {
 #[unstable = "API still in development"]
 impl<Idx: Clone + Step> ExactSizeIterator for Range<Idx> {}
 
+#[unstable = "API still in development"]
+impl<Idx: fmt::Show> fmt::Show for Range<Idx> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}..{:?}", self.start, self.end)
+    }
+}
+
 /// A range which is only bounded below.
-#[derive(Copy)]
+#[derive(Copy, PartialEq, Eq)]
 #[lang="range_from"]
 #[unstable = "API still in development"]
 pub struct RangeFrom<Idx> {
@@ -926,8 +941,15 @@ impl<Idx: Clone + Step> Iterator for RangeFrom<Idx> {
     }
 }
 
+#[unstable = "API still in development"]
+impl<Idx: fmt::Show> fmt::Show for RangeFrom<Idx> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}..", self.start)
+    }
+}
+
 /// A range which is only bounded above.
-#[derive(Copy)]
+#[derive(Copy, PartialEq, Eq)]
 #[lang="range_to"]
 #[unstable = "API still in development"]
 pub struct RangeTo<Idx> {
@@ -935,6 +957,13 @@ pub struct RangeTo<Idx> {
     pub end: Idx,
 }
 
+#[unstable = "API still in development"]
+impl<Idx: fmt::Show> fmt::Show for RangeTo<Idx> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "..{:?}", self.end)
+    }
+}
+
 
 /// The `Deref` trait is used to specify the functionality of dereferencing
 /// operations like `*v`.
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index 272570a0d5bb9..deee67b6d2fd7 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -66,10 +66,11 @@
 //! not (`None`).
 //!
 //! ```
+//! # use std::boxed::Box;
 //! let optional: Option<Box<int>> = None;
 //! check_optional(&optional);
 //!
-//! let optional: Option<Box<int>> = Some(box 9000);
+//! let optional: Option<Box<int>> = Some(Box::new(9000));
 //! check_optional(&optional);
 //!
 //! fn check_optional(optional: &Option<Box<int>>) {
@@ -145,17 +146,17 @@
 
 use self::Option::*;
 
+use clone::Clone;
 use cmp::{Eq, Ord};
 use default::Default;
-use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator};
 use iter::{ExactSizeIterator};
+use iter::{Iterator, IteratorExt, DoubleEndedIterator, FromIterator};
 use mem;
-use result::Result;
+use ops::{Deref, FnOnce};
 use result::Result::{Ok, Err};
-use slice;
+use result::Result;
 use slice::AsSlice;
-use clone::Clone;
-use ops::{Deref, FnOnce};
+use slice;
 
 // Note that this is not a lang item per se, but it has a hidden dependency on
 // `Iterator`, which is one. The compiler assumes that the `next` method of
@@ -533,7 +534,7 @@ impl<T> Option<T> {
     /// ```
     /// let mut x = Some(4u);
     /// match x.iter_mut().next() {
-    ///     Some(&ref mut v) => *v = 42u,
+    ///     Some(&mut ref mut v) => *v = 42u,
     ///     None => {},
     /// }
     /// assert_eq!(x, Some(42));
@@ -762,7 +763,6 @@ impl<T> AsSlice<T> for Option<T> {
 
 #[stable]
 impl<T> Default for Option<T> {
-    #[stable]
     #[inline]
     #[stable]
     fn default() -> Option<T> { None }
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index 20305c3191a09..a17cd410303a5 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -46,12 +46,13 @@
 //! though unsafely, transformed from one type to the other.
 //!
 //! ```
+//! # use std::boxed::Box;
 //! use std::mem;
 //!
 //! unsafe {
-//!     let my_num: Box<int> = box 10;
+//!     let my_num: Box<int> = Box::new(10);
 //!     let my_num: *const int = mem::transmute(my_num);
-//!     let my_speed: Box<int> = box 88;
+//!     let my_speed: Box<int> = Box::new(88);
 //!     let my_speed: *mut int = mem::transmute(my_speed);
 //!
 //!     // By taking ownership of the original `Box<T>` though
diff --git a/src/libcore/result.rs b/src/libcore/result.rs
index 95ae6ebfb68c3..7868ec67c8a3a 100644
--- a/src/libcore/result.rs
+++ b/src/libcore/result.rs
@@ -383,8 +383,8 @@ impl<T, E> Result<T, E> {
     /// ```
     /// fn mutate(r: &mut Result<int, int>) {
     ///     match r.as_mut() {
-    ///         Ok(&ref mut v) => *v = 42,
-    ///         Err(&ref mut e) => *e = 0,
+    ///         Ok(&mut ref mut v) => *v = 42,
+    ///         Err(&mut ref mut e) => *e = 0,
     ///     }
     /// }
     ///
@@ -529,7 +529,7 @@ impl<T, E> Result<T, E> {
     /// ```
     /// let mut x: Result<uint, &str> = Ok(7);
     /// match x.iter_mut().next() {
-    ///     Some(&ref mut x) => *x = 40,
+    ///     Some(&mut ref mut x) => *x = 40,
     ///     None => {},
     /// }
     /// assert_eq!(x, Ok(40));
diff --git a/src/libcore/slice.rs b/src/libcore/slice.rs
index bf2df46537008..6c62bfda1fecc 100644
--- a/src/libcore/slice.rs
+++ b/src/libcore/slice.rs
@@ -159,7 +159,7 @@ impl<T> SliceExt for [T] {
 
     #[inline]
     fn split_at(&self, mid: uint) -> (&[T], &[T]) {
-        (self.index(&(0..mid)), self.index(&(mid..)))
+        (&self[0..mid], &self[mid..])
     }
 
     #[inline]
@@ -236,11 +236,11 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn tail(&self) -> &[T] { self.index(&(1..)) }
+    fn tail(&self) -> &[T] { &self[1..] }
 
     #[inline]
     fn init(&self) -> &[T] {
-        self.index(&(0..(self.len() - 1)))
+        &self[0..(self.len() - 1)]
     }
 
     #[inline]
@@ -443,13 +443,13 @@ impl<T> SliceExt for [T] {
     #[inline]
     fn starts_with(&self, needle: &[T]) -> bool where T: PartialEq {
         let n = needle.len();
-        self.len() >= n && needle == self.index(&(0..n))
+        self.len() >= n && needle == &self[0..n]
     }
 
     #[inline]
     fn ends_with(&self, needle: &[T]) -> bool where T: PartialEq {
         let (m, n) = (self.len(), needle.len());
-        m >= n && needle == self.index(&((m-n)..))
+        m >= n && needle == &self[(m-n)..]
     }
 
     #[unstable]
@@ -972,8 +972,8 @@ impl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {
         match self.v.iter().position(|x| (self.pred)(x)) {
             None => self.finish(),
             Some(idx) => {
-                let ret = Some(self.v.index(&(0..idx)));
-                self.v = self.v.index(&((idx + 1)..));
+                let ret = Some(&self.v[0..idx]);
+                self.v = &self.v[(idx + 1)..];
                 ret
             }
         }
@@ -998,8 +998,8 @@ impl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> boo
         match self.v.iter().rposition(|x| (self.pred)(x)) {
             None => self.finish(),
             Some(idx) => {
-                let ret = Some(self.v.index(&((idx + 1)..)));
-                self.v = self.v.index(&(0..idx));
+                let ret = Some(&self.v[(idx + 1)..]);
+                self.v = &self.v[0..idx];
                 ret
             }
         }
@@ -1195,8 +1195,8 @@ impl<'a, T> Iterator for Windows<'a, T> {
         if self.size > self.v.len() {
             None
         } else {
-            let ret = Some(self.v.index(&(0..self.size)));
-            self.v = self.v.index(&(1..));
+            let ret = Some(&self.v[0..self.size]);
+            self.v = &self.v[1..];
             ret
         }
     }
@@ -1283,7 +1283,7 @@ impl<'a, T> RandomAccessIterator for Chunks<'a, T> {
             let mut hi = lo + self.size;
             if hi < lo || hi > self.v.len() { hi = self.v.len(); }
 
-            Some(self.v.index(&(lo..hi)))
+            Some(&self.v[lo..hi])
         } else {
             None
         }
diff --git a/src/libcore/str/mod.rs b/src/libcore/str/mod.rs
index 3f8ce000e214c..6051c68b116ba 100644
--- a/src/libcore/str/mod.rs
+++ b/src/libcore/str/mod.rs
@@ -26,7 +26,7 @@ use iter::{Map, Iterator, IteratorExt, DoubleEndedIterator};
 use marker::Sized;
 use mem;
 use num::Int;
-use ops::{Fn, FnMut, Index};
+use ops::{Fn, FnMut};
 use option::Option::{self, None, Some};
 use ptr::PtrExt;
 use raw::{Repr, Slice};
@@ -580,7 +580,7 @@ impl NaiveSearcher {
 
     fn next(&mut self, haystack: &[u8], needle: &[u8]) -> Option<(uint, uint)> {
         while self.position + needle.len() <= haystack.len() {
-            if haystack.index(&(self.position .. self.position + needle.len())) == needle {
+            if &haystack[self.position .. self.position + needle.len()] == needle {
                 let match_pos = self.position;
                 self.position += needle.len(); // add 1 for all matches
                 return Some((match_pos, match_pos + needle.len()));
@@ -701,10 +701,10 @@ impl TwoWaySearcher {
         //
         // What's going on is we have some critical factorization (u, v) of the
         // needle, and we want to determine whether u is a suffix of
-        // v.index(&(0..period)). If it is, we use "Algorithm CP1". Otherwise we use
+        // &v[0..period]. If it is, we use "Algorithm CP1". Otherwise we use
         // "Algorithm CP2", which is optimized for when the period of the needle
         // is large.
-        if needle.index(&(0..crit_pos)) == needle.index(&(period.. period + crit_pos)) {
+        if &needle[0..crit_pos] == &needle[period.. period + crit_pos] {
             TwoWaySearcher {
                 crit_pos: crit_pos,
                 period: period,
@@ -1412,13 +1412,13 @@ impl StrExt for str {
     #[inline]
     fn starts_with(&self, needle: &str) -> bool {
         let n = needle.len();
-        self.len() >= n && needle.as_bytes() == self.as_bytes().index(&(0..n))
+        self.len() >= n && needle.as_bytes() == &self.as_bytes()[0..n]
     }
 
     #[inline]
     fn ends_with(&self, needle: &str) -> bool {
         let (m, n) = (self.len(), needle.len());
-        m >= n && needle.as_bytes() == self.as_bytes().index(&((m-n)..))
+        m >= n && needle.as_bytes() == &self.as_bytes()[(m-n)..]
     }
 
     #[inline]
diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index c0be3a287940a..e6a7170aceafb 100644
--- a/src/libcoretest/any.rs
+++ b/src/libcoretest/any.rs
@@ -101,12 +101,12 @@ fn any_downcast_mut() {
     }
 
     match a_r.downcast_mut::<uint>() {
-        Some(&612) => {}
+        Some(&mut 612) => {}
         x => panic!("Unexpected value {:?}", x)
     }
 
     match b_r.downcast_mut::<uint>() {
-        Some(&413) => {}
+        Some(&mut 413) => {}
         x => panic!("Unexpected value {:?}", x)
     }
 }
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index f901e8001767d..7b6b4f848085e 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -167,7 +167,7 @@ fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
         let mut buf = [0u8; 4];
         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf.index(&(0..n)), expect);
+        assert_eq!(&buf[0..n], expect);
     }
 
     check('x', &[0x78]);
@@ -181,7 +181,7 @@ fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
         let mut buf = [0u16; 2];
         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf.index(&(0..n)), expect);
+        assert_eq!(&buf[0..n], expect);
     }
 
     check('x', &[0x0078]);
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index 63bf9ec331454..d48820aee0640 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -7,27 +7,22 @@
 // <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.
-use core::marker::Sized;
-use std::mem;
-
-use core::slice::SliceExt;
-use core::hash::{Hash, Hasher, Writer};
 
-struct MyWriterHasher;
+use std::mem;
+use std::hash::{Hash, Hasher, Writer};
+use std::default::Default;
 
-impl Hasher<MyWriter> for MyWriterHasher {
-    fn hash<T: ?Sized + Hash<MyWriter>>(&self, value: &T) -> u64 {
-        let mut state = MyWriter { hash: 0 };
-        value.hash(&mut state);
-        state.hash
-    }
+struct MyHasher {
+    hash: u64,
 }
 
-struct MyWriter {
-    hash: u64,
+impl Default for MyHasher {
+    fn default() -> MyHasher {
+        MyHasher { hash: 0 }
+    }
 }
 
-impl Writer for MyWriter {
+impl Writer for MyHasher {
     // Most things we'll just add up the bytes.
     fn write(&mut self, buf: &[u8]) {
         for byte in buf.iter() {
@@ -36,66 +31,87 @@ impl Writer for MyWriter {
     }
 }
 
+impl Hasher for MyHasher {
+    type Output = u64;
+    fn reset(&mut self) { self.hash = 0; }
+    fn finish(&self) -> u64 { self.hash }
+}
+
+
 #[test]
 fn test_writer_hasher() {
-    let hasher = MyWriterHasher;
+    fn hash<T: Hash<MyHasher>>(t: &T) -> u64 {
+        ::std::hash::hash::<_, MyHasher>(t)
+    }
 
-    assert_eq!(hasher.hash(&()), 0);
+    assert_eq!(hash(&()), 0);
 
-    assert_eq!(hasher.hash(&5u8), 5);
-    assert_eq!(hasher.hash(&5u16), 5);
-    assert_eq!(hasher.hash(&5u32), 5);
-    assert_eq!(hasher.hash(&5u64), 5);
-    assert_eq!(hasher.hash(&5u), 5);
+    assert_eq!(hash(&5u8), 5);
+    assert_eq!(hash(&5u16), 5);
+    assert_eq!(hash(&5u32), 5);
+    assert_eq!(hash(&5u64), 5);
+    assert_eq!(hash(&5u), 5);
 
-    assert_eq!(hasher.hash(&5i8), 5);
-    assert_eq!(hasher.hash(&5i16), 5);
-    assert_eq!(hasher.hash(&5i32), 5);
-    assert_eq!(hasher.hash(&5i64), 5);
-    assert_eq!(hasher.hash(&5i), 5);
+    assert_eq!(hash(&5i8), 5);
+    assert_eq!(hash(&5i16), 5);
+    assert_eq!(hash(&5i32), 5);
+    assert_eq!(hash(&5i64), 5);
+    assert_eq!(hash(&5i), 5);
 
-    assert_eq!(hasher.hash(&false), 0);
-    assert_eq!(hasher.hash(&true), 1);
+    assert_eq!(hash(&false), 0);
+    assert_eq!(hash(&true), 1);
 
-    assert_eq!(hasher.hash(&'a'), 97);
+    assert_eq!(hash(&'a'), 97);
 
     let s: &str = "a";
-    assert_eq!(hasher.hash(& s), 97 + 0xFF);
+    assert_eq!(hash(& s), 97 + 0xFF);
     // FIXME (#18283) Enable test
     //let s: Box<str> = box "a";
     //assert_eq!(hasher.hash(& s), 97 + 0xFF);
     let cs: &[u8] = &[1u8, 2u8, 3u8];
-    assert_eq!(hasher.hash(& cs), 9);
+    assert_eq!(hash(& cs), 9);
     let cs: Box<[u8]> = box [1u8, 2u8, 3u8];
-    assert_eq!(hasher.hash(& cs), 9);
+    assert_eq!(hash(& cs), 9);
 
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
 
     unsafe {
         let ptr: *const int = mem::transmute(5i);
-        assert_eq!(hasher.hash(&ptr), 5);
+        assert_eq!(hash(&ptr), 5);
     }
 
     unsafe {
         let ptr: *mut int = mem::transmute(5i);
-        assert_eq!(hasher.hash(&ptr), 5);
+        assert_eq!(hash(&ptr), 5);
     }
 }
 
-struct Custom {
-    hash: u64
+struct Custom { hash: u64 }
+struct CustomHasher { output: u64 }
+
+impl Hasher for CustomHasher {
+    type Output = u64;
+    fn reset(&mut self) { self.output = 0; }
+    fn finish(&self) -> u64 { self.output }
+}
+
+impl Default for CustomHasher {
+    fn default() -> CustomHasher {
+        CustomHasher { output: 0 }
+    }
 }
 
-impl Hash<u64> for Custom {
-    fn hash(&self, state: &mut u64) {
-        *state = self.hash;
+impl Hash<CustomHasher> for Custom {
+    fn hash(&self, state: &mut CustomHasher) {
+        state.output = self.hash;
     }
 }
 
 #[test]
 fn test_custom_state() {
-    let custom = Custom { hash: 5 };
-    let mut state = 0;
-    custom.hash(&mut state);
-    assert_eq!(state, 5);
+    fn hash<T: Hash<CustomHasher>>(t: &T) -> u64 {
+        ::std::hash::hash::<_, CustomHasher>(t)
+    }
+
+    assert_eq!(hash(&Custom { hash: 5 }), 5);
 }
diff --git a/src/libcoretest/intrinsics.rs b/src/libcoretest/intrinsics.rs
new file mode 100644
index 0000000000000..bcf8a6a433b94
--- /dev/null
+++ b/src/libcoretest/intrinsics.rs
@@ -0,0 +1,31 @@
+// 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.
+
+use core::intrinsics::TypeId;
+
+#[test]
+fn test_typeid_sized_types() {
+    struct X; struct Y(uint);
+
+    assert_eq!(TypeId::of::<X>(), TypeId::of::<X>());
+    assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>());
+    assert!(TypeId::of::<X>() != TypeId::of::<Y>());
+}
+
+#[test]
+fn test_typeid_unsized_types() {
+    trait Z {}
+    struct X(str); struct Y(Z + 'static);
+
+    assert_eq!(TypeId::of::<X>(), TypeId::of::<X>());
+    assert_eq!(TypeId::of::<Y>(), TypeId::of::<Y>());
+    assert!(TypeId::of::<X>() != TypeId::of::<Y>());
+}
+
diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs
index 50ae59e70dc93..c12981b7d2484 100644
--- a/src/libcoretest/lib.rs
+++ b/src/libcoretest/lib.rs
@@ -7,8 +7,10 @@
 // <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.
-#![feature(globs, unsafe_destructor, slicing_syntax, default_type_params)]
+
+#![feature(unsafe_destructor, slicing_syntax)]
 #![feature(unboxed_closures)]
+#![feature(box_syntax)]
 
 extern crate core;
 extern crate test;
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index b9403598ec2b2..485549cc552ac 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::iter::range;
-
 pub fn op1() -> Result<int, &'static str> { Ok(666) }
 pub fn op2() -> Result<int, &'static str> { Err("sadface") }
 
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
index b714b6a4e417d..6fae384763f84 100644
--- a/src/libcoretest/slice.rs
+++ b/src/libcoretest/slice.rs
@@ -57,17 +57,17 @@ fn iterator_to_slice() {
             }
             {
                 let mut iter = data.iter_mut();
-                assert_eq!(iter.index(&FullRange), other_data.index(&FullRange));
+                assert_eq!(&iter[], &other_data[]);
                 // mutability:
                 assert!(&mut iter[] == other_data);
 
                 iter.next();
-                assert_eq!(iter.index(&FullRange), other_data.index(&(1..)));
+                assert_eq!(&iter[], &other_data[1..]);
                 assert!(&mut iter[] == &mut other_data[1..]);
 
                 iter.next_back();
 
-                assert_eq!(iter.index(&FullRange), other_data.index(&(1..2)));
+                assert_eq!(&iter[], &other_data[1..2]);
                 assert!(&mut iter[] == &mut other_data[1..2]);
 
                 let s = iter.into_slice();
diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs
index f38440d86c6e8..1896bdd182ae0 100644
--- a/src/libflate/lib.rs
+++ b/src/libflate/lib.rs
@@ -16,6 +16,7 @@
 
 #![crate_name = "flate"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
diff --git a/src/libfmt_macros/lib.rs b/src/libfmt_macros/lib.rs
index 47cc072a636a1..02eea5d024c7a 100644
--- a/src/libfmt_macros/lib.rs
+++ b/src/libfmt_macros/lib.rs
@@ -16,6 +16,7 @@
 
 #![crate_name = "fmt_macros"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -211,12 +212,12 @@ impl<'a> Parser<'a> {
                 self.cur.next();
             }
             Some((_, other)) => {
-                self.err(format!("expected `{:?}`, found `{:?}`", c,
-                                 other).index(&FullRange));
+                self.err(&format!("expected `{:?}`, found `{:?}`", c,
+                                  other)[]);
             }
             None => {
-                self.err(format!("expected `{:?}` but string was terminated",
-                                 c).index(&FullRange));
+                self.err(&format!("expected `{:?}` but string was terminated",
+                                  c)[]);
             }
         }
     }
@@ -239,12 +240,12 @@ impl<'a> Parser<'a> {
             // we may not consume the character, so clone the iterator
             match self.cur.clone().next() {
                 Some((pos, '}')) | Some((pos, '{')) => {
-                    return self.input.index(&(start..pos));
+                    return &self.input[start..pos];
                 }
                 Some(..) => { self.cur.next(); }
                 None => {
                     self.cur.next();
-                    return self.input.index(&(start..self.input.len()));
+                    return &self.input[start..self.input.len()];
                 }
             }
         }
@@ -284,7 +285,7 @@ impl<'a> Parser<'a> {
             flags: 0,
             precision: CountImplied,
             width: CountImplied,
-            ty: self.input.index(&(0..0)),
+            ty: &self.input[0..0],
         };
         if !self.consume(':') { return spec }
 
@@ -393,7 +394,7 @@ impl<'a> Parser<'a> {
                 self.cur.next();
                 pos
             }
-            Some(..) | None => { return self.input.index(&(0..0)); }
+            Some(..) | None => { return &self.input[0..0]; }
         };
         let mut end;
         loop {
@@ -405,7 +406,7 @@ impl<'a> Parser<'a> {
                 None => { end = self.input.len(); break }
             }
         }
-        self.input.index(&(start..end))
+        &self.input[start..end]
     }
 
     /// Optionally parses an integer at the current position. This doesn't deal
diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index f50e24c6354f1..1d6c99542b58e 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -79,6 +79,7 @@
 
 #![crate_name = "getopts"]
 #![experimental = "use the crates.io `getopts` library instead"]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -280,7 +281,7 @@ impl OptGroup {
 
 impl Matches {
     fn opt_vals(&self, nm: &str) -> Vec<Optval> {
-        match find_opt(self.opts.index(&FullRange), Name::from_str(nm)) {
+        match find_opt(&self.opts[], Name::from_str(nm)) {
             Some(id) => self.vals[id].clone(),
             None => panic!("No option '{}' defined", nm)
         }
@@ -308,7 +309,7 @@ impl Matches {
     /// Returns true if any of several options were matched.
     pub fn opts_present(&self, names: &[String]) -> bool {
         for nm in names.iter() {
-            match find_opt(self.opts.as_slice(), Name::from_str(nm.index(&FullRange))) {
+            match find_opt(self.opts.as_slice(), Name::from_str(&nm[])) {
                 Some(id) if !self.vals[id].is_empty() => return true,
                 _ => (),
             };
@@ -319,7 +320,7 @@ impl Matches {
     /// Returns the string argument supplied to one of several matching options or `None`.
     pub fn opts_str(&self, names: &[String]) -> Option<String> {
         for nm in names.iter() {
-            match self.opt_val(nm.index(&FullRange)) {
+            match self.opt_val(&nm[]) {
                 Some(Val(ref s)) => return Some(s.clone()),
                 _ => ()
             }
@@ -584,7 +585,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     while i < l {
         let cur = args[i].clone();
         let curlen = cur.len();
-        if !is_arg(cur.index(&FullRange)) {
+        if !is_arg(&cur[]) {
             free.push(cur);
         } else if cur == "--" {
             let mut j = i + 1;
@@ -594,7 +595,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
             let mut names;
             let mut i_arg = None;
             if cur.as_bytes()[1] == b'-' {
-                let tail = cur.index(&(2..curlen));
+                let tail = &cur[2..curlen];
                 let tail_eq: Vec<&str> = tail.split('=').collect();
                 if tail_eq.len() <= 1 {
                     names = vec!(Long(tail.to_string()));
@@ -630,7 +631,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                     };
 
                     if arg_follows && range.next < curlen {
-                        i_arg = Some(cur.index(&(range.next..curlen)).to_string());
+                        i_arg = Some((&cur[range.next..curlen]).to_string());
                         break;
                     }
 
@@ -658,7 +659,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                         v.push(Val((i_arg.clone())
                             .unwrap()));
                     } else if name_pos < names.len() || i + 1 == l ||
-                            is_arg(args[i + 1].index(&FullRange)) {
+                            is_arg(&args[i + 1][]) {
                         let v = &mut vals[optid];
                         v.push(Given);
                     } else {
@@ -721,7 +722,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
             0 => {}
             1 => {
                 row.push('-');
-                row.push_str(short_name.index(&FullRange));
+                row.push_str(&short_name[]);
                 row.push(' ');
             }
             _ => panic!("the short name should only be 1 ascii char long"),
@@ -732,7 +733,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
             0 => {}
             _ => {
                 row.push_str("--");
-                row.push_str(long_name.index(&FullRange));
+                row.push_str(&long_name[]);
                 row.push(' ');
             }
         }
@@ -740,10 +741,10 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
         // arg
         match hasarg {
             No => {}
-            Yes => row.push_str(hint.index(&FullRange)),
+            Yes => row.push_str(&hint[]),
             Maybe => {
                 row.push('[');
-                row.push_str(hint.index(&FullRange));
+                row.push_str(&hint[]);
                 row.push(']');
             }
         }
@@ -756,7 +757,7 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
                 row.push(' ');
             }
         } else {
-            row.push_str(desc_sep.index(&FullRange));
+            row.push_str(&desc_sep[]);
         }
 
         // Normalize desc to contain words separated by one space character
@@ -768,14 +769,14 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
 
         // FIXME: #5516 should be graphemes not codepoints
         let mut desc_rows = Vec::new();
-        each_split_within(desc_normalized_whitespace.index(&FullRange), 54, |substr| {
+        each_split_within(&desc_normalized_whitespace[], 54, |substr| {
             desc_rows.push(substr.to_string());
             true
         });
 
         // FIXME: #5516 should be graphemes not codepoints
         // wrapped description
-        row.push_str(desc_rows.connect(desc_sep.index(&FullRange)).index(&FullRange));
+        row.push_str(&desc_rows.connect(&desc_sep[])[]);
 
         row
     });
@@ -794,10 +795,10 @@ fn format_option(opt: &OptGroup) -> String {
     // Use short_name is possible, but fallback to long_name.
     if opt.short_name.len() > 0 {
         line.push('-');
-        line.push_str(opt.short_name.index(&FullRange));
+        line.push_str(&opt.short_name[]);
     } else {
         line.push_str("--");
-        line.push_str(opt.long_name.index(&FullRange));
+        line.push_str(&opt.long_name[]);
     }
 
     if opt.hasarg != No {
@@ -805,7 +806,7 @@ fn format_option(opt: &OptGroup) -> String {
         if opt.hasarg == Maybe {
             line.push('[');
         }
-        line.push_str(opt.hint.index(&FullRange));
+        line.push_str(&opt.hint[]);
         if opt.hasarg == Maybe {
             line.push(']');
         }
@@ -824,10 +825,10 @@ fn format_option(opt: &OptGroup) -> String {
 /// Derive a short one-line usage summary from a set of long options.
 pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> String {
     let mut line = format!("Usage: {} ", program_name);
-    line.push_str(opts.iter()
-                      .map(format_option)
-                      .collect::<Vec<String>>()
-                      .connect(" ").index(&FullRange));
+    line.push_str(&opts.iter()
+                       .map(format_option)
+                       .collect::<Vec<String>>()
+                       .connect(" ")[]);
     line
 }
 
@@ -890,9 +891,9 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
             (B, Cr, UnderLim) => { B }
             (B, Cr, OverLim)  if (i - last_start + 1) > lim
                             => panic!("word starting with {} longer than limit!",
-                                    ss.index(&(last_start..(i + 1)))),
+                                      &ss[last_start..(i + 1)]),
             (B, Cr, OverLim)  => {
-                *cont = it(ss.index(&(slice_start..last_end)));
+                *cont = it(&ss[slice_start..last_end]);
                 slice_start = last_start;
                 B
             }
@@ -902,7 +903,7 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
             }
             (B, Ws, OverLim)  => {
                 last_end = i;
-                *cont = it(ss.index(&(slice_start..last_end)));
+                *cont = it(&ss[slice_start..last_end]);
                 A
             }
 
@@ -911,14 +912,14 @@ fn each_split_within<F>(ss: &str, lim: uint, mut it: F) -> bool where
                 B
             }
             (C, Cr, OverLim)  => {
-                *cont = it(ss.index(&(slice_start..last_end)));
+                *cont = it(&ss[slice_start..last_end]);
                 slice_start = i;
                 last_start = i;
                 last_end = i;
                 B
             }
             (C, Ws, OverLim)  => {
-                *cont = it(ss.index(&(slice_start..last_end)));
+                *cont = it(&ss[slice_start..last_end]);
                 A
             }
             (C, Ws, UnderLim) => {
diff --git a/src/libgraphviz/lib.rs b/src/libgraphviz/lib.rs
index 83bad70e7b117..9d2318e253e72 100644
--- a/src/libgraphviz/lib.rs
+++ b/src/libgraphviz/lib.rs
@@ -266,6 +266,7 @@
 
 #![crate_name = "graphviz"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -452,7 +453,7 @@ impl<'a> LabelText<'a> {
     pub fn escape(&self) -> String {
         match self {
             &LabelStr(ref s) => s.escape_default(),
-            &EscStr(ref s) => LabelText::escape_str(s.index(&FullRange)),
+            &EscStr(ref s) => LabelText::escape_str(&s[]),
         }
     }
 
@@ -481,7 +482,7 @@ impl<'a> LabelText<'a> {
         let mut prefix = self.pre_escaped_content().into_owned();
         let suffix = suffix.pre_escaped_content();
         prefix.push_str(r"\n\n");
-        prefix.push_str(suffix.index(&FullRange));
+        prefix.push_str(&suffix[]);
         EscStr(prefix.into_cow())
     }
 }
@@ -675,7 +676,7 @@ mod tests {
 
     impl<'a> Labeller<'a, Node, &'a Edge> for LabelledGraph {
         fn graph_id(&'a self) -> Id<'a> {
-            Id::new(self.name.index(&FullRange)).unwrap()
+            Id::new(&self.name[]).unwrap()
         }
         fn node_id(&'a self, n: &Node) -> Id<'a> {
             id_name(n)
diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs
index 347a958076dff..c39fd074387f5 100644
--- a/src/liblibc/lib.rs
+++ b/src/liblibc/lib.rs
@@ -11,6 +11,7 @@
 #![crate_name = "libc"]
 #![crate_type = "rlib"]
 #![cfg_attr(not(feature = "cargo-build"), experimental)]
+#![cfg_attr(not(feature = "cargo-build"), staged_api)]
 #![no_std]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
@@ -5065,7 +5066,5 @@ pub fn issue_14344_workaround() {} // FIXME #14344 force linkage to happen corre
 #[doc(hidden)]
 #[cfg(not(test))]
 mod std {
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;
 }
diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs
index 08b01e956e1ac..0d5f6b65827a4 100644
--- a/src/liblog/lib.rs
+++ b/src/liblog/lib.rs
@@ -157,13 +157,17 @@
 
 #![crate_name = "log"]
 #![experimental = "use the crates.io `log` library instead"]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
+
+#![allow(unknown_features)]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 #![deny(missing_docs)]
 
 extern crate regex;
@@ -287,7 +291,7 @@ pub fn log(level: u32, loc: &'static LogLocation, args: fmt::Arguments) {
     // Test the literal string from args against the current filter, if there
     // is one.
     match unsafe { FILTER.as_ref() } {
-        Some(filter) if !filter.is_match(args.to_string().index(&FullRange)) => return,
+        Some(filter) if !filter.is_match(&args.to_string()[]) => return,
         _ => {}
     }
 
@@ -382,7 +386,7 @@ fn enabled(level: u32,
     // Search for the longest match, the vector is assumed to be pre-sorted.
     for directive in iter.rev() {
         match directive.name {
-            Some(ref name) if !module.starts_with(name.index(&FullRange)) => {},
+            Some(ref name) if !module.starts_with(&name[]) => {},
             Some(..) | None => {
                 return level <= directive.level
             }
@@ -397,7 +401,7 @@ fn enabled(level: u32,
 /// `Once` primitive (and this function is called from that primitive).
 fn init() {
     let (mut directives, filter) = match os::getenv("RUST_LOG") {
-        Some(spec) => directive::parse_logging_spec(spec.index(&FullRange)),
+        Some(spec) => directive::parse_logging_spec(&spec[]),
         None => (Vec::new(), None),
     };
 
diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index ad2a4dbec4e92..497e339b316c1 100644
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -25,6 +25,7 @@
 
 #![no_std]
 #![experimental]
+#![staged_api]
 
 #[macro_use]
 extern crate core;
@@ -193,7 +194,7 @@ pub trait Rng : Sized {
     ///
     /// let mut rng = thread_rng();
     /// let x = rng.gen_iter::<uint>().take(10).collect::<Vec<uint>>();
-    /// println!("{}", x);
+    /// println!("{:?}", x);
     /// println!("{:?}", rng.gen_iter::<(f64, bool)>().take(5)
     ///                     .collect::<Vec<(f64, bool)>>());
     /// ```
@@ -270,7 +271,7 @@ pub trait Rng : Sized {
     /// let mut rng = thread_rng();
     /// println!("{:?}", rng.choose(&choices));
     /// # // uncomment when slicing syntax is stable
-    /// //assert_eq!(rng.choose(choices.index(&(0..0))), None);
+    /// //assert_eq!(rng.choose(&choices[0..0]), None);
     /// ```
     fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
         if values.is_empty() {
@@ -290,9 +291,9 @@ pub trait Rng : Sized {
     /// let mut rng = thread_rng();
     /// let mut y = [1i, 2, 3];
     /// rng.shuffle(&mut y);
-    /// println!("{}", y.as_slice());
+    /// println!("{:?}", y.as_slice());
     /// rng.shuffle(&mut y);
-    /// println!("{}", y.as_slice());
+    /// println!("{:?}", y.as_slice());
     /// ```
     fn shuffle<T>(&mut self, values: &mut [T]) {
         let mut i = values.len();
@@ -495,8 +496,6 @@ pub struct Closed01<F>(pub F);
 mod std {
     pub use core::{option, fmt}; // panic!()
     pub use core::clone; // derive Clone
-    #[cfg(stage0)]
-    pub use core::marker as kinds;
     pub use core::marker;
 }
 
diff --git a/src/librbml/io.rs b/src/librbml/io.rs
index 5ebec32d73384..bdc00d7db97fe 100644
--- a/src/librbml/io.rs
+++ b/src/librbml/io.rs
@@ -95,7 +95,7 @@ impl Writer for SeekableMemWriter {
             // there (left), and what will be appended on the end (right)
             let cap = self.buf.len() - self.pos;
             let (left, right) = if cap <= buf.len() {
-                (buf.index(&(0..cap)), buf.index(&(cap..)))
+                (&buf[0..cap], &buf[cap..])
             } else {
                 let result: (_, &[_]) = (buf, &[]);
                 result
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
index a66d1dd08c1eb..da803aa50119c 100644
--- a/src/librbml/lib.rs
+++ b/src/librbml/lib.rs
@@ -17,6 +17,7 @@
 
 #![crate_name = "rbml"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -56,7 +57,7 @@ impl<'doc> Doc<'doc> {
     }
 
     pub fn as_str_slice<'a>(&'a self) -> &'a str {
-        str::from_utf8(self.data.index(&(self.start..self.end))).unwrap()
+        str::from_utf8(&self.data[self.start..self.end]).unwrap()
     }
 
     pub fn as_str(&self) -> String {
@@ -291,7 +292,7 @@ pub mod reader {
     pub fn with_doc_data<T, F>(d: Doc, f: F) -> T where
         F: FnOnce(&[u8]) -> T,
     {
-        f(d.data.index(&(d.start..d.end)))
+        f(&d.data[d.start..d.end])
     }
 
 
diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs
index 5803da1d3350d..d29a7a425c116 100644
--- a/src/libregex/compile.rs
+++ b/src/libregex/compile.rs
@@ -105,7 +105,7 @@ impl Program {
         // This is a bit hacky since we have to skip over the initial
         // 'Save' instruction.
         let mut pre = String::with_capacity(5);
-        for inst in c.insts.index(&(1..)).iter() {
+        for inst in c.insts[1..].iter() {
             match *inst {
                 OneChar(c, FLAG_EMPTY) => pre.push(c),
                 _ => break
diff --git a/src/libregex/lib.rs b/src/libregex/lib.rs
index c039abc9aff2a..d19ce3b460ae5 100644
--- a/src/libregex/lib.rs
+++ b/src/libregex/lib.rs
@@ -17,6 +17,7 @@
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![experimental = "use the crates.io `regex` library instead"]
+#![staged_api]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/",
@@ -24,6 +25,7 @@
 
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 #![deny(missing_docs)]
 
 #[cfg(test)]
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index dd11d42b8aad6..1cc2b271e9ccd 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -18,7 +18,6 @@ use std::cmp;
 use std::fmt;
 use std::iter;
 use std::num;
-use std::ops::Index;
 
 /// Static data containing Unicode ranges for general categories and scripts.
 use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
@@ -285,8 +284,8 @@ impl<'a> Parser<'a> {
         match self.next_char() {
             true => Ok(()),
             false => {
-                self.err(format!("Expected {:?} but got EOF.",
-                                 expected).index(&FullRange))
+                self.err(&format!("Expected {:?} but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -294,11 +293,11 @@ impl<'a> Parser<'a> {
     fn expect(&mut self, expected: char) -> Result<(), Error> {
         match self.next_char() {
             true if self.cur() == expected => Ok(()),
-            true => self.err(format!("Expected '{:?}' but got '{:?}'.",
-                                     expected, self.cur()).index(&FullRange)),
+            true => self.err(&format!("Expected '{:?}' but got '{:?}'.",
+                                      expected, self.cur())[]),
             false => {
-                self.err(format!("Expected '{:?}' but got EOF.",
-                                 expected).index(&FullRange))
+                self.err(&format!("Expected '{:?}' but got EOF.",
+                                  expected)[])
             }
         }
     }
@@ -443,15 +442,15 @@ impl<'a> Parser<'a> {
                     match try!(self.parse_escape()) {
                         Literal(c3, _) => c2 = c3, // allow literal escapes below
                         ast =>
-                            return self.err(format!("Expected a literal, but got {:?}.",
-                                                    ast).index(&FullRange)),
+                            return self.err(&format!("Expected a literal, but got {:?}.",
+                                                     ast)[]),
                     }
                 }
                 if c2 < c {
-                    return self.err(format!("Invalid character class \
-                                             range '{}-{}'",
-                                            c,
-                                            c2).index(&FullRange))
+                    return self.err(&format!("Invalid character class \
+                                              range '{}-{}'",
+                                             c,
+                                             c2)[])
                 }
                 ranges.push((c, self.cur()))
             } else {
@@ -489,7 +488,7 @@ impl<'a> Parser<'a> {
                 FLAG_EMPTY
             };
         let name = self.slice(name_start, closer - 1);
-        match find_class(ASCII_CLASSES, name.index(&FullRange)) {
+        match find_class(ASCII_CLASSES, &name[]) {
             None => None,
             Some(ranges) => {
                 self.chari = closer;
@@ -511,21 +510,21 @@ impl<'a> Parser<'a> {
             match self.pos('}') {
                 Some(i) => i,
                 None => {
-                    return self.err(format!("No closing brace for counted \
-                                             repetition starting at position \
-                                             {:?}.",
-                                            start).index(&FullRange))
+                    return self.err(&format!("No closing brace for counted \
+                                              repetition starting at position \
+                                              {:?}.",
+                                             start)[])
                 }
             };
         self.chari = closer;
         let greed = try!(self.get_next_greedy());
-        let inner = self.chars.index(&((start+1)..closer)).iter().cloned()
+        let inner = self.chars[(start+1)..closer].iter().cloned()
                                                .collect::<String>();
 
         // Parse the min and max values from the regex.
         let (mut min, mut max): (uint, Option<uint>);
         if !inner.contains(",") {
-            min = try!(self.parse_uint(inner.index(&FullRange)));
+            min = try!(self.parse_uint(&inner[]));
             max = Some(min);
         } else {
             let pieces: Vec<&str> = inner.splitn(1, ',').collect();
@@ -545,21 +544,21 @@ impl<'a> Parser<'a> {
 
         // Do some bounds checking and make sure max >= min.
         if min > MAX_REPEAT {
-            return self.err(format!(
+            return self.err(&format!(
                 "{} exceeds maximum allowed repetitions ({})",
-                min, MAX_REPEAT).index(&FullRange));
+                min, MAX_REPEAT)[]);
         }
         if max.is_some() {
             let m = max.unwrap();
             if m > MAX_REPEAT {
-                return self.err(format!(
+                return self.err(&format!(
                     "{} exceeds maximum allowed repetitions ({})",
-                    m, MAX_REPEAT).index(&FullRange));
+                    m, MAX_REPEAT)[]);
             }
             if m < min {
-                return self.err(format!(
+                return self.err(&format!(
                     "Max repetitions ({}) cannot be smaller than min \
-                     repetitions ({}).", m, min).index(&FullRange));
+                     repetitions ({}).", m, min)[]);
             }
         }
 
@@ -623,7 +622,7 @@ impl<'a> Parser<'a> {
                 Ok(AstClass(ranges, flags))
             }
             _ => {
-                self.err(format!("Invalid escape sequence '\\\\{}'", c).index(&FullRange))
+                self.err(&format!("Invalid escape sequence '\\\\{}'", c)[])
             }
         }
     }
@@ -641,9 +640,9 @@ impl<'a> Parser<'a> {
             let closer =
                 match self.pos('}') {
                     Some(i) => i,
-                    None => return self.err(format!(
+                    None => return self.err(&format!(
                         "Missing '}}' for unclosed '{{' at position {}",
-                        self.chari).index(&FullRange)),
+                        self.chari)[]),
                 };
             if closer - self.chari + 1 == 0 {
                 return self.err("No Unicode class name found.")
@@ -657,10 +656,10 @@ impl<'a> Parser<'a> {
             name = self.slice(self.chari + 1, self.chari + 2);
             self.chari += 1;
         }
-        match find_class(UNICODE_CLASSES, name.index(&FullRange)) {
+        match find_class(UNICODE_CLASSES, &name[]) {
             None => {
-                return self.err(format!("Could not find Unicode class '{}'",
-                                        name).index(&FullRange))
+                return self.err(&format!("Could not find Unicode class '{}'",
+                                        name)[])
             }
             Some(ranges) => {
                 Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
@@ -683,11 +682,11 @@ impl<'a> Parser<'a> {
             }
         }
         let s = self.slice(start, end);
-        match num::from_str_radix::<u32>(s.index(&FullRange), 8) {
+        match num::from_str_radix::<u32>(&s[], 8) {
             Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
             None => {
-                self.err(format!("Could not parse '{:?}' as octal number.",
-                                 s).index(&FullRange))
+                self.err(&format!("Could not parse '{:?}' as octal number.",
+                                 s)[])
             }
         }
     }
@@ -703,14 +702,14 @@ impl<'a> Parser<'a> {
         let closer =
             match self.pos('}') {
                 None => {
-                    return self.err(format!("Missing '}}' for unclosed \
+                    return self.err(&format!("Missing '}}' for unclosed \
                                              '{{' at position {}",
-                                            start).index(&FullRange))
+                                            start)[])
                 }
                 Some(i) => i,
             };
         self.chari = closer;
-        self.parse_hex_digits(self.slice(start, closer).index(&FullRange))
+        self.parse_hex_digits(&self.slice(start, closer)[])
     }
 
     // Parses a two-digit hex number.
@@ -730,7 +729,7 @@ impl<'a> Parser<'a> {
         match num::from_str_radix::<u32>(s, 16) {
             Some(n) => Ok(Literal(try!(self.char_from_u32(n)), FLAG_EMPTY)),
             None => {
-                self.err(format!("Could not parse '{}' as hex number.", s).index(&FullRange))
+                self.err(&format!("Could not parse '{}' as hex number.", s)[])
             }
         }
     }
@@ -755,8 +754,8 @@ impl<'a> Parser<'a> {
                 "Capture names can only have underscores, letters and digits.")
         }
         if self.names.contains(&name) {
-            return self.err(format!("Duplicate capture group name '{}'.",
-                                    name).index(&FullRange))
+            return self.err(&format!("Duplicate capture group name '{}'.",
+                                    name)[])
         }
         self.names.push(name.clone());
         self.chari = closer;
@@ -788,9 +787,9 @@ impl<'a> Parser<'a> {
                 'U' => { flags = flags | FLAG_SWAP_GREED; saw_flag = true},
                 '-' => {
                     if sign < 0 {
-                        return self.err(format!(
+                        return self.err(&format!(
                             "Cannot negate flags twice in '{}'.",
-                            self.slice(start, self.chari + 1)).index(&FullRange))
+                            self.slice(start, self.chari + 1))[])
                     }
                     sign = -1;
                     saw_flag = false;
@@ -799,9 +798,9 @@ impl<'a> Parser<'a> {
                 ':' | ')' => {
                     if sign < 0 {
                         if !saw_flag {
-                            return self.err(format!(
+                            return self.err(&format!(
                                 "A valid flag does not follow negation in '{}'",
-                                self.slice(start, self.chari + 1)).index(&FullRange))
+                                self.slice(start, self.chari + 1))[])
                         }
                         flags = flags ^ flags;
                     }
@@ -812,8 +811,8 @@ impl<'a> Parser<'a> {
                     self.flags = flags;
                     return Ok(())
                 }
-                _ => return self.err(format!(
-                    "Unrecognized flag '{}'.", self.cur()).index(&FullRange)),
+                _ => return self.err(&format!(
+                    "Unrecognized flag '{}'.", self.cur())[]),
             }
         }
     }
@@ -910,8 +909,8 @@ impl<'a> Parser<'a> {
         match s.parse::<uint>() {
             Some(i) => Ok(i),
             None => {
-                self.err(format!("Expected an unsigned integer but got '{}'.",
-                                 s).index(&FullRange))
+                self.err(&format!("Expected an unsigned integer but got '{}'.",
+                                 s)[])
             }
         }
     }
@@ -920,8 +919,8 @@ impl<'a> Parser<'a> {
         match char::from_u32(n) {
             Some(c) => Ok(c),
             None => {
-                self.err(format!("Could not decode '{}' to unicode \
-                                  character.", n).index(&FullRange))
+                self.err(&format!("Could not decode '{}' to unicode \
+                                  character.", n)[])
             }
         }
     }
@@ -954,7 +953,7 @@ impl<'a> Parser<'a> {
     }
 
     fn slice(&self, start: uint, end: uint) -> String {
-        self.chars.index(&(start..end)).iter().cloned().collect()
+        self.chars[start..end].iter().cloned().collect()
     }
 }
 
diff --git a/src/libregex/re.rs b/src/libregex/re.rs
index 37f9869f3bfaf..16dd32b6be220 100644
--- a/src/libregex/re.rs
+++ b/src/libregex/re.rs
@@ -90,15 +90,6 @@ impl Clone for ExNative {
     }
 }
 
-#[cfg(stage0)]
-//FIXME: remove after stage0 snapshot
-impl fmt::Show for Regex {
-    /// Shows the original regular expression.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self.as_str(), f)
-    }
-}
-
 impl fmt::String for Regex {
     /// Shows the original regular expression.
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -247,19 +238,19 @@ impl Regex {
             }
 
             let (s, e) = cap.pos(0).unwrap(); // captures only reports matches
-            new.push_str(text.index(&(last_match..s)));
-            new.push_str(rep.reg_replace(&cap).index(&FullRange));
+            new.push_str(&text[last_match..s]);
+            new.push_str(&rep.reg_replace(&cap)[]);
             last_match = e;
         }
-        new.push_str(text.index(&(last_match..text.len())));
+        new.push_str(&text[last_match..text.len()]);
         return new;
     }
 
     /// Returns the original string of this regex.
     pub fn as_str<'a>(&'a self) -> &'a str {
         match *self {
-            Dynamic(ExDynamic { ref original, .. }) => original.index(&FullRange),
-            Native(ExNative { ref original, .. }) => original.index(&FullRange),
+            Dynamic(ExDynamic { ref original, .. }) => &original[],
+            Native(ExNative { ref original, .. }) => &original[],
         }
     }
 
@@ -356,13 +347,13 @@ impl<'r, 't> Iterator for RegexSplits<'r, 't> {
                 if self.last >= text.len() {
                     None
                 } else {
-                    let s = text.index(&(self.last..text.len()));
+                    let s = &text[self.last..text.len()];
                     self.last = text.len();
                     Some(s)
                 }
             }
             Some((s, e)) => {
-                let matched = text.index(&(self.last..s));
+                let matched = &text[self.last..s];
                 self.last = e;
                 Some(matched)
             }
@@ -393,7 +384,7 @@ impl<'r, 't> Iterator for RegexSplitsN<'r, 't> {
         } else {
             self.cur += 1;
             if self.cur >= self.limit {
-                Some(text.index(&(self.splits.last..text.len())))
+                Some(&text[self.splits.last..text.len()])
             } else {
                 self.splits.next()
             }
@@ -526,7 +517,7 @@ impl<'t> Captures<'t> {
             })
         });
         let re = Regex::new(r"\$\$").unwrap();
-        re.replace_all(text.index(&FullRange), NoExpand("$"))
+        re.replace_all(&text[], NoExpand("$"))
     }
 
     /// Returns the number of captured groups.
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index 04c430da4d290..9605536a052c0 100644
--- a/src/libregex/vm.rs
+++ b/src/libregex/vm.rs
@@ -152,7 +152,7 @@ impl<'r, 't> Nfa<'r, 't> {
                 // out early.
                 if self.prog.prefix.len() > 0 && clist.size == 0 {
                     let needle = self.prog.prefix.as_bytes();
-                    let haystack = self.input.as_bytes().index(&(self.ic..));
+                    let haystack = &self.input.as_bytes()[self.ic..];
                     match find_prefix(needle, haystack) {
                         None => break,
                         Some(i) => {
diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs
index a3a041c2497c7..e0143917a7cff 100644
--- a/src/librustc/lib.rs
+++ b/src/librustc/lib.rs
@@ -16,6 +16,7 @@
 
 #![crate_name = "rustc"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -25,6 +26,7 @@
 #![allow(unknown_features)]
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
+#![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![feature(old_impl_check)]
 
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
index 1af8e2f29ebd7..7d893f3a106cc 100644
--- a/src/librustc/lint/builtin.rs
+++ b/src/librustc/lint/builtin.rs
@@ -34,7 +34,7 @@ use middle::{def, pat_util, stability};
 use middle::const_eval::{eval_const_expr_partial, const_int, const_uint};
 use util::ppaux::{ty_to_string};
 use util::nodemap::{FnvHashMap, NodeSet};
-use lint::{Context, LintPass, LintArray};
+use lint::{Context, LintPass, LintArray, Lint};
 
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::num::SignedInt;
@@ -506,7 +506,7 @@ impl BoxPointers {
         if n_uniq > 0 {
             let s = ty_to_string(cx.tcx, ty);
             let m = format!("type uses owned (Box type) pointers: {}", s);
-            cx.span_lint(BOX_POINTERS, span, m.index(&FullRange));
+            cx.span_lint(BOX_POINTERS, span, &m[]);
         }
     }
 }
@@ -586,7 +586,7 @@ impl LintPass for RawPointerDerive {
     }
 
     fn check_item(&mut self, cx: &Context, item: &ast::Item) {
-        if !attr::contains_name(item.attrs.index(&FullRange), "automatically_derived") {
+        if !attr::contains_name(&item.attrs[], "automatically_derived") {
             return
         }
         let did = match item.node {
@@ -770,11 +770,11 @@ impl LintPass for UnusedResults {
             ty::ty_enum(did, _) => {
                 if ast_util::is_local(did) {
                     if let ast_map::NodeItem(it) = cx.tcx.map.get(did.node) {
-                        warned |= check_must_use(cx, it.attrs.index(&FullRange), s.span);
+                        warned |= check_must_use(cx, &it.attrs[], s.span);
                     }
                 } else {
                     csearch::get_item_attrs(&cx.sess().cstore, did, |attrs| {
-                        warned |= check_must_use(cx, attrs.index(&FullRange), s.span);
+                        warned |= check_must_use(cx, &attrs[], s.span);
                     });
                 }
             }
@@ -796,7 +796,7 @@ impl LintPass for UnusedResults {
                             msg.push_str(s.get());
                         }
                     }
-                    cx.span_lint(UNUSED_MUST_USE, sp, msg.index(&FullRange));
+                    cx.span_lint(UNUSED_MUST_USE, sp, &msg[]);
                     return true;
                 }
             }
@@ -842,7 +842,7 @@ impl NonCamelCaseTypes {
             } else {
                 format!("{} `{}` should have a camel case name such as `{}`", sort, s, c)
             };
-            cx.span_lint(NON_CAMEL_CASE_TYPES, span, m.index(&FullRange));
+            cx.span_lint(NON_CAMEL_CASE_TYPES, span, &m[]);
         }
     }
 }
@@ -981,8 +981,8 @@ impl NonSnakeCase {
 
         if !is_snake_case(ident) {
             cx.span_lint(NON_SNAKE_CASE, span,
-                format!("{} `{}` should have a snake case name such as `{}`",
-                        sort, s, to_snake_case(s.get())).index(&FullRange));
+                &format!("{} `{}` should have a snake case name such as `{}`",
+                        sort, s, to_snake_case(s.get()))[]);
         }
     }
 }
@@ -1066,10 +1066,10 @@ impl LintPass for NonUpperCaseGlobals {
                 // upper/lowercase)
                 if s.get().chars().any(|c| c.is_lowercase()) {
                     cx.span_lint(NON_UPPER_CASE_GLOBALS, it.span,
-                        format!("static constant `{}` should have an uppercase name \
+                        &format!("static constant `{}` should have an uppercase name \
                                  such as `{}`",
-                                s.get(), s.get().chars().map(|c| c.to_uppercase())
-                                .collect::<String>().index(&FullRange)).index(&FullRange));
+                                s.get(), &s.get().chars().map(|c| c.to_uppercase())
+                                .collect::<String>()[])[]);
                 }
             }
             _ => {}
@@ -1083,10 +1083,10 @@ impl LintPass for NonUpperCaseGlobals {
                 let s = token::get_ident(path1.node);
                 if s.get().chars().any(|c| c.is_lowercase()) {
                     cx.span_lint(NON_UPPER_CASE_GLOBALS, path1.span,
-                        format!("static constant in pattern `{}` should have an uppercase \
+                        &format!("static constant in pattern `{}` should have an uppercase \
                                  name such as `{}`",
-                                s.get(), s.get().chars().map(|c| c.to_uppercase())
-                                    .collect::<String>().index(&FullRange)).index(&FullRange));
+                                s.get(), &s.get().chars().map(|c| c.to_uppercase())
+                                    .collect::<String>()[])[]);
                 }
             }
             _ => {}
@@ -1110,8 +1110,8 @@ impl UnusedParens {
             let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner);
             if !necessary {
                 cx.span_lint(UNUSED_PARENS, value.span,
-                             format!("unnecessary parentheses around {}",
-                                     msg).index(&FullRange))
+                             &format!("unnecessary parentheses around {}",
+                                     msg)[])
             }
         }
 
@@ -1213,7 +1213,7 @@ impl LintPass for UnusedImportBraces {
                                     let m = format!("braces around {} is unnecessary",
                                                     token::get_ident(*name).get());
                                     cx.span_lint(UNUSED_IMPORT_BRACES, view_item.span,
-                                                 m.index(&FullRange));
+                                                 &m[]);
                                 },
                                 _ => ()
                             }
@@ -1251,8 +1251,8 @@ impl LintPass for NonShorthandFieldPatterns {
                 if let ast::PatIdent(_, ident, None) = fieldpat.node.pat.node {
                     if ident.node.as_str() == fieldpat.node.ident.as_str() {
                         cx.span_lint(NON_SHORTHAND_FIELD_PATTERNS, fieldpat.span,
-                                     format!("the `{}:` in this pattern is redundant and can \
-                                              be removed", ident.node.as_str()).index(&FullRange))
+                                     &format!("the `{}:` in this pattern is redundant and can \
+                                              be removed", ident.node.as_str())[])
                     }
                 }
             }
@@ -1356,7 +1356,7 @@ impl LintPass for UnusedMut {
     fn check_expr(&mut self, cx: &Context, e: &ast::Expr) {
         if let ast::ExprMatch(_, ref arms, _) = e.node {
             for a in arms.iter() {
-                self.check_unused_mut_pat(cx, a.pats.index(&FullRange))
+                self.check_unused_mut_pat(cx, &a.pats[])
             }
         }
     }
@@ -1477,7 +1477,7 @@ impl MissingDoc {
         });
         if !has_doc {
             cx.span_lint(MISSING_DOCS, sp,
-                format!("missing documentation for {}", desc).index(&FullRange));
+                &format!("missing documentation for {}", desc)[]);
         }
     }
 }
@@ -1491,7 +1491,7 @@ impl LintPass for MissingDoc {
         let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| {
             attr.check_name("doc") && match attr.meta_item_list() {
                 None => false,
-                Some(l) => attr::contains_name(l.index(&FullRange), "hidden"),
+                Some(l) => attr::contains_name(&l[], "hidden"),
             }
         });
         self.doc_hidden_stack.push(doc_hidden);
@@ -1513,7 +1513,7 @@ impl LintPass for MissingDoc {
     }
 
     fn check_crate(&mut self, cx: &Context, krate: &ast::Crate) {
-        self.check_missing_docs_attrs(cx, None, krate.attrs.index(&FullRange),
+        self.check_missing_docs_attrs(cx, None, &krate.attrs[],
                                      krate.span, "crate");
     }
 
@@ -1527,7 +1527,7 @@ impl LintPass for MissingDoc {
             ast::ItemTy(..) => "a type alias",
             _ => return
         };
-        self.check_missing_docs_attrs(cx, Some(it.id), it.attrs.index(&FullRange),
+        self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs[],
                                      it.span, desc);
     }
 
@@ -1540,13 +1540,13 @@ impl LintPass for MissingDoc {
 
             // Otherwise, doc according to privacy. This will also check
             // doc for default methods defined on traits.
-            self.check_missing_docs_attrs(cx, Some(m.id), m.attrs.index(&FullRange),
+            self.check_missing_docs_attrs(cx, Some(m.id), &m.attrs[],
                                           m.span, "a method");
         }
     }
 
     fn check_ty_method(&mut self, cx: &Context, tm: &ast::TypeMethod) {
-        self.check_missing_docs_attrs(cx, Some(tm.id), tm.attrs.index(&FullRange),
+        self.check_missing_docs_attrs(cx, Some(tm.id), &tm.attrs[],
                                      tm.span, "a type method");
     }
 
@@ -1556,14 +1556,14 @@ impl LintPass for MissingDoc {
                 let cur_struct_def = *self.struct_def_stack.last()
                     .expect("empty struct_def_stack");
                 self.check_missing_docs_attrs(cx, Some(cur_struct_def),
-                                              sf.node.attrs.index(&FullRange), sf.span,
+                                              &sf.node.attrs[], sf.span,
                                               "a struct field")
             }
         }
     }
 
     fn check_variant(&mut self, cx: &Context, v: &ast::Variant, _: &ast::Generics) {
-        self.check_missing_docs_attrs(cx, Some(v.node.id), v.node.attrs.index(&FullRange),
+        self.check_missing_docs_attrs(cx, Some(v.node.id), &v.node.attrs[],
                                      v.span, "a variant");
         assert!(!self.in_variant);
         self.in_variant = true;
@@ -1643,6 +1643,13 @@ declare_lint! {
     "detects use of #[unstable] items (incl. items with no stability attribute)"
 }
 
+declare_lint!(STAGED_EXPERIMENTAL, Warn,
+              "detects use of #[experimental] items in staged builds");
+
+declare_lint!(STAGED_UNSTABLE, Warn,
+              "detects use of #[unstable] items (incl. items with no stability attribute) \
+               in staged builds");
+
 /// Checks for use of items with `#[deprecated]`, `#[experimental]` and
 /// `#[unstable]` attributes, or no stability attribute.
 #[derive(Copy)]
@@ -1650,12 +1657,13 @@ pub struct Stability;
 
 impl Stability {
     fn lint(&self, cx: &Context, id: ast::DefId, span: Span) {
-        let stability = stability::lookup(cx.tcx, id);
+
+        let ref stability = stability::lookup(cx.tcx, id);
         let cross_crate = !ast_util::is_local(id);
 
         // stability attributes are promises made across crates; only
         // check DEPRECATED for crate-local usage.
-        let (lint, label) = match stability {
+        let (lint, label) = match *stability {
             // no stability attributes == Unstable
             None if cross_crate => (UNSTABLE, "unmarked"),
             Some(attr::Stability { level: attr::Unstable, .. }) if cross_crate =>
@@ -1667,24 +1675,53 @@ impl Stability {
             _ => return
         };
 
-        let msg = match stability {
-            Some(attr::Stability { text: Some(ref s), .. }) => {
-                format!("use of {} item: {}", label, *s)
+        output(cx, span, stability, lint, label);
+        if cross_crate && stability::is_staged_api(cx.tcx, id) {
+            if lint.name == UNSTABLE.name {
+                output(cx, span, stability, STAGED_UNSTABLE, label);
+            } else if lint.name == EXPERIMENTAL.name {
+                output(cx, span, stability, STAGED_EXPERIMENTAL, label);
             }
-            _ => format!("use of {} item", label)
-        };
+        }
+
+        fn output(cx: &Context, span: Span, stability: &Option<attr::Stability>,
+                  lint: &'static Lint, label: &'static str) {
+            let msg = match *stability {
+                Some(attr::Stability { text: Some(ref s), .. }) => {
+                    format!("use of {} item: {}", label, *s)
+                }
+                _ => format!("use of {} item", label)
+            };
 
-        cx.span_lint(lint, span, msg.index(&FullRange));
+            cx.span_lint(lint, span, &msg[]);
+        }
     }
 
+
     fn is_internal(&self, cx: &Context, span: Span) -> bool {
         cx.tcx.sess.codemap().span_is_internal(span)
     }
+
 }
 
 impl LintPass for Stability {
     fn get_lints(&self) -> LintArray {
-        lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE)
+        lint_array!(DEPRECATED, EXPERIMENTAL, UNSTABLE, STAGED_EXPERIMENTAL, STAGED_UNSTABLE)
+    }
+
+    fn check_crate(&mut self, _: &Context, c: &ast::Crate) {
+        // Just mark the #[staged_api] attribute used, though nothing else is done
+        // with it during this pass over the source.
+        for attr in c.attrs.iter() {
+            if attr.name().get() == "staged_api" {
+                match attr.node.value.node {
+                    ast::MetaWord(_) => {
+                        attr::mark_used(attr);
+                    }
+                    _ => (/*pass*/)
+                }
+            }
+        }
     }
 
     fn check_view_item(&mut self, cx: &Context, item: &ast::ViewItem) {
@@ -1746,6 +1783,7 @@ impl LintPass for Stability {
             }
             _ => return
         };
+
         self.lint(cx, id, span);
     }
 
@@ -1878,3 +1916,22 @@ impl LintPass for HardwiredLints {
         )
     }
 }
+
+/// Forbids using the `#[feature(...)]` attribute
+#[derive(Copy)]
+pub struct UnstableFeatures;
+
+declare_lint!(UNSTABLE_FEATURES, Allow,
+              "enabling unstable features");
+
+impl LintPass for UnstableFeatures {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(UNSTABLE_FEATURES)
+    }
+    fn check_attribute(&mut self, ctx: &Context, attr: &ast::Attribute) {
+        use syntax::attr;
+        if attr::contains_name(&[attr.node.value.clone()], "feature") {
+            ctx.span_lint(UNSTABLE_FEATURES, attr.span, "unstable feature");
+        }
+    }
+}
diff --git a/src/librustc/lint/context.rs b/src/librustc/lint/context.rs
index 51998bdbcf299..db4d99fe4940d 100644
--- a/src/librustc/lint/context.rs
+++ b/src/librustc/lint/context.rs
@@ -28,8 +28,9 @@ use self::TargetLint::*;
 use middle::privacy::ExportedItems;
 use middle::ty::{self, Ty};
 use session::{early_error, Session};
+use session::config::UnstableFeatures;
 use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass, LintPassObject};
-use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
+use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid, ReleaseChannel};
 use lint::builtin;
 use util::nodemap::FnvHashMap;
 
@@ -104,7 +105,7 @@ impl LintStore {
     }
 
     pub fn get_lints<'t>(&'t self) -> &'t [(&'static Lint, bool)] {
-        self.lints.index(&FullRange)
+        &self.lints[]
     }
 
     pub fn get_lint_groups<'t>(&'t self) -> Vec<(&'static str, Vec<LintId>, bool)> {
@@ -124,11 +125,11 @@ impl LintStore {
                 match (sess, from_plugin) {
                     // We load builtin lints first, so a duplicate is a compiler bug.
                     // Use early_error when handling -W help with no crate.
-                    (None, _) => early_error(msg.index(&FullRange)),
-                    (Some(sess), false) => sess.bug(msg.index(&FullRange)),
+                    (None, _) => early_error(&msg[]),
+                    (Some(sess), false) => sess.bug(&msg[]),
 
                     // A duplicate name from a plugin is a user error.
-                    (Some(sess), true)  => sess.err(msg.index(&FullRange)),
+                    (Some(sess), true)  => sess.err(&msg[]),
                 }
             }
 
@@ -149,11 +150,11 @@ impl LintStore {
             match (sess, from_plugin) {
                 // We load builtin lints first, so a duplicate is a compiler bug.
                 // Use early_error when handling -W help with no crate.
-                (None, _) => early_error(msg.index(&FullRange)),
-                (Some(sess), false) => sess.bug(msg.index(&FullRange)),
+                (None, _) => early_error(&msg[]),
+                (Some(sess), false) => sess.bug(&msg[]),
 
                 // A duplicate name from a plugin is a user error.
-                (Some(sess), true)  => sess.err(msg.index(&FullRange)),
+                (Some(sess), true)  => sess.err(&msg[]),
             }
         }
     }
@@ -210,6 +211,7 @@ impl LintStore {
                      UnusedAllocation,
                      Stability,
                      MissingCopyImplementations,
+                     UnstableFeatures,
         );
 
         add_builtin_with_new!(sess,
@@ -267,8 +269,8 @@ impl LintStore {
                 let warning = format!("lint {} has been renamed to {}",
                                       lint_name, new_name);
                 match span {
-                    Some(span) => sess.span_warn(span, warning.index(&FullRange)),
-                    None => sess.warn(warning.index(&FullRange)),
+                    Some(span) => sess.span_warn(span, &warning[]),
+                    None => sess.warn(&warning[]),
                 };
                 Some(lint_id)
             }
@@ -278,26 +280,49 @@ impl LintStore {
 
     pub fn process_command_line(&mut self, sess: &Session) {
         for &(ref lint_name, level) in sess.opts.lint_opts.iter() {
-            match self.find_lint(lint_name.index(&FullRange), sess, None) {
+            match self.find_lint(&lint_name[], sess, None) {
                 Some(lint_id) => self.set_level(lint_id, (level, CommandLine)),
                 None => {
                     match self.lint_groups.iter().map(|(&x, pair)| (x, pair.0.clone()))
                                                  .collect::<FnvHashMap<&'static str,
                                                                        Vec<LintId>>>()
-                                                 .get(lint_name.index(&FullRange)) {
+                                                 .get(&lint_name[]) {
                         Some(v) => {
                             v.iter()
                              .map(|lint_id: &LintId|
                                      self.set_level(*lint_id, (level, CommandLine)))
                              .collect::<Vec<()>>();
                         }
-                        None => sess.err(format!("unknown {} flag: {}",
-                                                 level.as_str(), lint_name).index(&FullRange)),
+                        None => sess.err(&format!("unknown {} flag: {}",
+                                                 level.as_str(), lint_name)[]),
                     }
                 }
             }
         }
     }
+
+    fn maybe_stage_features(&mut self, sess: &Session) {
+        let lvl = match sess.opts.unstable_features {
+            UnstableFeatures::Default => return,
+            UnstableFeatures::Disallow => Warn,
+            UnstableFeatures::Cheat => Allow
+        };
+        match self.by_name.get("unstable_features") {
+            Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            None => unreachable!()
+        }
+        match self.by_name.get("staged_unstable") {
+            Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            None => unreachable!()
+        }
+        match self.by_name.get("staged_experimental") {
+            Some(&Id(lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            Some(&Renamed(_, lint_id)) => self.set_level(lint_id, (lvl, ReleaseChannel)),
+            None => unreachable!()
+        }
+    }
 }
 
 /// Context for lint checking.
@@ -380,6 +405,7 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
     if level == Allow { return }
 
     let name = lint.name_lower();
+    let mut def = None;
     let mut note = None;
     let msg = match source {
         Default => {
@@ -394,7 +420,13 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
                     }, name.replace("_", "-"))
         },
         Node(src) => {
-            note = Some(src);
+            def = Some(src);
+            msg.to_string()
+        }
+        ReleaseChannel => {
+            let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)");
+            note = Some(format!("this feature may not be used in the {} release channel",
+                                release_channel));
             msg.to_string()
         }
     };
@@ -403,14 +435,18 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
     if level == Forbid { level = Deny; }
 
     match (level, span) {
-        (Warn, Some(sp)) => sess.span_warn(sp, msg.index(&FullRange)),
-        (Warn, None)     => sess.warn(msg.index(&FullRange)),
-        (Deny, Some(sp)) => sess.span_err(sp, msg.index(&FullRange)),
-        (Deny, None)     => sess.err(msg.index(&FullRange)),
+        (Warn, Some(sp)) => sess.span_warn(sp, &msg[]),
+        (Warn, None)     => sess.warn(&msg[]),
+        (Deny, Some(sp)) => sess.span_err(sp, &msg[]),
+        (Deny, None)     => sess.err(&msg[]),
         _ => sess.bug("impossible level in raw_emit_lint"),
     }
 
-    for span in note.into_iter() {
+    for note in note.into_iter() {
+        sess.note(&note[]);
+    }
+
+    for span in def.into_iter() {
         sess.span_note(span, "lint level defined here");
     }
 }
@@ -513,9 +549,9 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
                 if now == Forbid && level != Forbid {
                     let lint_name = lint_id.as_str();
                     self.tcx.sess.span_err(span,
-                                           format!("{}({}) overruled by outer forbid({})",
+                                           &format!("{}({}) overruled by outer forbid({})",
                                                    level.as_str(), lint_name,
-                                                   lint_name).index(&FullRange));
+                                                   lint_name)[]);
                 } else if now != level {
                     let src = self.lints.get_level_source(lint_id).1;
                     self.level_stack.push((lint_id, (now, src)));
@@ -550,7 +586,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
 
 impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
     fn visit_item(&mut self, it: &ast::Item) {
-        self.with_lint_attrs(it.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&it.attrs[], |cx| {
             run_lints!(cx, check_item, it);
             cx.visit_ids(|v| v.visit_item(it));
             visit::walk_item(cx, it);
@@ -558,14 +594,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
     }
 
     fn visit_foreign_item(&mut self, it: &ast::ForeignItem) {
-        self.with_lint_attrs(it.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&it.attrs[], |cx| {
             run_lints!(cx, check_foreign_item, it);
             visit::walk_foreign_item(cx, it);
         })
     }
 
     fn visit_view_item(&mut self, i: &ast::ViewItem) {
-        self.with_lint_attrs(i.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&i.attrs[], |cx| {
             run_lints!(cx, check_view_item, i);
             cx.visit_ids(|v| v.visit_view_item(i));
             visit::walk_view_item(cx, i);
@@ -591,7 +627,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
                 body: &'v ast::Block, span: Span, id: ast::NodeId) {
         match fk {
             visit::FkMethod(_, _, m) => {
-                self.with_lint_attrs(m.attrs.index(&FullRange), |cx| {
+                self.with_lint_attrs(&m.attrs[], |cx| {
                     run_lints!(cx, check_fn, fk, decl, body, span, id);
                     cx.visit_ids(|v| {
                         v.visit_fn(fk, decl, body, span, id);
@@ -607,7 +643,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
     }
 
     fn visit_ty_method(&mut self, t: &ast::TypeMethod) {
-        self.with_lint_attrs(t.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&t.attrs[], |cx| {
             run_lints!(cx, check_ty_method, t);
             visit::walk_ty_method(cx, t);
         })
@@ -624,14 +660,14 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
     }
 
     fn visit_struct_field(&mut self, s: &ast::StructField) {
-        self.with_lint_attrs(s.node.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&s.node.attrs[], |cx| {
             run_lints!(cx, check_struct_field, s);
             visit::walk_struct_field(cx, s);
         })
     }
 
     fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) {
-        self.with_lint_attrs(v.node.attrs.index(&FullRange), |cx| {
+        self.with_lint_attrs(&v.node.attrs[], |cx| {
             run_lints!(cx, check_variant, v, g);
             visit::walk_variant(cx, v, g);
             run_lints!(cx, check_variant_post, v, g);
@@ -725,7 +761,7 @@ impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> {
             None => {}
             Some(lints) => {
                 for (lint_id, span, msg) in lints.into_iter() {
-                    self.span_lint(lint_id.lint, span, msg.index(&FullRange))
+                    self.span_lint(lint_id.lint, span, &msg[])
                 }
             }
         }
@@ -767,11 +803,15 @@ impl LintPass for GatherNodeLevels {
 /// Consumes the `lint_store` field of the `Session`.
 pub fn check_crate(tcx: &ty::ctxt,
                    exported_items: &ExportedItems) {
+
+    // If this is a feature-staged build of rustc then flip several lints to 'forbid'
+    tcx.sess.lint_store.borrow_mut().maybe_stage_features(&tcx.sess);
+
     let krate = tcx.map.krate();
     let mut cx = Context::new(tcx, krate, exported_items);
 
     // Visit the whole crate.
-    cx.with_lint_attrs(krate.attrs.index(&FullRange), |cx| {
+    cx.with_lint_attrs(&krate.attrs[], |cx| {
         cx.visit_id(ast::CRATE_NODE_ID);
         cx.visit_ids(|v| {
             v.visited_outermost = true;
diff --git a/src/librustc/lint/mod.rs b/src/librustc/lint/mod.rs
index e9778fa05ff17..8a266a2530b53 100644
--- a/src/librustc/lint/mod.rs
+++ b/src/librustc/lint/mod.rs
@@ -186,7 +186,7 @@ impl PartialEq for LintId {
 
 impl Eq for LintId { }
 
-impl<S: hash::Writer> hash::Hash<S> for LintId {
+impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for LintId {
     fn hash(&self, state: &mut S) {
         let ptr = self.lint as *const Lint;
         ptr.hash(state);
@@ -248,6 +248,9 @@ pub enum LintSource {
 
     /// Lint level was set by a command-line flag.
     CommandLine,
+
+    /// Lint level was set by the release channel.
+    ReleaseChannel
 }
 
 pub type LevelSource = (Level, LintSource);
diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs
index 66967a735460f..310874c311b12 100644
--- a/src/librustc/metadata/creader.rs
+++ b/src/librustc/metadata/creader.rs
@@ -65,7 +65,7 @@ fn dump_crates(cstore: &CStore) {
 }
 
 fn should_link(i: &ast::ViewItem) -> bool {
-    !attr::contains_name(i.attrs.index(&FullRange), "no_link")
+    !attr::contains_name(&i.attrs[], "no_link")
 
 }
 
@@ -90,7 +90,7 @@ pub fn validate_crate_name(sess: Option<&Session>, s: &str, sp: Option<Span>) {
     for c in s.chars() {
         if c.is_alphanumeric() { continue }
         if c == '_' || c == '-' { continue }
-        err(format!("invalid character `{}` in crate name: `{}`", c, s).index(&FullRange));
+        err(&format!("invalid character `{}` in crate name: `{}`", c, s)[]);
     }
     match sess {
         Some(sess) => sess.abort_if_errors(),
@@ -189,8 +189,8 @@ impl<'a> CrateReader<'a> {
         match self.extract_crate_info(i) {
             Some(info) => {
                 let (cnum, _, _) = self.resolve_crate(&None,
-                                                      info.ident.index(&FullRange),
-                                                      info.name.index(&FullRange),
+                                                      &info.ident[],
+                                                      &info.name[],
                                                       None,
                                                       i.span,
                                                       PathKind::Crate);
@@ -209,7 +209,7 @@ impl<'a> CrateReader<'a> {
                 let name = match *path_opt {
                     Some((ref path_str, _)) => {
                         let name = path_str.get().to_string();
-                        validate_crate_name(Some(self.sess), name.index(&FullRange),
+                        validate_crate_name(Some(self.sess), &name[],
                                             Some(i.span));
                         name
                     }
@@ -275,8 +275,8 @@ impl<'a> CrateReader<'a> {
                                         cstore::NativeUnknown
                                     } else {
                                         self.sess.span_err(m.span,
-                                            format!("unknown kind: `{}`",
-                                                    k).index(&FullRange));
+                                            &format!("unknown kind: `{}`",
+                                                    k)[]);
                                         cstore::NativeUnknown
                                     }
                                 }
@@ -330,7 +330,7 @@ impl<'a> CrateReader<'a> {
             match self.sess.opts.externs.get(name) {
                 Some(locs) => {
                     let found = locs.iter().any(|l| {
-                        let l = fs::realpath(&Path::new(l.index(&FullRange))).ok();
+                        let l = fs::realpath(&Path::new(&l[])).ok();
                         l == source.dylib || l == source.rlib
                     });
                     if found {
@@ -409,7 +409,7 @@ impl<'a> CrateReader<'a> {
                     crate_name: name,
                     hash: hash.map(|a| &*a),
                     filesearch: self.sess.target_filesearch(kind),
-                    triple: self.sess.opts.target_triple.index(&FullRange),
+                    triple: &self.sess.opts.target_triple[],
                     root: root,
                     rejected_via_hash: vec!(),
                     rejected_via_triple: vec!(),
@@ -435,8 +435,8 @@ impl<'a> CrateReader<'a> {
         decoder::get_crate_deps(cdata).iter().map(|dep| {
             debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash);
             let (local_cnum, _, _) = self.resolve_crate(root,
-                                                   dep.name.index(&FullRange),
-                                                   dep.name.index(&FullRange),
+                                                   &dep.name[],
+                                                   &dep.name[],
                                                    Some(&dep.hash),
                                                    span,
                                                    PathKind::Dependency);
@@ -447,7 +447,7 @@ impl<'a> CrateReader<'a> {
     pub fn read_plugin_metadata<'b>(&'b mut self,
                                     vi: &'b ast::ViewItem) -> PluginMetadata<'b> {
         let info = self.extract_crate_info(vi).unwrap();
-        let target_triple = self.sess.opts.target_triple.index(&FullRange);
+        let target_triple = &self.sess.opts.target_triple[];
         let is_cross = target_triple != config::host_triple();
         let mut should_link = info.should_link && !is_cross;
         let mut target_only = false;
@@ -456,8 +456,8 @@ impl<'a> CrateReader<'a> {
         let mut load_ctxt = loader::Context {
             sess: self.sess,
             span: vi.span,
-            ident: ident.index(&FullRange),
-            crate_name: name.index(&FullRange),
+            ident: &ident[],
+            crate_name: &name[],
             hash: None,
             filesearch: self.sess.host_filesearch(PathKind::Crate),
             triple: config::host_triple(),
@@ -485,8 +485,8 @@ impl<'a> CrateReader<'a> {
         let register = should_link && self.existing_match(info.name.as_slice(), None).is_none();
         let metadata = if register {
             // Register crate now to avoid double-reading metadata
-            let (_, cmd, _) = self.register_crate(&None, info.ident.index(&FullRange),
-                                info.name.index(&FullRange), vi.span, library);
+            let (_, cmd, _) = self.register_crate(&None, &info.ident[],
+                                &info.name[], vi.span, library);
             PMDSource::Registered(cmd)
         } else {
             // Not registering the crate; just hold on to the metadata
@@ -507,8 +507,8 @@ impl<'a> CrateReader<'a> {
 impl<'a> PluginMetadata<'a> {
     /// Read exported macros
     pub fn exported_macros(&self) -> Vec<ast::MacroDef> {
-        let imported_from = Some(token::intern(self.info.ident.index(&FullRange)).ident());
-        let source_name = format!("<{} macros>", self.info.ident.index(&FullRange));
+        let imported_from = Some(token::intern(&self.info.ident[]).ident());
+        let source_name = format!("<{} macros>", &self.info.ident[]);
         let mut macros = vec![];
         decoder::each_exported_macro(self.metadata.as_slice(),
                                      &*self.sess.cstore.intr,
@@ -550,7 +550,7 @@ impl<'a> PluginMetadata<'a> {
                                   self.info.ident,
                                   config::host_triple(),
                                   self.sess.opts.target_triple);
-            self.sess.span_err(self.vi_span, message.index(&FullRange));
+            self.sess.span_err(self.vi_span, &message[]);
             self.sess.abort_if_errors();
         }
 
@@ -563,7 +563,7 @@ impl<'a> PluginMetadata<'a> {
                 let message = format!("plugin crate `{}` only found in rlib format, \
                                        but must be available in dylib format",
                                        self.info.ident);
-                self.sess.span_err(self.vi_span, message.index(&FullRange));
+                self.sess.span_err(self.vi_span, &message[]);
                 // No need to abort because the loading code will just ignore this
                 // empty dylib.
                 None
diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs
index 72ce61b133a2b..cfff7c9935bc8 100644
--- a/src/librustc/metadata/csearch.rs
+++ b/src/librustc/metadata/csearch.rs
@@ -27,6 +27,7 @@ use std::rc::Rc;
 use syntax::ast;
 use syntax::ast_map;
 use syntax::attr;
+use syntax::attr::AttrMetaMethods;
 use syntax::diagnostic::expect;
 use syntax::parse::token;
 
@@ -95,7 +96,7 @@ pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem>
 
     // FIXME #1920: This path is not always correct if the crate is not linked
     // into the root namespace.
-    let mut r = vec![ast_map::PathMod(token::intern(cdata.name.index(&FullRange)))];
+    let mut r = vec![ast_map::PathMod(token::intern(&cdata.name[]))];
     r.push_all(path.as_slice());
     r
 }
@@ -375,6 +376,18 @@ pub fn get_stability(cstore: &cstore::CStore,
     decoder::get_stability(&*cdata, def.node)
 }
 
+pub fn is_staged_api(cstore: &cstore::CStore, def: ast::DefId) -> bool {
+    let cdata = cstore.get_crate_data(def.krate);
+    let attrs = decoder::get_crate_attributes(cdata.data());
+    for attr in attrs.iter() {
+        if attr.name().get() == "staged_api" {
+            match attr.node.value.node { ast::MetaWord(_) => return true, _ => (/*pass*/) }
+        }
+    }
+
+    return false;
+}
+
 pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId)
                       -> Vec<attr::ReprAttr> {
     let cdata = cstore.get_crate_data(def.krate);
diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs
index 9e71c867efa09..5ac8f908bf164 100644
--- a/src/librustc/metadata/decoder.rs
+++ b/src/librustc/metadata/decoder.rs
@@ -33,8 +33,7 @@ use middle::ty::{self, Ty};
 use middle::astencode::vtable_decoder_helpers;
 
 use std::collections::HashMap;
-use std::hash::Hash;
-use std::hash;
+use std::hash::{self, Hash, SipHasher};
 use std::io::extensions::u64_from_be_bytes;
 use std::io;
 use std::num::FromPrimitive;
@@ -75,7 +74,7 @@ fn lookup_hash<'a, F>(d: rbml::Doc<'a>, mut eq_fn: F, hash: u64) -> Option<rbml:
     let mut ret = None;
     reader::tagged_docs(tagged_doc.doc, belt, |elt| {
         let pos = u64_from_be_bytes(elt.data, elt.start, 4) as uint;
-        if eq_fn(elt.data.index(&((elt.start + 4) .. elt.end))) {
+        if eq_fn(&elt.data[(elt.start + 4) .. elt.end]) {
             ret = Some(reader::doc_at(d.data, pos).unwrap().doc);
             false
         } else {
@@ -89,12 +88,12 @@ pub fn maybe_find_item<'a>(item_id: ast::NodeId,
                            items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> {
     fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
         return u64_from_be_bytes(
-            bytes.index(&(0u..4u)), 0u, 4u) as ast::NodeId
+            &bytes[0u..4u], 0u, 4u) as ast::NodeId
             == item_id;
     }
     lookup_hash(items,
                 |a| eq_item(a, item_id),
-                hash::hash(&(item_id as i64)))
+                hash::hash::<i64, SipHasher>(&(item_id as i64)))
 }
 
 fn find_item<'a>(item_id: ast::NodeId, items: rbml::Doc<'a>) -> rbml::Doc<'a> {
@@ -1191,7 +1190,7 @@ pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> {
     }
     reader::tagged_docs(depsdoc, tag_crate_dep, |depdoc| {
         let name = docstr(depdoc, tag_crate_dep_crate_name);
-        let hash = Svh::new(docstr(depdoc, tag_crate_dep_hash).index(&FullRange));
+        let hash = Svh::new(&docstr(depdoc, tag_crate_dep_hash)[]);
         deps.push(CrateDep {
             cnum: crate_num,
             name: name,
diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs
index 83038df338b2d..c8921f1b2fb93 100644
--- a/src/librustc/metadata/encoder.rs
+++ b/src/librustc/metadata/encoder.rs
@@ -29,8 +29,7 @@ use util::nodemap::{FnvHashMap, NodeMap, NodeSet};
 
 use serialize::Encodable;
 use std::cell::RefCell;
-use std::hash::Hash;
-use std::hash;
+use std::hash::{Hash, Hasher, SipHasher};
 use syntax::abi;
 use syntax::ast::{self, DefId, NodeId};
 use syntax::ast_map::{PathElem, PathElems};
@@ -95,7 +94,7 @@ fn encode_impl_type_basename(rbml_w: &mut Encoder, name: ast::Ident) {
 }
 
 pub fn encode_def_id(rbml_w: &mut Encoder, id: DefId) {
-    rbml_w.wr_tagged_str(tag_def_id, def_to_string(id).index(&FullRange));
+    rbml_w.wr_tagged_str(tag_def_id, &def_to_string(id)[]);
 }
 
 #[derive(Clone)]
@@ -154,7 +153,7 @@ fn encode_variant_id(rbml_w: &mut Encoder, vid: DefId) {
     rbml_w.end_tag();
 
     rbml_w.start_tag(tag_mod_child);
-    rbml_w.wr_str(s.index(&FullRange));
+    rbml_w.wr_str(&s[]);
     rbml_w.end_tag();
 }
 
@@ -264,7 +263,7 @@ fn encode_symbol(ecx: &EncodeContext,
         }
         None => {
             ecx.diag.handler().bug(
-                format!("encode_symbol: id not found {}", id).index(&FullRange));
+                &format!("encode_symbol: id not found {}", id)[]);
         }
     }
     rbml_w.end_tag();
@@ -332,8 +331,8 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
         encode_name(rbml_w, variant.node.name.name);
         encode_parent_item(rbml_w, local_def(id));
         encode_visibility(rbml_w, variant.node.vis);
-        encode_attributes(rbml_w, variant.node.attrs.index(&FullRange));
-        encode_repr_attrs(rbml_w, ecx, variant.node.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &variant.node.attrs[]);
+        encode_repr_attrs(rbml_w, ecx, &variant.node.attrs[]);
 
         let stab = stability::lookup(ecx.tcx, ast_util::local_def(variant.node.id));
         encode_stability(rbml_w, stab);
@@ -344,9 +343,9 @@ fn encode_enum_variant_info(ecx: &EncodeContext,
                 let fields = ty::lookup_struct_fields(ecx.tcx, def_id);
                 let idx = encode_info_for_struct(ecx,
                                                  rbml_w,
-                                                 fields.index(&FullRange),
+                                                 &fields[],
                                                  index);
-                encode_struct_fields(rbml_w, fields.index(&FullRange), def_id);
+                encode_struct_fields(rbml_w, &fields[], def_id);
                 encode_index(rbml_w, idx, write_i64);
             }
         }
@@ -386,12 +385,12 @@ fn encode_reexported_static_method(rbml_w: &mut Encoder,
             exp.name, token::get_name(method_name));
     rbml_w.start_tag(tag_items_data_item_reexport);
     rbml_w.start_tag(tag_items_data_item_reexport_def_id);
-    rbml_w.wr_str(def_to_string(method_def_id).index(&FullRange));
+    rbml_w.wr_str(&def_to_string(method_def_id)[]);
     rbml_w.end_tag();
     rbml_w.start_tag(tag_items_data_item_reexport_name);
-    rbml_w.wr_str(format!("{}::{}",
+    rbml_w.wr_str(&format!("{}::{}",
                           exp.name,
-                          token::get_name(method_name)).index(&FullRange));
+                          token::get_name(method_name))[]);
     rbml_w.end_tag();
     rbml_w.end_tag();
 }
@@ -529,7 +528,7 @@ fn encode_reexports(ecx: &EncodeContext,
                        id);
                 rbml_w.start_tag(tag_items_data_item_reexport);
                 rbml_w.start_tag(tag_items_data_item_reexport_def_id);
-                rbml_w.wr_str(def_to_string(exp.def_id).index(&FullRange));
+                rbml_w.wr_str(&def_to_string(exp.def_id)[]);
                 rbml_w.end_tag();
                 rbml_w.start_tag(tag_items_data_item_reexport_name);
                 rbml_w.wr_str(exp.name.as_str());
@@ -562,13 +561,13 @@ fn encode_info_for_mod(ecx: &EncodeContext,
     // Encode info about all the module children.
     for item in md.items.iter() {
         rbml_w.start_tag(tag_mod_child);
-        rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange));
+        rbml_w.wr_str(&def_to_string(local_def(item.id))[]);
         rbml_w.end_tag();
 
         each_auxiliary_node_id(&**item, |auxiliary_node_id| {
             rbml_w.start_tag(tag_mod_child);
-            rbml_w.wr_str(def_to_string(local_def(
-                        auxiliary_node_id)).index(&FullRange));
+            rbml_w.wr_str(&def_to_string(local_def(
+                        auxiliary_node_id))[]);
             rbml_w.end_tag();
             true
         });
@@ -580,7 +579,7 @@ fn encode_info_for_mod(ecx: &EncodeContext,
                    did, ecx.tcx.map.node_to_string(did));
 
             rbml_w.start_tag(tag_mod_impl);
-            rbml_w.wr_str(def_to_string(local_def(did)).index(&FullRange));
+            rbml_w.wr_str(&def_to_string(local_def(did))[]);
             rbml_w.end_tag();
         }
     }
@@ -615,7 +614,7 @@ fn encode_visibility(rbml_w: &mut Encoder, visibility: ast::Visibility) {
         ast::Public => 'y',
         ast::Inherited => 'i',
     };
-    rbml_w.wr_str(ch.to_string().index(&FullRange));
+    rbml_w.wr_str(&ch.to_string()[]);
     rbml_w.end_tag();
 }
 
@@ -627,7 +626,7 @@ fn encode_unboxed_closure_kind(rbml_w: &mut Encoder,
         ty::FnMutUnboxedClosureKind => 'm',
         ty::FnOnceUnboxedClosureKind => 'o',
     };
-    rbml_w.wr_str(ch.to_string().index(&FullRange));
+    rbml_w.wr_str(&ch.to_string()[]);
     rbml_w.end_tag();
 }
 
@@ -788,7 +787,7 @@ fn encode_generics<'a, 'tcx>(rbml_w: &mut Encoder,
         rbml_w.end_tag();
 
         rbml_w.wr_tagged_str(tag_region_param_def_def_id,
-                             def_to_string(param.def_id).index(&FullRange));
+                             &def_to_string(param.def_id)[]);
 
         rbml_w.wr_tagged_u64(tag_region_param_def_space,
                              param.space.to_uint() as u64);
@@ -864,9 +863,9 @@ fn encode_info_for_method<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>,
     encode_path(rbml_w, impl_path.chain(Some(elem).into_iter()));
     match ast_item_opt {
         Some(&ast::MethodImplItem(ref ast_method)) => {
-            encode_attributes(rbml_w, ast_method.attrs.index(&FullRange));
+            encode_attributes(rbml_w, &ast_method.attrs[]);
             let any_types = !pty.generics.types.is_empty();
-            if any_types || is_default_impl || should_inline(ast_method.attrs.index(&FullRange)) {
+            if any_types || is_default_impl || should_inline(&ast_method.attrs[]) {
                 encode_inlined_item(ecx, rbml_w, IIImplItemRef(local_def(parent_id),
                                                                ast_item_opt.unwrap()));
             }
@@ -912,7 +911,7 @@ fn encode_info_for_associated_type(ecx: &EncodeContext,
     match typedef_opt {
         None => {}
         Some(typedef) => {
-            encode_attributes(rbml_w, typedef.attrs.index(&FullRange));
+            encode_attributes(rbml_w, &typedef.attrs[]);
             encode_type(ecx, rbml_w, ty::node_id_to_type(ecx.tcx,
                                                          typedef.id));
         }
@@ -1046,7 +1045,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_path(rbml_w, path);
         encode_visibility(rbml_w, vis);
         encode_stability(rbml_w, stab);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &item.attrs[]);
         rbml_w.end_tag();
       }
       ast::ItemConst(_, _) => {
@@ -1072,8 +1071,8 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
         encode_name(rbml_w, item.ident.name);
         encode_path(rbml_w, path);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
-        if tps_len > 0u || should_inline(item.attrs.index(&FullRange)) {
+        encode_attributes(rbml_w, &item.attrs[]);
+        if tps_len > 0u || should_inline(&item.attrs[]) {
             encode_inlined_item(ecx, rbml_w, IIItemRef(item));
         }
         if tps_len == 0 {
@@ -1089,7 +1088,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_info_for_mod(ecx,
                             rbml_w,
                             m,
-                            item.attrs.index(&FullRange),
+                            &item.attrs[],
                             item.id,
                             path,
                             item.ident,
@@ -1106,7 +1105,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         // Encode all the items in this module.
         for foreign_item in fm.items.iter() {
             rbml_w.start_tag(tag_mod_child);
-            rbml_w.wr_str(def_to_string(local_def(foreign_item.id)).index(&FullRange));
+            rbml_w.wr_str(&def_to_string(local_def(foreign_item.id))[]);
             rbml_w.end_tag();
         }
         encode_visibility(rbml_w, vis);
@@ -1134,8 +1133,8 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_item_variances(rbml_w, ecx, item.id);
         encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
         encode_name(rbml_w, item.ident.name);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
-        encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &item.attrs[]);
+        encode_repr_attrs(rbml_w, ecx, &item.attrs[]);
         for v in (*enum_definition).variants.iter() {
             encode_variant_id(rbml_w, local_def(v.node.id));
         }
@@ -1152,7 +1151,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_enum_variant_info(ecx,
                                  rbml_w,
                                  item.id,
-                                 (*enum_definition).variants.index(&FullRange),
+                                 &(*enum_definition).variants[],
                                  index);
       }
       ast::ItemStruct(ref struct_def, _) => {
@@ -1164,7 +1163,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
            class itself */
         let idx = encode_info_for_struct(ecx,
                                          rbml_w,
-                                         fields.index(&FullRange),
+                                         &fields[],
                                          index);
 
         /* Index the class*/
@@ -1178,16 +1177,16 @@ fn encode_info_for_item(ecx: &EncodeContext,
 
         encode_item_variances(rbml_w, ecx, item.id);
         encode_name(rbml_w, item.ident.name);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &item.attrs[]);
         encode_path(rbml_w, path.clone());
         encode_stability(rbml_w, stab);
         encode_visibility(rbml_w, vis);
-        encode_repr_attrs(rbml_w, ecx, item.attrs.index(&FullRange));
+        encode_repr_attrs(rbml_w, ecx, &item.attrs[]);
 
         /* Encode def_ids for each field and method
          for methods, write all the stuff get_trait_method
         needs to know*/
-        encode_struct_fields(rbml_w, fields.index(&FullRange), def_id);
+        encode_struct_fields(rbml_w, &fields[], def_id);
 
         encode_inlined_item(ecx, rbml_w, IIItemRef(item));
 
@@ -1219,7 +1218,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_family(rbml_w, 'i');
         encode_bounds_and_type(rbml_w, ecx, &lookup_item_type(tcx, def_id));
         encode_name(rbml_w, item.ident.name);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &item.attrs[]);
         encode_unsafety(rbml_w, unsafety);
         encode_polarity(rbml_w, polarity);
         match ty.node {
@@ -1323,7 +1322,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
         encode_generics(rbml_w, ecx, &trait_def.generics, tag_item_generics);
         encode_trait_ref(rbml_w, ecx, &*trait_def.trait_ref, tag_item_trait_ref);
         encode_name(rbml_w, item.ident.name);
-        encode_attributes(rbml_w, item.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &item.attrs[]);
         encode_visibility(rbml_w, vis);
         encode_stability(rbml_w, stab);
         for &method_def_id in ty::trait_item_def_ids(tcx, def_id).iter() {
@@ -1341,7 +1340,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
             rbml_w.end_tag();
 
             rbml_w.start_tag(tag_mod_child);
-            rbml_w.wr_str(def_to_string(method_def_id.def_id()).index(&FullRange));
+            rbml_w.wr_str(&def_to_string(method_def_id.def_id())[]);
             rbml_w.end_tag();
         }
         encode_path(rbml_w, path.clone());
@@ -1433,14 +1432,14 @@ fn encode_info_for_item(ecx: &EncodeContext,
             };
             match trait_item {
                 &ast::RequiredMethod(ref m) => {
-                    encode_attributes(rbml_w, m.attrs.index(&FullRange));
+                    encode_attributes(rbml_w, &m.attrs[]);
                     encode_trait_item(rbml_w);
                     encode_item_sort(rbml_w, 'r');
                     encode_method_argument_names(rbml_w, &*m.decl);
                 }
 
                 &ast::ProvidedMethod(ref m) => {
-                    encode_attributes(rbml_w, m.attrs.index(&FullRange));
+                    encode_attributes(rbml_w, &m.attrs[]);
                     encode_trait_item(rbml_w);
                     encode_item_sort(rbml_w, 'p');
                     encode_inlined_item(ecx, rbml_w, IITraitItemRef(def_id, trait_item));
@@ -1449,7 +1448,7 @@ fn encode_info_for_item(ecx: &EncodeContext,
 
                 &ast::TypeTraitItem(ref associated_type) => {
                     encode_attributes(rbml_w,
-                                      associated_type.attrs.index(&FullRange));
+                                      &associated_type.attrs[]);
                     encode_item_sort(rbml_w, 't');
                 }
             }
@@ -1598,11 +1597,13 @@ fn encode_info_for_items(ecx: &EncodeContext,
 
 fn encode_index<T, F>(rbml_w: &mut Encoder, index: Vec<entry<T>>, mut write_fn: F) where
     F: FnMut(&mut SeekableMemWriter, &T),
-    T: Hash,
+    T: Hash<SipHasher>,
 {
     let mut buckets: Vec<Vec<entry<T>>> = range(0, 256u16).map(|_| Vec::new()).collect();
     for elt in index.into_iter() {
-        let h = hash::hash(&elt.val) as uint;
+        let mut s = SipHasher::new();
+        elt.val.hash(&mut s);
+        let h = s.finish() as uint;
         (&mut buckets[h % 256]).push(elt);
     }
 
@@ -1826,10 +1827,10 @@ fn encode_macro_defs(rbml_w: &mut Encoder,
         rbml_w.start_tag(tag_macro_def);
 
         encode_name(rbml_w, def.ident.name);
-        encode_attributes(rbml_w, def.attrs.index(&FullRange));
+        encode_attributes(rbml_w, &def.attrs[]);
 
         rbml_w.start_tag(tag_macro_def_body);
-        rbml_w.wr_str(pprust::tts_to_string(def.body.index(&FullRange)).index(&FullRange));
+        rbml_w.wr_str(&pprust::tts_to_string(&def.body[])[]);
         rbml_w.end_tag();
 
         rbml_w.end_tag();
@@ -1869,7 +1870,7 @@ fn encode_struct_field_attrs(rbml_w: &mut Encoder, krate: &ast::Crate) {
         fn visit_struct_field(&mut self, field: &ast::StructField) {
             self.rbml_w.start_tag(tag_struct_field);
             self.rbml_w.wr_tagged_u32(tag_struct_field_id, field.node.id);
-            encode_attributes(self.rbml_w, field.node.attrs.index(&FullRange));
+            encode_attributes(self.rbml_w, &field.node.attrs[]);
             self.rbml_w.end_tag();
         }
     }
@@ -1941,13 +1942,13 @@ fn encode_misc_info(ecx: &EncodeContext,
     rbml_w.start_tag(tag_misc_info_crate_items);
     for item in krate.module.items.iter() {
         rbml_w.start_tag(tag_mod_child);
-        rbml_w.wr_str(def_to_string(local_def(item.id)).index(&FullRange));
+        rbml_w.wr_str(&def_to_string(local_def(item.id))[]);
         rbml_w.end_tag();
 
         each_auxiliary_node_id(&**item, |auxiliary_node_id| {
             rbml_w.start_tag(tag_mod_child);
-            rbml_w.wr_str(def_to_string(local_def(
-                        auxiliary_node_id)).index(&FullRange));
+            rbml_w.wr_str(&def_to_string(local_def(
+                        auxiliary_node_id))[]);
             rbml_w.end_tag();
             true
         });
@@ -2116,17 +2117,17 @@ fn encode_metadata_inner(wr: &mut SeekableMemWriter,
 
     let mut rbml_w = writer::Encoder::new(wr);
 
-    encode_crate_name(&mut rbml_w, ecx.link_meta.crate_name.index(&FullRange));
+    encode_crate_name(&mut rbml_w, &ecx.link_meta.crate_name[]);
     encode_crate_triple(&mut rbml_w,
-                        tcx.sess
+                        &tcx.sess
                            .opts
                            .target_triple
-                           .index(&FullRange));
+                           []);
     encode_hash(&mut rbml_w, &ecx.link_meta.crate_hash);
     encode_dylib_dependency_formats(&mut rbml_w, &ecx);
 
     let mut i = rbml_w.writer.tell().unwrap();
-    encode_attributes(&mut rbml_w, krate.attrs.index(&FullRange));
+    encode_attributes(&mut rbml_w, &krate.attrs[]);
     stats.attr_bytes = rbml_w.writer.tell().unwrap() - i;
 
     i = rbml_w.writer.tell().unwrap();
diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs
index 29625d0a6afac..e8160487e16f7 100644
--- a/src/librustc/metadata/filesearch.rs
+++ b/src/librustc/metadata/filesearch.rs
@@ -272,12 +272,12 @@ fn find_libdir(sysroot: &Path) -> String {
         }
     }
 
-    #[cfg(target_word_size = "64")]
+    #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
     fn primary_libdir_name() -> String {
         "lib64".to_string()
     }
 
-    #[cfg(target_word_size = "32")]
+    #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
     fn primary_libdir_name() -> String {
         "lib32".to_string()
     }
diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs
index 0fa9472287caa..3a925aba0b7c3 100644
--- a/src/librustc/metadata/loader.rs
+++ b/src/librustc/metadata/loader.rs
@@ -315,14 +315,14 @@ impl<'a> Context<'a> {
             &Some(ref r) => format!("{} which `{}` depends on",
                                     message, r.ident)
         };
-        self.sess.span_err(self.span, message.index(&FullRange));
+        self.sess.span_err(self.span, &message[]);
 
         if self.rejected_via_triple.len() > 0 {
             let mismatches = self.rejected_via_triple.iter();
             for (i, &CrateMismatch{ ref path, ref got }) in mismatches.enumerate() {
                 self.sess.fileline_note(self.span,
-                    format!("crate `{}`, path #{}, triple {}: {}",
-                            self.ident, i+1, got, path.display()).index(&FullRange));
+                    &format!("crate `{}`, path #{}, triple {}: {}",
+                            self.ident, i+1, got, path.display())[]);
             }
         }
         if self.rejected_via_hash.len() > 0 {
@@ -331,16 +331,16 @@ impl<'a> Context<'a> {
             let mismatches = self.rejected_via_hash.iter();
             for (i, &CrateMismatch{ ref path, .. }) in mismatches.enumerate() {
                 self.sess.fileline_note(self.span,
-                    format!("crate `{}` path {}{}: {}",
-                            self.ident, "#", i+1, path.display()).index(&FullRange));
+                    &format!("crate `{}` path {}{}: {}",
+                            self.ident, "#", i+1, path.display())[]);
             }
             match self.root {
                 &None => {}
                 &Some(ref r) => {
                     for (i, path) in r.paths().iter().enumerate() {
                         self.sess.fileline_note(self.span,
-                            format!("crate `{}` path #{}: {}",
-                                    r.ident, i+1, path.display()).index(&FullRange));
+                            &format!("crate `{}` path #{}: {}",
+                                    r.ident, i+1, path.display())[]);
                     }
                 }
             }
@@ -386,7 +386,7 @@ impl<'a> Context<'a> {
                 None => return FileDoesntMatch,
                 Some(file) => file,
             };
-            let (hash, rlib) = if file.starts_with(rlib_prefix.index(&FullRange)) &&
+            let (hash, rlib) = if file.starts_with(&rlib_prefix[]) &&
                     file.ends_with(".rlib") {
                 (file.slice(rlib_prefix.len(), file.len() - ".rlib".len()),
                  true)
@@ -445,27 +445,27 @@ impl<'a> Context<'a> {
             1 => Some(libraries.into_iter().next().unwrap()),
             _ => {
                 self.sess.span_err(self.span,
-                    format!("multiple matching crates for `{}`",
-                            self.crate_name).index(&FullRange));
+                    &format!("multiple matching crates for `{}`",
+                            self.crate_name)[]);
                 self.sess.note("candidates:");
                 for lib in libraries.iter() {
                     match lib.dylib {
                         Some(ref p) => {
-                            self.sess.note(format!("path: {}",
-                                                   p.display()).index(&FullRange));
+                            self.sess.note(&format!("path: {}",
+                                                   p.display())[]);
                         }
                         None => {}
                     }
                     match lib.rlib {
                         Some(ref p) => {
-                            self.sess.note(format!("path: {}",
-                                                   p.display()).index(&FullRange));
+                            self.sess.note(&format!("path: {}",
+                                                   p.display())[]);
                         }
                         None => {}
                     }
                     let data = lib.metadata.as_slice();
                     let name = decoder::get_crate_name(data);
-                    note_crate_name(self.sess.diagnostic(), name.index(&FullRange));
+                    note_crate_name(self.sess.diagnostic(), &name[]);
                 }
                 None
             }
@@ -516,22 +516,22 @@ impl<'a> Context<'a> {
             };
             if ret.is_some() {
                 self.sess.span_err(self.span,
-                                   format!("multiple {} candidates for `{}` \
+                                   &format!("multiple {} candidates for `{}` \
                                             found",
                                            flavor,
-                                           self.crate_name).index(&FullRange));
+                                           self.crate_name)[]);
                 self.sess.span_note(self.span,
-                                    format!(r"candidate #1: {}",
+                                    &format!(r"candidate #1: {}",
                                             ret.as_ref().unwrap()
-                                               .display()).index(&FullRange));
+                                               .display())[]);
                 error = 1;
                 ret = None;
             }
             if error > 0 {
                 error += 1;
                 self.sess.span_note(self.span,
-                                    format!(r"candidate #{}: {}", error,
-                                            lib.display()).index(&FullRange));
+                                    &format!(r"candidate #{}: {}", error,
+                                            lib.display())[]);
                 continue
             }
             *slot = Some(metadata);
@@ -606,17 +606,17 @@ impl<'a> Context<'a> {
         let mut rlibs = HashSet::new();
         let mut dylibs = HashSet::new();
         {
-            let mut locs = locs.iter().map(|l| Path::new(l.index(&FullRange))).filter(|loc| {
+            let mut locs = locs.iter().map(|l| Path::new(&l[])).filter(|loc| {
                 if !loc.exists() {
-                    sess.err(format!("extern location for {} does not exist: {}",
-                                     self.crate_name, loc.display()).index(&FullRange));
+                    sess.err(&format!("extern location for {} does not exist: {}",
+                                     self.crate_name, loc.display())[]);
                     return false;
                 }
                 let file = match loc.filename_str() {
                     Some(file) => file,
                     None => {
-                        sess.err(format!("extern location for {} is not a file: {}",
-                                         self.crate_name, loc.display()).index(&FullRange));
+                        sess.err(&format!("extern location for {} is not a file: {}",
+                                         self.crate_name, loc.display())[]);
                         return false;
                     }
                 };
@@ -624,13 +624,13 @@ impl<'a> Context<'a> {
                     return true
                 } else {
                     let (ref prefix, ref suffix) = dylibname;
-                    if file.starts_with(prefix.index(&FullRange)) &&
-                       file.ends_with(suffix.index(&FullRange)) {
+                    if file.starts_with(&prefix[]) &&
+                       file.ends_with(&suffix[]) {
                         return true
                     }
                 }
-                sess.err(format!("extern location for {} is of an unknown type: {}",
-                                 self.crate_name, loc.display()).index(&FullRange));
+                sess.err(&format!("extern location for {} is of an unknown type: {}",
+                                 self.crate_name, loc.display())[]);
                 false
             });
 
@@ -663,7 +663,7 @@ impl<'a> Context<'a> {
 }
 
 pub fn note_crate_name(diag: &SpanHandler, name: &str) {
-    diag.handler().note(format!("crate name: {}", name).index(&FullRange));
+    diag.handler().note(&format!("crate name: {}", name)[]);
 }
 
 impl ArchiveMetadata {
diff --git a/src/librustc/metadata/tydecode.rs b/src/librustc/metadata/tydecode.rs
index a4304bf1e2d62..5aacaa04e46d0 100644
--- a/src/librustc/metadata/tydecode.rs
+++ b/src/librustc/metadata/tydecode.rs
@@ -98,7 +98,7 @@ fn scan<R, F, G>(st: &mut PState, mut is_last: F, op: G) -> R where
     }
     let end_pos = st.pos;
     st.pos += 1;
-    return op(st.data.index(&(start_pos..end_pos)));
+    return op(&st.data[start_pos..end_pos]);
 }
 
 pub fn parse_ident(st: &mut PState, last: char) -> ast::Ident {
@@ -250,8 +250,8 @@ fn parse_trait_store_<F>(st: &mut PState, conv: &mut F) -> ty::TraitStore where
         '~' => ty::UniqTraitStore,
         '&' => ty::RegionTraitStore(parse_region_(st, conv), parse_mutability(st)),
         c => {
-            st.tcx.sess.bug(format!("parse_trait_store(): bad input '{}'",
-                                    c).index(&FullRange))
+            st.tcx.sess.bug(&format!("parse_trait_store(): bad input '{}'",
+                                    c)[])
         }
     }
 }
@@ -318,7 +318,7 @@ fn parse_bound_region_<F>(st: &mut PState, conv: &mut F) -> ty::BoundRegion wher
         }
         '[' => {
             let def = parse_def_(st, RegionParameter, conv);
-            let ident = token::str_to_ident(parse_str(st, ']').index(&FullRange));
+            let ident = token::str_to_ident(&parse_str(st, ']')[]);
             ty::BrNamed(def, ident.name)
         }
         'f' => {
@@ -357,7 +357,7 @@ fn parse_region_<F>(st: &mut PState, conv: &mut F) -> ty::Region where
         assert_eq!(next(st), '|');
         let index = parse_u32(st);
         assert_eq!(next(st), '|');
-        let nm = token::str_to_ident(parse_str(st, ']').index(&FullRange));
+        let nm = token::str_to_ident(&parse_str(st, ']')[]);
         ty::ReEarlyBound(node_id, space, index, nm.name)
       }
       'f' => {
@@ -481,7 +481,7 @@ fn parse_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>, conv: &mut F) -> Ty<'tcx> w
         assert_eq!(next(st), '|');
         let space = parse_param_space(st);
         assert_eq!(next(st), '|');
-        let name = token::intern(parse_str(st, ']').index(&FullRange));
+        let name = token::intern(&parse_str(st, ']')[]);
         return ty::mk_param(tcx, space, index, name);
       }
       '~' => return ty::mk_uniq(tcx, parse_ty_(st, conv)),
@@ -637,7 +637,7 @@ fn parse_abi_set(st: &mut PState) -> abi::Abi {
     assert_eq!(next(st), '[');
     scan(st, |c| c == ']', |bytes| {
         let abi_str = str::from_utf8(bytes).unwrap();
-        abi::lookup(abi_str.index(&FullRange)).expect(abi_str)
+        abi::lookup(&abi_str[]).expect(abi_str)
     })
 }
 
@@ -733,8 +733,8 @@ pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
         panic!();
     }
 
-    let crate_part = buf.index(&(0u..colon_idx));
-    let def_part = buf.index(&((colon_idx + 1u)..len));
+    let crate_part = &buf[0u..colon_idx];
+    let def_part = &buf[(colon_idx + 1u)..len];
 
     let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| s.parse::<uint>()) {
        Some(cn) => cn as ast::CrateNum,
diff --git a/src/librustc/middle/astconv_util.rs b/src/librustc/middle/astconv_util.rs
index 955f522b8041b..8cd3795580e8b 100644
--- a/src/librustc/middle/astconv_util.rs
+++ b/src/librustc/middle/astconv_util.rs
@@ -47,8 +47,8 @@ pub fn ast_ty_to_prim_ty<'tcx>(tcx: &ty::ctxt<'tcx>, ast_ty: &ast::Ty)
             let a_def = match tcx.def_map.borrow().get(&id) {
                 None => {
                     tcx.sess.span_bug(ast_ty.span,
-                                      format!("unbound path {}",
-                                              path.repr(tcx)).index(&FullRange))
+                                      &format!("unbound path {}",
+                                              path.repr(tcx))[])
                 }
                 Some(&d) => d
             };
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index 32ce131c57a3c..550c0f34cafec 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -132,7 +132,7 @@ pub fn decode_inlined_item<'tcx>(cdata: &cstore::crate_metadata,
             // Do an Option dance to use the path after it is moved below.
             let s = ast_map::path_to_string(ast_map::Values(path.iter()));
             path_as_str = Some(s);
-            path_as_str.as_ref().map(|x| x.index(&FullRange))
+            path_as_str.as_ref().map(|x| &x[])
         });
         let mut ast_dsr = reader::Decoder::new(ast_doc);
         let from_id_range = Decodable::decode(&mut ast_dsr).unwrap();
@@ -1876,8 +1876,8 @@ fn decode_side_tables(dcx: &DecodeContext,
         match c::astencode_tag::from_uint(tag) {
             None => {
                 dcx.tcx.sess.bug(
-                    format!("unknown tag found in side tables: {:x}",
-                            tag).index(&FullRange));
+                    &format!("unknown tag found in side tables: {:x}",
+                            tag)[]);
             }
             Some(value) => {
                 let val_doc = entry_doc.get(c::tag_table_val as uint);
@@ -1961,8 +1961,8 @@ fn decode_side_tables(dcx: &DecodeContext,
                     }
                     _ => {
                         dcx.tcx.sess.bug(
-                            format!("unknown tag found in side tables: {:x}",
-                                    tag).index(&FullRange));
+                            &format!("unknown tag found in side tables: {:x}",
+                                    tag)[]);
                     }
                 }
             }
diff --git a/src/librustc/middle/cfg/construct.rs b/src/librustc/middle/cfg/construct.rs
index f7fc90bcef651..b601ea59486ce 100644
--- a/src/librustc/middle/cfg/construct.rs
+++ b/src/librustc/middle/cfg/construct.rs
@@ -362,7 +362,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                 let mut cond_exit = discr_exit;
                 for arm in arms.iter() {
                     cond_exit = self.add_dummy_node(&[cond_exit]);        // 2
-                    let pats_exit = self.pats_any(arm.pats.index(&FullRange),
+                    let pats_exit = self.pats_any(&arm.pats[],
                                                   cond_exit);            // 3
                     let guard_exit = self.opt_expr(&arm.guard,
                                                    pats_exit);           // 4
@@ -615,15 +615,15 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                         }
                         self.tcx.sess.span_bug(
                             expr.span,
-                            format!("no loop scope for id {}",
-                                    loop_id).index(&FullRange));
+                            &format!("no loop scope for id {}",
+                                    loop_id)[]);
                     }
 
                     r => {
                         self.tcx.sess.span_bug(
                             expr.span,
-                            format!("bad entry `{:?}` in def_map for label",
-                                    r).index(&FullRange));
+                            &format!("bad entry `{:?}` in def_map for label",
+                                    r)[]);
                     }
                 }
             }
diff --git a/src/librustc/middle/cfg/graphviz.rs b/src/librustc/middle/cfg/graphviz.rs
index 8b9a0d89b380c..f4db2b6e61db2 100644
--- a/src/librustc/middle/cfg/graphviz.rs
+++ b/src/librustc/middle/cfg/graphviz.rs
@@ -52,7 +52,7 @@ fn replace_newline_with_backslash_l(s: String) -> String {
 }
 
 impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
-    fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(self.name.index(&FullRange)).unwrap() }
+    fn graph_id(&'a self) -> dot::Id<'a> { dot::Id::new(&self.name[]).unwrap() }
 
     fn node_id(&'a self, &(i,_): &Node<'a>) -> dot::Id<'a> {
         dot::Id::new(format!("N{}", i.node_id())).unwrap()
@@ -85,9 +85,9 @@ impl<'a, 'ast> dot::Labeller<'a, Node<'a>, Edge<'a>> for LabelledCFG<'a, 'ast> {
             let s = self.ast_map.node_to_string(node_id);
             // left-aligns the lines
             let s = replace_newline_with_backslash_l(s);
-            label.push_str(format!("exiting scope_{} {}",
+            label.push_str(&format!("exiting scope_{} {}",
                                    i,
-                                   s.index(&FullRange)).index(&FullRange));
+                                   &s[])[]);
         }
         dot::LabelText::EscStr(label.into_cow())
     }
diff --git a/src/librustc/middle/check_loop.rs b/src/librustc/middle/check_loop.rs
index 5024e5c4f77de..1f779acac2503 100644
--- a/src/librustc/middle/check_loop.rs
+++ b/src/librustc/middle/check_loop.rs
@@ -74,11 +74,11 @@ impl<'a> CheckLoopVisitor<'a> {
             Loop => {}
             Closure => {
                 self.sess.span_err(span,
-                                   format!("`{}` inside of a closure", name).index(&FullRange));
+                                   &format!("`{}` inside of a closure", name)[]);
             }
             Normal => {
                 self.sess.span_err(span,
-                                   format!("`{}` outside of loop", name).index(&FullRange));
+                                   &format!("`{}` outside of loop", name)[]);
             }
         }
     }
diff --git a/src/librustc/middle/check_match.rs b/src/librustc/middle/check_match.rs
index f1edfb37273bb..43f39a67f5c41 100644
--- a/src/librustc/middle/check_match.rs
+++ b/src/librustc/middle/check_match.rs
@@ -47,7 +47,7 @@ struct Matrix<'a>(Vec<Vec<&'a Pat>>);
 
 /// Pretty-printer for matrices of patterns, example:
 /// ++++++++++++++++++++++++++
-/// + _     + .index(&FullRange)             +
+/// + _     + []             +
 /// ++++++++++++++++++++++++++
 /// + true  + [First]        +
 /// ++++++++++++++++++++++++++
@@ -161,7 +161,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
                 // First, check legality of move bindings.
                 check_legality_of_move_bindings(cx,
                                                 arm.guard.is_some(),
-                                                arm.pats.index(&FullRange));
+                                                &arm.pats[]);
 
                 // Second, if there is a guard on each arm, make sure it isn't
                 // assigning or borrowing anything mutably.
@@ -198,7 +198,7 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
             }
 
             // Fourth, check for unreachable arms.
-            check_arms(cx, inlined_arms.index(&FullRange), source);
+            check_arms(cx, &inlined_arms[], source);
 
             // Finally, check if the whole match expression is exhaustive.
             // Check for empty enum, because is_useful only works on inhabited types.
@@ -228,9 +228,9 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &ast::Expr) {
             is_refutable(cx, &*static_inliner.fold_pat((*pat).clone()), |uncovered_pat| {
                 cx.tcx.sess.span_err(
                     pat.span,
-                    format!("refutable pattern in `for` loop binding: \
+                    &format!("refutable pattern in `for` loop binding: \
                             `{}` not covered",
-                            pat_to_string(uncovered_pat)).index(&FullRange));
+                            pat_to_string(uncovered_pat))[]);
             });
 
             // Check legality of move bindings.
@@ -303,7 +303,7 @@ fn check_arms(cx: &MatchCheckCtxt,
         for pat in pats.iter() {
             let v = vec![&**pat];
 
-            match is_useful(cx, &seen, v.index(&FullRange), LeaveOutWitness) {
+            match is_useful(cx, &seen, &v[], LeaveOutWitness) {
                 NotUseful => {
                     match source {
                         ast::MatchSource::IfLetDesugar { .. } => {
@@ -355,7 +355,7 @@ fn raw_pat<'a>(p: &'a Pat) -> &'a Pat {
 fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix) {
     match is_useful(cx, matrix, &[DUMMY_WILD_PAT], ConstructWitness) {
         UsefulWithWitness(pats) => {
-            let witness = match pats.index(&FullRange) {
+            let witness = match &pats[] {
                 [ref witness] => &**witness,
                 [] => DUMMY_WILD_PAT,
                 _ => unreachable!()
@@ -609,7 +609,7 @@ fn is_useful(cx: &MatchCheckCtxt,
                         UsefulWithWitness(pats) => UsefulWithWitness({
                             let arity = constructor_arity(cx, &c, left_ty);
                             let mut result = {
-                                let pat_slice = pats.index(&FullRange);
+                                let pat_slice = &pats[];
                                 let subpats: Vec<_> = range(0, arity).map(|i| {
                                     pat_slice.get(i).map_or(DUMMY_WILD_PAT, |p| &**p)
                                 }).collect();
@@ -656,10 +656,10 @@ fn is_useful_specialized(cx: &MatchCheckCtxt, &Matrix(ref m): &Matrix,
                          witness: WitnessPreference) -> Usefulness {
     let arity = constructor_arity(cx, &ctor, lty);
     let matrix = Matrix(m.iter().filter_map(|r| {
-        specialize(cx, r.index(&FullRange), &ctor, 0u, arity)
+        specialize(cx, &r[], &ctor, 0u, arity)
     }).collect());
     match specialize(cx, v, &ctor, 0u, arity) {
-        Some(v) => is_useful(cx, &matrix, v.index(&FullRange), witness),
+        Some(v) => is_useful(cx, &matrix, &v[], witness),
         None => NotUseful
     }
 }
@@ -729,7 +729,7 @@ fn pat_constructors(cx: &MatchCheckCtxt, p: &Pat,
 /// This computes the arity of a constructor. The arity of a constructor
 /// is how many subpattern patterns of that constructor should be expanded to.
 ///
-/// For instance, a tuple pattern (_, 42u, Some(.index(&FullRange))) has the arity of 3.
+/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3.
 /// A struct pattern's arity is the number of fields it contains, etc.
 pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint {
     match ty.sty {
@@ -926,8 +926,8 @@ pub fn specialize<'a>(cx: &MatchCheckCtxt, r: &[&'a Pat],
         }
     };
     head.map(|mut head| {
-        head.push_all(r.index(&(0..col)));
-        head.push_all(r.index(&((col + 1)..)));
+        head.push_all(&r[0..col]);
+        head.push_all(&r[(col + 1)..]);
         head
     })
 }
@@ -1041,10 +1041,10 @@ fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
                     _ => {
                         cx.tcx.sess.span_bug(
                             p.span,
-                            format!("binding pattern {} is not an \
+                            &format!("binding pattern {} is not an \
                                      identifier: {:?}",
                                     p.id,
-                                    p.node).index(&FullRange));
+                                    p.node)[]);
                     }
                 }
             }
diff --git a/src/librustc/middle/check_static.rs b/src/librustc/middle/check_static.rs
index 994a2b0dc8abc..154272d2deb41 100644
--- a/src/librustc/middle/check_static.rs
+++ b/src/librustc/middle/check_static.rs
@@ -111,8 +111,8 @@ impl<'a, 'tcx> CheckStaticVisitor<'a, 'tcx> {
             return
         };
 
-        self.tcx.sess.span_err(e.span, format!("mutable statics are not allowed \
-                                                to have {}", suffix).index(&FullRange));
+        self.tcx.sess.span_err(e.span, &format!("mutable statics are not allowed \
+                                                to have {}", suffix)[]);
     }
 
     fn check_static_type(&self, e: &ast::Expr) {
@@ -169,8 +169,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> {
             ty::ty_struct(did, _) |
             ty::ty_enum(did, _) if ty::has_dtor(self.tcx, did) => {
                 self.tcx.sess.span_err(e.span,
-                                       format!("{} are not allowed to have \
-                                                destructors", self.msg()).index(&FullRange))
+                                       &format!("{} are not allowed to have \
+                                                destructors", self.msg())[])
             }
             _ => {}
         }
@@ -234,7 +234,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for CheckStaticVisitor<'a, 'tcx> {
                         let msg = "constants cannot refer to other statics, \
                                    insert an intermediate constant \
                                    instead";
-                        self.tcx.sess.span_err(e.span, msg.index(&FullRange));
+                        self.tcx.sess.span_err(e.span, &msg[]);
                     }
                     _ => {}
                 }
diff --git a/src/librustc/middle/check_static_recursion.rs b/src/librustc/middle/check_static_recursion.rs
index 75851f0a85333..e2a0738def180 100644
--- a/src/librustc/middle/check_static_recursion.rs
+++ b/src/librustc/middle/check_static_recursion.rs
@@ -104,8 +104,8 @@ impl<'a, 'ast, 'v> Visitor<'v> for CheckItemRecursionVisitor<'a, 'ast> {
                           ast_map::NodeForeignItem(_) => {},
                           _ => {
                             self.sess.span_err(e.span,
-                              format!("expected item, found {}",
-                                      self.ast_map.node_to_string(def_id.node)).index(&FullRange));
+                              &format!("expected item, found {}",
+                                      self.ast_map.node_to_string(def_id.node))[]);
                             return;
                           },
                         }
diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs
index e726993bd4840..04d4b41b21aa4 100644
--- a/src/librustc/middle/const_eval.rs
+++ b/src/librustc/middle/const_eval.rs
@@ -48,7 +48,7 @@ use std::rc::Rc;
 //     target uses". This _includes_ integer-constants, plus the following
 //     constructors:
 //
-//        fixed-size vectors and strings: .index(&FullRange) and ""/_
+//        fixed-size vectors and strings: [] and ""/_
 //        vector and string slices: &[] and &""
 //        tuples: (,)
 //        enums: foo(...)
@@ -117,7 +117,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
             None => None,
             Some(ast_map::NodeItem(it)) => match it.node {
                 ast::ItemEnum(ast::EnumDef { ref variants }, _) => {
-                    variant_expr(variants.index(&FullRange), variant_def.node)
+                    variant_expr(&variants[], variant_def.node)
                 }
                 _ => None
             },
@@ -138,7 +138,7 @@ fn lookup_variant_by_id<'a>(tcx: &'a ty::ctxt,
                     // NOTE this doesn't do the right thing, it compares inlined
                     // NodeId's to the original variant_def's NodeId, but they
                     // come from different crates, so they will likely never match.
-                    variant_expr(variants.index(&FullRange), variant_def.node).map(|e| e.id)
+                    variant_expr(&variants[], variant_def.node).map(|e| e.id)
                 }
                 _ => None
             },
@@ -364,7 +364,7 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr) -> P<ast::Pat> {
 pub fn eval_const_expr(tcx: &ty::ctxt, e: &Expr) -> const_val {
     match eval_const_expr_partial(tcx, e) {
         Ok(r) => r,
-        Err(s) => tcx.sess.span_fatal(e.span, s.index(&FullRange))
+        Err(s) => tcx.sess.span_fatal(e.span, &s[])
     }
 }
 
diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs
index bdd98a94fc32f..4ae0aa434065f 100644
--- a/src/librustc/middle/dataflow.rs
+++ b/src/librustc/middle/dataflow.rs
@@ -312,7 +312,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
                 let mut t = on_entry.to_vec();
                 self.apply_gen_kill(cfgidx, t.as_mut_slice());
                 temp_bits = t;
-                temp_bits.index(&FullRange)
+                &temp_bits[]
             }
         };
         debug!("{} each_bit_for_node({:?}, cfgidx={:?}) bits={}",
@@ -421,7 +421,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> {
                 let bits = self.kills.slice_mut(start, end);
                 debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [before]",
                        self.analysis_name, flow_exit, mut_bits_to_string(bits));
-                bits.clone_from_slice(orig_kills.index(&FullRange));
+                bits.clone_from_slice(&orig_kills[]);
                 debug!("{} add_kills_from_flow_exits flow_exit={:?} bits={} [after]",
                        self.analysis_name, flow_exit, mut_bits_to_string(bits));
             }
@@ -554,7 +554,7 @@ fn bits_to_string(words: &[uint]) -> String {
         let mut v = word;
         for _ in range(0u, uint::BYTES) {
             result.push(sep);
-            result.push_str(format!("{:02x}", v & 0xFF).index(&FullRange));
+            result.push_str(&format!("{:02x}", v & 0xFF)[]);
             v >>= 8;
             sep = '-';
         }
diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs
index 0bc899a8a6293..cca0b7d9ad023 100644
--- a/src/librustc/middle/dependency_format.rs
+++ b/src/librustc/middle/dependency_format.rs
@@ -117,8 +117,8 @@ fn calculate_type(sess: &session::Session,
             sess.cstore.iter_crate_data(|cnum, data| {
                 let src = sess.cstore.get_used_crate_source(cnum).unwrap();
                 if src.rlib.is_some() { return }
-                sess.err(format!("dependency `{}` not found in rlib format",
-                                 data.name).index(&FullRange));
+                sess.err(&format!("dependency `{}` not found in rlib format",
+                                 data.name)[]);
             });
             return Vec::new();
         }
@@ -191,13 +191,13 @@ fn calculate_type(sess: &session::Session,
             Some(cstore::RequireDynamic) if src.dylib.is_some() => continue,
             Some(kind) => {
                 let data = sess.cstore.get_crate_data(cnum + 1);
-                sess.err(format!("crate `{}` required to be available in {}, \
+                sess.err(&format!("crate `{}` required to be available in {}, \
                                   but it was not available in this form",
                                  data.name,
                                  match kind {
                                      cstore::RequireStatic => "rlib",
                                      cstore::RequireDynamic => "dylib",
-                                 }).index(&FullRange));
+                                 })[]);
             }
         }
     }
@@ -220,9 +220,9 @@ fn add_library(sess: &session::Session,
             // can be refined over time.
             if link2 != link || link == cstore::RequireStatic {
                 let data = sess.cstore.get_crate_data(cnum);
-                sess.err(format!("cannot satisfy dependencies so `{}` only \
+                sess.err(&format!("cannot satisfy dependencies so `{}` only \
                                   shows up once",
-                                 data.name).index(&FullRange));
+                                 data.name)[]);
                 sess.help("having upstream crates all available in one format \
                            will likely make this go away");
             }
diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs
index 45838436e6097..e5eb439d42c75 100644
--- a/src/librustc/middle/expr_use_visitor.rs
+++ b/src/librustc/middle/expr_use_visitor.rs
@@ -857,8 +857,8 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                     let (m, r) = match self_ty.sty {
                         ty::ty_rptr(r, ref m) => (m.mutbl, r),
                         _ => self.tcx().sess.span_bug(expr.span,
-                                format!("bad overloaded deref type {}",
-                                    method_ty.repr(self.tcx())).index(&FullRange))
+                                &format!("bad overloaded deref type {}",
+                                    method_ty.repr(self.tcx()))[])
                     };
                     let bk = ty::BorrowKind::from_mutbl(m);
                     self.delegate.borrow(expr.id, expr.span, cmt,
@@ -1180,7 +1180,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                                 let msg = format!("Pattern has unexpected def: {:?} and type {}",
                                                   def,
                                                   cmt_pat.ty.repr(tcx));
-                                tcx.sess.span_bug(pat.span, msg.index(&FullRange))
+                                tcx.sess.span_bug(pat.span, &msg[])
                             }
                         }
                     }
diff --git a/src/librustc/middle/infer/combine.rs b/src/librustc/middle/infer/combine.rs
index 22975f54a9fb4..4a4328fa98baf 100644
--- a/src/librustc/middle/infer/combine.rs
+++ b/src/librustc/middle/infer/combine.rs
@@ -142,7 +142,7 @@ pub trait Combine<'tcx> : Sized {
                             for _ in a_regions.iter() {
                                 invariance.push(ty::Invariant);
                             }
-                            invariance.index(&FullRange)
+                            &invariance[]
                         }
                     };
 
@@ -427,6 +427,16 @@ impl<'tcx> Combineable<'tcx> for ty::TraitRef<'tcx> {
     }
 }
 
+impl<'tcx> Combineable<'tcx> for Ty<'tcx> {
+    fn combine<C:Combine<'tcx>>(combiner: &C,
+                                a: &Ty<'tcx>,
+                                b: &Ty<'tcx>)
+                                -> cres<'tcx, Ty<'tcx>>
+    {
+        combiner.tys(*a, *b)
+    }
+}
+
 impl<'tcx> Combineable<'tcx> for ty::ProjectionPredicate<'tcx> {
     fn combine<C:Combine<'tcx>>(combiner: &C,
                                 a: &ty::ProjectionPredicate<'tcx>,
@@ -477,10 +487,10 @@ pub fn super_tys<'tcx, C: Combine<'tcx>>(this: &C,
       (&ty::ty_infer(TyVar(_)), _) |
       (_, &ty::ty_infer(TyVar(_))) => {
         tcx.sess.bug(
-            format!("{}: bot and var types should have been handled ({},{})",
+            &format!("{}: bot and var types should have been handled ({},{})",
                     this.tag(),
                     a.repr(this.infcx().tcx),
-                    b.repr(this.infcx().tcx)).index(&FullRange));
+                    b.repr(this.infcx().tcx))[]);
       }
 
       (&ty::ty_err, _) | (_, &ty::ty_err) => {
@@ -855,8 +865,8 @@ impl<'cx, 'tcx> ty_fold::TypeFolder<'tcx> for Generalizer<'cx, 'tcx> {
             ty::ReEarlyBound(..) => {
                 self.tcx().sess.span_bug(
                     self.span,
-                    format!("Encountered early bound region when generalizing: {}",
-                            r.repr(self.tcx())).index(&FullRange));
+                    &format!("Encountered early bound region when generalizing: {}",
+                            r.repr(self.tcx()))[]);
             }
 
             // Always make a fresh region variable for skolemized regions;
diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs
index 762617fb49b88..bbd12c9671d28 100644
--- a/src/librustc/middle/infer/error_reporting.rs
+++ b/src/librustc/middle/infer/error_reporting.rs
@@ -200,9 +200,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                                 ref trace_origins,
                                 ref same_regions) => {
                     if !same_regions.is_empty() {
-                        self.report_processed_errors(var_origins.index(&FullRange),
-                                                     trace_origins.index(&FullRange),
-                                                     same_regions.index(&FullRange));
+                        self.report_processed_errors(&var_origins[],
+                                                     &trace_origins[],
+                                                     &same_regions[]);
                     }
                 }
             }
@@ -373,10 +373,10 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
 
         self.tcx.sess.span_err(
             trace.origin.span(),
-            format!("{}: {} ({})",
+            &format!("{}: {} ({})",
                  message_root_str,
                  expected_found_str,
-                 ty::type_err_to_str(self.tcx, terr)).index(&FullRange));
+                 ty::type_err_to_str(self.tcx, terr))[]);
 
         match trace.origin {
             infer::MatchExpressionArm(_, arm_span) =>
@@ -445,42 +445,42 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                 // Does the required lifetime have a nice name we can print?
                 self.tcx.sess.span_err(
                     origin.span(),
-                    format!("{} may not live long enough", labeled_user_string).index(&FullRange));
+                    &format!("{} may not live long enough", labeled_user_string)[]);
                 self.tcx.sess.span_help(
                     origin.span(),
-                    format!(
+                    &format!(
                         "consider adding an explicit lifetime bound `{}: {}`...",
                         bound_kind.user_string(self.tcx),
-                        sub.user_string(self.tcx)).index(&FullRange));
+                        sub.user_string(self.tcx))[]);
             }
 
             ty::ReStatic => {
                 // Does the required lifetime have a nice name we can print?
                 self.tcx.sess.span_err(
                     origin.span(),
-                    format!("{} may not live long enough", labeled_user_string).index(&FullRange));
+                    &format!("{} may not live long enough", labeled_user_string)[]);
                 self.tcx.sess.span_help(
                     origin.span(),
-                    format!(
+                    &format!(
                         "consider adding an explicit lifetime bound `{}: 'static`...",
-                        bound_kind.user_string(self.tcx)).index(&FullRange));
+                        bound_kind.user_string(self.tcx))[]);
             }
 
             _ => {
                 // If not, be less specific.
                 self.tcx.sess.span_err(
                     origin.span(),
-                    format!(
+                    &format!(
                         "{} may not live long enough",
-                        labeled_user_string).index(&FullRange));
+                        labeled_user_string)[]);
                 self.tcx.sess.span_help(
                     origin.span(),
-                    format!(
+                    &format!(
                         "consider adding an explicit lifetime bound for `{}`",
-                        bound_kind.user_string(self.tcx)).index(&FullRange));
+                        bound_kind.user_string(self.tcx))[]);
                 note_and_explain_region(
                     self.tcx,
-                    format!("{} must be valid for ", labeled_user_string).index(&FullRange),
+                    &format!("{} must be valid for ", labeled_user_string)[],
                     sub,
                     "...");
             }
@@ -517,12 +517,12 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ReborrowUpvar(span, ref upvar_id) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("lifetime of borrowed pointer outlives \
+                    &format!("lifetime of borrowed pointer outlives \
                             lifetime of captured variable `{}`...",
                             ty::local_var_name_str(self.tcx,
                                                    upvar_id.var_id)
                                 .get()
-                                .to_string()).index(&FullRange));
+                                .to_string())[]);
                 note_and_explain_region(
                     self.tcx,
                     "...the borrowed pointer is valid for ",
@@ -530,11 +530,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                     "...");
                 note_and_explain_region(
                     self.tcx,
-                    format!("...but `{}` is only valid for ",
+                    &format!("...but `{}` is only valid for ",
                             ty::local_var_name_str(self.tcx,
                                                    upvar_id.var_id)
                                 .get()
-                                .to_string()).index(&FullRange),
+                                .to_string())[],
                     sup,
                     "");
             }
@@ -576,11 +576,11 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::FreeVariable(span, id) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("captured variable `{}` does not \
+                    &format!("captured variable `{}` does not \
                             outlive the enclosing closure",
                             ty::local_var_name_str(self.tcx,
                                                    id).get()
-                                                      .to_string()).index(&FullRange));
+                                                      .to_string())[]);
                 note_and_explain_region(
                     self.tcx,
                     "captured variable is valid for ",
@@ -620,9 +620,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::RelateParamBound(span, ty) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("the type `{}` does not fulfill the \
+                    &format!("the type `{}` does not fulfill the \
                              required lifetime",
-                            self.ty_to_string(ty)).index(&FullRange));
+                            self.ty_to_string(ty))[]);
                 note_and_explain_region(self.tcx,
                                         "type must outlive ",
                                         sub,
@@ -646,9 +646,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::RelateDefaultParamBound(span, ty) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("the type `{}` (provided as the value of \
+                    &format!("the type `{}` (provided as the value of \
                              a type parameter) is not valid at this point",
-                            self.ty_to_string(ty)).index(&FullRange));
+                            self.ty_to_string(ty))[]);
                 note_and_explain_region(self.tcx,
                                         "type must outlive ",
                                         sub,
@@ -712,9 +712,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ExprTypeIsNotInScope(t, span) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("type of expression contains references \
+                    &format!("type of expression contains references \
                              that are not valid during the expression: `{}`",
-                            self.ty_to_string(t)).index(&FullRange));
+                            self.ty_to_string(t))[]);
                 note_and_explain_region(
                     self.tcx,
                     "type is only valid for ",
@@ -734,9 +734,9 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ReferenceOutlivesReferent(ty, span) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("in type `{}`, reference has a longer lifetime \
+                    &format!("in type `{}`, reference has a longer lifetime \
                              than the data it references",
-                            self.ty_to_string(ty)).index(&FullRange));
+                            self.ty_to_string(ty))[]);
                 note_and_explain_region(
                     self.tcx,
                     "the pointer is valid for ",
@@ -861,7 +861,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         let (fn_decl, generics, unsafety, ident, expl_self, span)
                                     = node_inner.expect("expect item fn");
         let taken = lifetimes_in_scope(self.tcx, scope_id);
-        let life_giver = LifeGiver::with_taken(taken.index(&FullRange));
+        let life_giver = LifeGiver::with_taken(&taken[]);
         let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self,
                                        generics, same_regions, &life_giver);
         let (fn_decl, expl_self, generics) = rebuilder.rebuild();
@@ -937,7 +937,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
             }
             expl_self_opt = self.rebuild_expl_self(expl_self_opt, lifetime,
                                                    &anon_nums, &region_names);
-            inputs = self.rebuild_args_ty(inputs.index(&FullRange), lifetime,
+            inputs = self.rebuild_args_ty(&inputs[], lifetime,
                                           &anon_nums, &region_names);
             output = self.rebuild_output(&output, lifetime, &anon_nums, &region_names);
             ty_params = self.rebuild_ty_params(ty_params, lifetime,
@@ -972,7 +972,7 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                 names.push(lt_name);
             }
             names.sort();
-            let name = token::str_to_ident(names[0].index(&FullRange)).name;
+            let name = token::str_to_ident(&names[0][]).name;
             return (name_to_dummy_lifetime(name), Kept);
         }
         return (self.life_giver.give_lifetime(), Fresh);
@@ -1220,9 +1220,9 @@ impl<'a, 'tcx> Rebuilder<'a, 'tcx> {
                         None => {
                             self.tcx
                                 .sess
-                                .fatal(format!(
+                                .fatal(&format!(
                                         "unbound path {}",
-                                        pprust::path_to_string(path)).index(&FullRange))
+                                        pprust::path_to_string(path))[])
                         }
                         Some(&d) => d
                     };
@@ -1420,7 +1420,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                                               opt_explicit_self, generics);
         let msg = format!("consider using an explicit lifetime \
                            parameter as shown: {}", suggested_fn);
-        self.tcx.sess.span_help(span, msg.index(&FullRange));
+        self.tcx.sess.span_help(span, &msg[]);
     }
 
     fn report_inference_failure(&self,
@@ -1461,9 +1461,9 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
 
         self.tcx.sess.span_err(
             var_origin.span(),
-            format!("cannot infer an appropriate lifetime{} \
+            &format!("cannot infer an appropriate lifetime{} \
                     due to conflicting requirements",
-                    var_description).index(&FullRange));
+                    var_description)[]);
     }
 
     fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) {
@@ -1510,8 +1510,8 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                     Some(values_str) => {
                         self.tcx.sess.span_note(
                             trace.origin.span(),
-                            format!("...so that {} ({})",
-                                    desc, values_str).index(&FullRange));
+                            &format!("...so that {} ({})",
+                                    desc, values_str)[]);
                     }
                     None => {
                         // Really should avoid printing this error at
@@ -1520,7 +1520,7 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                         // doing right now. - nmatsakis
                         self.tcx.sess.span_note(
                             trace.origin.span(),
-                            format!("...so that {}", desc).index(&FullRange));
+                            &format!("...so that {}", desc)[]);
                     }
                 }
             }
@@ -1533,11 +1533,11 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ReborrowUpvar(span, ref upvar_id) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!(
+                    &format!(
                         "...so that closure can access `{}`",
                         ty::local_var_name_str(self.tcx, upvar_id.var_id)
                             .get()
-                            .to_string()).index(&FullRange))
+                            .to_string())[])
             }
             infer::InfStackClosure(span) => {
                 self.tcx.sess.span_note(
@@ -1558,11 +1558,11 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
             infer::FreeVariable(span, id) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so that captured variable `{}` \
+                    &format!("...so that captured variable `{}` \
                             does not outlive the enclosing closure",
                             ty::local_var_name_str(
                                 self.tcx,
-                                id).get().to_string()).index(&FullRange));
+                                id).get().to_string())[]);
             }
             infer::IndexSlice(span) => {
                 self.tcx.sess.span_note(
@@ -1604,9 +1604,9 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ExprTypeIsNotInScope(t, span) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so type `{}` of expression is valid during the \
+                    &format!("...so type `{}` of expression is valid during the \
                              expression",
-                            self.ty_to_string(t)).index(&FullRange));
+                            self.ty_to_string(t))[]);
             }
             infer::BindingTypeIsNotValidAtDecl(span) => {
                 self.tcx.sess.span_note(
@@ -1616,30 +1616,30 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
             infer::ReferenceOutlivesReferent(ty, span) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so that the reference type `{}` \
+                    &format!("...so that the reference type `{}` \
                              does not outlive the data it points at",
-                            self.ty_to_string(ty)).index(&FullRange));
+                            self.ty_to_string(ty))[]);
             }
             infer::RelateParamBound(span, t) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so that the type `{}` \
+                    &format!("...so that the type `{}` \
                              will meet the declared lifetime bounds",
-                            self.ty_to_string(t)).index(&FullRange));
+                            self.ty_to_string(t))[]);
             }
             infer::RelateDefaultParamBound(span, t) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so that type parameter \
+                    &format!("...so that type parameter \
                              instantiated with `{}`, \
                              will meet its declared lifetime bounds",
-                            self.ty_to_string(t)).index(&FullRange));
+                            self.ty_to_string(t))[]);
             }
             infer::RelateRegionParamBound(span) => {
                 self.tcx.sess.span_note(
                     span,
-                    format!("...so that the declared lifetime parameter bounds \
-                                are satisfied").index(&FullRange));
+                    &format!("...so that the declared lifetime parameter bounds \
+                                are satisfied")[]);
             }
         }
     }
@@ -1691,7 +1691,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt,
         Some(node) => match node {
             ast_map::NodeItem(item) => match item.node {
                 ast::ItemFn(_, _, _, ref gen, _) => {
-                    taken.push_all(gen.lifetimes.index(&FullRange));
+                    taken.push_all(&gen.lifetimes[]);
                     None
                 },
                 _ => None
@@ -1699,7 +1699,7 @@ fn lifetimes_in_scope(tcx: &ty::ctxt,
             ast_map::NodeImplItem(ii) => {
                 match *ii {
                     ast::MethodImplItem(ref m) => {
-                        taken.push_all(m.pe_generics().lifetimes.index(&FullRange));
+                        taken.push_all(&m.pe_generics().lifetimes[]);
                         Some(m.id)
                     }
                     ast::TypeImplItem(_) => None,
@@ -1758,10 +1758,10 @@ impl LifeGiver {
         let mut lifetime;
         loop {
             let mut s = String::from_str("'");
-            s.push_str(num_to_string(self.counter.get()).index(&FullRange));
+            s.push_str(&num_to_string(self.counter.get())[]);
             if !self.taken.contains(&s) {
                 lifetime = name_to_dummy_lifetime(
-                                    token::str_to_ident(s.index(&FullRange)).name);
+                                    token::str_to_ident(&s[]).name);
                 self.generated.borrow_mut().push(lifetime);
                 break;
             }
diff --git a/src/librustc/middle/infer/freshen.rs b/src/librustc/middle/infer/freshen.rs
index 02c52f8296761..6bc424fdf9528 100644
--- a/src/librustc/middle/infer/freshen.rs
+++ b/src/librustc/middle/infer/freshen.rs
@@ -135,10 +135,7 @@ impl<'a, 'tcx> TypeFolder<'tcx> for TypeFreshener<'a, 'tcx> {
                 t
             }
 
-            ty::ty_open(..) => {
-                self.tcx().sess.bug("Cannot freshen an open existential type");
-            }
-
+            ty::ty_open(..) |
             ty::ty_bool |
             ty::ty_char |
             ty::ty_int(..) |
diff --git a/src/librustc/middle/infer/higher_ranked/mod.rs b/src/librustc/middle/infer/higher_ranked/mod.rs
index 073052dd36870..0df84323ae53f 100644
--- a/src/librustc/middle/infer/higher_ranked/mod.rs
+++ b/src/librustc/middle/infer/higher_ranked/mod.rs
@@ -187,9 +187,9 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C
 
             infcx.tcx.sess.span_bug(
                 span,
-                format!("region {:?} is not associated with \
+                &format!("region {:?} is not associated with \
                          any bound region from A!",
-                        r0).index(&FullRange))
+                        r0)[])
         }
     }
 
@@ -322,7 +322,7 @@ impl<'tcx,C> HigherRankedRelations<'tcx> for C
             }
             infcx.tcx.sess.span_bug(
                 span,
-                format!("could not find original bound region for {:?}", r).index(&FullRange));
+                &format!("could not find original bound region for {:?}", r)[]);
         }
 
         fn fresh_bound_variable(infcx: &InferCtxt, debruijn: ty::DebruijnIndex) -> ty::Region {
@@ -339,7 +339,7 @@ fn var_ids<'tcx, T: Combine<'tcx>>(combiner: &T,
             r => {
                 combiner.infcx().tcx.sess.span_bug(
                     combiner.trace().origin.span(),
-                    format!("found non-region-vid: {:?}", r).index(&FullRange));
+                    &format!("found non-region-vid: {:?}", r)[]);
             }
         }).collect()
 }
@@ -468,7 +468,7 @@ pub fn skolemize_late_bound_regions<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
      * when higher-ranked things are involved. See `doc.rs` for more details.
      */
 
-    let (result, map) = ty::replace_late_bound_regions(infcx.tcx, binder, |br, _| {
+    let (result, map) = ty::replace_late_bound_regions(infcx.tcx, binder, |br| {
         infcx.region_vars.new_skolemized(br, &snapshot.region_vars_snapshot)
     });
 
diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs
index 3f18af3d768e4..ab1c41f69683e 100644
--- a/src/librustc/middle/infer/mod.rs
+++ b/src/librustc/middle/infer/mod.rs
@@ -39,7 +39,7 @@ use util::ppaux::{ty_to_string};
 use util::ppaux::{Repr, UserString};
 
 use self::coercion::Coerce;
-use self::combine::{Combine, CombineFields};
+use self::combine::{Combine, Combineable, CombineFields};
 use self::region_inference::{RegionVarBindings, RegionSnapshot};
 use self::equate::Equate;
 use self::sub::Sub;
@@ -360,17 +360,9 @@ pub fn can_mk_subty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
     })
 }
 
-pub fn can_mk_eqty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
-                             a: Ty<'tcx>, b: Ty<'tcx>)
-                             -> ures<'tcx> {
-    debug!("can_mk_subty({} <: {})", a.repr(cx.tcx), b.repr(cx.tcx));
-    cx.probe(|_| {
-        let trace = TypeTrace {
-            origin: Misc(codemap::DUMMY_SP),
-            values: Types(expected_found(true, a, b))
-        };
-        cx.equate(true, trace).tys(a, b)
-    }).to_ures()
+pub fn can_mk_eqty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> ures<'tcx>
+{
+    cx.can_equate(&a, &b)
 }
 
 pub fn mk_subr<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>,
@@ -1000,9 +992,9 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     format!(" ({})", ty::type_err_to_str(self.tcx, t_err))
                 });
 
-                self.tcx.sess.span_err(sp, format!("{}{}",
+                self.tcx.sess.span_err(sp, &format!("{}{}",
                     mk_msg(resolved_expected.map(|t| self.ty_to_string(t)), actual_ty),
-                    error_str).index(&FullRange));
+                    error_str)[]);
 
                 for err in err.iter() {
                     ty::note_and_explain_type_err(self.tcx, *err)
@@ -1056,7 +1048,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         ty::replace_late_bound_regions(
             self.tcx,
             value,
-            |br, _| self.next_region_var(LateBoundRegion(span, br, lbrct)))
+            |br| self.next_region_var(LateBoundRegion(span, br, lbrct)))
     }
 
     /// See `verify_generic_bound` method in `region_inference`
@@ -1072,6 +1064,23 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 
         self.region_vars.verify_generic_bound(origin, kind, a, bs);
     }
+
+    pub fn can_equate<T>(&self, a: &T, b: &T) -> ures<'tcx>
+        where T : Combineable<'tcx> + Repr<'tcx>
+    {
+        debug!("can_equate({}, {})", a.repr(self.tcx), b.repr(self.tcx));
+        self.probe(|_| {
+            // Gin up a dummy trace, since this won't be committed
+            // anyhow. We should make this typetrace stuff more
+            // generic so we don't have to do anything quite this
+            // terrible.
+            let e = self.tcx.types.err;
+            let trace = TypeTrace { origin: Misc(codemap::DUMMY_SP),
+                                    values: Types(expected_found(true, e, e)) };
+            let eq = self.equate(true, trace);
+            Combineable::combine(&eq, a, b)
+        }).to_ures()
+    }
 }
 
 impl<'tcx> TypeTrace<'tcx> {
diff --git a/src/librustc/middle/infer/region_inference/mod.rs b/src/librustc/middle/infer/region_inference/mod.rs
index 5c5c08b53a275..d54d0ae87aec0 100644
--- a/src/librustc/middle/infer/region_inference/mod.rs
+++ b/src/librustc/middle/infer/region_inference/mod.rs
@@ -473,9 +473,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
           (_, ReLateBound(..)) => {
             self.tcx.sess.span_bug(
                 origin.span(),
-                format!("cannot relate bound region: {} <= {}",
+                &format!("cannot relate bound region: {} <= {}",
                         sub.repr(self.tcx),
-                        sup.repr(self.tcx)).index(&FullRange));
+                        sup.repr(self.tcx))[]);
           }
           (_, ReStatic) => {
             // all regions are subregions of static, so we can ignore this
@@ -734,9 +734,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
           (ReEarlyBound(..), _) |
           (_, ReEarlyBound(..)) => {
             self.tcx.sess.bug(
-                format!("cannot relate bound region: LUB({}, {})",
+                &format!("cannot relate bound region: LUB({}, {})",
                         a.repr(self.tcx),
-                        b.repr(self.tcx)).index(&FullRange));
+                        b.repr(self.tcx))[]);
           }
 
           (ReStatic, _) | (_, ReStatic) => {
@@ -750,10 +750,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
           (ReInfer(ReVar(v_id)), _) | (_, ReInfer(ReVar(v_id))) => {
             self.tcx.sess.span_bug(
                 (*self.var_origins.borrow())[v_id.index as uint].span(),
-                format!("lub_concrete_regions invoked with \
+                &format!("lub_concrete_regions invoked with \
                          non-concrete regions: {:?}, {:?}",
                         a,
-                        b).index(&FullRange));
+                        b)[]);
           }
 
           (ReFree(ref fr), ReScope(s_id)) |
@@ -834,9 +834,9 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
             (ReEarlyBound(..), _) |
             (_, ReEarlyBound(..)) => {
               self.tcx.sess.bug(
-                  format!("cannot relate bound region: GLB({}, {})",
+                  &format!("cannot relate bound region: GLB({}, {})",
                           a.repr(self.tcx),
-                          b.repr(self.tcx)).index(&FullRange));
+                          b.repr(self.tcx))[]);
             }
 
             (ReStatic, r) | (r, ReStatic) => {
@@ -853,10 +853,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
             (_, ReInfer(ReVar(v_id))) => {
                 self.tcx.sess.span_bug(
                     (*self.var_origins.borrow())[v_id.index as uint].span(),
-                    format!("glb_concrete_regions invoked with \
+                    &format!("glb_concrete_regions invoked with \
                              non-concrete regions: {:?}, {:?}",
                             a,
-                            b).index(&FullRange));
+                            b)[]);
             }
 
             (ReFree(ref fr), ReScope(s_id)) |
@@ -977,7 +977,7 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
         self.expansion(var_data.as_mut_slice());
         self.contraction(var_data.as_mut_slice());
         let values =
-            self.extract_values_and_collect_conflicts(var_data.index(&FullRange),
+            self.extract_values_and_collect_conflicts(&var_data[],
                                                       errors);
         self.collect_concrete_region_errors(&values, errors);
         values
@@ -1411,11 +1411,11 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
 
         self.tcx.sess.span_bug(
             (*self.var_origins.borrow())[node_idx.index as uint].span(),
-            format!("collect_error_for_expanding_node() could not find error \
+            &format!("collect_error_for_expanding_node() could not find error \
                     for var {:?}, lower_bounds={}, upper_bounds={}",
                     node_idx,
                     lower_bounds.repr(self.tcx),
-                    upper_bounds.repr(self.tcx)).index(&FullRange));
+                    upper_bounds.repr(self.tcx))[]);
     }
 
     fn collect_error_for_contracting_node(
@@ -1456,10 +1456,10 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
 
         self.tcx.sess.span_bug(
             (*self.var_origins.borrow())[node_idx.index as uint].span(),
-            format!("collect_error_for_contracting_node() could not find error \
+            &format!("collect_error_for_contracting_node() could not find error \
                      for var {:?}, upper_bounds={}",
                     node_idx,
-                    upper_bounds.repr(self.tcx)).index(&FullRange));
+                    upper_bounds.repr(self.tcx))[]);
     }
 
     fn collect_concrete_regions(&self,
diff --git a/src/librustc/middle/infer/resolve.rs b/src/librustc/middle/infer/resolve.rs
index 9035d72e9a2fb..7bb3106b0ba6c 100644
--- a/src/librustc/middle/infer/resolve.rs
+++ b/src/librustc/middle/infer/resolve.rs
@@ -95,8 +95,8 @@ impl<'a, 'tcx> ty_fold::TypeFolder<'tcx> for FullTypeResolver<'a, 'tcx> {
                 }
                 ty::ty_infer(_) => {
                     self.infcx.tcx.sess.bug(
-                        format!("Unexpected type in full type resolver: {}",
-                                t.repr(self.infcx.tcx)).index(&FullRange));
+                        &format!("Unexpected type in full type resolver: {}",
+                                t.repr(self.infcx.tcx))[]);
                 }
                 _ => {
                     ty_fold::super_fold_ty(self, t)
diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs
index 850033b3ed126..1b1dca004228e 100644
--- a/src/librustc/middle/liveness.rs
+++ b/src/librustc/middle/liveness.rs
@@ -326,8 +326,8 @@ impl<'a, 'tcx> IrMaps<'a, 'tcx> {
           None => {
             self.tcx
                 .sess
-                .span_bug(span, format!("no variable registered for id {}",
-                                        node_id).index(&FullRange));
+                .span_bug(span, &format!("no variable registered for id {}",
+                                        node_id)[]);
           }
         }
     }
@@ -597,8 +597,8 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             // creating liveness nodes for.
             self.ir.tcx.sess.span_bug(
                 span,
-                format!("no live node registered for node {}",
-                        node_id).index(&FullRange));
+                &format!("no live node registered for node {}",
+                        node_id)[]);
           }
         }
     }
@@ -1133,7 +1133,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
           // Uninteresting cases: just propagate in rev exec order
 
           ast::ExprVec(ref exprs) => {
-            self.propagate_through_exprs(exprs.index(&FullRange), succ)
+            self.propagate_through_exprs(&exprs[], succ)
           }
 
           ast::ExprRepeat(ref element, ref count) => {
@@ -1157,7 +1157,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             } else {
                 succ
             };
-            let succ = self.propagate_through_exprs(args.index(&FullRange), succ);
+            let succ = self.propagate_through_exprs(&args[], succ);
             self.propagate_through_expr(&**f, succ)
           }
 
@@ -1170,11 +1170,11 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             } else {
                 succ
             };
-            self.propagate_through_exprs(args.index(&FullRange), succ)
+            self.propagate_through_exprs(&args[], succ)
           }
 
           ast::ExprTup(ref exprs) => {
-            self.propagate_through_exprs(exprs.index(&FullRange), succ)
+            self.propagate_through_exprs(&exprs[], succ)
           }
 
           ast::ExprBinary(op, ref l, ref r) if ast_util::lazy_binop(op) => {
diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs
index b29c24c586114..fb9a16f86e5bc 100644
--- a/src/librustc/middle/mem_categorization.rs
+++ b/src/librustc/middle/mem_categorization.rs
@@ -584,9 +584,9 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
                   _ => {
                       self.tcx().sess.span_bug(
                           span,
-                          format!("Upvar of non-closure {} - {}",
+                          &format!("Upvar of non-closure {} - {}",
                                   fn_node_id,
-                                  ty.repr(self.tcx())).index(&FullRange));
+                                  ty.repr(self.tcx()))[]);
                   }
               }
           }
diff --git a/src/librustc/middle/privacy.rs b/src/librustc/middle/privacy.rs
index 861c4a2c85e35..aa37c2fe348b5 100644
--- a/src/librustc/middle/privacy.rs
+++ b/src/librustc/middle/privacy.rs
@@ -615,10 +615,10 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
         match result {
             None => true,
             Some((span, msg, note)) => {
-                self.tcx.sess.span_err(span, msg.index(&FullRange));
+                self.tcx.sess.span_err(span, &msg[]);
                 match note {
                     Some((span, msg)) => {
-                        self.tcx.sess.span_note(span, msg.index(&FullRange))
+                        self.tcx.sess.span_note(span, &msg[])
                     }
                     None => {},
                 }
@@ -720,7 +720,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
             UnnamedField(idx) => format!("field #{} of {} is private",
                                          idx + 1, struct_desc),
         };
-        self.tcx.sess.span_err(span, msg.index(&FullRange));
+        self.tcx.sess.span_err(span, &msg[]);
     }
 
     // Given the ID of a method, checks to ensure it's in scope.
@@ -741,8 +741,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
         self.report_error(self.ensure_public(span,
                                              method_id,
                                              None,
-                                             format!("method `{}`",
-                                                     string).index(&FullRange)));
+                                             &format!("method `{}`",
+                                                     string)[]));
     }
 
     // Checks that a path is in scope.
@@ -756,7 +756,7 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
                 self.ensure_public(span,
                                    def,
                                    Some(origdid),
-                                   format!("{} `{}`", tyname, name).index(&FullRange))
+                                   &format!("{} `{}`", tyname, name)[])
             };
 
             match self.last_private_map[path_id] {
diff --git a/src/librustc/middle/reachable.rs b/src/librustc/middle/reachable.rs
index 51602e88f9342..906607ddc5ba1 100644
--- a/src/librustc/middle/reachable.rs
+++ b/src/librustc/middle/reachable.rs
@@ -50,7 +50,7 @@ fn generics_require_inlining(generics: &ast::Generics) -> bool {
 // monomorphized or it was marked with `#[inline]`. This will only return
 // true for functions.
 fn item_might_be_inlined(item: &ast::Item) -> bool {
-    if attributes_specify_inlining(item.attrs.index(&FullRange)) {
+    if attributes_specify_inlining(&item.attrs[]) {
         return true
     }
 
@@ -65,7 +65,7 @@ fn item_might_be_inlined(item: &ast::Item) -> bool {
 
 fn method_might_be_inlined(tcx: &ty::ctxt, method: &ast::Method,
                            impl_src: ast::DefId) -> bool {
-    if attributes_specify_inlining(method.attrs.index(&FullRange)) ||
+    if attributes_specify_inlining(&method.attrs[]) ||
         generics_require_inlining(method.pe_generics()) {
         return true
     }
@@ -202,7 +202,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
                     ast::MethodImplItem(ref method) => {
                         if generics_require_inlining(method.pe_generics()) ||
                                 attributes_specify_inlining(
-                                    method.attrs.index(&FullRange)) {
+                                    &method.attrs[]) {
                             true
                         } else {
                             let impl_did = self.tcx
@@ -247,9 +247,9 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
                 Some(ref item) => self.propagate_node(item, search_item),
                 None if search_item == ast::CRATE_NODE_ID => {}
                 None => {
-                    self.tcx.sess.bug(format!("found unmapped ID in worklist: \
+                    self.tcx.sess.bug(&format!("found unmapped ID in worklist: \
                                                {}",
-                                              search_item).index(&FullRange))
+                                              search_item)[])
                 }
             }
         }
@@ -338,10 +338,10 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
             _ => {
                 self.tcx
                     .sess
-                    .bug(format!("found unexpected thingy in worklist: {}",
+                    .bug(&format!("found unexpected thingy in worklist: {}",
                                  self.tcx
                                      .map
-                                     .node_to_string(search_item)).index(&FullRange))
+                                     .node_to_string(search_item))[])
             }
         }
     }
diff --git a/src/librustc/middle/region.rs b/src/librustc/middle/region.rs
index 5d18843097f37..5d33a7efd3bee 100644
--- a/src/librustc/middle/region.rs
+++ b/src/librustc/middle/region.rs
@@ -643,7 +643,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &ast::Local) {
     // A, but the inner rvalues `a()` and `b()` have an extended lifetime
     // due to rule C.
     //
-    // FIXME(#6308) -- Note that `.index(&FullRange)` patterns work more smoothly post-DST.
+    // FIXME(#6308) -- Note that `[]` patterns work more smoothly post-DST.
 
     match local.init {
         Some(ref expr) => {
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index 8e03d774b8124..b670099ff962a 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -398,8 +398,8 @@ impl<'a> LifetimeContext<'a> {
     fn unresolved_lifetime_ref(&self, lifetime_ref: &ast::Lifetime) {
         self.sess.span_err(
             lifetime_ref.span,
-            format!("use of undeclared lifetime name `{}`",
-                    token::get_name(lifetime_ref.name)).index(&FullRange));
+            &format!("use of undeclared lifetime name `{}`",
+                    token::get_name(lifetime_ref.name))[]);
     }
 
     fn check_lifetime_defs(&mut self, old_scope: Scope, lifetimes: &Vec<ast::LifetimeDef>) {
@@ -411,9 +411,9 @@ impl<'a> LifetimeContext<'a> {
                 if special_idents.iter().any(|&i| i.name == lifetime.lifetime.name) {
                     self.sess.span_err(
                         lifetime.lifetime.span,
-                        format!("illegal lifetime parameter name: `{}`",
+                        &format!("illegal lifetime parameter name: `{}`",
                                 token::get_name(lifetime.lifetime.name))
-                            .index(&FullRange));
+                        []);
                 }
             }
 
@@ -424,10 +424,10 @@ impl<'a> LifetimeContext<'a> {
                 if lifetime_i.lifetime.name == lifetime_j.lifetime.name {
                     self.sess.span_err(
                         lifetime_j.lifetime.span,
-                        format!("lifetime name `{}` declared twice in \
+                        &format!("lifetime name `{}` declared twice in \
                                 the same scope",
                                 token::get_name(lifetime_j.lifetime.name))
-                            .index(&FullRange));
+                        []);
                 }
             }
 
diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs
index 359ad8d394129..e712f510d9dc8 100644
--- a/src/librustc/middle/stability.rs
+++ b/src/librustc/middle/stability.rs
@@ -189,3 +189,19 @@ pub fn lookup(tcx: &ty::ctxt, id: DefId) -> Option<Stability> {
         }
     })
 }
+
+pub fn is_staged_api(tcx: &ty::ctxt, id: DefId) -> bool {
+    match ty::trait_item_of_item(tcx, id) {
+        Some(ty::MethodTraitItemId(trait_method_id))
+            if trait_method_id != id => {
+                is_staged_api(tcx, trait_method_id)
+            }
+        _ if is_local(id) => {
+            // Unused case
+            unreachable!()
+        }
+        _ => {
+            csearch::is_staged_api(&tcx.sess.cstore, id)
+        }
+    }
+}
diff --git a/src/librustc/middle/subst.rs b/src/librustc/middle/subst.rs
index 98bb0645befd1..5fbae6c359dc1 100644
--- a/src/librustc/middle/subst.rs
+++ b/src/librustc/middle/subst.rs
@@ -394,7 +394,7 @@ impl<T> VecPerParamSpace<T> {
         self.content.as_slice()
     }
 
-    pub fn to_vec(self) -> Vec<T> {
+    pub fn into_vec(self) -> Vec<T> {
         self.content
     }
 
@@ -599,12 +599,12 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
                                 let span = self.span.unwrap_or(DUMMY_SP);
                                 self.tcx().sess.span_bug(
                                     span,
-                                    format!("Type parameter out of range \
+                                    &format!("Type parameter out of range \
                                      when substituting in region {} (root type={}) \
                                      (space={:?}, index={})",
                                     region_name.as_str(),
                                     self.root_ty.repr(self.tcx()),
-                                    space, i).index(&FullRange));
+                                    space, i)[]);
                             }
                         }
                 }
@@ -654,14 +654,14 @@ impl<'a,'tcx> SubstFolder<'a,'tcx> {
                 let span = self.span.unwrap_or(DUMMY_SP);
                 self.tcx().sess.span_bug(
                     span,
-                    format!("Type parameter `{}` ({}/{:?}/{}) out of range \
+                    &format!("Type parameter `{}` ({}/{:?}/{}) out of range \
                                  when substituting (root type={}) substs={}",
                             p.repr(self.tcx()),
                             source_ty.repr(self.tcx()),
                             p.space,
                             p.idx,
                             self.root_ty.repr(self.tcx()),
-                            self.substs.repr(self.tcx())).index(&FullRange));
+                            self.substs.repr(self.tcx()))[]);
             }
         };
 
diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs
index 49c7d6aafaa5e..489731e755489 100644
--- a/src/librustc/middle/traits/coherence.rs
+++ b/src/librustc/middle/traits/coherence.rs
@@ -136,8 +136,8 @@ fn ty_is_local_constructor<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
         ty::ty_open(..) |
         ty::ty_err => {
             tcx.sess.bug(
-                format!("ty_is_local invoked on unexpected type: {}",
-                        ty.repr(tcx)).index(&FullRange))
+                &format!("ty_is_local invoked on unexpected type: {}",
+                        ty.repr(tcx))[])
         }
     }
 }
diff --git a/src/librustc/middle/traits/error_reporting.rs b/src/librustc/middle/traits/error_reporting.rs
index fd6773afb765d..02c913a9e81ae 100644
--- a/src/librustc/middle/traits/error_reporting.rs
+++ b/src/librustc/middle/traits/error_reporting.rs
@@ -337,7 +337,7 @@ pub fn suggest_new_overflow_limit(tcx: &ty::ctxt, span: Span) {
     let suggested_limit = current_limit * 2;
     tcx.sess.span_note(
         span,
-        format!(
+        &format!(
             "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate",
-            suggested_limit).index(&FullRange));
+            suggested_limit)[]);
 }
diff --git a/src/librustc/middle/traits/fulfill.rs b/src/librustc/middle/traits/fulfill.rs
index 71a3ad64faf9b..c3b9be85eb505 100644
--- a/src/librustc/middle/traits/fulfill.rs
+++ b/src/librustc/middle/traits/fulfill.rs
@@ -227,7 +227,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
     }
 
     pub fn pending_obligations(&self) -> &[PredicateObligation<'tcx>] {
-        self.predicates.index(&FullRange)
+        &self.predicates[]
     }
 
     /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it
diff --git a/src/librustc/middle/traits/object_safety.rs b/src/librustc/middle/traits/object_safety.rs
index aaf0d4fcb33eb..c0399112c33a9 100644
--- a/src/librustc/middle/traits/object_safety.rs
+++ b/src/librustc/middle/traits/object_safety.rs
@@ -178,7 +178,7 @@ fn object_safety_violations_for_method<'tcx>(tcx: &ty::ctxt<'tcx>,
     // The `Self` type is erased, so it should not appear in list of
     // arguments or return type apart from the receiver.
     let ref sig = method.fty.sig;
-    for &input_ty in sig.0.inputs.index(&(1..)).iter() {
+    for &input_ty in sig.0.inputs[1..].iter() {
         if contains_illegal_self_type_reference(tcx, trait_def_id, input_ty) {
             return Some(MethodViolationCode::ReferencesSelf);
         }
diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs
index e9eb3f4f4b032..aaf5df4ce4a56 100644
--- a/src/librustc/middle/traits/project.rs
+++ b/src/librustc/middle/traits/project.rs
@@ -649,7 +649,7 @@ fn confirm_candidate<'cx,'tcx>(
             }
 
             match impl_ty {
-                Some(ty) => (ty, impl_vtable.nested.to_vec()),
+                Some(ty) => (ty, impl_vtable.nested.into_vec()),
                 None => {
                     // This means that the impl is missing a
                     // definition for the associated type. This error
diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs
index 7c8e0d90e11f7..f42f43d25764d 100644
--- a/src/librustc/middle/traits/select.rs
+++ b/src/librustc/middle/traits/select.rs
@@ -835,7 +835,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                bounds.repr(self.tcx()));
 
         let matching_bound =
-            util::elaborate_predicates(self.tcx(), bounds.predicates.to_vec())
+            util::elaborate_predicates(self.tcx(), bounds.predicates.into_vec())
             .filter_to_traits()
             .find(
                 |bound| self.infcx.probe(
@@ -903,7 +903,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let all_bounds =
             util::transitive_bounds(
-                self.tcx(), caller_trait_refs.index(&FullRange));
+                self.tcx(), &caller_trait_refs[]);
 
         let matching_bounds =
             all_bounds.filter(
@@ -1457,17 +1457,32 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(AmbiguousBuiltin)
             }
 
+            ty::ty_open(ty) => {
+                // these only crop up in trans, and represent an
+                // "opened" unsized/existential type (one that has
+                // been dereferenced)
+                match bound {
+                    ty::BoundCopy |
+                    ty::BoundSync |
+                    ty::BoundSend => {
+                        Ok(If(vec!(ty)))
+                    }
+
+                    ty::BoundSized => {
+                        Err(Unimplemented)
+                    }
+                }
+            }
             ty::ty_err => {
                 Ok(If(Vec::new()))
             }
 
-            ty::ty_open(_) |
             ty::ty_infer(ty::FreshTy(_)) |
             ty::ty_infer(ty::FreshIntTy(_)) => {
                 self.tcx().sess.bug(
-                    format!(
+                    &format!(
                         "asked to assemble builtin bounds of unexpected type: {}",
-                        self_ty.repr(self.tcx())).index(&FullRange));
+                        self_ty.repr(self.tcx()))[]);
             }
         };
 
@@ -1636,8 +1651,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             AmbiguousBuiltin | ParameterBuiltin => {
                 self.tcx().sess.span_bug(
                     obligation.cause.span,
-                    format!("builtin bound for {} was ambig",
-                            obligation.repr(self.tcx())).index(&FullRange));
+                    &format!("builtin bound for {} was ambig",
+                            obligation.repr(self.tcx()))[]);
             }
         }
     }
@@ -1815,8 +1830,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             _ => {
                 self.tcx().sess.span_bug(
                     obligation.cause.span,
-                    format!("Fn pointer candidate for inappropriate self type: {}",
-                            self_ty.repr(self.tcx())).index(&FullRange));
+                    &format!("Fn pointer candidate for inappropriate self type: {}",
+                            self_ty.repr(self.tcx()))[]);
             }
         };
 
@@ -1944,9 +1959,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             }
             Err(()) => {
                 self.tcx().sess.bug(
-                    format!("Impl {} was matchable against {} but now is not",
+                    &format!("Impl {} was matchable against {} but now is not",
                             impl_def_id.repr(self.tcx()),
-                            obligation.repr(self.tcx())).index(&FullRange));
+                            obligation.repr(self.tcx()))[]);
             }
         }
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 46d2ff7e1b946..64f0bcb1c88db 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -72,7 +72,7 @@ use std::borrow::BorrowFrom;
 use std::cell::{Cell, RefCell};
 use std::cmp::{self, Ordering};
 use std::fmt::{self, Show};
-use std::hash::{Hash, sip, Writer};
+use std::hash::{Hash, Writer, SipHasher, Hasher};
 use std::mem;
 use std::ops;
 use std::rc::Rc;
@@ -107,7 +107,7 @@ pub struct CrateAnalysis<'tcx> {
     pub glob_map: Option<GlobMap>,
 }
 
-#[derive(Copy, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
 pub struct field<'tcx> {
     pub name: ast::Name,
     pub mt: mt<'tcx>
@@ -946,11 +946,18 @@ impl<'tcx> PartialEq for TyS<'tcx> {
 }
 impl<'tcx> Eq for TyS<'tcx> {}
 
+#[cfg(stage0)]
 impl<'tcx, S: Writer> Hash<S> for TyS<'tcx> {
     fn hash(&self, s: &mut S) {
         (self as *const _).hash(s)
     }
 }
+#[cfg(not(stage0))]
+impl<'tcx, S: Writer + Hasher> Hash<S> for TyS<'tcx> {
+    fn hash(&self, s: &mut S) {
+        (self as *const _).hash(s)
+    }
+}
 
 pub type Ty<'tcx> = &'tcx TyS<'tcx>;
 
@@ -968,7 +975,7 @@ impl<'tcx> PartialEq for InternedTy<'tcx> {
 
 impl<'tcx> Eq for InternedTy<'tcx> {}
 
-impl<'tcx, S: Writer> Hash<S> for InternedTy<'tcx> {
+impl<'tcx, S: Writer + Hasher> Hash<S> for InternedTy<'tcx> {
     fn hash(&self, s: &mut S) {
         self.ty.sty.hash(s)
     }
@@ -1491,10 +1498,12 @@ impl<'tcx> PolyTraitRef<'tcx> {
     }
 
     pub fn substs(&self) -> &'tcx Substs<'tcx> {
+        // FIXME(#20664) every use of this fn is probably a bug, it should yield Binder<>
         self.0.substs
     }
 
     pub fn input_types(&self) -> &[Ty<'tcx>] {
+        // FIXME(#20664) every use of this fn is probably a bug, it should yield Binder<>
         self.0.input_types()
     }
 
@@ -2036,8 +2045,8 @@ impl<'tcx> Predicate<'tcx> {
 ///     struct Foo<T,U:Bar<T>> { ... }
 ///
 /// Here, the `Generics` for `Foo` would contain a list of bounds like
-/// `[.index(&FullRange), [U:Bar<T>]]`.  Now if there were some particular reference
-/// like `Foo<int,uint>`, then the `GenericBounds` would be `[.index(&FullRange),
+/// `[[], [U:Bar<T>]]`.  Now if there were some particular reference
+/// like `Foo<int,uint>`, then the `GenericBounds` would be `[[],
 /// [uint:Bar<int>]]`.
 #[derive(Clone, Show)]
 pub struct GenericBounds<'tcx> {
@@ -2212,9 +2221,9 @@ impl<'a, 'tcx> ParameterEnvironment<'a, 'tcx> {
                 ParameterEnvironment::for_item(cx, cx.map.get_parent(id))
             }
             _ => {
-                cx.sess.bug(format!("ParameterEnvironment::from_item(): \
+                cx.sess.bug(&format!("ParameterEnvironment::from_item(): \
                                      `{}` is not an item",
-                                    cx.map.node_to_string(id)).index(&FullRange))
+                                    cx.map.node_to_string(id))[])
             }
         }
     }
@@ -2299,7 +2308,7 @@ impl UnboxedClosureKind {
         };
         match result {
             Ok(trait_did) => trait_did,
-            Err(err) => cx.sess.fatal(err.index(&FullRange)),
+            Err(err) => cx.sess.fatal(&err[]),
         }
     }
 }
@@ -2620,7 +2629,7 @@ impl FlagComputation {
             }
 
             &ty_tup(ref ts) => {
-                self.add_tys(ts.index(&FullRange));
+                self.add_tys(&ts[]);
             }
 
             &ty_bare_fn(_, ref f) => {
@@ -2643,7 +2652,7 @@ impl FlagComputation {
     fn add_fn_sig(&mut self, fn_sig: &PolyFnSig) {
         let mut computation = FlagComputation::new();
 
-        computation.add_tys(fn_sig.0.inputs.index(&FullRange));
+        computation.add_tys(&fn_sig.0.inputs[]);
 
         if let ty::FnConverging(output) = fn_sig.0.output {
             computation.add_ty(output);
@@ -2812,7 +2821,7 @@ pub fn mk_trait<'tcx>(cx: &ctxt<'tcx>,
 
 fn bound_list_is_sorted(bounds: &[ty::PolyProjectionPredicate]) -> bool {
     bounds.len() == 0 ||
-        bounds.index(&(1..)).iter().enumerate().all(
+        bounds[1..].iter().enumerate().all(
             |(index, bound)| bounds[index].sort_key() <= bound.sort_key())
 }
 
@@ -3066,8 +3075,8 @@ pub fn sequence_element_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
         ty_vec(ty, _) => ty,
         ty_str => mk_mach_uint(cx, ast::TyU8),
         ty_open(ty) => sequence_element_type(cx, ty),
-        _ => cx.sess.bug(format!("sequence_element_type called on non-sequence value: {}",
-                                 ty_to_string(cx, ty)).index(&FullRange)),
+        _ => cx.sess.bug(&format!("sequence_element_type called on non-sequence value: {}",
+                                 ty_to_string(cx, ty))[]),
     }
 }
 
@@ -3401,7 +3410,7 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
             ty_struct(did, substs) => {
                 let flds = struct_fields(cx, did, substs);
                 let mut res =
-                    TypeContents::union(flds.index(&FullRange),
+                    TypeContents::union(&flds[],
                                         |f| tc_mt(cx, f.mt, cache));
 
                 if !lookup_repr_hints(cx, did).contains(&attr::ReprExtern) {
@@ -3425,15 +3434,15 @@ pub fn type_contents<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> TypeContents {
             }
 
             ty_tup(ref tys) => {
-                TypeContents::union(tys.index(&FullRange),
+                TypeContents::union(&tys[],
                                     |ty| tc_ty(cx, *ty, cache))
             }
 
             ty_enum(did, substs) => {
                 let variants = substd_enum_variants(cx, did, substs);
                 let mut res =
-                    TypeContents::union(variants.index(&FullRange), |variant| {
-                        TypeContents::union(variant.args.index(&FullRange),
+                    TypeContents::union(&variants[], |variant| {
+                        TypeContents::union(&variant.args[],
                                             |arg_ty| {
                             tc_ty(cx, *arg_ty, cache)
                         })
@@ -4017,8 +4026,8 @@ pub fn deref<'tcx>(ty: Ty<'tcx>, explicit: bool) -> Option<mt<'tcx>> {
 pub fn close_type<'tcx>(cx: &ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
     match ty.sty {
         ty_open(ty) => mk_rptr(cx, cx.mk_region(ReStatic), mt {ty: ty, mutbl:ast::MutImmutable}),
-        _ => cx.sess.bug(format!("Trying to close a non-open type {}",
-                                 ty_to_string(cx, ty)).index(&FullRange))
+        _ => cx.sess.bug(&format!("Trying to close a non-open type {}",
+                                 ty_to_string(cx, ty))[])
     }
 }
 
@@ -4118,8 +4127,8 @@ pub fn node_id_to_trait_ref<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId)
     match cx.trait_refs.borrow().get(&id) {
         Some(ty) => ty.clone(),
         None => cx.sess.bug(
-            format!("node_id_to_trait_ref: no trait ref for node `{}`",
-                    cx.map.node_to_string(id)).index(&FullRange))
+            &format!("node_id_to_trait_ref: no trait ref for node `{}`",
+                    cx.map.node_to_string(id))[])
     }
 }
 
@@ -4131,8 +4140,8 @@ pub fn node_id_to_type<'tcx>(cx: &ctxt<'tcx>, id: ast::NodeId) -> Ty<'tcx> {
     match try_node_id_to_type(cx, id) {
        Some(ty) => ty,
        None => cx.sess.bug(
-           format!("node_id_to_type: no type for node `{}`",
-                   cx.map.node_to_string(id)).index(&FullRange))
+           &format!("node_id_to_type: no type for node `{}`",
+                   cx.map.node_to_string(id))[])
     }
 }
 
@@ -4218,8 +4227,8 @@ pub fn ty_region(tcx: &ctxt,
         ref s => {
             tcx.sess.span_bug(
                 span,
-                format!("ty_region() invoked on an inappropriate ty: {:?}",
-                        s).index(&FullRange));
+                &format!("ty_region() invoked on an inappropriate ty: {:?}",
+                        s)[]);
         }
     }
 }
@@ -4278,13 +4287,13 @@ pub fn expr_span(cx: &ctxt, id: NodeId) -> Span {
             e.span
         }
         Some(f) => {
-            cx.sess.bug(format!("Node id {} is not an expr: {:?}",
+            cx.sess.bug(&format!("Node id {} is not an expr: {:?}",
                                 id,
-                                f).index(&FullRange));
+                                f)[]);
         }
         None => {
-            cx.sess.bug(format!("Node id {} is not present \
-                                in the node map", id).index(&FullRange));
+            cx.sess.bug(&format!("Node id {} is not present \
+                                in the node map", id)[]);
         }
     }
 }
@@ -4298,16 +4307,16 @@ pub fn local_var_name_str(cx: &ctxt, id: NodeId) -> InternedString {
                 }
                 _ => {
                     cx.sess.bug(
-                        format!("Variable id {} maps to {:?}, not local",
+                        &format!("Variable id {} maps to {:?}, not local",
                                 id,
-                                pat).index(&FullRange));
+                                pat)[]);
                 }
             }
         }
         r => {
-            cx.sess.bug(format!("Variable id {} maps to {:?}, not local",
+            cx.sess.bug(&format!("Variable id {} maps to {:?}, not local",
                                 id,
-                                r).index(&FullRange));
+                                r)[]);
         }
     }
 }
@@ -4336,9 +4345,9 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>,
                         }
                         ref b => {
                             cx.sess.bug(
-                                format!("AdjustReifyFnPointer adjustment on non-fn-item: \
+                                &format!("AdjustReifyFnPointer adjustment on non-fn-item: \
                                          {:?}",
-                                        b).index(&FullRange));
+                                        b)[]);
                         }
                     }
                 }
@@ -4365,11 +4374,11 @@ pub fn adjust_ty<'tcx, F>(cx: &ctxt<'tcx>,
                                 None => {
                                     cx.sess.span_bug(
                                         span,
-                                        format!("the {}th autoderef failed: \
+                                        &format!("the {}th autoderef failed: \
                                                 {}",
                                                 i,
                                                 ty_to_string(cx, adjusted_ty))
-                                                          .index(&FullRange));
+                                        []);
                                 }
                             }
                         }
@@ -4431,8 +4440,8 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>,
                 mk_vec(cx, ty, None)
             }
             _ => cx.sess.span_bug(span,
-                                  format!("UnsizeLength with bad sty: {:?}",
-                                          ty_to_string(cx, ty)).index(&FullRange))
+                                  &format!("UnsizeLength with bad sty: {:?}",
+                                          ty_to_string(cx, ty))[])
         },
         &UnsizeStruct(box ref k, tp_index) => match ty.sty {
             ty_struct(did, substs) => {
@@ -4443,8 +4452,8 @@ pub fn unsize_ty<'tcx>(cx: &ctxt<'tcx>,
                 mk_struct(cx, did, cx.mk_substs(unsized_substs))
             }
             _ => cx.sess.span_bug(span,
-                                  format!("UnsizeStruct with bad sty: {:?}",
-                                          ty_to_string(cx, ty)).index(&FullRange))
+                                  &format!("UnsizeStruct with bad sty: {:?}",
+                                          ty_to_string(cx, ty))[])
         },
         &UnsizeVtable(TyTrait { ref principal, ref bounds }, _) => {
             mk_trait(cx, principal.clone(), bounds.clone())
@@ -4456,8 +4465,8 @@ pub fn resolve_expr(tcx: &ctxt, expr: &ast::Expr) -> def::Def {
     match tcx.def_map.borrow().get(&expr.id) {
         Some(&def) => def,
         None => {
-            tcx.sess.span_bug(expr.span, format!(
-                "no def-map entry for expr {}", expr.id).index(&FullRange));
+            tcx.sess.span_bug(expr.span, &format!(
+                "no def-map entry for expr {}", expr.id)[]);
         }
     }
 }
@@ -4550,9 +4559,9 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
                 def => {
                     tcx.sess.span_bug(
                         expr.span,
-                        format!("uncategorized def for expr {}: {:?}",
+                        &format!("uncategorized def for expr {}: {:?}",
                                 expr.id,
-                                def).index(&FullRange));
+                                def)[]);
                 }
             }
         }
@@ -4672,12 +4681,12 @@ pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field])
                      -> uint {
     let mut i = 0u;
     for f in fields.iter() { if f.name == name { return i; } i += 1u; }
-    tcx.sess.bug(format!(
+    tcx.sess.bug(&format!(
         "no field named `{}` found in the list of fields `{:?}`",
         token::get_name(name),
         fields.iter()
               .map(|f| token::get_name(f.name).get().to_string())
-              .collect::<Vec<String>>()).index(&FullRange));
+              .collect::<Vec<String>>())[]);
 }
 
 pub fn impl_or_trait_item_idx(id: ast::Name, trait_items: &[ImplOrTraitItem])
@@ -4932,7 +4941,7 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId)
                 match item.node {
                     ItemTrait(_, _, _, ref ms) => {
                         let (_, p) =
-                            ast_util::split_trait_methods(ms.index(&FullRange));
+                            ast_util::split_trait_methods(&ms[]);
                         p.iter()
                          .map(|m| {
                             match impl_or_trait_item(
@@ -4949,16 +4958,16 @@ pub fn provided_trait_methods<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId)
                          }).collect()
                     }
                     _ => {
-                        cx.sess.bug(format!("provided_trait_methods: `{:?}` is \
+                        cx.sess.bug(&format!("provided_trait_methods: `{:?}` is \
                                              not a trait",
-                                            id).index(&FullRange))
+                                            id)[])
                     }
                 }
             }
             _ => {
-                cx.sess.bug(format!("provided_trait_methods: `{:?}` is not a \
+                cx.sess.bug(&format!("provided_trait_methods: `{:?}` is not a \
                                      trait",
-                                    id).index(&FullRange))
+                                    id)[])
             }
         }
     } else {
@@ -5196,7 +5205,7 @@ impl<'tcx> VariantInfo<'tcx> {
                 };
             },
             ast::StructVariantKind(ref struct_def) => {
-                let fields: &[StructField] = struct_def.fields.index(&FullRange);
+                let fields: &[StructField] = &struct_def.fields[];
 
                 assert!(fields.len() > 0);
 
@@ -5346,8 +5355,8 @@ pub fn enum_variants<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId)
                                             Err(ref err) => {
                                                 cx.sess
                                                   .span_err(e.span,
-                                                            format!("expected constant: {}",
-                                                                    *err).index(&FullRange));
+                                                            &format!("expected constant: {}",
+                                                                    *err)[]);
                                             }
                                         },
                                     None => {}
@@ -5636,8 +5645,8 @@ pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec<field_ty> {
             Some(fields) => (**fields).clone(),
             _ => {
                 cx.sess.bug(
-                    format!("ID not mapped to struct fields: {}",
-                            cx.map.node_to_string(did.node)).index(&FullRange));
+                    &format!("ID not mapped to struct fields: {}",
+                            cx.map.node_to_string(did.node))[]);
             }
         }
     } else {
@@ -5670,7 +5679,7 @@ pub fn struct_fields<'tcx>(cx: &ctxt<'tcx>, did: ast::DefId, substs: &Substs<'tc
 pub fn tup_fields<'tcx>(v: &[Ty<'tcx>]) -> Vec<field<'tcx>> {
     v.iter().enumerate().map(|(i, &f)| {
        field {
-            name: token::intern(i.to_string().index(&FullRange)),
+            name: token::intern(&i.to_string()[]),
             mt: mt {
                 ty: f,
                 mutbl: MutImmutable
@@ -5845,9 +5854,9 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint {
                 const_eval::const_binary(_) =>
                     "binary array"
             };
-            tcx.sess.span_err(count_expr.span, format!(
+            tcx.sess.span_err(count_expr.span, &format!(
                 "expected positive integer for repeat count, found {}",
-                found).index(&FullRange));
+                found)[]);
         }
         Err(_) => {
             let found = match count_expr.node {
@@ -5860,9 +5869,9 @@ pub fn eval_repeat_count(tcx: &ctxt, count_expr: &ast::Expr) -> uint {
                 _ =>
                     "non-constant expression"
             };
-            tcx.sess.span_err(count_expr.span, format!(
+            tcx.sess.span_err(count_expr.span, &format!(
                 "expected constant integer for repeat count, found {}",
-                found).index(&FullRange));
+                found)[]);
         }
     }
     0
@@ -6168,15 +6177,16 @@ pub fn trait_item_of_item(tcx: &ctxt, def_id: ast::DefId)
 /// Creates a hash of the type `Ty` which will be the same no matter what crate
 /// context it's calculated within. This is used by the `type_id` intrinsic.
 pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -> u64 {
-    let mut state = sip::SipState::new();
+    let mut state = SipHasher::new();
     helper(tcx, ty, svh, &mut state);
-    return state.result();
+    return state.finish();
 
-    fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh, state: &mut sip::SipState) {
+    fn helper<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh,
+                    state: &mut SipHasher) {
         macro_rules! byte { ($b:expr) => { ($b as u8).hash(state) } }
         macro_rules! hash { ($e:expr) => { $e.hash(state) }  }
 
-        let region = |&: state: &mut sip::SipState, r: Region| {
+        let region = |&: state: &mut SipHasher, r: Region| {
             match r {
                 ReStatic => {}
                 ReLateBound(db, BrAnon(i)) => {
@@ -6193,7 +6203,7 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -
                 }
             }
         };
-        let did = |&: state: &mut sip::SipState, did: DefId| {
+        let did = |&: state: &mut SipHasher, did: DefId| {
             let h = if ast_util::is_local(did) {
                 svh.clone()
             } else {
@@ -6202,10 +6212,10 @@ pub fn hash_crate_independent<'tcx>(tcx: &ctxt<'tcx>, ty: Ty<'tcx>, svh: &Svh) -
             h.as_str().hash(state);
             did.node.hash(state);
         };
-        let mt = |&: state: &mut sip::SipState, mt: mt| {
+        let mt = |&: state: &mut SipHasher, mt: mt| {
             mt.mutbl.hash(state);
         };
-        let fn_sig = |&: state: &mut sip::SipState, sig: &Binder<FnSig<'tcx>>| {
+        let fn_sig = |&: state: &mut SipHasher, sig: &Binder<FnSig<'tcx>>| {
             let sig = anonymize_late_bound_regions(tcx, sig).0;
             for a in sig.inputs.iter() { helper(tcx, *a, svh, state); }
             if let ty::FnConverging(output) = sig.output {
@@ -6646,7 +6656,7 @@ pub fn with_freevars<T, F>(tcx: &ty::ctxt, fid: ast::NodeId, f: F) -> T where
 {
     match tcx.freevars.borrow().get(&fid) {
         None => f(&[]),
-        Some(d) => f(d.index(&FullRange))
+        Some(d) => f(&d[])
     }
 }
 
@@ -6676,7 +6686,7 @@ pub fn liberate_late_bound_regions<'tcx, T>(
 {
     replace_late_bound_regions(
         tcx, value,
-        |br, _| ty::ReFree(ty::FreeRegion{scope: scope, bound_region: br})).0
+        |br| ty::ReFree(ty::FreeRegion{scope: scope, bound_region: br})).0
 }
 
 pub fn count_late_bound_regions<'tcx, T>(
@@ -6685,7 +6695,7 @@ pub fn count_late_bound_regions<'tcx, T>(
     -> uint
     where T : TypeFoldable<'tcx> + Repr<'tcx>
 {
-    let (_, skol_map) = replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic);
+    let (_, skol_map) = replace_late_bound_regions(tcx, value, |_| ty::ReStatic);
     skol_map.len()
 }
 
@@ -6716,7 +6726,7 @@ pub fn erase_late_bound_regions<'tcx, T>(
     -> T
     where T : TypeFoldable<'tcx> + Repr<'tcx>
 {
-    replace_late_bound_regions(tcx, value, |_, _| ty::ReStatic).0
+    replace_late_bound_regions(tcx, value, |_| ty::ReStatic).0
 }
 
 /// Rewrite any late-bound regions so that they are anonymous.  Region numbers are
@@ -6734,9 +6744,9 @@ pub fn anonymize_late_bound_regions<'tcx, T>(
     where T : TypeFoldable<'tcx> + Repr<'tcx>,
 {
     let mut counter = 0;
-    ty::Binder(replace_late_bound_regions(tcx, sig, |_, db| {
+    ty::Binder(replace_late_bound_regions(tcx, sig, |_| {
         counter += 1;
-        ReLateBound(db, BrAnon(counter))
+        ReLateBound(ty::DebruijnIndex::new(1), BrAnon(counter))
     }).0)
 }
 
@@ -6747,7 +6757,7 @@ pub fn replace_late_bound_regions<'tcx, T, F>(
     mut mapf: F)
     -> (T, FnvHashMap<ty::BoundRegion,ty::Region>)
     where T : TypeFoldable<'tcx> + Repr<'tcx>,
-          F : FnMut(BoundRegion, DebruijnIndex) -> ty::Region,
+          F : FnMut(BoundRegion) -> ty::Region,
 {
     debug!("replace_late_bound_regions({})", binder.repr(tcx));
 
@@ -6759,8 +6769,19 @@ pub fn replace_late_bound_regions<'tcx, T, F>(
         debug!("region={}", region.repr(tcx));
         match region {
             ty::ReLateBound(debruijn, br) if debruijn.depth == current_depth => {
-                * map.entry(br).get().unwrap_or_else(
-                      |vacant_entry| vacant_entry.insert(mapf(br, debruijn)))
+                let region =
+                    * map.entry(br).get().unwrap_or_else(
+                        |vacant_entry| vacant_entry.insert(mapf(br)));
+
+                if let ty::ReLateBound(debruijn1, br) = region {
+                    // If the callback returns a late-bound region,
+                    // that region should always use depth 1. Then we
+                    // adjust it to the correct depth.
+                    assert_eq!(debruijn1.depth, 1);
+                    ty::ReLateBound(debruijn, br)
+                } else {
+                    region
+                }
             }
             _ => {
                 region
@@ -6907,6 +6928,7 @@ pub enum CopyImplementationError {
     FieldDoesNotImplementCopy(ast::Name),
     VariantDoesNotImplementCopy(ast::Name),
     TypeIsStructural,
+    TypeHasDestructor,
 }
 
 pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tcx>,
@@ -6916,7 +6938,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc
 {
     let tcx = param_env.tcx;
 
-    match self_type.sty {
+    let did = match self_type.sty {
         ty::ty_struct(struct_did, substs) => {
             let fields = ty::struct_fields(tcx, struct_did, substs);
             for field in fields.iter() {
@@ -6924,6 +6946,7 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc
                     return Err(FieldDoesNotImplementCopy(field.name))
                 }
             }
+            struct_did
         }
         ty::ty_enum(enum_did, substs) => {
             let enum_variants = ty::enum_variants(tcx, enum_did);
@@ -6936,8 +6959,13 @@ pub fn can_type_implement_copy<'a,'tcx>(param_env: &ParameterEnvironment<'a, 'tc
                     }
                 }
             }
+            enum_did
         }
         _ => return Err(TypeIsStructural),
+    };
+
+    if ty::has_dtor(tcx, did) {
+        return Err(TypeHasDestructor)
     }
 
     Ok(())
@@ -6962,6 +6990,13 @@ impl<'tcx> RegionEscape for Ty<'tcx> {
     }
 }
 
+impl<'tcx> RegionEscape for Substs<'tcx> {
+    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
+        self.types.has_regions_escaping_depth(depth) ||
+            self.regions.has_regions_escaping_depth(depth)
+    }
+}
+
 impl<'tcx,T:RegionEscape> RegionEscape for VecPerParamSpace<T> {
     fn has_regions_escaping_depth(&self, depth: u32) -> bool {
         self.iter_enumerated().any(|(space, _, t)| {
@@ -7216,6 +7251,12 @@ impl<'tcx> HasProjectionTypes for FnSig<'tcx> {
     }
 }
 
+impl<'tcx> HasProjectionTypes for field<'tcx> {
+    fn has_projection_types(&self) -> bool {
+        self.mt.ty.has_projection_types()
+    }
+}
+
 impl<'tcx> HasProjectionTypes for BareFnTy<'tcx> {
     fn has_projection_types(&self) -> bool {
         self.sig.has_projection_types()
@@ -7315,3 +7356,11 @@ impl<'tcx> Repr<'tcx> for UnboxedClosureUpvar<'tcx> {
                 self.ty.repr(tcx))
     }
 }
+
+impl<'tcx> Repr<'tcx> for field<'tcx> {
+    fn repr(&self, tcx: &ctxt<'tcx>) -> String {
+        format!("field({},{})",
+                self.name.repr(tcx),
+                self.mt.repr(tcx))
+    }
+}
diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs
index 424e357d8d456..b81a4ed2f58ff 100644
--- a/src/librustc/middle/ty_fold.rs
+++ b/src/librustc/middle/ty_fold.rs
@@ -273,6 +273,15 @@ impl<'tcx> TypeFoldable<'tcx> for ty::TraitRef<'tcx> {
     }
 }
 
+impl<'tcx> TypeFoldable<'tcx> for ty::field<'tcx> {
+    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::field<'tcx> {
+        ty::field {
+            name: self.name,
+            mt: self.mt.fold_with(folder),
+        }
+    }
+}
+
 impl<'tcx> TypeFoldable<'tcx> for ty::Region {
     fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::Region {
         folder.fold_region(*self)
@@ -853,7 +862,10 @@ impl<'a, 'tcx> TypeFolder<'tcx> for RegionFolder<'a, 'tcx>
 ///////////////////////////////////////////////////////////////////////////
 // Region eraser
 //
-// Replaces all free regions with 'static. Useful in trans.
+// Replaces all free regions with 'static. Useful in contexts, such as
+// method probing, where precise region relationships are not
+// important. Note that in trans you should use
+// `common::erase_regions` instead.
 
 pub struct RegionEraser<'a, 'tcx: 'a> {
     tcx: &'a ty::ctxt<'tcx>,
diff --git a/src/librustc/plugin/load.rs b/src/librustc/plugin/load.rs
index a38298d52dd87..87f5ba0246fc3 100644
--- a/src/librustc/plugin/load.rs
+++ b/src/librustc/plugin/load.rs
@@ -223,17 +223,17 @@ impl<'a> PluginLoader<'a> {
             // this is fatal: there are almost certainly macros we need
             // inside this crate, so continue would spew "macro undefined"
             // errors
-            Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange))
+            Err(err) => self.sess.span_fatal(vi.span, &err[])
         };
 
         unsafe {
             let registrar =
-                match lib.symbol(symbol.index(&FullRange)) {
+                match lib.symbol(&symbol[]) {
                     Ok(registrar) => {
                         mem::transmute::<*mut u8,PluginRegistrarFun>(registrar)
                     }
                     // again fatal if we can't register macros
-                    Err(err) => self.sess.span_fatal(vi.span, err.index(&FullRange))
+                    Err(err) => self.sess.span_fatal(vi.span, &err[])
                 };
 
             // Intentionally leak the dynamic library. We can't ever unload it
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 4968066f7b696..72b1669843a67 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -111,7 +111,24 @@ pub struct Options {
     /// An optional name to use as the crate for std during std injection,
     /// written `extern crate std = "name"`. Default to "std". Used by
     /// out-of-tree drivers.
-    pub alt_std_name: Option<String>
+    pub alt_std_name: Option<String>,
+    /// Indicates how the compiler should treat unstable features
+    pub unstable_features: UnstableFeatures
+}
+
+#[derive(Clone, Copy)]
+pub enum UnstableFeatures {
+    /// Hard errors for unstable features are active, as on
+    /// beta/stable channels.
+    Disallow,
+    /// Use the default lint levels
+    Default,
+    /// Errors are bypassed for bootstrapping. This is required any time
+    /// during the build that feature-related lints are set to warn or above
+    /// because the build turns on warnings-as-errors and uses lots of unstable
+    /// features. As a result, this this is always required for building Rust
+    /// itself.
+    Cheat
 }
 
 #[derive(Clone, PartialEq, Eq)]
@@ -217,6 +234,7 @@ pub fn basic_options() -> Options {
         crate_name: None,
         alt_std_name: None,
         libs: Vec::new(),
+        unstable_features: UnstableFeatures::Disallow
     }
 }
 
@@ -558,18 +576,18 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions
             if !setter(&mut cg, value) {
                 match (value, opt_type_desc) {
                     (Some(..), None) => {
-                        early_error(format!("codegen option `{}` takes no \
-                                             value", key).index(&FullRange))
+                        early_error(&format!("codegen option `{}` takes no \
+                                             value", key)[])
                     }
                     (None, Some(type_desc)) => {
-                        early_error(format!("codegen option `{0}` requires \
+                        early_error(&format!("codegen option `{0}` requires \
                                              {1} (-C {0}=<value>)",
-                                            key, type_desc).index(&FullRange))
+                                            key, type_desc)[])
                     }
                     (Some(value), Some(type_desc)) => {
-                        early_error(format!("incorrect value `{}` for codegen \
+                        early_error(&format!("incorrect value `{}` for codegen \
                                              option `{}` - {} was expected",
-                                             value, key, type_desc).index(&FullRange))
+                                             value, key, type_desc)[])
                     }
                     (None, None) => unreachable!()
                 }
@@ -578,8 +596,8 @@ pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions
             break;
         }
         if !found {
-            early_error(format!("unknown codegen option: `{}`",
-                                key).index(&FullRange));
+            early_error(&format!("unknown codegen option: `{}`",
+                                key)[]);
         }
     }
     return cg;
@@ -592,10 +610,10 @@ pub fn default_lib_output() -> CrateType {
 pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
     use syntax::parse::token::intern_and_get_ident as intern;
 
-    let end = sess.target.target.target_endian.index(&FullRange);
-    let arch = sess.target.target.arch.index(&FullRange);
-    let wordsz = sess.target.target.target_word_size.index(&FullRange);
-    let os = sess.target.target.target_os.index(&FullRange);
+    let end = &sess.target.target.target_endian[];
+    let arch = &sess.target.target.arch[];
+    let wordsz = &sess.target.target.target_pointer_width[];
+    let os = &sess.target.target.target_os[];
 
     let fam = match sess.target.target.options.is_like_windows {
         true  => InternedString::new("windows"),
@@ -609,7 +627,7 @@ pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
          mk(InternedString::new("target_family"), fam),
          mk(InternedString::new("target_arch"), intern(arch)),
          mk(InternedString::new("target_endian"), intern(end)),
-         mk(InternedString::new("target_word_size"),
+         mk(InternedString::new("target_pointer_width"),
             intern(wordsz))
     );
 }
@@ -631,23 +649,23 @@ pub fn build_configuration(sess: &Session) -> ast::CrateConfig {
         append_configuration(&mut user_cfg, InternedString::new("test"))
     }
     let mut v = user_cfg.into_iter().collect::<Vec<_>>();
-    v.push_all(default_cfg.index(&FullRange));
+    v.push_all(&default_cfg[]);
     v
 }
 
 pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
-    let target = match Target::search(opts.target_triple.index(&FullRange)) {
+    let target = match Target::search(&opts.target_triple[]) {
         Ok(t) => t,
         Err(e) => {
             sp.handler().fatal((format!("Error loading target specification: {}", e)).as_slice());
     }
     };
 
-    let (int_type, uint_type) = match target.target_word_size.index(&FullRange) {
+    let (int_type, uint_type) = match &target.target_pointer_width[] {
         "32" => (ast::TyI32, ast::TyU32),
         "64" => (ast::TyI64, ast::TyU64),
-        w    => sp.handler().fatal((format!("target specification was invalid: unrecognized \
-                                            target-word-size {}", w)).index(&FullRange))
+        w    => sp.handler().fatal(&format!("target specification was invalid: unrecognized \
+                                            target-word-size {}", w)[])
     };
 
     Config {
@@ -845,7 +863,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
 
     let unparsed_crate_types = matches.opt_strs("crate-type");
     let crate_types = parse_crate_types_from_list(unparsed_crate_types)
-        .unwrap_or_else(|e| early_error(e.index(&FullRange)));
+        .unwrap_or_else(|e| early_error(&e[]));
 
     let mut lint_opts = vec!();
     let mut describe_lints = false;
@@ -872,8 +890,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             }
         }
         if this_bit == 0 {
-            early_error(format!("unknown debug flag: {}",
-                                *debug_flag).index(&FullRange))
+            early_error(&format!("unknown debug flag: {}",
+                                *debug_flag)[])
         }
         debugging_opts |= this_bit;
     }
@@ -917,8 +935,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
                     "link" => OutputTypeExe,
                     "dep-info" => OutputTypeDepInfo,
                     _ => {
-                        early_error(format!("unknown emission type: `{}`",
-                                            part).index(&FullRange))
+                        early_error(&format!("unknown emission type: `{}`",
+                                            part)[])
                     }
                 };
                 output_types.push(output_type)
@@ -955,9 +973,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
                 Some("2") => Default,
                 Some("3") => Aggressive,
                 Some(arg) => {
-                    early_error(format!("optimization level needs to be \
+                    early_error(&format!("optimization level needs to be \
                                          between 0-3 (instead was `{}`)",
-                                        arg).index(&FullRange));
+                                        arg)[]);
                 }
             }
         } else {
@@ -993,9 +1011,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             None      |
             Some("2") => FullDebugInfo,
             Some(arg) => {
-                early_error(format!("debug info level needs to be between \
+                early_error(&format!("debug info level needs to be between \
                                      0-2 (instead was `{}`)",
-                                    arg).index(&FullRange));
+                                    arg)[]);
             }
         }
     } else {
@@ -1013,7 +1031,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
 
     let mut search_paths = SearchPaths::new();
     for s in matches.opt_strs("L").iter() {
-        search_paths.add_path(s.index(&FullRange));
+        search_paths.add_path(&s[]);
     }
 
     let libs = matches.opt_strs("l").into_iter().map(|s| {
@@ -1043,9 +1061,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
             (Some(name), "framework") => (name, cstore::NativeFramework),
             (Some(name), "static") => (name, cstore::NativeStatic),
             (_, s) => {
-                early_error(format!("unknown library kind `{}`, expected \
+                early_error(&format!("unknown library kind `{}`, expected \
                                      one of dylib, framework, or static",
-                                    s).index(&FullRange));
+                                    s)[]);
             }
         };
         (name.to_string(), kind)
@@ -1089,7 +1107,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
                     --debuginfo");
     }
 
-    let color = match matches.opt_str("color").as_ref().map(|s| s.index(&FullRange)) {
+    let color = match matches.opt_str("color").as_ref().map(|s| &s[]) {
         Some("auto")   => Auto,
         Some("always") => Always,
         Some("never")  => Never,
@@ -1097,9 +1115,9 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         None => Auto,
 
         Some(arg) => {
-            early_error(format!("argument for --color must be auto, always \
+            early_error(&format!("argument for --color must be auto, always \
                                  or never (instead was `{}`)",
-                                arg).index(&FullRange))
+                                arg)[])
         }
     };
 
@@ -1149,6 +1167,7 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
         crate_name: crate_name,
         alt_std_name: None,
         libs: libs,
+        unstable_features: UnstableFeatures::Disallow
     }
 }
 
@@ -1201,7 +1220,7 @@ mod test {
     #[test]
     fn test_switch_implies_cfg_test() {
         let matches =
-            &match getopts(&["--test".to_string()], optgroups().index(&FullRange)) {
+            &match getopts(&["--test".to_string()], &optgroups()[]) {
               Ok(m) => m,
               Err(f) => panic!("test_switch_implies_cfg_test: {}", f)
             };
@@ -1209,7 +1228,7 @@ mod test {
         let sessopts = build_session_options(matches);
         let sess = build_session(sessopts, None, registry);
         let cfg = build_configuration(&sess);
-        assert!((attr::contains_name(cfg.index(&FullRange), "test")));
+        assert!((attr::contains_name(&cfg[], "test")));
     }
 
     // When the user supplies --test and --cfg test, don't implicitly add
@@ -1218,7 +1237,7 @@ mod test {
     fn test_switch_implies_cfg_test_unless_cfg_test() {
         let matches =
             &match getopts(&["--test".to_string(), "--cfg=test".to_string()],
-                           optgroups().index(&FullRange)) {
+                           &optgroups()[]) {
               Ok(m) => m,
               Err(f) => {
                 panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
@@ -1238,7 +1257,7 @@ mod test {
         {
             let matches = getopts(&[
                 "-Awarnings".to_string()
-            ], optgroups().index(&FullRange)).unwrap();
+            ], &optgroups()[]).unwrap();
             let registry = diagnostics::registry::Registry::new(&[]);
             let sessopts = build_session_options(&matches);
             let sess = build_session(sessopts, None, registry);
@@ -1249,7 +1268,7 @@ mod test {
             let matches = getopts(&[
                 "-Awarnings".to_string(),
                 "-Dwarnings".to_string()
-            ], optgroups().index(&FullRange)).unwrap();
+            ], &optgroups()[]).unwrap();
             let registry = diagnostics::registry::Registry::new(&[]);
             let sessopts = build_session_options(&matches);
             let sess = build_session(sessopts, None, registry);
@@ -1259,7 +1278,7 @@ mod test {
         {
             let matches = getopts(&[
                 "-Adead_code".to_string()
-            ], optgroups().index(&FullRange)).unwrap();
+            ], &optgroups()[]).unwrap();
             let registry = diagnostics::registry::Registry::new(&[]);
             let sessopts = build_session_options(&matches);
             let sess = build_session(sessopts, None, registry);
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index 94a6bca4e06e5..65dac1a5fac88 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -174,7 +174,7 @@ impl Session {
     // cases later on
     pub fn impossible_case(&self, sp: Span, msg: &str) -> ! {
         self.span_bug(sp,
-                      format!("impossible case reached: {}", msg).index(&FullRange));
+                      &format!("impossible case reached: {}", msg)[]);
     }
     pub fn verbose(&self) -> bool { self.debugging_opt(config::VERBOSE) }
     pub fn time_passes(&self) -> bool { self.debugging_opt(config::TIME_PASSES) }
@@ -216,7 +216,7 @@ impl Session {
     }
     pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch {
         filesearch::FileSearch::new(self.sysroot(),
-                                    self.opts.target_triple.index(&FullRange),
+                                    &self.opts.target_triple[],
                                     &self.opts.search_paths,
                                     kind)
     }
diff --git a/src/librustc/util/common.rs b/src/librustc/util/common.rs
index 26f98e28a8d95..c505e9e311256 100644
--- a/src/librustc/util/common.rs
+++ b/src/librustc/util/common.rs
@@ -16,6 +16,7 @@ use std::fmt::Show;
 use std::hash::{Hash, Hasher};
 use std::iter::repeat;
 use std::time::Duration;
+use std::collections::hash_state::HashState;
 
 use syntax::ast;
 use syntax::visit;
@@ -140,11 +141,11 @@ pub fn block_query<P>(b: &ast::Block, p: P) -> bool where P: FnMut(&ast::Expr) -
 /// Efficiency note: This is implemented in an inefficient way because it is typically invoked on
 /// very small graphs. If the graphs become larger, a more efficient graph representation and
 /// algorithm would probably be advised.
-pub fn can_reach<S,H:Hasher<S>,T:Eq+Clone+Hash<S>>(
-    edges_map: &HashMap<T,Vec<T>,H>,
-    source: T,
-    destination: T)
-    -> bool
+pub fn can_reach<T, S>(edges_map: &HashMap<T, Vec<T>, S>, source: T,
+                       destination: T) -> bool
+    where S: HashState,
+          <S as HashState>::Hasher: Hasher<Output=u64>,
+          T: Hash< <S as HashState>::Hasher> + Eq + Clone,
 {
     if source == destination {
         return true;
@@ -202,11 +203,12 @@ pub fn can_reach<S,H:Hasher<S>,T:Eq+Clone+Hash<S>>(
 /// }
 /// ```
 #[inline(always)]
-pub fn memoized<T, U, S, H, F>(cache: &RefCell<HashMap<T, U, H>>, arg: T, f: F) -> U where
-    T: Clone + Hash<S> + Eq,
-    U: Clone,
-    H: Hasher<S>,
-    F: FnOnce(T) -> U,
+pub fn memoized<T, U, S, F>(cache: &RefCell<HashMap<T, U, S>>, arg: T, f: F) -> U
+    where T: Clone + Hash<<S as HashState>::Hasher> + Eq,
+          U: Clone,
+          S: HashState,
+          <S as HashState>::Hasher: Hasher<Output=u64>,
+          F: FnOnce(T) -> U,
 {
     let key = arg.clone();
     let result = cache.borrow().get(&key).map(|result| result.clone());
diff --git a/src/librustc/util/lev_distance.rs b/src/librustc/util/lev_distance.rs
index 8f5820d92c589..ec840498ae661 100644
--- a/src/librustc/util/lev_distance.rs
+++ b/src/librustc/util/lev_distance.rs
@@ -48,7 +48,7 @@ fn test_lev_distance() {
     for c in range(0u32, MAX as u32)
              .filter_map(|i| from_u32(i))
              .map(|i| i.to_string()) {
-        assert_eq!(lev_distance(c.index(&FullRange), c.index(&FullRange)), 0);
+        assert_eq!(lev_distance(&c[], &c[]), 0);
     }
 
     let a = "\nMäry häd ä little lämb\n\nLittle lämb\n";
diff --git a/src/librustc/util/nodemap.rs b/src/librustc/util/nodemap.rs
index ee224d1ec80fe..044534ae85236 100644
--- a/src/librustc/util/nodemap.rs
+++ b/src/librustc/util/nodemap.rs
@@ -12,12 +12,14 @@
 
 #![allow(non_snake_case)]
 
+use std::collections::hash_state::{DefaultState};
 use std::collections::{HashMap, HashSet};
-use std::hash::{Hasher, Hash, Writer};
+use std::default::Default;
+use std::hash::{Hasher, Writer};
 use syntax::ast;
 
-pub type FnvHashMap<K, V> = HashMap<K, V, FnvHasher>;
-pub type FnvHashSet<V> = HashSet<V, FnvHasher>;
+pub type FnvHashMap<K, V> = HashMap<K, V, DefaultState<FnvHasher>>;
+pub type FnvHashSet<V> = HashSet<V, DefaultState<FnvHasher>>;
 
 pub type NodeMap<T> = FnvHashMap<ast::NodeId, T>;
 pub type DefIdMap<T> = FnvHashMap<ast::DefId, T>;
@@ -28,16 +30,16 @@ pub type DefIdSet = FnvHashSet<ast::DefId>;
 // Hacks to get good names
 pub mod FnvHashMap {
     use std::hash::Hash;
-    use std::collections::HashMap;
-    pub fn new<K: Hash<super::FnvState> + Eq, V>() -> super::FnvHashMap<K, V> {
-        HashMap::with_hasher(super::FnvHasher)
+    use std::default::Default;
+    pub fn new<K: Hash<super::FnvHasher> + Eq, V>() -> super::FnvHashMap<K, V> {
+        Default::default()
     }
 }
 pub mod FnvHashSet {
     use std::hash::Hash;
-    use std::collections::HashSet;
-    pub fn new<V: Hash<super::FnvState> + Eq>() -> super::FnvHashSet<V> {
-        HashSet::with_hasher(super::FnvHasher)
+    use std::default::Default;
+    pub fn new<V: Hash<super::FnvHasher> + Eq>() -> super::FnvHashSet<V> {
+        Default::default()
     }
 }
 pub mod NodeMap {
@@ -68,28 +70,26 @@ pub mod DefIdSet {
 ///
 /// This uses FNV hashing, as described here:
 /// http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
-#[derive(Clone, Copy, Default)]
-pub struct FnvHasher;
-
 #[allow(missing_copy_implementations)]
-pub struct FnvState(u64);
+pub struct FnvHasher(u64);
 
-impl Hasher<FnvState> for FnvHasher {
-    fn hash<T: ?Sized + Hash<FnvState>>(&self, t: &T) -> u64 {
-        let mut state = FnvState(0xcbf29ce484222325);
-        t.hash(&mut state);
-        let FnvState(ret) = state;
-        return ret;
-    }
+impl Default for FnvHasher {
+    fn default() -> FnvHasher { FnvHasher(0xcbf29ce484222325) }
+}
+
+impl Hasher for FnvHasher {
+    type Output = u64;
+    fn reset(&mut self) { *self = Default::default(); }
+    fn finish(&self) -> u64 { self.0 }
 }
 
-impl Writer for FnvState {
+impl Writer for FnvHasher {
     fn write(&mut self, bytes: &[u8]) {
-        let FnvState(mut hash) = *self;
+        let FnvHasher(mut hash) = *self;
         for byte in bytes.iter() {
             hash = hash ^ (*byte as u64);
             hash = hash * 0x100000001b3;
         }
-        *self = FnvState(hash);
+        *self = FnvHasher(hash);
     }
 }
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index 2d433369366eb..559ec533baa9e 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -26,6 +26,7 @@ use middle::ty;
 use middle::ty_fold::TypeFoldable;
 
 use std::collections::HashMap;
+use std::collections::hash_state::HashState;
 use std::hash::{Hash, Hasher};
 use std::rc::Rc;
 use syntax::abi;
@@ -55,12 +56,12 @@ pub fn note_and_explain_region(cx: &ctxt,
       (ref str, Some(span)) => {
         cx.sess.span_note(
             span,
-            format!("{}{}{}", prefix, *str, suffix).index(&FullRange));
+            &format!("{}{}{}", prefix, *str, suffix)[]);
         Some(span)
       }
       (ref str, None) => {
         cx.sess.note(
-            format!("{}{}{}", prefix, *str, suffix).index(&FullRange));
+            &format!("{}{}{}", prefix, *str, suffix)[]);
         None
       }
     }
@@ -271,7 +272,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         };
 
         if abi != abi::Rust {
-            s.push_str(format!("extern {} ", abi.to_string()).index(&FullRange));
+            s.push_str(&format!("extern {} ", abi.to_string())[]);
         };
 
         s.push_str("fn");
@@ -290,7 +291,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
             Some(def_id) => {
                 s.push_str(" {");
                 let path_str = ty::item_path_str(cx, def_id);
-                s.push_str(path_str.index(&FullRange));
+                s.push_str(&path_str[]);
                 s.push_str("}");
             }
             None => { }
@@ -305,7 +306,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         match cty.store {
             ty::UniqTraitStore => {}
             ty::RegionTraitStore(region, _) => {
-                s.push_str(region_to_string(cx, "", true, region).index(&FullRange));
+                s.push_str(&region_to_string(cx, "", true, region)[]);
             }
         }
 
@@ -324,7 +325,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
                 assert_eq!(cty.onceness, ast::Once);
                 s.push_str("proc");
                 push_sig_to_string(cx, &mut s, '(', ')', &cty.sig,
-                                   bounds_str.index(&FullRange));
+                                   &bounds_str[]);
             }
             ty::RegionTraitStore(..) => {
                 match cty.onceness {
@@ -332,7 +333,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
                     ast::Once => s.push_str("once ")
                 }
                 push_sig_to_string(cx, &mut s, '|', '|', &cty.sig,
-                                   bounds_str.index(&FullRange));
+                                   &bounds_str[]);
             }
         }
 
@@ -365,7 +366,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
             ty::FnConverging(t) => {
                 if !ty::type_is_nil(t) {
                    s.push_str(" -> ");
-                   s.push_str(ty_to_string(cx, t).index(&FullRange));
+                   s.push_str(&ty_to_string(cx, t)[]);
                 }
             }
             ty::FnDiverging => {
@@ -402,7 +403,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
         }
         ty_rptr(r, ref tm) => {
             let mut buf = region_ptr_to_string(cx, *r);
-            buf.push_str(mt_to_string(cx, tm).index(&FullRange));
+            buf.push_str(&mt_to_string(cx, tm)[]);
             buf
         }
         ty_open(typ) =>
@@ -412,7 +413,7 @@ pub fn ty_to_string<'tcx>(cx: &ctxt<'tcx>, typ: &ty::TyS<'tcx>) -> String {
                 .iter()
                 .map(|elem| ty_to_string(cx, *elem))
                 .collect::<Vec<_>>();
-            match strs.index(&FullRange) {
+            match &strs[] {
                 [ref string] => format!("({},)", string),
                 strs => format!("({})", strs.connect(", "))
             }
@@ -541,7 +542,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>,
         0
     };
 
-    for t in tps.index(&(0..(tps.len() - num_defaults))).iter() {
+    for t in tps[0..(tps.len() - num_defaults)].iter() {
         strs.push(ty_to_string(cx, *t))
     }
 
@@ -549,11 +550,11 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>,
         format!("{}({}){}",
                 base,
                 if strs[0].starts_with("(") && strs[0].ends_with(",)") {
-                    strs[0].index(&(1 .. (strs[0].len() - 2))) // Remove '(' and ',)'
+                    &strs[0][1 .. (strs[0].len() - 2)] // Remove '(' and ',)'
                 } else if strs[0].starts_with("(") && strs[0].ends_with(")") {
-                    strs[0].index(&(1 .. (strs[0].len() - 1))) // Remove '(' and ')'
+                    &strs[0][1 .. (strs[0].len() - 1)] // Remove '(' and ')'
                 } else {
-                    strs[0].index(&FullRange)
+                    &strs[0][]
                 },
                 if &*strs[1] == "()" { String::new() } else { format!(" -> {}", strs[1]) })
     } else if strs.len() > 0 {
@@ -566,7 +567,7 @@ pub fn parameterized<'tcx>(cx: &ctxt<'tcx>,
 pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String {
     let mut s = typ.repr(cx).to_string();
     if s.len() >= 32u {
-        s = s.index(&(0u..32u)).to_string();
+        s = (&s[0u..32u]).to_string();
     }
     return s;
 }
@@ -631,7 +632,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for [T] {
 
 impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice<T> {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        repr_vec(tcx, self.index(&FullRange))
+        repr_vec(tcx, &self[])
     }
 }
 
@@ -639,7 +640,7 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for OwnedSlice<T> {
 // autoderef cannot convert the &[T] handler
 impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for Vec<T> {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        repr_vec(tcx, self.index(&FullRange))
+        repr_vec(tcx, &self[])
     }
 }
 
@@ -1182,8 +1183,8 @@ impl<'tcx, T> UserString<'tcx> for ty::Binder<T>
         // the output. We'll probably want to tweak this over time to
         // decide just how much information to give.
         let mut names = Vec::new();
-        let (unbound_value, _) = ty::replace_late_bound_regions(tcx, self, |br, debruijn| {
-            ty::ReLateBound(debruijn, match br {
+        let (unbound_value, _) = ty::replace_late_bound_regions(tcx, self, |br| {
+            ty::ReLateBound(ty::DebruijnIndex::new(1), match br {
                 ty::BrNamed(_, name) => {
                     names.push(token::get_name(name));
                     br
@@ -1350,11 +1351,11 @@ impl<'tcx, T:Repr<'tcx>> Repr<'tcx> for ty::Binder<T> {
     }
 }
 
-#[old_impl_check]
-impl<'tcx, S, H, K, V> Repr<'tcx> for HashMap<K,V,H>
-    where K : Hash<S> + Eq + Repr<'tcx>,
-          V : Repr<'tcx>,
-          H : Hasher<S>
+impl<'tcx, S, K, V> Repr<'tcx> for HashMap<K, V, S>
+    where K: Hash<<S as HashState>::Hasher> + Eq + Repr<'tcx>,
+          V: Repr<'tcx>,
+          S: HashState,
+          <S as HashState>::Hasher: Hasher<Output=u64>,
 {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
         format!("HashMap({})",
diff --git a/src/librustc/util/snapshot_vec.rs b/src/librustc/util/snapshot_vec.rs
index d68b13aa2ff58..8fc95529bc087 100644
--- a/src/librustc/util/snapshot_vec.rs
+++ b/src/librustc/util/snapshot_vec.rs
@@ -116,7 +116,7 @@ impl<T,U,D:SnapshotVecDelegate<T,U>> SnapshotVec<T,U,D> {
     pub fn actions_since_snapshot(&self,
                                   snapshot: &Snapshot)
                                   -> &[UndoLog<T,U>] {
-        self.undo_log.index(&(snapshot.length..))
+        &self.undo_log[snapshot.length..]
     }
 
     fn assert_open_snapshot(&self, snapshot: &Snapshot) {
diff --git a/src/librustc_back/archive.rs b/src/librustc_back/archive.rs
index 48004acaac087..7ea192b8d6bc8 100644
--- a/src/librustc_back/archive.rs
+++ b/src/librustc_back/archive.rs
@@ -53,7 +53,7 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,
           args: &str, cwd: Option<&Path>,
           paths: &[&Path]) -> ProcessOutput {
     let ar = match *maybe_ar_prog {
-        Some(ref ar) => ar.index(&FullRange),
+        Some(ref ar) => &ar[],
         None => "ar"
     };
     let mut cmd = Command::new(ar);
@@ -73,24 +73,21 @@ fn run_ar(handler: &ErrorHandler, maybe_ar_prog: &Option<String>,
         Ok(prog) => {
             let o = prog.wait_with_output().unwrap();
             if !o.status.success() {
-                handler.err(format!("{} failed with: {}",
+                handler.err(&format!("{} failed with: {}",
                                  cmd,
-                                 o.status).index(&FullRange));
-                handler.note(format!("stdout ---\n{}",
-                                  str::from_utf8(o.output
-                                                  .index(&FullRange)).unwrap())
-                          .index(&FullRange));
-                handler.note(format!("stderr ---\n{}",
-                                  str::from_utf8(o.error
-                                                  .index(&FullRange)).unwrap())
-                          .index(&FullRange));
+                                 o.status)[]);
+                handler.note(&format!("stdout ---\n{}",
+                                  str::from_utf8(&o.output[]).unwrap())[]);
+                handler.note(&format!("stderr ---\n{}",
+                                  str::from_utf8(&o.error[]).unwrap())
+                             []);
                 handler.abort_if_errors();
             }
             o
         },
         Err(e) => {
-            handler.err(format!("could not exec `{}`: {}", ar.index(&FullRange),
-                             e).index(&FullRange));
+            handler.err(&format!("could not exec `{}`: {}", &ar[],
+                             e)[]);
             handler.abort_if_errors();
             panic!("rustc::back::archive::run_ar() should not reach this point");
         }
@@ -106,16 +103,16 @@ pub fn find_library(name: &str, osprefix: &str, ossuffix: &str,
 
     for path in search_paths.iter() {
         debug!("looking for {} inside {:?}", name, path.display());
-        let test = path.join(oslibname.index(&FullRange));
+        let test = path.join(&oslibname[]);
         if test.exists() { return test }
         if oslibname != unixlibname {
-            let test = path.join(unixlibname.index(&FullRange));
+            let test = path.join(&unixlibname[]);
             if test.exists() { return test }
         }
     }
-    handler.fatal(format!("could not find native static library `{}`, \
+    handler.fatal(&format!("could not find native static library `{}`, \
                            perhaps an -L flag is missing?",
-                          name).index(&FullRange));
+                          name)[]);
 }
 
 impl<'a> Archive<'a> {
@@ -147,7 +144,7 @@ impl<'a> Archive<'a> {
     /// Lists all files in an archive
     pub fn files(&self) -> Vec<String> {
         let output = run_ar(self.handler, &self.maybe_ar_prog, "t", None, &[&self.dst]);
-        let output = str::from_utf8(output.output.index(&FullRange)).unwrap();
+        let output = str::from_utf8(&output.output[]).unwrap();
         // use lines_any because windows delimits output with `\r\n` instead of
         // just `\n`
         output.lines_any().map(|s| s.to_string()).collect()
@@ -179,9 +176,9 @@ impl<'a> ArchiveBuilder<'a> {
     /// search in the relevant locations for a library named `name`.
     pub fn add_native_library(&mut self, name: &str) -> io::IoResult<()> {
         let location = find_library(name,
-                                    self.archive.slib_prefix.index(&FullRange),
-                                    self.archive.slib_suffix.index(&FullRange),
-                                    self.archive.lib_search_paths.index(&FullRange),
+                                    &self.archive.slib_prefix[],
+                                    &self.archive.slib_suffix[],
+                                    &self.archive.lib_search_paths[],
                                     self.archive.handler);
         self.add_archive(&location, name, |_| false)
     }
@@ -197,12 +194,12 @@ impl<'a> ArchiveBuilder<'a> {
         // as simple comparison is not enough - there
         // might be also an extra name suffix
         let obj_start = format!("{}", name);
-        let obj_start = obj_start.index(&FullRange);
+        let obj_start = &obj_start[];
         // Ignoring all bytecode files, no matter of
         // name
         let bc_ext = ".bytecode.deflate";
 
-        self.add_archive(rlib, name.index(&FullRange), |fname: &str| {
+        self.add_archive(rlib, &name[], |fname: &str| {
             let skip_obj = lto && fname.starts_with(obj_start)
                 && fname.ends_with(".o");
             skip_obj || fname.ends_with(bc_ext) || fname == METADATA_FILENAME
@@ -239,7 +236,7 @@ impl<'a> ArchiveBuilder<'a> {
             // allow running `ar s file.a` to update symbols only.
             if self.should_update_symbols {
                 run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
-                       "s", Some(self.work_dir.path()), args.index(&FullRange));
+                       "s", Some(self.work_dir.path()), &args[]);
             }
             return self.archive;
         }
@@ -259,7 +256,7 @@ impl<'a> ArchiveBuilder<'a> {
                 // Add the archive members seen so far, without updating the
                 // symbol table (`S`).
                 run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
-                       "cruS", Some(self.work_dir.path()), args.index(&FullRange));
+                       "cruS", Some(self.work_dir.path()), &args[]);
 
                 args.clear();
                 args.push(&abs_dst);
@@ -274,7 +271,7 @@ impl<'a> ArchiveBuilder<'a> {
         // necessary.
         let flags = if self.should_update_symbols { "crus" } else { "cruS" };
         run_ar(self.archive.handler, &self.archive.maybe_ar_prog,
-               flags, Some(self.work_dir.path()), args.index(&FullRange));
+               flags, Some(self.work_dir.path()), &args[]);
 
         self.archive
     }
@@ -316,7 +313,7 @@ impl<'a> ArchiveBuilder<'a> {
             } else {
                 filename
             };
-            let new_filename = self.work_dir.path().join(filename.index(&FullRange));
+            let new_filename = self.work_dir.path().join(&filename[]);
             try!(fs::rename(file, &new_filename));
             self.members.push(Path::new(filename));
         }
diff --git a/src/librustc_back/lib.rs b/src/librustc_back/lib.rs
index ca39477fbdcb2..fcd20158c0a29 100644
--- a/src/librustc_back/lib.rs
+++ b/src/librustc_back/lib.rs
@@ -23,12 +23,14 @@
 
 #![crate_name = "rustc_back"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/nightly/")]
-#![feature(slicing_syntax)]
+#![allow(unknown_features)]
+#![feature(slicing_syntax, box_syntax)]
 
 extern crate syntax;
 extern crate serialize;
diff --git a/src/librustc_back/rpath.rs b/src/librustc_back/rpath.rs
index db1dfa6b6eed8..d24fd6a5b3f05 100644
--- a/src/librustc_back/rpath.rs
+++ b/src/librustc_back/rpath.rs
@@ -44,15 +44,15 @@ pub fn get_rpath_flags<F, G>(config: RPathConfig<F, G>) -> Vec<String> where
         l.map(|p| p.clone())
     }).collect::<Vec<_>>();
 
-    let rpaths = get_rpaths(config, libs.index(&FullRange));
-    flags.push_all(rpaths_to_flags(rpaths.index(&FullRange)).index(&FullRange));
+    let rpaths = get_rpaths(config, &libs[]);
+    flags.push_all(&rpaths_to_flags(&rpaths[])[]);
     flags
 }
 
 fn rpaths_to_flags(rpaths: &[String]) -> Vec<String> {
     let mut ret = Vec::new();
     for rpath in rpaths.iter() {
-        ret.push(format!("-Wl,-rpath,{}", (*rpath).index(&FullRange)));
+        ret.push(format!("-Wl,-rpath,{}", &(*rpath)[]));
     }
     return ret;
 }
@@ -82,14 +82,14 @@ fn get_rpaths<F, G>(mut config: RPathConfig<F, G>, libs: &[Path]) -> Vec<String>
         }
     }
 
-    log_rpaths("relative", rel_rpaths.index(&FullRange));
-    log_rpaths("fallback", fallback_rpaths.index(&FullRange));
+    log_rpaths("relative", &rel_rpaths[]);
+    log_rpaths("fallback", &fallback_rpaths[]);
 
     let mut rpaths = rel_rpaths;
-    rpaths.push_all(fallback_rpaths.index(&FullRange));
+    rpaths.push_all(&fallback_rpaths[]);
 
     // Remove duplicates
-    let rpaths = minimize_rpaths(rpaths.index(&FullRange));
+    let rpaths = minimize_rpaths(&rpaths[]);
     return rpaths;
 }
 
@@ -140,7 +140,7 @@ fn minimize_rpaths(rpaths: &[String]) -> Vec<String> {
     let mut set = HashSet::new();
     let mut minimized = Vec::new();
     for rpath in rpaths.iter() {
-        if set.insert(rpath.index(&FullRange)) {
+        if set.insert(&rpath[]) {
             minimized.push(rpath.clone());
         }
     }
diff --git a/src/librustc_back/sha2.rs b/src/librustc_back/sha2.rs
index f33971a6ac0c2..ac5662f534c86 100644
--- a/src/librustc_back/sha2.rs
+++ b/src/librustc_back/sha2.rs
@@ -140,7 +140,7 @@ impl FixedBuffer for FixedBuffer64 {
             if input.len() >= buffer_remaining {
                     copy_memory(
                         self.buffer.slice_mut(self.buffer_idx, size),
-                        input.index(&(0..buffer_remaining)));
+                        &input[0..buffer_remaining]);
                 self.buffer_idx = 0;
                 func(&self.buffer);
                 i += buffer_remaining;
@@ -156,7 +156,7 @@ impl FixedBuffer for FixedBuffer64 {
         // While we have at least a full buffer size chunk's worth of data, process that data
         // without copying it into the buffer
         while input.len() - i >= size {
-            func(input.index(&(i..(i + size))));
+            func(&input[i..(i + size)]);
             i += size;
         }
 
@@ -166,7 +166,7 @@ impl FixedBuffer for FixedBuffer64 {
         let input_remaining = input.len() - i;
         copy_memory(
             self.buffer.slice_to_mut(input_remaining),
-            input.index(&(i..)));
+            &input[i..]);
         self.buffer_idx += input_remaining;
     }
 
@@ -188,7 +188,7 @@ impl FixedBuffer for FixedBuffer64 {
     fn full_buffer<'s>(&'s mut self) -> &'s [u8] {
         assert!(self.buffer_idx == 64);
         self.buffer_idx = 0;
-        return self.buffer.index(&(0..64));
+        return &self.buffer[0..64];
     }
 
     fn position(&self) -> uint { self.buffer_idx }
diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs
index 863c1a7c865f3..4e260da2e4ded 100644
--- a/src/librustc_back/svh.rs
+++ b/src/librustc_back/svh.rs
@@ -47,8 +47,7 @@
 //! Original issue: https://github.com/rust-lang/rust/issues/10207
 
 use std::fmt;
-use std::hash::Hash;
-use std::hash::sip::SipState;
+use std::hash::{Hash, SipHasher, Hasher};
 use std::iter::range_step;
 use syntax::ast;
 use syntax::visit;
@@ -65,7 +64,7 @@ impl Svh {
     }
 
     pub fn as_str<'a>(&'a self) -> &'a str {
-        self.hash.index(&FullRange)
+        &self.hash[]
     }
 
     pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh {
@@ -78,7 +77,7 @@ impl Svh {
 
         // FIXME: this should use SHA1, not SipHash. SipHash is not built to
         //        avoid collisions.
-        let mut state = SipState::new();
+        let mut state = SipHasher::new();
 
         for data in metadata.iter() {
             data.hash(&mut state);
@@ -102,7 +101,7 @@ impl Svh {
             attr.node.value.hash(&mut state);
         }
 
-        let hash = state.result();
+        let hash = state.finish();
         return Svh {
             hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect()
         };
@@ -120,9 +119,7 @@ impl Svh {
 
 impl fmt::Show for Svh {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        //NOTE(stage0): uncomment after snapshot
-        //write!(f, "Svh {{ {} }}", self.as_str())
-        fmt::String::fmt(self, f)
+        write!(f, "Svh {{ {} }}", self.as_str())
     }
 }
 
@@ -149,14 +146,13 @@ mod svh_visitor {
     use syntax::visit;
     use syntax::visit::{Visitor, FnKind};
 
-    use std::hash::Hash;
-    use std::hash::sip::SipState;
+    use std::hash::{Hash, SipHasher};
 
     pub struct StrictVersionHashVisitor<'a> {
-        pub st: &'a mut SipState,
+        pub st: &'a mut SipHasher,
     }
 
-    pub fn make<'a>(st: &'a mut SipState) -> StrictVersionHashVisitor<'a> {
+    pub fn make<'a>(st: &'a mut SipHasher) -> StrictVersionHashVisitor<'a> {
         StrictVersionHashVisitor { st: st }
     }
 
@@ -366,7 +362,7 @@ mod svh_visitor {
             fn macro_name(mac: &Mac) -> token::InternedString {
                 match &mac.node {
                     &MacInvocTT(ref path, ref _tts, ref _stx_ctxt) => {
-                        let s = path.segments.index(&FullRange);
+                        let s = &path.segments[];
                         assert_eq!(s.len(), 1);
                         content(s[0].identifier)
                     }
@@ -400,7 +396,7 @@ mod svh_visitor {
         }
 
         // All of the remaining methods just record (in the hash
-        // SipState) that the visitor saw that particular variant
+        // SipHasher) that the visitor saw that particular variant
         // (with its payload), and continue walking as the default
         // visitor would.
         //
diff --git a/src/librustc_back/target/aarch64_unknown_linux_gnu.rs b/src/librustc_back/target/aarch64_unknown_linux_gnu.rs
index 296552a6abd90..a3ef6372f0648 100644
--- a/src/librustc_back/target/aarch64_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/aarch64_unknown_linux_gnu.rs
@@ -18,7 +18,7 @@ pub fn target() -> Target {
                       n32:64-S128".to_string(),
         llvm_target: "aarch64-unknown-linux-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "aarch64".to_string(),
         target_os: "linux".to_string(),
         options: base,
diff --git a/src/librustc_back/target/arm_apple_ios.rs b/src/librustc_back/target/arm_apple_ios.rs
index 8bb64eae625f4..e0afef6e3904f 100644
--- a/src/librustc_back/target/arm_apple_ios.rs
+++ b/src/librustc_back/target/arm_apple_ios.rs
@@ -19,7 +19,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "arm-apple-ios".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "arm".to_string(),
         target_os: "ios".to_string(),
         options: TargetOptions {
diff --git a/src/librustc_back/target/arm_linux_androideabi.rs b/src/librustc_back/target/arm_linux_androideabi.rs
index ecfb1667f60e1..6fc77a715a556 100644
--- a/src/librustc_back/target/arm_linux_androideabi.rs
+++ b/src/librustc_back/target/arm_linux_androideabi.rs
@@ -27,7 +27,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "arm-linux-androideabi".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "arm".to_string(),
         target_os: "android".to_string(),
         options: base,
diff --git a/src/librustc_back/target/arm_unknown_linux_gnueabi.rs b/src/librustc_back/target/arm_unknown_linux_gnueabi.rs
index 985af35e1454c..32eccaf54b038 100644
--- a/src/librustc_back/target/arm_unknown_linux_gnueabi.rs
+++ b/src/librustc_back/target/arm_unknown_linux_gnueabi.rs
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "arm-unknown-linux-gnueabi".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "arm".to_string(),
         target_os: "linux".to_string(),
 
diff --git a/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs b/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs
index 3cf0c31282052..eff3601250f87 100644
--- a/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs
+++ b/src/librustc_back/target/arm_unknown_linux_gnueabihf.rs
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "arm-unknown-linux-gnueabihf".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "arm".to_string(),
         target_os: "linux".to_string(),
 
diff --git a/src/librustc_back/target/i386_apple_ios.rs b/src/librustc_back/target/i386_apple_ios.rs
index 45669bc958599..a1fcc9ac53fb2 100644
--- a/src/librustc_back/target/i386_apple_ios.rs
+++ b/src/librustc_back/target/i386_apple_ios.rs
@@ -19,7 +19,7 @@ pub fn target() -> Target {
                       -n8:16:32".to_string(),
         llvm_target: "i386-apple-ios".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "x86".to_string(),
         target_os: "ios".to_string(),
 
diff --git a/src/librustc_back/target/i686_apple_darwin.rs b/src/librustc_back/target/i686_apple_darwin.rs
index feef5b98dcbcf..1b079323bf9ca 100644
--- a/src/librustc_back/target/i686_apple_darwin.rs
+++ b/src/librustc_back/target/i686_apple_darwin.rs
@@ -22,7 +22,7 @@ pub fn target() -> Target {
                       -n8:16:32".to_string(),
         llvm_target: "i686-apple-darwin".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "x86".to_string(),
         target_os: "macos".to_string(),
         options: base,
diff --git a/src/librustc_back/target/i686_pc_windows_gnu.rs b/src/librustc_back/target/i686_pc_windows_gnu.rs
index 4d75590e6647c..c2ab68ee05256 100644
--- a/src/librustc_back/target/i686_pc_windows_gnu.rs
+++ b/src/librustc_back/target/i686_pc_windows_gnu.rs
@@ -26,7 +26,7 @@ pub fn target() -> Target {
         data_layout: "e-p:32:32-f64:64:64-i64:64:64-f80:32:32-n8:16:32".to_string(),
         llvm_target: "i686-pc-windows-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "x86".to_string(),
         target_os: "windows".to_string(),
         options: options,
diff --git a/src/librustc_back/target/i686_unknown_dragonfly.rs b/src/librustc_back/target/i686_unknown_dragonfly.rs
index a12657ff4dcdc..7910eba7ea124 100644
--- a/src/librustc_back/target/i686_unknown_dragonfly.rs
+++ b/src/librustc_back/target/i686_unknown_dragonfly.rs
@@ -18,7 +18,7 @@ pub fn target() -> Target {
         data_layout: "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(),
         llvm_target: "i686-unknown-dragonfly".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "x86".to_string(),
         target_os: "dragonfly".to_string(),
         options: base,
diff --git a/src/librustc_back/target/i686_unknown_linux_gnu.rs b/src/librustc_back/target/i686_unknown_linux_gnu.rs
index 1a4560d5cd5fc..c93a564fef5f4 100644
--- a/src/librustc_back/target/i686_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/i686_unknown_linux_gnu.rs
@@ -18,7 +18,7 @@ pub fn target() -> Target {
         data_layout: "e-p:32:32-f64:32:64-i64:32:64-f80:32:32-n8:16:32".to_string(),
         llvm_target: "i686-unknown-linux-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "x86".to_string(),
         target_os: "linux".to_string(),
         options: base,
diff --git a/src/librustc_back/target/mips_unknown_linux_gnu.rs b/src/librustc_back/target/mips_unknown_linux_gnu.rs
index c8c5ddcbd0d00..8acc248e23410 100644
--- a/src/librustc_back/target/mips_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/mips_unknown_linux_gnu.rs
@@ -19,7 +19,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "mips-unknown-linux-gnu".to_string(),
         target_endian: "big".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "mips".to_string(),
         target_os: "linux".to_string(),
         options: super::linux_base::opts()
diff --git a/src/librustc_back/target/mipsel_unknown_linux_gnu.rs b/src/librustc_back/target/mipsel_unknown_linux_gnu.rs
index 3571f7b26c021..604c62eb69f0f 100644
--- a/src/librustc_back/target/mipsel_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/mipsel_unknown_linux_gnu.rs
@@ -19,7 +19,7 @@ pub fn target() -> Target {
                       -a:0:64-n32".to_string(),
         llvm_target: "mipsel-unknown-linux-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "32".to_string(),
+        target_pointer_width: "32".to_string(),
         arch: "mips".to_string(),
         target_os: "linux".to_string(),
 
diff --git a/src/librustc_back/target/mod.rs b/src/librustc_back/target/mod.rs
index 23c8fc7de51b5..069e798887b93 100644
--- a/src/librustc_back/target/mod.rs
+++ b/src/librustc_back/target/mod.rs
@@ -85,8 +85,8 @@ pub struct Target {
     pub llvm_target: String,
     /// String to use as the `target_endian` `cfg` variable.
     pub target_endian: String,
-    /// String to use as the `target_word_size` `cfg` variable.
-    pub target_word_size: String,
+    /// String to use as the `target_pointer_width` `cfg` variable.
+    pub target_pointer_width: String,
     /// OS name to use for conditional compilation.
     pub target_os: String,
     /// Architecture to use for ABI considerations. Valid options: "x86", "x86_64", "arm",
@@ -224,8 +224,7 @@ impl Target {
                      .and_then(|os| os.map(|s| s.to_string())) {
                 Some(val) => val,
                 None =>
-                    handler.fatal((format!("Field {} in target specification is required", name))
-                                  .index(&FullRange))
+                    handler.fatal(&format!("Field {} in target specification is required", name)[])
             }
         };
 
@@ -233,7 +232,7 @@ impl Target {
             data_layout: get_req_field("data-layout"),
             llvm_target: get_req_field("llvm-target"),
             target_endian: get_req_field("target-endian"),
-            target_word_size: get_req_field("target-word-size"),
+            target_pointer_width: get_req_field("target-word-size"),
             arch: get_req_field("arch"),
             target_os: get_req_field("os"),
             options: Default::default(),
@@ -242,18 +241,18 @@ impl Target {
         macro_rules! key {
             ($key_name:ident) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
-                obj.find(name.index(&FullRange)).map(|o| o.as_string()
+                obj.find(&name[]).map(|o| o.as_string()
                                     .map(|s| base.options.$key_name = s.to_string()));
             } );
             ($key_name:ident, bool) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
-                obj.find(name.index(&FullRange))
+                obj.find(&name[])
                     .map(|o| o.as_boolean()
                          .map(|s| base.options.$key_name = s));
             } );
             ($key_name:ident, list) => ( {
                 let name = (stringify!($key_name)).replace("_", "-");
-                obj.find(name.index(&FullRange)).map(|o| o.as_array()
+                obj.find(&name[]).map(|o| o.as_array()
                     .map(|v| base.options.$key_name = v.iter()
                         .map(|a| a.as_string().unwrap().to_string()).collect()
                         )
@@ -369,7 +368,7 @@ impl Target {
 
         let target_path = os::getenv("RUST_TARGET_PATH").unwrap_or(String::new());
 
-        let paths = os::split_paths(target_path.index(&FullRange));
+        let paths = os::split_paths(&target_path[]);
         // FIXME 16351: add a sane default search path?
 
         for dir in paths.iter() {
diff --git a/src/librustc_back/target/x86_64_apple_darwin.rs b/src/librustc_back/target/x86_64_apple_darwin.rs
index 07e6cdfed2c67..0ebd3bd321583 100644
--- a/src/librustc_back/target/x86_64_apple_darwin.rs
+++ b/src/librustc_back/target/x86_64_apple_darwin.rs
@@ -21,7 +21,7 @@ pub fn target() -> Target {
                       s0:64:64-f80:128:128-n8:16:32:64".to_string(),
         llvm_target: "x86_64-apple-darwin".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "x86_64".to_string(),
         target_os: "macos".to_string(),
         options: base,
diff --git a/src/librustc_back/target/x86_64_pc_windows_gnu.rs b/src/librustc_back/target/x86_64_pc_windows_gnu.rs
index 6ca74eb7fc07d..9e1294a89625f 100644
--- a/src/librustc_back/target/x86_64_pc_windows_gnu.rs
+++ b/src/librustc_back/target/x86_64_pc_windows_gnu.rs
@@ -23,7 +23,7 @@ pub fn target() -> Target {
                       s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(),
         llvm_target: "x86_64-pc-windows-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "x86_64".to_string(),
         target_os: "windows".to_string(),
         options: base,
diff --git a/src/librustc_back/target/x86_64_unknown_dragonfly.rs b/src/librustc_back/target/x86_64_unknown_dragonfly.rs
index bff3eaf6bc8fa..6635306b0e193 100644
--- a/src/librustc_back/target/x86_64_unknown_dragonfly.rs
+++ b/src/librustc_back/target/x86_64_unknown_dragonfly.rs
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                      s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(),
         llvm_target: "x86_64-unknown-dragonfly".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "x86_64".to_string(),
         target_os: "dragonfly".to_string(),
         options: base,
diff --git a/src/librustc_back/target/x86_64_unknown_freebsd.rs b/src/librustc_back/target/x86_64_unknown_freebsd.rs
index 8d5603a3878db..2aba2b8defbdc 100644
--- a/src/librustc_back/target/x86_64_unknown_freebsd.rs
+++ b/src/librustc_back/target/x86_64_unknown_freebsd.rs
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                      s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(),
         llvm_target: "x86_64-unknown-freebsd".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "x86_64".to_string(),
         target_os: "freebsd".to_string(),
         options: base,
diff --git a/src/librustc_back/target/x86_64_unknown_linux_gnu.rs b/src/librustc_back/target/x86_64_unknown_linux_gnu.rs
index e0a67cd62504c..d7a6df3a8b0be 100644
--- a/src/librustc_back/target/x86_64_unknown_linux_gnu.rs
+++ b/src/librustc_back/target/x86_64_unknown_linux_gnu.rs
@@ -20,7 +20,7 @@ pub fn target() -> Target {
                       s0:64:64-f80:128:128-n8:16:32:64-S128".to_string(),
         llvm_target: "x86_64-unknown-linux-gnu".to_string(),
         target_endian: "little".to_string(),
-        target_word_size: "64".to_string(),
+        target_pointer_width: "64".to_string(),
         arch: "x86_64".to_string(),
         target_os: "linux".to_string(),
         options: base,
diff --git a/src/librustc_borrowck/borrowck/check_loans.rs b/src/librustc_borrowck/borrowck/check_loans.rs
index d942581ca62f2..d5ad201eabfaa 100644
--- a/src/librustc_borrowck/borrowck/check_loans.rs
+++ b/src/librustc_borrowck/borrowck/check_loans.rs
@@ -463,38 +463,38 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 (ty::MutBorrow, ty::MutBorrow) => {
                     self.bccx.span_err(
                         new_loan.span,
-                        format!("cannot borrow `{}`{} as mutable \
+                        &format!("cannot borrow `{}`{} as mutable \
                                 more than once at a time",
-                                nl, new_loan_msg).index(&FullRange))
+                                nl, new_loan_msg)[])
                 }
 
                 (ty::UniqueImmBorrow, _) => {
                     self.bccx.span_err(
                         new_loan.span,
-                        format!("closure requires unique access to `{}` \
+                        &format!("closure requires unique access to `{}` \
                                 but {} is already borrowed{}",
-                                nl, ol_pronoun, old_loan_msg).index(&FullRange));
+                                nl, ol_pronoun, old_loan_msg)[]);
                 }
 
                 (_, ty::UniqueImmBorrow) => {
                     self.bccx.span_err(
                         new_loan.span,
-                        format!("cannot borrow `{}`{} as {} because \
+                        &format!("cannot borrow `{}`{} as {} because \
                                 previous closure requires unique access",
-                                nl, new_loan_msg, new_loan.kind.to_user_str()).index(&FullRange));
+                                nl, new_loan_msg, new_loan.kind.to_user_str())[]);
                 }
 
                 (_, _) => {
                     self.bccx.span_err(
                         new_loan.span,
-                        format!("cannot borrow `{}`{} as {} because \
+                        &format!("cannot borrow `{}`{} as {} because \
                                 {} is also borrowed as {}{}",
                                 nl,
                                 new_loan_msg,
                                 new_loan.kind.to_user_str(),
                                 ol_pronoun,
                                 old_loan.kind.to_user_str(),
-                                old_loan_msg).index(&FullRange));
+                                old_loan_msg)[]);
                 }
             }
 
@@ -502,8 +502,8 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 euv::ClosureCapture(span) => {
                     self.bccx.span_note(
                         span,
-                        format!("borrow occurs due to use of `{}` in closure",
-                                nl).index(&FullRange));
+                        &format!("borrow occurs due to use of `{}` in closure",
+                                nl)[]);
                 }
                 _ => { }
             }
@@ -552,7 +552,7 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
 
             self.bccx.span_note(
                 old_loan.span,
-                format!("{}; {}", borrow_summary, rule_summary).index(&FullRange));
+                &format!("{}; {}", borrow_summary, rule_summary)[]);
 
             let old_loan_span = self.tcx().map.span(old_loan.kill_scope.node_id());
             self.bccx.span_end_note(old_loan_span,
@@ -621,14 +621,14 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
             UseWhileBorrowed(loan_path, loan_span) => {
                 self.bccx.span_err(
                     span,
-                    format!("cannot use `{}` because it was mutably borrowed",
-                            self.bccx.loan_path_to_string(copy_path).index(&FullRange))
-                    .index(&FullRange));
+                    &format!("cannot use `{}` because it was mutably borrowed",
+                            &self.bccx.loan_path_to_string(copy_path)[])
+                    []);
                 self.bccx.span_note(
                     loan_span,
-                    format!("borrow of `{}` occurs here",
-                            self.bccx.loan_path_to_string(&*loan_path).index(&FullRange))
-                    .index(&FullRange));
+                    &format!("borrow of `{}` occurs here",
+                            &self.bccx.loan_path_to_string(&*loan_path)[])
+                    []);
             }
         }
     }
@@ -647,20 +647,20 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 let err_message = match move_kind {
                     move_data::Captured =>
                         format!("cannot move `{}` into closure because it is borrowed",
-                                self.bccx.loan_path_to_string(move_path).index(&FullRange)),
+                                &self.bccx.loan_path_to_string(move_path)[]),
                     move_data::Declared |
                     move_data::MoveExpr |
                     move_data::MovePat =>
                         format!("cannot move out of `{}` because it is borrowed",
-                                self.bccx.loan_path_to_string(move_path).index(&FullRange))
+                                &self.bccx.loan_path_to_string(move_path)[])
                 };
 
-                self.bccx.span_err(span, err_message.index(&FullRange));
+                self.bccx.span_err(span, &err_message[]);
                 self.bccx.span_note(
                     loan_span,
-                    format!("borrow of `{}` occurs here",
-                            self.bccx.loan_path_to_string(&*loan_path).index(&FullRange))
-                    .index(&FullRange));
+                    &format!("borrow of `{}` occurs here",
+                            &self.bccx.loan_path_to_string(&*loan_path)[])
+                    []);
             }
         }
     }
@@ -809,34 +809,34 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                 if kind == ty::FnUnboxedClosureKind {
                     self.bccx.span_err(
                         assignment_span,
-                        format!("cannot assign to {}",
-                                self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
+                        &format!("cannot assign to {}",
+                                self.bccx.cmt_to_string(&*assignee_cmt))[]);
                     self.bccx.span_help(
                         self.tcx().map.span(upvar_id.closure_expr_id),
                         "consider changing this closure to take self by mutable reference");
                 } else {
                     self.bccx.span_err(
                         assignment_span,
-                        format!("cannot assign to {} {}",
+                        &format!("cannot assign to {} {}",
                                 assignee_cmt.mutbl.to_user_str(),
-                                self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
+                                self.bccx.cmt_to_string(&*assignee_cmt))[]);
                 }
             }
             _ => match opt_loan_path(&assignee_cmt) {
                 Some(lp) => {
                     self.bccx.span_err(
                         assignment_span,
-                        format!("cannot assign to {} {} `{}`",
+                        &format!("cannot assign to {} {} `{}`",
                                 assignee_cmt.mutbl.to_user_str(),
                                 self.bccx.cmt_to_string(&*assignee_cmt),
-                                self.bccx.loan_path_to_string(&*lp)).index(&FullRange));
+                                self.bccx.loan_path_to_string(&*lp))[]);
                 }
                 None => {
                     self.bccx.span_err(
                         assignment_span,
-                        format!("cannot assign to {} {}",
+                        &format!("cannot assign to {} {}",
                                 assignee_cmt.mutbl.to_user_str(),
-                                self.bccx.cmt_to_string(&*assignee_cmt)).index(&FullRange));
+                                self.bccx.cmt_to_string(&*assignee_cmt))[]);
                 }
             }
         }
@@ -955,11 +955,11 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
                                    loan: &Loan) {
         self.bccx.span_err(
             span,
-            format!("cannot assign to `{}` because it is borrowed",
-                    self.bccx.loan_path_to_string(loan_path)).index(&FullRange));
+            &format!("cannot assign to `{}` because it is borrowed",
+                    self.bccx.loan_path_to_string(loan_path))[]);
         self.bccx.span_note(
             loan.span,
-            format!("borrow of `{}` occurs here",
-                    self.bccx.loan_path_to_string(loan_path)).index(&FullRange));
+            &format!("borrow of `{}` occurs here",
+                    self.bccx.loan_path_to_string(loan_path))[]);
     }
 }
diff --git a/src/librustc_borrowck/borrowck/fragments.rs b/src/librustc_borrowck/borrowck/fragments.rs
index d752748746589..1b12020821771 100644
--- a/src/librustc_borrowck/borrowck/fragments.rs
+++ b/src/librustc_borrowck/borrowck/fragments.rs
@@ -38,7 +38,7 @@ enum Fragment {
     // This represents the collection of all but one of the elements
     // from an array at the path described by the move path index.
     // Note that attached MovePathIndex should have mem_categorization
-    // of InteriorElement (i.e. array dereference `.index(&FullRange)`).
+    // of InteriorElement (i.e. array dereference `&foo[]`).
     AllButOneFrom(MovePathIndex),
 }
 
@@ -123,12 +123,12 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
         let attrs : &[ast::Attribute];
         attrs = match tcx.map.find(id) {
             Some(ast_map::NodeItem(ref item)) =>
-                item.attrs.index(&FullRange),
+                &item.attrs[],
             Some(ast_map::NodeImplItem(&ast::MethodImplItem(ref m))) =>
-                m.attrs.index(&FullRange),
+                &m.attrs[],
             Some(ast_map::NodeTraitItem(&ast::ProvidedMethod(ref m))) =>
-                m.attrs.index(&FullRange),
-            _ => [].index(&FullRange),
+                &m.attrs[],
+            _ => &[][],
         };
 
         let span_err =
@@ -144,7 +144,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
         for (i, mpi) in vec_rc.iter().enumerate() {
             let render = |&:| this.path_loan_path(*mpi).user_string(tcx);
             if span_err {
-                tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange));
+                tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render())[]);
             }
             if print {
                 println!("id:{} {}[{}] `{}`", id, kind, i, render());
@@ -156,7 +156,7 @@ pub fn instrument_move_fragments<'tcx>(this: &MoveData<'tcx>,
         for (i, f) in vec_rc.iter().enumerate() {
             let render = |&:| f.loan_path_user_string(this, tcx);
             if span_err {
-                tcx.sess.span_err(sp, format!("{}: `{}`", kind, render()).index(&FullRange));
+                tcx.sess.span_err(sp, &format!("{}: `{}`", kind, render())[]);
             }
             if print {
                 println!("id:{} {}[{}] `{}`", id, kind, i, render());
@@ -198,11 +198,11 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
     // First, filter out duplicates
     moved.sort();
     moved.dedup();
-    debug!("fragments 1 moved: {:?}", path_lps(moved.index(&FullRange)));
+    debug!("fragments 1 moved: {:?}", path_lps(&moved[]));
 
     assigned.sort();
     assigned.dedup();
-    debug!("fragments 1 assigned: {:?}", path_lps(assigned.index(&FullRange)));
+    debug!("fragments 1 assigned: {:?}", path_lps(&assigned[]));
 
     // Second, build parents from the moved and assigned.
     for m in moved.iter() {
@@ -222,14 +222,14 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
 
     parents.sort();
     parents.dedup();
-    debug!("fragments 2 parents: {:?}", path_lps(parents.index(&FullRange)));
+    debug!("fragments 2 parents: {:?}", path_lps(&parents[]));
 
     // Third, filter the moved and assigned fragments down to just the non-parents
-    moved.retain(|f| non_member(*f, parents.index(&FullRange)));
-    debug!("fragments 3 moved: {:?}", path_lps(moved.index(&FullRange)));
+    moved.retain(|f| non_member(*f, &parents[]));
+    debug!("fragments 3 moved: {:?}", path_lps(&moved[]));
 
-    assigned.retain(|f| non_member(*f, parents.index(&FullRange)));
-    debug!("fragments 3 assigned: {:?}", path_lps(assigned.index(&FullRange)));
+    assigned.retain(|f| non_member(*f, &parents[]));
+    debug!("fragments 3 assigned: {:?}", path_lps(&assigned[]));
 
     // Fourth, build the leftover from the moved, assigned, and parents.
     for m in moved.iter() {
@@ -247,16 +247,16 @@ pub fn fixup_fragment_sets<'tcx>(this: &MoveData<'tcx>, tcx: &ty::ctxt<'tcx>) {
 
     unmoved.sort();
     unmoved.dedup();
-    debug!("fragments 4 unmoved: {:?}", frag_lps(unmoved.index(&FullRange)));
+    debug!("fragments 4 unmoved: {:?}", frag_lps(&unmoved[]));
 
     // Fifth, filter the leftover fragments down to its core.
     unmoved.retain(|f| match *f {
         AllButOneFrom(_) => true,
-        Just(mpi) => non_member(mpi, parents.index(&FullRange)) &&
-            non_member(mpi, moved.index(&FullRange)) &&
-            non_member(mpi, assigned.index(&FullRange))
+        Just(mpi) => non_member(mpi, &parents[]) &&
+            non_member(mpi, &moved[]) &&
+            non_member(mpi, &assigned[])
     });
-    debug!("fragments 5 unmoved: {:?}", frag_lps(unmoved.index(&FullRange)));
+    debug!("fragments 5 unmoved: {:?}", frag_lps(&unmoved[]));
 
     // Swap contents back in.
     fragments.unmoved_fragments = unmoved;
@@ -433,7 +433,7 @@ fn add_fragment_siblings_for_extension<'tcx>(this: &MoveData<'tcx>,
             let msg = format!("type {} ({:?}) is not fragmentable",
                               parent_ty.repr(tcx), sty_and_variant_info);
             let opt_span = origin_id.and_then(|id|tcx.map.opt_span(id));
-            tcx.sess.opt_span_bug(opt_span, msg.index(&FullRange))
+            tcx.sess.opt_span_bug(opt_span, &msg[])
         }
     }
 }
diff --git a/src/librustc_borrowck/borrowck/gather_loans/mod.rs b/src/librustc_borrowck/borrowck/gather_loans/mod.rs
index 2c48e0da01d77..889a359b019cd 100644
--- a/src/librustc_borrowck/borrowck/gather_loans/mod.rs
+++ b/src/librustc_borrowck/borrowck/gather_loans/mod.rs
@@ -306,8 +306,8 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
                     ty::ReInfer(..) => {
                         self.tcx().sess.span_bug(
                             cmt.span,
-                            format!("invalid borrow lifetime: {:?}",
-                                    loan_region).index(&FullRange));
+                            &format!("invalid borrow lifetime: {:?}",
+                                    loan_region)[]);
                     }
                 };
                 debug!("loan_scope = {:?}", loan_scope);
diff --git a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
index 1bb143e1dc8d3..a7771fefec412 100644
--- a/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
+++ b/src/librustc_borrowck/borrowck/gather_loans/move_error.rs
@@ -119,8 +119,8 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
         mc::cat_static_item => {
             bccx.span_err(
                 move_from.span,
-                format!("cannot move out of {}",
-                        bccx.cmt_to_string(&*move_from)).index(&FullRange));
+                &format!("cannot move out of {}",
+                        bccx.cmt_to_string(&*move_from))[]);
         }
 
         mc::cat_downcast(ref b, _) |
@@ -130,9 +130,9 @@ fn report_cannot_move_out_of<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
                 | ty::ty_enum(did, _) if ty::has_dtor(bccx.tcx, did) => {
                     bccx.span_err(
                         move_from.span,
-                        format!("cannot move out of type `{}`, \
+                        &format!("cannot move out of type `{}`, \
                                  which defines the `Drop` trait",
-                                b.ty.user_string(bccx.tcx)).index(&FullRange));
+                                b.ty.user_string(bccx.tcx))[]);
                 },
                 _ => panic!("this path should not cause illegal move")
             }
@@ -152,13 +152,13 @@ fn note_move_destination(bccx: &BorrowckCtxt,
             "attempting to move value to here");
         bccx.span_help(
             move_to_span,
-            format!("to prevent the move, \
+            &format!("to prevent the move, \
                      use `ref {0}` or `ref mut {0}` to capture value by \
                      reference",
-                    pat_name).index(&FullRange));
+                    pat_name)[]);
     } else {
         bccx.span_note(move_to_span,
-                       format!("and here (use `ref {0}` or `ref mut {0}`)",
-                               pat_name).index(&FullRange));
+                       &format!("and here (use `ref {0}` or `ref mut {0}`)",
+                               pat_name)[]);
     }
 }
diff --git a/src/librustc_borrowck/borrowck/mod.rs b/src/librustc_borrowck/borrowck/mod.rs
index 88f56f6862218..e734e8fb6ffb7 100644
--- a/src/librustc_borrowck/borrowck/mod.rs
+++ b/src/librustc_borrowck/borrowck/mod.rs
@@ -137,7 +137,7 @@ fn borrowck_fn(this: &mut BorrowckCtxt,
     check_loans::check_loans(this,
                              &loan_dfcx,
                              flowed_moves,
-                             all_loans.index(&FullRange),
+                             &all_loans[],
                              id,
                              decl,
                              body);
@@ -505,7 +505,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
     pub fn report(&self, err: BckError<'tcx>) {
         self.span_err(
             err.span,
-            self.bckerr_to_string(&err).index(&FullRange));
+            &self.bckerr_to_string(&err)[]);
         self.note_and_explain_bckerr(err);
     }
 
@@ -525,9 +525,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             move_data::Declared => {
                 self.tcx.sess.span_err(
                     use_span,
-                    format!("{} of possibly uninitialized variable: `{}`",
+                    &format!("{} of possibly uninitialized variable: `{}`",
                             verb,
-                            self.loan_path_to_string(lp)).index(&FullRange));
+                            self.loan_path_to_string(lp))[]);
                 (self.loan_path_to_string(moved_lp),
                  String::new())
             }
@@ -566,10 +566,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                           else { "" };
                 self.tcx.sess.span_err(
                     use_span,
-                    format!("{} of {}moved value: `{}`",
+                    &format!("{} of {}moved value: `{}`",
                             verb,
                             msg,
-                            nl).index(&FullRange));
+                            nl)[]);
                 (ol, moved_lp_msg)
             }
         };
@@ -585,32 +585,32 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span)
                     }
                     r => {
-                        self.tcx.sess.bug(format!("MoveExpr({}) maps to \
+                        self.tcx.sess.bug(&format!("MoveExpr({}) maps to \
                                                    {:?}, not Expr",
                                                   the_move.id,
-                                                  r).index(&FullRange))
+                                                  r)[])
                     }
                 };
                 let (suggestion, _) =
                     move_suggestion(param_env, expr_span, expr_ty, ("moved by default", ""));
                 self.tcx.sess.span_note(
                     expr_span,
-                    format!("`{}` moved here{} because it has type `{}`, which is {}",
+                    &format!("`{}` moved here{} because it has type `{}`, which is {}",
                             ol,
                             moved_lp_msg,
                             expr_ty.user_string(self.tcx),
-                            suggestion).index(&FullRange));
+                            suggestion)[]);
             }
 
             move_data::MovePat => {
                 let pat_ty = ty::node_id_to_type(self.tcx, the_move.id);
                 let span = self.tcx.map.span(the_move.id);
                 self.tcx.sess.span_note(span,
-                    format!("`{}` moved here{} because it has type `{}`, \
+                    &format!("`{}` moved here{} because it has type `{}`, \
                              which is moved by default",
                             ol,
                             moved_lp_msg,
-                            pat_ty.user_string(self.tcx)).index(&FullRange));
+                            pat_ty.user_string(self.tcx))[]);
                 self.tcx.sess.span_help(span,
                     "use `ref` to override");
             }
@@ -623,10 +623,10 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                         (ty::expr_ty_adjusted(self.tcx, &*expr), expr.span)
                     }
                     r => {
-                        self.tcx.sess.bug(format!("Captured({}) maps to \
+                        self.tcx.sess.bug(&format!("Captured({}) maps to \
                                                    {:?}, not Expr",
                                                   the_move.id,
-                                                  r).index(&FullRange))
+                                                  r)[])
                     }
                 };
                 let (suggestion, help) =
@@ -637,12 +637,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                                      "make a copy and capture that instead to override"));
                 self.tcx.sess.span_note(
                     expr_span,
-                    format!("`{}` moved into closure environment here{} because it \
+                    &format!("`{}` moved into closure environment here{} because it \
                             has type `{}`, which is {}",
                             ol,
                             moved_lp_msg,
                             expr_ty.user_string(self.tcx),
-                            suggestion).index(&FullRange));
+                            suggestion)[]);
                 self.tcx.sess.span_help(expr_span, help);
             }
         }
@@ -672,8 +672,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                                                 &move_data::Assignment) {
         self.tcx.sess.span_err(
             span,
-            format!("re-assignment of immutable variable `{}`",
-                    self.loan_path_to_string(lp)).index(&FullRange));
+            &format!("re-assignment of immutable variable `{}`",
+                    self.loan_path_to_string(lp))[]);
         self.tcx.sess.span_note(assign.span, "prior assignment occurs here");
     }
 
@@ -798,8 +798,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             mc::AliasableOther => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("{} in an aliasable location",
-                             prefix).index(&FullRange));
+                    &format!("{} in an aliasable location",
+                             prefix)[]);
             }
             mc::AliasableClosure(id) => {
                 self.tcx.sess.span_err(span,
@@ -812,12 +812,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
             mc::AliasableStaticMut(..) => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("{} in a static location", prefix).index(&FullRange));
+                    &format!("{} in a static location", prefix)[]);
             }
             mc::AliasableBorrowed => {
                 self.tcx.sess.span_err(
                     span,
-                    format!("{} in a `&` reference", prefix).index(&FullRange));
+                    &format!("{} in a `&` reference", prefix)[]);
             }
         }
 
@@ -884,13 +884,13 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                 };
                 note_and_explain_region(
                     self.tcx,
-                    format!("{} would have to be valid for ",
-                            descr).index(&FullRange),
+                    &format!("{} would have to be valid for ",
+                            descr)[],
                     loan_scope,
                     "...");
                 note_and_explain_region(
                     self.tcx,
-                    format!("...but {} is only valid for ", descr).index(&FullRange),
+                    &format!("...but {} is only valid for ", descr)[],
                     ptr_scope,
                     "");
             }
@@ -910,7 +910,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                 out.push('(');
                 self.append_loan_path_to_string(&**lp_base, out);
                 out.push_str(DOWNCAST_PRINTED_OPERATOR);
-                out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange));
+                out.push_str(&ty::item_path_str(self.tcx, variant_def_id)[]);
                 out.push(')');
             }
 
@@ -924,7 +924,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                     }
                     mc::PositionalField(idx) => {
                         out.push('.');
-                        out.push_str(idx.to_string().index(&FullRange));
+                        out.push_str(&idx.to_string()[]);
                     }
                 }
             }
@@ -956,7 +956,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
                 out.push('(');
                 self.append_autoderefd_loan_path_to_string(&**lp_base, out);
                 out.push(':');
-                out.push_str(ty::item_path_str(self.tcx, variant_def_id).index(&FullRange));
+                out.push_str(&ty::item_path_str(self.tcx, variant_def_id)[]);
                 out.push(')');
             }
 
diff --git a/src/librustc_borrowck/graphviz.rs b/src/librustc_borrowck/graphviz.rs
index 647a5dd559c1d..20ad1307da3e2 100644
--- a/src/librustc_borrowck/graphviz.rs
+++ b/src/librustc_borrowck/graphviz.rs
@@ -60,7 +60,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> {
             if seen_one { sets.push_str(" "); } else { seen_one = true; }
             sets.push_str(variant.short_name());
             sets.push_str(": ");
-            sets.push_str(self.dataflow_for_variant(e, n, variant).index(&FullRange));
+            sets.push_str(&self.dataflow_for_variant(e, n, variant)[]);
         }
         sets
     }
@@ -89,7 +89,7 @@ impl<'a, 'tcx> DataflowLabeller<'a, 'tcx> {
                 set.push_str(", ");
             }
             let loan_str = self.borrowck_ctxt.loan_path_to_string(&*lp);
-            set.push_str(loan_str.index(&FullRange));
+            set.push_str(&loan_str[]);
             saw_some = true;
             true
         });
diff --git a/src/librustc_borrowck/lib.rs b/src/librustc_borrowck/lib.rs
index 26bcd5f4c10cd..452eaaaa52dab 100644
--- a/src/librustc_borrowck/lib.rs
+++ b/src/librustc_borrowck/lib.rs
@@ -10,6 +10,7 @@
 
 #![crate_name = "rustc_borrowck"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index 52d49924d05d5..019691c1e1027 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -58,12 +58,12 @@ pub fn compile_input(sess: Session,
             let outputs = build_output_filenames(input,
                                                  outdir,
                                                  output,
-                                                 krate.attrs.index(&FullRange),
+                                                 &krate.attrs[],
                                                  &sess);
-            let id = link::find_crate_name(Some(&sess), krate.attrs.index(&FullRange),
+            let id = link::find_crate_name(Some(&sess), &krate.attrs[],
                                            input);
             let expanded_crate
-                = match phase_2_configure_and_expand(&sess, krate, id.index(&FullRange),
+                = match phase_2_configure_and_expand(&sess, krate, &id[],
                                                      addl_plugins) {
                     None => return,
                     Some(k) => k
@@ -75,7 +75,7 @@ pub fn compile_input(sess: Session,
         let mut forest = ast_map::Forest::new(expanded_crate);
         let ast_map = assign_node_ids_and_map(&sess, &mut forest);
 
-        write_out_deps(&sess, input, &outputs, id.index(&FullRange));
+        write_out_deps(&sess, input, &outputs, &id[]);
 
         if stop_after_phase_2(&sess) { return; }
 
@@ -171,9 +171,9 @@ pub fn phase_2_configure_and_expand(sess: &Session,
     let time_passes = sess.time_passes();
 
     *sess.crate_types.borrow_mut() =
-        collect_crate_types(sess, krate.attrs.index(&FullRange));
+        collect_crate_types(sess, &krate.attrs[]);
     *sess.crate_metadata.borrow_mut() =
-        collect_crate_metadata(sess, krate.attrs.index(&FullRange));
+        collect_crate_metadata(sess, &krate.attrs[]);
 
     time(time_passes, "recursion limit", (), |_| {
         middle::recursion_limit::update_recursion_limit(sess, &krate);
@@ -268,8 +268,8 @@ pub fn phase_2_configure_and_expand(sess: &Session,
             if cfg!(windows) {
                 _old_path = os::getenv("PATH").unwrap_or(_old_path);
                 let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths();
-                new_path.extend(os::split_paths(_old_path.index(&FullRange)).into_iter());
-                os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap());
+                new_path.extend(os::split_paths(&_old_path[]).into_iter());
+                os::setenv("PATH", os::join_paths(&new_path[]).unwrap());
             }
             let cfg = syntax::ext::expand::ExpansionConfig {
                 crate_name: crate_name.to_string(),
@@ -533,7 +533,7 @@ pub fn phase_5_run_llvm_passes(sess: &Session,
         time(sess.time_passes(), "LLVM passes", (), |_|
             write::run_passes(sess,
                               trans,
-                              sess.opts.output_types.index(&FullRange),
+                              &sess.opts.output_types[],
                               outputs));
     }
 
@@ -547,14 +547,14 @@ pub fn phase_6_link_output(sess: &Session,
                            outputs: &OutputFilenames) {
     let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
     let mut new_path = sess.host_filesearch(PathKind::All).get_tools_search_paths();
-    new_path.extend(os::split_paths(old_path.index(&FullRange)).into_iter());
-    os::setenv("PATH", os::join_paths(new_path.index(&FullRange)).unwrap());
+    new_path.extend(os::split_paths(&old_path[]).into_iter());
+    os::setenv("PATH", os::join_paths(&new_path[]).unwrap());
 
     time(sess.time_passes(), "linking", (), |_|
          link::link_binary(sess,
                            trans,
                            outputs,
-                           trans.link.crate_name.index(&FullRange)));
+                           &trans.link.crate_name[]));
 
     os::setenv("PATH", old_path);
 }
@@ -643,7 +643,7 @@ fn write_out_deps(sess: &Session,
         // write Makefile-compatible dependency rules
         let files: Vec<String> = sess.codemap().files.borrow()
                                    .iter().filter(|fmap| fmap.is_real_file())
-                                   .map(|fmap| escape_dep_filename(fmap.name.index(&FullRange)))
+                                   .map(|fmap| escape_dep_filename(&fmap.name[]))
                                    .collect();
         let mut file = try!(io::File::create(&deps_filename));
         for path in out_filenames.iter() {
@@ -656,8 +656,8 @@ fn write_out_deps(sess: &Session,
     match result {
         Ok(()) => {}
         Err(e) => {
-            sess.fatal(format!("error writing dependencies to `{}`: {}",
-                               deps_filename.display(), e).index(&FullRange));
+            sess.fatal(&format!("error writing dependencies to `{}`: {}",
+                               deps_filename.display(), e)[]);
         }
     }
 }
@@ -726,9 +726,9 @@ pub fn collect_crate_types(session: &Session,
         let res = !link::invalid_output_for_target(session, *crate_type);
 
         if !res {
-            session.warn(format!("dropping unsupported crate type `{:?}` \
+            session.warn(&format!("dropping unsupported crate type `{:?}` \
                                    for target `{}`",
-                                 *crate_type, session.opts.target_triple).index(&FullRange));
+                                 *crate_type, session.opts.target_triple)[]);
         }
 
         res
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index 5af114abeea77..27e1eaacdfd99 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -16,14 +16,17 @@
 
 #![crate_name = "rustc_driver"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
+#![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 
 extern crate arena;
@@ -46,7 +49,7 @@ pub use syntax::diagnostic;
 
 use rustc_trans::back::link;
 use rustc::session::{config, Session, build_session};
-use rustc::session::config::{Input, PrintRequest};
+use rustc::session::config::{Input, PrintRequest, UnstableFeatures};
 use rustc::lint::Lint;
 use rustc::lint;
 use rustc::metadata;
@@ -89,12 +92,12 @@ fn run_compiler(args: &[String]) {
     let descriptions = diagnostics::registry::Registry::new(&DIAGNOSTICS);
     match matches.opt_str("explain") {
         Some(ref code) => {
-            match descriptions.find_description(code.index(&FullRange)) {
+            match descriptions.find_description(&code[]) {
                 Some(ref description) => {
                     println!("{}", description);
                 }
                 None => {
-                    early_error(format!("no extended information for {}", code).index(&FullRange));
+                    early_error(&format!("no extended information for {}", code)[]);
                 }
             }
             return;
@@ -120,7 +123,7 @@ fn run_compiler(args: &[String]) {
             early_error("no input filename given");
         }
         1u => {
-            let ifile = matches.free[0].index(&FullRange);
+            let ifile = &matches.free[0][];
             if ifile == "-" {
                 let contents = io::stdin().read_to_end().unwrap();
                 let src = String::from_utf8(contents).unwrap();
@@ -132,7 +135,11 @@ fn run_compiler(args: &[String]) {
         _ => early_error("multiple input filenames provided")
     };
 
+    let mut sopts = sopts;
+    sopts.unstable_features = get_unstable_features_setting();
+
     let mut sess = build_session(sopts, input_file_path, descriptions);
+
     let cfg = config::build_configuration(&sess);
     if print_crate_info(&sess, Some(&input), &odir, &ofile) {
         return
@@ -181,6 +188,21 @@ fn run_compiler(args: &[String]) {
     driver::compile_input(sess, cfg, &input, &odir, &ofile, None);
 }
 
+pub fn get_unstable_features_setting() -> UnstableFeatures {
+    // Whether this is a feature-staged build, i.e. on the beta or stable channel
+    let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
+    // The secret key needed to get through the rustc build itself by
+    // subverting the unstable features lints
+    let bootstrap_secret_key = option_env!("CFG_BOOTSTRAP_KEY");
+    // The matching key to the above, only known by the build system
+    let bootstrap_provided_key = os::getenv("RUSTC_BOOTSTRAP_KEY");
+    match (disable_unstable_features, bootstrap_secret_key, bootstrap_provided_key) {
+        (_, Some(ref s), Some(ref p)) if s == p => UnstableFeatures::Cheat,
+        (true, _, _) => UnstableFeatures::Disallow,
+        (false, _, _) => UnstableFeatures::Default
+    }
+}
+
 /// Returns a version string such as "0.12.0-dev".
 pub fn release_str() -> Option<&'static str> {
     option_env!("CFG_RELEASE")
@@ -297,7 +319,7 @@ Available lint options:
         for lint in lints.into_iter() {
             let name = lint.name_lower().replace("_", "-");
             println!("    {}  {:7.7}  {}",
-                     padded(name.index(&FullRange)), lint.default_level.as_str(), lint.desc);
+                     padded(&name[]), lint.default_level.as_str(), lint.desc);
         }
         println!("\n");
     };
@@ -327,7 +349,7 @@ Available lint options:
             let desc = to.into_iter().map(|x| x.as_str().replace("_", "-"))
                          .collect::<Vec<String>>().connect(", ");
             println!("    {}  {}",
-                     padded(name.index(&FullRange)), desc);
+                     padded(&name[]), desc);
         }
         println!("\n");
     };
@@ -393,7 +415,7 @@ pub fn handle_options(mut args: Vec<String>) -> Option<getopts::Matches> {
     }
 
     let matches =
-        match getopts::getopts(args.index(&FullRange), config::optgroups().index(&FullRange)) {
+        match getopts::getopts(&args[], &config::optgroups()[]) {
             Ok(m) => m,
             Err(f_stable_attempt) => {
                 // redo option parsing, including unstable options this time,
@@ -567,15 +589,15 @@ pub fn monitor<F:FnOnce()+Send>(f: F) {
                     "run with `RUST_BACKTRACE=1` for a backtrace".to_string(),
                 ];
                 for note in xs.iter() {
-                    emitter.emit(None, note.index(&FullRange), None, diagnostic::Note)
+                    emitter.emit(None, &note[], None, diagnostic::Note)
                 }
 
                 match r.read_to_string() {
                     Ok(s) => println!("{}", s),
                     Err(e) => {
                         emitter.emit(None,
-                                     format!("failed to read internal \
-                                              stderr: {}", e).index(&FullRange),
+                                     &format!("failed to read internal \
+                                              stderr: {}", e)[],
                                      None,
                                      diagnostic::Error)
                     }
diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs
index 44a35ef6be70b..7592fbc05b338 100644
--- a/src/librustc_driver/pretty.rs
+++ b/src/librustc_driver/pretty.rs
@@ -294,9 +294,9 @@ impl<'tcx> pprust::PpAnn for TypedAnnotation<'tcx> {
                 try!(pp::word(&mut s.s, "as"));
                 try!(pp::space(&mut s.s));
                 try!(pp::word(&mut s.s,
-                              ppaux::ty_to_string(
+                              &ppaux::ty_to_string(
                                   tcx,
-                                  ty::expr_ty(tcx, expr)).index(&FullRange)));
+                                  ty::expr_ty(tcx, expr))[]));
                 s.pclose()
             }
             _ => Ok(())
@@ -350,8 +350,8 @@ impl<'a, 'ast> Iterator for NodesMatchingUII<'a, 'ast> {
 
     fn next(&mut self) -> Option<ast::NodeId> {
         match self {
-            &NodesMatchingDirect(ref mut iter) => iter.next(),
-            &NodesMatchingSuffix(ref mut iter) => iter.next(),
+            &mut NodesMatchingDirect(ref mut iter) => iter.next(),
+            &mut NodesMatchingSuffix(ref mut iter) => iter.next(),
         }
     }
 }
@@ -370,7 +370,7 @@ impl UserIdentifiedItem {
             ItemViaNode(node_id) =>
                 NodesMatchingDirect(Some(node_id).into_iter()),
             ItemViaPath(ref parts) =>
-                NodesMatchingSuffix(map.nodes_matching_suffix(parts.index(&FullRange))),
+                NodesMatchingSuffix(map.nodes_matching_suffix(&parts[])),
         }
     }
 
@@ -382,7 +382,7 @@ impl UserIdentifiedItem {
                         user_option,
                         self.reconstructed_input(),
                         is_wrong_because);
-            sess.fatal(message.index(&FullRange))
+            sess.fatal(&message[])
         };
 
         let mut saw_node = ast::DUMMY_NODE_ID;
@@ -509,7 +509,7 @@ pub fn pretty_print_input(sess: Session,
     let is_expanded = needs_expansion(&ppm);
     let compute_ast_map = needs_ast_map(&ppm, &opt_uii);
     let krate = if compute_ast_map {
-        match driver::phase_2_configure_and_expand(&sess, krate, id.index(&FullRange), None) {
+        match driver::phase_2_configure_and_expand(&sess, krate, &id[], None) {
             None => return,
             Some(k) => k
         }
@@ -528,7 +528,7 @@ pub fn pretty_print_input(sess: Session,
     };
 
     let src_name = driver::source_name(input);
-    let src = sess.codemap().get_filemap(src_name.index(&FullRange))
+    let src = sess.codemap().get_filemap(&src_name[])
                             .src.as_bytes().to_vec();
     let mut rdr = MemReader::new(src);
 
@@ -588,16 +588,16 @@ pub fn pretty_print_input(sess: Session,
         (PpmFlowGraph, opt_uii) => {
             debug!("pretty printing flow graph for {:?}", opt_uii);
             let uii = opt_uii.unwrap_or_else(|| {
-                sess.fatal(format!("`pretty flowgraph=..` needs NodeId (int) or
-                                     unique path suffix (b::c::d)").index(&FullRange))
+                sess.fatal(&format!("`pretty flowgraph=..` needs NodeId (int) or
+                                     unique path suffix (b::c::d)")[])
 
             });
             let ast_map = ast_map.expect("--pretty flowgraph missing ast_map");
             let nodeid = uii.to_one_node_id("--pretty", &sess, &ast_map);
 
             let node = ast_map.find(nodeid).unwrap_or_else(|| {
-                sess.fatal(format!("--pretty flowgraph couldn't find id: {}",
-                                   nodeid).index(&FullRange))
+                sess.fatal(&format!("--pretty flowgraph couldn't find id: {}",
+                                   nodeid)[])
             });
 
             let code = blocks::Code::from_node(node);
@@ -615,8 +615,8 @@ pub fn pretty_print_input(sess: Session,
                     // point to what was found, if there's an
                     // accessible span.
                     match ast_map.opt_span(nodeid) {
-                        Some(sp) => sess.span_fatal(sp, message.index(&FullRange)),
-                        None => sess.fatal(message.index(&FullRange))
+                        Some(sp) => sess.span_fatal(sp, &message[]),
+                        None => sess.fatal(&message[])
                     }
                 }
             }
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
index d301e9c7b5c27..a798ec9aaf760 100644
--- a/src/librustc_driver/test.rs
+++ b/src/librustc_driver/test.rs
@@ -61,7 +61,7 @@ fn remove_message(e: &mut ExpectErrorEmitter, msg: &str, lvl: Level) {
             e.messages.remove(i);
         }
         None => {
-            panic!("Unexpected error: {} Expected: {}",
+            panic!("Unexpected error: {} Expected: {:?}",
                   msg, e.messages);
         }
     }
@@ -279,7 +279,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> {
 
     pub fn t_param(&self, space: subst::ParamSpace, index: u32) -> Ty<'tcx> {
         let name = format!("T{}", index);
-        ty::mk_param(self.infcx.tcx, space, index, token::intern(name.index(&FullRange)))
+        ty::mk_param(self.infcx.tcx, space, index, token::intern(&name[]))
     }
 
     pub fn re_early_bound(&self,
diff --git a/src/librustc_llvm/lib.rs b/src/librustc_llvm/lib.rs
index 0bed754aa3c1b..4a281c413d6fc 100644
--- a/src/librustc_llvm/lib.rs
+++ b/src/librustc_llvm/lib.rs
@@ -15,13 +15,16 @@
 
 #![crate_name = "rustc_llvm"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(link_args)]
+#![feature(box_syntax)]
 
 extern crate libc;
 
diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs
index ca6b1469f8569..466bd608736ce 100644
--- a/src/librustc_resolve/build_reduced_graph.rs
+++ b/src/librustc_resolve/build_reduced_graph.rs
@@ -219,16 +219,16 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
                     // had the duplicate.
                     let ns = ns.unwrap();
                     self.resolve_error(sp,
-                        format!("duplicate definition of {} `{}`",
+                        &format!("duplicate definition of {} `{}`",
                              namespace_error_to_string(duplicate_type),
-                             token::get_name(name)).index(&FullRange));
+                             token::get_name(name))[]);
                     {
                         let r = child.span_for_namespace(ns);
                         for sp in r.iter() {
                             self.session.span_note(*sp,
-                                 format!("first definition of {} `{}` here",
+                                 &format!("first definition of {} `{}` here",
                                       namespace_error_to_string(duplicate_type),
-                                      token::get_name(name)).index(&FullRange));
+                                      token::get_name(name))[]);
                         }
                     }
                 }
@@ -1200,8 +1200,8 @@ impl<'a, 'b:'a, 'tcx:'b> GraphBuilder<'a, 'b, 'tcx> {
             SingleImport(target, _) => {
                 debug!("(building import directive) building import \
                         directive: {}::{}",
-                       self.names_to_string(module_.imports.borrow().last().unwrap()
-                                                 .module_path.index(&FullRange)),
+                       self.names_to_string(&module_.imports.borrow().last().unwrap().
+                                                             module_path[]),
                        token::get_name(target));
 
                 let mut import_resolutions = module_.import_resolutions
diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs
index 93ad69e03b17f..a1ae96490cad7 100644
--- a/src/librustc_resolve/lib.rs
+++ b/src/librustc_resolve/lib.rs
@@ -10,6 +10,7 @@
 
 #![crate_name = "rustc_resolve"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -1057,11 +1058,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     };
                     let msg = format!("unresolved import `{}`{}",
                                       self.import_path_to_string(
-                                          import_directive.module_path
-                                                          .index(&FullRange),
+                                          &import_directive.module_path[],
                                           import_directive.subclass),
                                       help);
-                    self.resolve_error(span, msg.index(&FullRange));
+                    self.resolve_error(span, &msg[]);
                 }
                 Indeterminate => break, // Bail out. We'll come around next time.
                 Success(()) => () // Good. Continue.
@@ -1091,7 +1091,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                         .iter()
                                         .map(|seg| seg.identifier.name)
                                         .collect();
-        self.names_to_string(names.index(&FullRange))
+        self.names_to_string(&names[])
     }
 
     fn import_directive_subclass_to_string(&mut self,
@@ -1155,7 +1155,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         let module_path = &import_directive.module_path;
 
         debug!("(resolving import for module) resolving import `{}::...` in `{}`",
-               self.names_to_string(module_path.index(&FullRange)),
+               self.names_to_string(&module_path[]),
                self.module_to_string(&*module_));
 
         // First, resolve the module path for the directive, if necessary.
@@ -1164,7 +1164,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Some((self.graph_root.get_module(), LastMod(AllPublic)))
         } else {
             match self.resolve_module_path(module_.clone(),
-                                           module_path.index(&FullRange),
+                                           &module_path[],
                                            DontUseLexicalScope,
                                            import_directive.span,
                                            ImportSearch) {
@@ -1761,7 +1761,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     ValueNS => "value",
                                   },
                                   token::get_name(name).get());
-                self.session.span_err(import_span, msg.index(&FullRange));
+                self.session.span_err(import_span, &msg[]);
             }
             Some(_) | None => {}
         }
@@ -1776,7 +1776,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if !name_bindings.defined_in_namespace_with(namespace, IMPORTABLE) {
             let msg = format!("`{}` is not directly importable",
                               token::get_name(name));
-            self.session.span_err(import_span, msg.index(&FullRange));
+            self.session.span_err(import_span, &msg[]);
         }
     }
 
@@ -1801,7 +1801,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                        crate in this module \
                                        (maybe you meant `use {0}::*`?)",
                                       token::get_name(name).get());
-                    self.session.span_err(import_span, msg.index(&FullRange));
+                    self.session.span_err(import_span, &msg[]);
                 }
                 Some(_) | None => {}
             }
@@ -1823,7 +1823,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     let msg = format!("import `{}` conflicts with value \
                                        in this module",
                                       token::get_name(name).get());
-                    self.session.span_err(import_span, msg.index(&FullRange));
+                    self.session.span_err(import_span, &msg[]);
                     if let Some(span) = value.value_span {
                         self.session.span_note(span,
                                                "conflicting value here");
@@ -1841,7 +1841,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                             let msg = format!("import `{}` conflicts with type in \
                                                this module",
                                               token::get_name(name).get());
-                            self.session.span_err(import_span, msg.index(&FullRange));
+                            self.session.span_err(import_span, &msg[]);
                             if let Some(span) = ty.type_span {
                                 self.session.span_note(span,
                                                        "note conflicting type here")
@@ -1854,7 +1854,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                         let msg = format!("inherent implementations \
                                                            are only allowed on types \
                                                            defined in the current module");
-                                        self.session.span_err(span, msg.index(&FullRange));
+                                        self.session.span_err(span, &msg[]);
                                         self.session.span_note(import_span,
                                                                "import from other module here")
                                     }
@@ -1863,7 +1863,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     let msg = format!("import `{}` conflicts with existing \
                                                        submodule",
                                                       token::get_name(name).get());
-                                    self.session.span_err(import_span, msg.index(&FullRange));
+                                    self.session.span_err(import_span, &msg[]);
                                     if let Some(span) = ty.type_span {
                                         self.session.span_note(span,
                                                                "note conflicting module here")
@@ -1891,9 +1891,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if module.external_module_children.borrow().contains_key(&name) {
             self.session
                 .span_err(span,
-                          format!("an external crate named `{}` has already \
+                          &format!("an external crate named `{}` has already \
                                    been imported into this module",
-                                  token::get_name(name).get()).index(&FullRange));
+                                  token::get_name(name).get())[]);
         }
     }
 
@@ -1909,10 +1909,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if module.external_module_children.borrow().contains_key(&name) {
             self.session
                 .span_err(span,
-                          format!("the name `{}` conflicts with an external \
+                          &format!("the name `{}` conflicts with an external \
                                    crate that has been imported into this \
                                    module",
-                                  token::get_name(name).get()).index(&FullRange));
+                                  token::get_name(name).get())[]);
         }
     }
 
@@ -1960,7 +1960,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     let segment_name = token::get_name(name);
                     let module_name = self.module_to_string(&*search_module);
                     let mut span = span;
-                    let msg = if "???" == module_name.index(&FullRange) {
+                    let msg = if "???" == &module_name[] {
                         span.hi = span.lo + Pos::from_uint(segment_name.get().len());
 
                         match search_parent_externals(name,
@@ -2073,14 +2073,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         match module_prefix_result {
             Failed(None) => {
                 let mpath = self.names_to_string(module_path);
-                let mpath = mpath.index(&FullRange);
+                let mpath = &mpath[];
                 match mpath.rfind(':') {
                     Some(idx) => {
                         let msg = format!("Could not find `{}` in `{}`",
                                             // idx +- 1 to account for the
                                             // colons on either side
-                                            mpath.index(&((idx + 1)..)),
-                                            mpath.index(&(0..(idx - 1))));
+                                            &mpath[(idx + 1)..],
+                                            &mpath[0..(idx - 1)]);
                         return Failed(Some((span, msg)));
                     },
                     None => {
@@ -2254,8 +2254,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                               PathSearch,
                                               true) {
                 Failed(Some((span, msg))) =>
-                    self.resolve_error(span, format!("failed to resolve. {}",
-                                                     msg).index(&FullRange)),
+                    self.resolve_error(span, &format!("failed to resolve. {}",
+                                                     msg)[]),
                 Failed(None) => (), // Continue up the search chain.
                 Indeterminate => {
                     // We couldn't see through the higher scope because of an
@@ -2515,7 +2515,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             } else {
                 let err = format!("unresolved import (maybe you meant `{}::*`?)",
                                   sn);
-                self.resolve_error((*imports)[index].span, err.index(&FullRange));
+                self.resolve_error((*imports)[index].span, &err[]);
             }
         }
 
@@ -2607,7 +2607,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         match def_like {
             DlDef(d @ DefUpvar(..)) => {
                 self.session.span_bug(span,
-                    format!("unexpected {:?} in bindings", d).index(&FullRange))
+                    &format!("unexpected {:?} in bindings", d)[])
             }
             DlDef(d @ DefLocal(_)) => {
                 let node_id = d.def_id().node;
@@ -2753,7 +2753,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         for (i, rib) in ribs.iter().enumerate().rev() {
             match rib.bindings.get(&name).cloned() {
                 Some(def_like) => {
-                    return self.upvarify(ribs.index(&((i + 1)..)), def_like, span);
+                    return self.upvarify(&ribs[(i + 1)..], def_like, span);
                 }
                 None => {
                     // Continue.
@@ -2846,7 +2846,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                             generics,
                                             implemented_traits,
                                             &**self_type,
-                                            impl_items.index(&FullRange));
+                                            &impl_items[]);
             }
 
             ItemTrait(_, ref generics, ref bounds, ref trait_items) => {
@@ -2924,7 +2924,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             ItemStruct(ref struct_def, ref generics) => {
                 self.resolve_struct(item.id,
                                     generics,
-                                    struct_def.fields.index(&FullRange));
+                                    &struct_def.fields[]);
             }
 
             ItemMod(ref module_) => {
@@ -2943,8 +2943,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     HasTypeParameters(
                                         generics, FnSpace, foreign_item.id,
                                         ItemRibKind),
-                                    |this| visit::walk_foreign_item(this,
-                                                                    &**foreign_item));
+                                    |this| {
+                                        this.resolve_type_parameters(&generics.ty_params);
+                                        this.resolve_where_clause(&generics.where_clause);
+                                        visit::walk_foreign_item(this, &**foreign_item)
+                                    });
                             }
                             ForeignItemStatic(..) => {
                                 visit::walk_foreign_item(this,
@@ -2992,12 +2995,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
 
                     if seen_bindings.contains(&name) {
                         self.resolve_error(type_parameter.span,
-                                           format!("the name `{}` is already \
+                                           &format!("the name `{}` is already \
                                                     used for a type \
                                                     parameter in this type \
                                                     parameter list",
                                                    token::get_name(
-                                                       name)).index(&FullRange))
+                                                       name))[])
                     }
                     seen_bindings.insert(name);
 
@@ -3169,7 +3172,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 };
 
                 let msg = format!("attempt to {} a nonexistent trait `{}`", usage_str, path_str);
-                self.resolve_error(trait_reference.path.span, msg.index(&FullRange));
+                self.resolve_error(trait_reference.path.span, &msg[]);
             }
             Some(def) => {
                 match def {
@@ -3179,16 +3182,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     }
                     (def, _) => {
                         self.resolve_error(trait_reference.path.span,
-                                           format!("`{}` is not a trait",
+                                           &format!("`{}` is not a trait",
                                                    self.path_names_to_string(
-                                                       &trait_reference.path)).index(&FullRange));
+                                                       &trait_reference.path))[]);
 
                         // If it's a typedef, give a note
                         if let DefTy(..) = def {
                             self.session.span_note(
                                 trait_reference.path.span,
-                                format!("`type` aliases cannot be used for traits")
-                                    .index(&FullRange));
+                                &format!("`type` aliases cannot be used for traits")
+                                []);
                         }
                     }
                 }
@@ -3383,9 +3386,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             if self.trait_item_map.get(&(name, did)).is_none() {
                 let path_str = self.path_names_to_string(&trait_ref.path);
                 self.resolve_error(span,
-                                    format!("method `{}` is not a member of trait `{}`",
+                                    &format!("method `{}` is not a member of trait `{}`",
                                             token::get_name(name),
-                                            path_str).index(&FullRange));
+                                            path_str)[]);
             }
         }
     }
@@ -3451,19 +3454,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                   None => {
                     self.resolve_error(
                         p.span,
-                        format!("variable `{}` from pattern #1 is \
+                        &format!("variable `{}` from pattern #1 is \
                                   not bound in pattern #{}",
                                 token::get_name(key),
-                                i + 1).index(&FullRange));
+                                i + 1)[]);
                   }
                   Some(binding_i) => {
                     if binding_0.binding_mode != binding_i.binding_mode {
                         self.resolve_error(
                             binding_i.span,
-                            format!("variable `{}` is bound with different \
+                            &format!("variable `{}` is bound with different \
                                       mode in pattern #{} than in pattern #1",
                                     token::get_name(key),
-                                    i + 1).index(&FullRange));
+                                    i + 1)[]);
                     }
                   }
                 }
@@ -3473,10 +3476,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 if !map_0.contains_key(&key) {
                     self.resolve_error(
                         binding.span,
-                        format!("variable `{}` from pattern {}{} is \
+                        &format!("variable `{}` from pattern {}{} is \
                                   not bound in pattern {}1",
                                 token::get_name(key),
-                                "#", i + 1, "#").index(&FullRange));
+                                "#", i + 1, "#")[]);
                 }
             }
         }
@@ -3591,7 +3594,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     None => {
                         let msg = format!("use of undeclared type name `{}`",
                                           self.path_names_to_string(path));
-                        self.resolve_error(ty.span, msg.index(&FullRange));
+                        self.resolve_error(ty.span, &msg[]);
                     }
                 }
             }
@@ -3660,10 +3663,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                         FoundStructOrEnumVariant(..) => {
                             self.resolve_error(
                                 pattern.span,
-                                format!("declaration of `{}` shadows an enum \
+                                &format!("declaration of `{}` shadows an enum \
                                          variant or unit-like struct in \
                                          scope",
-                                        token::get_name(renamed)).index(&FullRange));
+                                        token::get_name(renamed))[]);
                         }
                         FoundConst(ref def, lp) if mode == RefutableMode => {
                             debug!("(resolving pattern) resolving `{}` to \
@@ -3708,23 +3711,23 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                 // Forbid duplicate bindings in the same
                                 // parameter list.
                                 self.resolve_error(pattern.span,
-                                                   format!("identifier `{}` \
+                                                   &format!("identifier `{}` \
                                                             is bound more \
                                                             than once in \
                                                             this parameter \
                                                             list",
                                                            token::get_ident(
                                                                ident))
-                                                   .index(&FullRange))
+                                                   [])
                             } else if bindings_list.get(&renamed) ==
                                     Some(&pat_id) {
                                 // Then this is a duplicate variable in the
                                 // same disjunction, which is an error.
                                 self.resolve_error(pattern.span,
-                                    format!("identifier `{}` is bound \
+                                    &format!("identifier `{}` is bound \
                                              more than once in the same \
                                              pattern",
-                                            token::get_ident(ident)).index(&FullRange));
+                                            token::get_ident(ident))[]);
                             }
                             // Else, not bound in the same pattern: do
                             // nothing.
@@ -3787,7 +3790,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                     def: {:?}", result);
                             let msg = format!("`{}` does not name a structure",
                                               self.path_names_to_string(path));
-                            self.resolve_error(path.span, msg.index(&FullRange));
+                            self.resolve_error(path.span, &msg[]);
                         }
                     }
                 }
@@ -3848,8 +3851,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Failed(err) => {
                 match err {
                     Some((span, msg)) => {
-                        self.resolve_error(span, format!("failed to resolve: {}",
-                                                         msg).index(&FullRange));
+                        self.resolve_error(span, &format!("failed to resolve: {}",
+                                                         msg)[]);
                     }
                     None => ()
                 }
@@ -4044,7 +4047,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         let last_private;
         let module = self.current_module.clone();
         match self.resolve_module_path(module,
-                                       module_path.index(&FullRange),
+                                       &module_path[],
                                        UseLexicalScope,
                                        path.span,
                                        PathSearch) {
@@ -4058,8 +4061,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     }
                 };
 
-                self.resolve_error(span, format!("failed to resolve. {}",
-                                                 msg).index(&FullRange));
+                self.resolve_error(span, &format!("failed to resolve. {}",
+                                                 msg)[]);
                 return None;
             }
             Indeterminate => panic!("indeterminate unexpected"),
@@ -4102,7 +4105,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         let containing_module;
         let last_private;
         match self.resolve_module_path_from_root(root_module,
-                                                 module_path.index(&FullRange),
+                                                 &module_path[],
                                                  0,
                                                  path.span,
                                                  PathSearch,
@@ -4112,13 +4115,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     Some((span, msg)) => (span, msg),
                     None => {
                         let msg = format!("Use of undeclared module `::{}`",
-                                          self.names_to_string(module_path.index(&FullRange)));
+                                          self.names_to_string(&module_path[]));
                         (path.span, msg)
                     }
                 };
 
-                self.resolve_error(span, format!("failed to resolve. {}",
-                                                 msg).index(&FullRange));
+                self.resolve_error(span, &format!("failed to resolve. {}",
+                                                 msg)[]);
                 return None;
             }
 
@@ -4159,7 +4162,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             }
             TypeNS => {
                 let name = ident.name;
-                self.search_ribs(self.type_ribs.index(&FullRange), name, span)
+                self.search_ribs(&self.type_ribs[], name, span)
             }
         };
 
@@ -4213,8 +4216,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             Failed(err) => {
                 match err {
                     Some((span, msg)) =>
-                        self.resolve_error(span, format!("failed to resolve. {}",
-                                                         msg).index(&FullRange)),
+                        self.resolve_error(span, &format!("failed to resolve. {}",
+                                                         msg)[]),
                     None => ()
                 }
 
@@ -4271,7 +4274,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 }
             } else {
                 match this.resolve_module_path(root,
-                                                name_path.index(&FullRange),
+                                                &name_path[],
                                                 UseLexicalScope,
                                                 span,
                                                 PathSearch) {
@@ -4309,7 +4312,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         let name_path = path.segments.iter().map(|seg| seg.identifier.name).collect::<Vec<_>>();
 
         // Look for a method in the current self type's impl module.
-        match get_module(self, path.span, name_path.index(&FullRange)) {
+        match get_module(self, path.span, &name_path[]) {
             Some(module) => match module.children.borrow().get(&name) {
                 Some(binding) => {
                     let p_str = self.path_names_to_string(&path);
@@ -4520,7 +4523,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                                 def: {:?}", result);
                         let msg = format!("`{}` does not name a structure",
                                           self.path_names_to_string(path));
-                        self.resolve_error(path.span, msg.index(&FullRange));
+                        self.resolve_error(path.span, &msg[]);
                     }
                 }
 
@@ -4580,8 +4583,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                     None => {
                         self.resolve_error(
                             expr.span,
-                            format!("use of undeclared label `{}`",
-                                    token::get_ident(label)).index(&FullRange))
+                            &format!("use of undeclared label `{}`",
+                                    token::get_ident(label))[])
                     }
                     Some(DlDef(def @ DefLabel(_))) => {
                         // Since this def is a label, it is never read.
@@ -4716,11 +4719,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             // the same conclusion! - nmatsakis
             Occupied(entry) => if def != *entry.get() {
                 self.session
-                    .bug(format!("node_id {} resolved first to {:?} and \
+                    .bug(&format!("node_id {} resolved first to {:?} and \
                                   then {:?}",
                                  node_id,
                                  *entry.get(),
-                                 def).index(&FullRange));
+                                 def)[]);
             },
             Vacant(entry) => { entry.insert(def); },
         }
@@ -4734,9 +4737,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             BindByValue(_) => {}
             BindByRef(..) => {
                 self.resolve_error(pat.span,
-                                   format!("cannot use `ref` binding mode \
+                                   &format!("cannot use `ref` binding mode \
                                             with {}",
-                                           descr).index(&FullRange));
+                                           descr)[]);
             }
         }
     }
@@ -4771,8 +4774,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         if names.len() == 0 {
             return "???".to_string();
         }
-        self.names_to_string(names.into_iter().rev()
-                                  .collect::<Vec<ast::Name>>().index(&FullRange))
+        self.names_to_string(&names.into_iter().rev()
+                                  .collect::<Vec<ast::Name>>()[])
     }
 
     #[allow(dead_code)]   // useful for debugging
diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs
index 26241ace76f48..43f8c677e303b 100644
--- a/src/librustc_trans/back/link.rs
+++ b/src/librustc_trans/back/link.rs
@@ -128,7 +128,7 @@ pub fn find_crate_name(sess: Option<&Session>,
                        attrs: &[ast::Attribute],
                        input: &Input) -> String {
     let validate = |&: s: String, span: Option<Span>| {
-        creader::validate_crate_name(sess, s.index(&FullRange), span);
+        creader::validate_crate_name(sess, &s[], span);
         s
     };
 
@@ -146,7 +146,7 @@ pub fn find_crate_name(sess: Option<&Session>,
                     let msg = format!("--crate-name and #[crate_name] are \
                                        required to match, but `{}` != `{}`",
                                       s, name);
-                    sess.span_err(attr.span, msg.index(&FullRange));
+                    sess.span_err(attr.span, &msg[]);
                 }
             }
             return validate(s.clone(), None);
@@ -192,17 +192,17 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>,
     // to be independent of one another in the crate.
 
     symbol_hasher.reset();
-    symbol_hasher.input_str(link_meta.crate_name.index(&FullRange));
+    symbol_hasher.input_str(&link_meta.crate_name[]);
     symbol_hasher.input_str("-");
     symbol_hasher.input_str(link_meta.crate_hash.as_str());
     for meta in tcx.sess.crate_metadata.borrow().iter() {
-        symbol_hasher.input_str(meta.index(&FullRange));
+        symbol_hasher.input_str(&meta[]);
     }
     symbol_hasher.input_str("-");
-    symbol_hasher.input_str(encoder::encoded_ty(tcx, t).index(&FullRange));
+    symbol_hasher.input_str(&encoder::encoded_ty(tcx, t)[]);
     // Prefix with 'h' so that it never blends into adjacent digits
     let mut hash = String::from_str("h");
-    hash.push_str(truncated_hash_result(symbol_hasher).index(&FullRange));
+    hash.push_str(&truncated_hash_result(symbol_hasher)[]);
     hash
 }
 
@@ -251,7 +251,7 @@ pub fn sanitize(s: &str) -> String {
                 let mut tstr = String::new();
                 for c in c.escape_unicode() { tstr.push(c) }
                 result.push('$');
-                result.push_str(tstr.index(&(1..)));
+                result.push_str(&tstr[1..]);
             }
         }
     }
@@ -260,7 +260,7 @@ pub fn sanitize(s: &str) -> String {
     if result.len() > 0u &&
         result.as_bytes()[0] != '_' as u8 &&
         ! (result.as_bytes()[0] as char).is_xid_start() {
-        return format!("_{}", result.index(&FullRange));
+        return format!("_{}", &result[]);
     }
 
     return result;
@@ -286,12 +286,12 @@ pub fn mangle<PI: Iterator<Item=PathElem>>(mut path: PI,
 
     fn push(n: &mut String, s: &str) {
         let sani = sanitize(s);
-        n.push_str(format!("{}{}", sani.len(), sani).index(&FullRange));
+        n.push_str(&format!("{}{}", sani.len(), sani)[]);
     }
 
     // First, connect each component with <len, name> pairs.
     for e in path {
-        push(&mut n, token::get_name(e.name()).get().index(&FullRange))
+        push(&mut n, &token::get_name(e.name()).get()[])
     }
 
     match hash {
@@ -329,17 +329,17 @@ pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathEl
     hash.push(EXTRA_CHARS.as_bytes()[extra2] as char);
     hash.push(EXTRA_CHARS.as_bytes()[extra3] as char);
 
-    exported_name(path, hash.index(&FullRange))
+    exported_name(path, &hash[])
 }
 
 pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                                       t: Ty<'tcx>,
                                                       name: &str) -> String {
     let s = ppaux::ty_to_string(ccx.tcx(), t);
-    let path = [PathName(token::intern(s.index(&FullRange))),
+    let path = [PathName(token::intern(&s[])),
                 gensym_name(name)];
     let hash = get_symbol_hash(ccx, t);
-    mangle(ast_map::Values(path.iter()), Some(hash.index(&FullRange)))
+    mangle(ast_map::Values(path.iter()), Some(&hash[]))
 }
 
 pub fn mangle_internal_name_by_path_and_seq(path: PathElems, flav: &str) -> String {
@@ -357,9 +357,9 @@ pub fn remove(sess: &Session, path: &Path) {
     match fs::unlink(path) {
         Ok(..) => {}
         Err(e) => {
-            sess.err(format!("failed to remove {}: {}",
+            sess.err(&format!("failed to remove {}: {}",
                              path.display(),
-                             e).index(&FullRange));
+                             e)[]);
         }
     }
 }
@@ -373,8 +373,8 @@ pub fn link_binary(sess: &Session,
     let mut out_filenames = Vec::new();
     for &crate_type in sess.crate_types.borrow().iter() {
         if invalid_output_for_target(sess, crate_type) {
-            sess.bug(format!("invalid output type `{:?}` for target os `{}`",
-                             crate_type, sess.opts.target_triple).index(&FullRange));
+            sess.bug(&format!("invalid output type `{:?}` for target os `{}`",
+                             crate_type, sess.opts.target_triple)[]);
         }
         let out_file = link_binary_output(sess, trans, crate_type, outputs,
                                           crate_name);
@@ -439,8 +439,8 @@ pub fn filename_for_input(sess: &Session,
             out_filename.with_filename(format!("lib{}.rlib", libname))
         }
         config::CrateTypeDylib => {
-            let (prefix, suffix) = (sess.target.target.options.dll_prefix.index(&FullRange),
-                                    sess.target.target.options.dll_suffix.index(&FullRange));
+            let (prefix, suffix) = (&sess.target.target.options.dll_prefix[],
+                                    &sess.target.target.options.dll_suffix[]);
             out_filename.with_filename(format!("{}{}{}",
                                                prefix,
                                                libname,
@@ -450,7 +450,7 @@ pub fn filename_for_input(sess: &Session,
             out_filename.with_filename(format!("lib{}.a", libname))
         }
         config::CrateTypeExecutable => {
-            let suffix = sess.target.target.options.exe_suffix.index(&FullRange);
+            let suffix = &sess.target.target.options.exe_suffix[];
             out_filename.with_filename(format!("{}{}", libname, suffix))
         }
     }
@@ -477,14 +477,14 @@ fn link_binary_output(sess: &Session,
     let obj_is_writeable = is_writeable(&obj_filename);
     let out_is_writeable = is_writeable(&out_filename);
     if !out_is_writeable {
-        sess.fatal(format!("output file {} is not writeable -- check its \
+        sess.fatal(&format!("output file {} is not writeable -- check its \
                             permissions.",
-                           out_filename.display()).index(&FullRange));
+                           out_filename.display())[]);
     }
     else if !obj_is_writeable {
-        sess.fatal(format!("object file {} is not writeable -- check its \
+        sess.fatal(&format!("object file {} is not writeable -- check its \
                             permissions.",
-                           obj_filename.display()).index(&FullRange));
+                           obj_filename.display())[]);
     }
 
     match crate_type {
@@ -539,7 +539,7 @@ fn link_rlib<'a>(sess: &'a Session,
     for &(ref l, kind) in sess.cstore.get_used_libraries().borrow().iter() {
         match kind {
             cstore::NativeStatic => {
-                ab.add_native_library(l.index(&FullRange)).unwrap();
+                ab.add_native_library(&l[]).unwrap();
             }
             cstore::NativeFramework | cstore::NativeUnknown => {}
         }
@@ -586,13 +586,13 @@ fn link_rlib<'a>(sess: &'a Session,
             // the same filename for metadata (stomping over one another)
             let tmpdir = TempDir::new("rustc").ok().expect("needs a temp dir");
             let metadata = tmpdir.path().join(METADATA_FILENAME);
-            match fs::File::create(&metadata).write(trans.metadata
-                                                         .index(&FullRange)) {
+            match fs::File::create(&metadata).write(&trans.metadata
+                                                    []) {
                 Ok(..) => {}
                 Err(e) => {
-                    sess.err(format!("failed to write {}: {}",
+                    sess.err(&format!("failed to write {}: {}",
                                      metadata.display(),
-                                     e).index(&FullRange));
+                                     e)[]);
                     sess.abort_if_errors();
                 }
             }
@@ -610,25 +610,25 @@ fn link_rlib<'a>(sess: &'a Session,
                 // was exactly 16 bytes.
                 let bc_filename = obj_filename.with_extension(format!("{}.bc", i).as_slice());
                 let bc_deflated_filename = obj_filename.with_extension(
-                    format!("{}.bytecode.deflate", i).index(&FullRange));
+                    &format!("{}.bytecode.deflate", i)[]);
 
                 let bc_data = match fs::File::open(&bc_filename).read_to_end() {
                     Ok(buffer) => buffer,
-                    Err(e) => sess.fatal(format!("failed to read bytecode: {}",
-                                                 e).index(&FullRange))
+                    Err(e) => sess.fatal(&format!("failed to read bytecode: {}",
+                                                 e)[])
                 };
 
-                let bc_data_deflated = match flate::deflate_bytes(bc_data.index(&FullRange)) {
+                let bc_data_deflated = match flate::deflate_bytes(&bc_data[]) {
                     Some(compressed) => compressed,
-                    None => sess.fatal(format!("failed to compress bytecode from {}",
-                                               bc_filename.display()).index(&FullRange))
+                    None => sess.fatal(&format!("failed to compress bytecode from {}",
+                                               bc_filename.display())[])
                 };
 
                 let mut bc_file_deflated = match fs::File::create(&bc_deflated_filename) {
                     Ok(file) => file,
                     Err(e) => {
-                        sess.fatal(format!("failed to create compressed bytecode \
-                                            file: {}", e).index(&FullRange))
+                        sess.fatal(&format!("failed to create compressed bytecode \
+                                            file: {}", e)[])
                     }
                 };
 
@@ -636,8 +636,8 @@ fn link_rlib<'a>(sess: &'a Session,
                                                     bc_data_deflated.as_slice()) {
                     Ok(()) => {}
                     Err(e) => {
-                        sess.err(format!("failed to write compressed bytecode: \
-                                          {}", e).index(&FullRange));
+                        sess.err(&format!("failed to write compressed bytecode: \
+                                          {}", e)[]);
                         sess.abort_if_errors()
                     }
                 };
@@ -677,7 +677,7 @@ fn write_rlib_bytecode_object_v1<T: Writer>(writer: &mut T,
     try! { writer.write(RLIB_BYTECODE_OBJECT_MAGIC) };
     try! { writer.write_le_u32(1) };
     try! { writer.write_le_u64(bc_data_deflated_size) };
-    try! { writer.write(bc_data_deflated.index(&FullRange)) };
+    try! { writer.write(&bc_data_deflated[]) };
 
     let number_of_bytes_written_so_far =
         RLIB_BYTECODE_OBJECT_MAGIC.len() +                // magic id
@@ -727,12 +727,12 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) {
         let ref name = sess.cstore.get_crate_data(cnum).name;
         let p = match *path {
             Some(ref p) => p.clone(), None => {
-                sess.err(format!("could not find rlib for: `{}`",
-                                 name).index(&FullRange));
+                sess.err(&format!("could not find rlib for: `{}`",
+                                 name)[]);
                 continue
             }
         };
-        ab.add_rlib(&p, name.index(&FullRange), sess.lto()).unwrap();
+        ab.add_rlib(&p, &name[], sess.lto()).unwrap();
 
         let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
         all_native_libs.extend(native_libs.into_iter());
@@ -754,7 +754,7 @@ fn link_staticlib(sess: &Session, obj_filename: &Path, out_filename: &Path) {
             cstore::NativeUnknown => "library",
             cstore::NativeFramework => "framework",
         };
-        sess.note(format!("{}: {}", name, *lib).index(&FullRange));
+        sess.note(&format!("{}: {}", name, *lib)[]);
     }
 }
 
@@ -768,12 +768,12 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
 
     // The invocations of cc share some flags across platforms
     let pname = get_cc_prog(sess);
-    let mut cmd = Command::new(pname.index(&FullRange));
+    let mut cmd = Command::new(&pname[]);
 
-    cmd.args(sess.target.target.options.pre_link_args.index(&FullRange));
+    cmd.args(&sess.target.target.options.pre_link_args[]);
     link_args(&mut cmd, sess, dylib, tmpdir.path(),
               trans, obj_filename, out_filename);
-    cmd.args(sess.target.target.options.post_link_args.index(&FullRange));
+    cmd.args(&sess.target.target.options.post_link_args[]);
     if !sess.target.target.options.no_compiler_rt {
         cmd.arg("-lcompiler-rt");
     }
@@ -791,22 +791,22 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
     match prog {
         Ok(prog) => {
             if !prog.status.success() {
-                sess.err(format!("linking with `{}` failed: {}",
+                sess.err(&format!("linking with `{}` failed: {}",
                                  pname,
-                                 prog.status).index(&FullRange));
-                sess.note(format!("{}", &cmd).index(&FullRange));
+                                 prog.status)[]);
+                sess.note(&format!("{}", &cmd)[]);
                 let mut output = prog.error.clone();
-                output.push_all(prog.output.index(&FullRange));
-                sess.note(str::from_utf8(output.index(&FullRange)).unwrap());
+                output.push_all(&prog.output[]);
+                sess.note(str::from_utf8(&output[]).unwrap());
                 sess.abort_if_errors();
             }
             debug!("linker stderr:\n{}", String::from_utf8(prog.error).unwrap());
             debug!("linker stdout:\n{}", String::from_utf8(prog.output).unwrap());
         },
         Err(e) => {
-            sess.err(format!("could not exec the linker `{}`: {}",
+            sess.err(&format!("could not exec the linker `{}`: {}",
                              pname,
-                             e).index(&FullRange));
+                             e)[]);
             sess.abort_if_errors();
         }
     }
@@ -818,7 +818,7 @@ fn link_natively(sess: &Session, trans: &CrateTranslation, dylib: bool,
         match Command::new("dsymutil").arg(out_filename).output() {
             Ok(..) => {}
             Err(e) => {
-                sess.err(format!("failed to run dsymutil: {}", e).index(&FullRange));
+                sess.err(&format!("failed to run dsymutil: {}", e)[]);
                 sess.abort_if_errors();
             }
         }
@@ -867,7 +867,7 @@ fn link_args(cmd: &mut Command,
 
             let mut v = b"-Wl,-force_load,".to_vec();
             v.push_all(morestack.as_vec());
-            cmd.arg(v.index(&FullRange));
+            cmd.arg(&v[]);
         } else {
             cmd.args(&["-Wl,--whole-archive", "-lmorestack", "-Wl,--no-whole-archive"]);
         }
@@ -992,7 +992,7 @@ fn link_args(cmd: &mut Command,
             if sess.opts.cg.rpath {
                 let mut v = "-Wl,-install_name,@rpath/".as_bytes().to_vec();
                 v.push_all(out_filename.filename().unwrap());
-                cmd.arg(v.index(&FullRange));
+                cmd.arg(&v[]);
             }
         } else {
             cmd.arg("-shared");
@@ -1004,7 +1004,7 @@ fn link_args(cmd: &mut Command,
     // addl_lib_search_paths
     if sess.opts.cg.rpath {
         let sysroot = sess.sysroot();
-        let target_triple = sess.opts.target_triple.index(&FullRange);
+        let target_triple = &sess.opts.target_triple[];
         let get_install_prefix_lib_path = |:| {
             let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX");
             let tlib = filesearch::relative_target_lib_path(sysroot, target_triple);
@@ -1021,14 +1021,14 @@ fn link_args(cmd: &mut Command,
             get_install_prefix_lib_path: get_install_prefix_lib_path,
             realpath: ::util::fs::realpath
         };
-        cmd.args(rpath::get_rpath_flags(rpath_config).index(&FullRange));
+        cmd.args(&rpath::get_rpath_flags(rpath_config)[]);
     }
 
     // Finally add all the linker arguments provided on the command line along
     // with any #[link_args] attributes found inside the crate
     let empty = Vec::new();
-    cmd.args(sess.opts.cg.link_args.as_ref().unwrap_or(&empty).index(&FullRange));
-    cmd.args(used_link_args.index(&FullRange));
+    cmd.args(&sess.opts.cg.link_args.as_ref().unwrap_or(&empty)[]);
+    cmd.args(&used_link_args[]);
 }
 
 // # Native library linking
@@ -1082,14 +1082,14 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) {
         } else {
             // -force_load is the OSX equivalent of --whole-archive, but it
             // involves passing the full path to the library to link.
-            let lib = archive::find_library(l.index(&FullRange),
+            let lib = archive::find_library(&l[],
                                             sess.target.target.options.staticlib_prefix.as_slice(),
                                             sess.target.target.options.staticlib_suffix.as_slice(),
-                                            search_path.index(&FullRange),
+                                            &search_path[],
                                             &sess.diagnostic().handler);
             let mut v = b"-Wl,-force_load,".to_vec();
             v.push_all(lib.as_vec());
-            cmd.arg(v.index(&FullRange));
+            cmd.arg(&v[]);
         }
     }
     if takes_hints {
@@ -1102,7 +1102,7 @@ fn add_local_native_libraries(cmd: &mut Command, sess: &Session) {
                 cmd.arg(format!("-l{}", l));
             }
             cstore::NativeFramework => {
-                cmd.arg("-framework").arg(l.index(&FullRange));
+                cmd.arg("-framework").arg(&l[]);
             }
             cstore::NativeStatic => unreachable!(),
         }
@@ -1158,7 +1158,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
     // Converts a library file-stem into a cc -l argument
     fn unlib<'a>(config: &config::Config, stem: &'a [u8]) -> &'a [u8] {
         if stem.starts_with("lib".as_bytes()) && !config.target.options.is_like_windows {
-            stem.index(&(3..))
+            &stem[3..]
         } else {
             stem
         }
@@ -1183,18 +1183,18 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
         // against the archive.
         if sess.lto() {
             let name = cratepath.filename_str().unwrap();
-            let name = name.index(&(3..(name.len() - 5))); // chop off lib/.rlib
+            let name = &name[3..(name.len() - 5)]; // chop off lib/.rlib
             time(sess.time_passes(),
-                 format!("altering {}.rlib", name).index(&FullRange),
+                 &format!("altering {}.rlib", name)[],
                  (), |()| {
                 let dst = tmpdir.join(cratepath.filename().unwrap());
                 match fs::copy(&cratepath, &dst) {
                     Ok(..) => {}
                     Err(e) => {
-                        sess.err(format!("failed to copy {} to {}: {}",
+                        sess.err(&format!("failed to copy {} to {}: {}",
                                          cratepath.display(),
                                          dst.display(),
-                                         e).index(&FullRange));
+                                         e)[]);
                         sess.abort_if_errors();
                     }
                 }
@@ -1204,9 +1204,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
                 match fs::chmod(&dst, io::USER_READ | io::USER_WRITE) {
                     Ok(..) => {}
                     Err(e) => {
-                        sess.err(format!("failed to chmod {} when preparing \
+                        sess.err(&format!("failed to chmod {} when preparing \
                                           for LTO: {}", dst.display(),
-                                         e).index(&FullRange));
+                                         e)[]);
                         sess.abort_if_errors();
                     }
                 }
@@ -1220,9 +1220,9 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
                     maybe_ar_prog: sess.opts.cg.ar.clone()
                 };
                 let mut archive = Archive::open(config);
-                archive.remove_file(format!("{}.o", name).index(&FullRange));
+                archive.remove_file(&format!("{}.o", name)[]);
                 let files = archive.files();
-                if files.iter().any(|s| s.index(&FullRange).ends_with(".o")) {
+                if files.iter().any(|s| s[].ends_with(".o")) {
                     cmd.arg(dst);
                 }
             });
@@ -1244,7 +1244,7 @@ fn add_upstream_rust_crates(cmd: &mut Command, sess: &Session,
 
         let mut v = "-l".as_bytes().to_vec();
         v.push_all(unlib(&sess.target, cratepath.filestem().unwrap()));
-        cmd.arg(v.index(&FullRange));
+        cmd.arg(&v[]);
     }
 }
 
@@ -1286,7 +1286,7 @@ fn add_upstream_native_libraries(cmd: &mut Command, sess: &Session) {
                 }
                 cstore::NativeFramework => {
                     cmd.arg("-framework");
-                    cmd.arg(lib.index(&FullRange));
+                    cmd.arg(&lib[]);
                 }
                 cstore::NativeStatic => {
                     sess.bug("statics shouldn't be propagated");
diff --git a/src/librustc_trans/back/lto.rs b/src/librustc_trans/back/lto.rs
index ecf2e9ed72425..e457de6bc771b 100644
--- a/src/librustc_trans/back/lto.rs
+++ b/src/librustc_trans/back/lto.rs
@@ -53,30 +53,30 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
         let path = match path {
             Some(p) => p,
             None => {
-                sess.fatal(format!("could not find rlib for: `{}`",
-                                   name).index(&FullRange));
+                sess.fatal(&format!("could not find rlib for: `{}`",
+                                   name)[]);
             }
         };
 
         let archive = ArchiveRO::open(&path).expect("wanted an rlib");
         let file = path.filename_str().unwrap();
-        let file = file.index(&(3..(file.len() - 5))); // chop off lib/.rlib
+        let file = &file[3..(file.len() - 5)]; // chop off lib/.rlib
         debug!("reading {}", file);
         for i in iter::count(0u, 1) {
             let bc_encoded = time(sess.time_passes(),
                                   format!("check for {}.{}.bytecode.deflate", name, i).as_slice(),
                                   (),
                                   |_| {
-                                      archive.read(format!("{}.{}.bytecode.deflate",
-                                                           file, i).index(&FullRange))
+                                      archive.read(&format!("{}.{}.bytecode.deflate",
+                                                           file, i)[])
                                   });
             let bc_encoded = match bc_encoded {
                 Some(data) => data,
                 None => {
                     if i == 0 {
                         // No bitcode was found at all.
-                        sess.fatal(format!("missing compressed bytecode in {}",
-                                           path.display()).index(&FullRange));
+                        sess.fatal(&format!("missing compressed bytecode in {}",
+                                           path.display())[]);
                     }
                     // No more bitcode files to read.
                     break;
@@ -91,20 +91,20 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
                     if version == 1 {
                         // The only version existing so far
                         let data_size = extract_compressed_bytecode_size_v1(bc_encoded);
-                        let compressed_data = bc_encoded.index(&(
+                        let compressed_data = &bc_encoded[
                             link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET..
-                            (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint)));
+                            (link::RLIB_BYTECODE_OBJECT_V1_DATA_OFFSET + data_size as uint)];
 
                         match flate::inflate_bytes(compressed_data) {
                             Some(inflated) => inflated,
                             None => {
-                                sess.fatal(format!("failed to decompress bc of `{}`",
-                                                   name).index(&FullRange))
+                                sess.fatal(&format!("failed to decompress bc of `{}`",
+                                                   name)[])
                             }
                         }
                     } else {
-                        sess.fatal(format!("Unsupported bytecode format version {}",
-                                           version).index(&FullRange))
+                        sess.fatal(&format!("Unsupported bytecode format version {}",
+                                           version)[])
                     }
                 })
             } else {
@@ -114,8 +114,8 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
                     match flate::inflate_bytes(bc_encoded) {
                         Some(bc) => bc,
                         None => {
-                            sess.fatal(format!("failed to decompress bc of `{}`",
-                                               name).index(&FullRange))
+                            sess.fatal(&format!("failed to decompress bc of `{}`",
+                                               name)[])
                         }
                     }
                 })
@@ -124,7 +124,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
             let ptr = bc_decoded.as_slice().as_ptr();
             debug!("linking {}, part {}", name, i);
             time(sess.time_passes(),
-                 format!("ll link {}.{}", name, i).index(&FullRange),
+                 &format!("ll link {}.{}", name, i)[],
                  (),
                  |()| unsafe {
                 if !llvm::LLVMRustLinkInExternalBitcode(llmod,
@@ -132,7 +132,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
                                                         bc_decoded.len() as libc::size_t) {
                     write::llvm_err(sess.diagnostic().handler(),
                                     format!("failed to load bc of `{}`",
-                                            name.index(&FullRange)));
+                                            &name[]));
                 }
             });
         }
@@ -186,7 +186,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
 fn is_versioned_bytecode_format(bc: &[u8]) -> bool {
     let magic_id_byte_count = link::RLIB_BYTECODE_OBJECT_MAGIC.len();
     return bc.len() > magic_id_byte_count &&
-           bc.index(&(0..magic_id_byte_count)) == link::RLIB_BYTECODE_OBJECT_MAGIC;
+           &bc[0..magic_id_byte_count] == link::RLIB_BYTECODE_OBJECT_MAGIC;
 }
 
 fn extract_bytecode_format_version(bc: &[u8]) -> u32 {
@@ -198,8 +198,7 @@ fn extract_compressed_bytecode_size_v1(bc: &[u8]) -> u64 {
 }
 
 fn read_from_le_bytes<T: Int>(bytes: &[u8], position_in_bytes: uint) -> T {
-    let byte_data = bytes.index(&(position_in_bytes..
-                                  (position_in_bytes + mem::size_of::<T>())));
+    let byte_data = &bytes[position_in_bytes..(position_in_bytes + mem::size_of::<T>())];
     let data = unsafe {
         *(byte_data.as_ptr() as *const T)
     };
diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs
index 8a80019143ea3..e0ba6d569cc03 100644
--- a/src/librustc_trans/back/write.rs
+++ b/src/librustc_trans/back/write.rs
@@ -47,14 +47,14 @@ pub fn llvm_err(handler: &diagnostic::Handler, msg: String) -> ! {
     unsafe {
         let cstr = llvm::LLVMRustGetLastError();
         if cstr == ptr::null() {
-            handler.fatal(msg.index(&FullRange));
+            handler.fatal(&msg[]);
         } else {
             let err = ffi::c_str_to_bytes(&cstr);
             let err = String::from_utf8_lossy(err.as_slice()).to_string();
             libc::free(cstr as *mut _);
-            handler.fatal(format!("{}: {}",
-                                  msg.index(&FullRange),
-                                  err.index(&FullRange)).index(&FullRange));
+            handler.fatal(&format!("{}: {}",
+                                  &msg[],
+                                  &err[])[]);
         }
     }
 }
@@ -104,13 +104,13 @@ impl SharedEmitter {
             match diag.code {
                 Some(ref code) => {
                     handler.emit_with_code(None,
-                                           diag.msg.index(&FullRange),
-                                           code.index(&FullRange),
+                                           &diag.msg[],
+                                           &code[],
                                            diag.lvl);
                 },
                 None => {
                     handler.emit(None,
-                                 diag.msg.index(&FullRange),
+                                 &diag.msg[],
                                  diag.lvl);
                 },
             }
@@ -165,8 +165,8 @@ fn get_llvm_opt_level(optimize: config::OptLevel) -> llvm::CodeGenOptLevel {
 
 fn create_target_machine(sess: &Session) -> TargetMachineRef {
     let reloc_model_arg = match sess.opts.cg.relocation_model {
-        Some(ref s) => s.index(&FullRange),
-        None => sess.target.target.options.relocation_model.index(&FullRange)
+        Some(ref s) => &s[],
+        None => &sess.target.target.options.relocation_model[]
     };
     let reloc_model = match reloc_model_arg {
         "pic" => llvm::RelocPIC,
@@ -174,10 +174,10 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
         "default" => llvm::RelocDefault,
         "dynamic-no-pic" => llvm::RelocDynamicNoPic,
         _ => {
-            sess.err(format!("{:?} is not a valid relocation mode",
+            sess.err(&format!("{:?} is not a valid relocation mode",
                              sess.opts
                                  .cg
-                                 .relocation_model).index(&FullRange));
+                                 .relocation_model)[]);
             sess.abort_if_errors();
             unreachable!();
         }
@@ -198,8 +198,8 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
     let fdata_sections = ffunction_sections;
 
     let code_model_arg = match sess.opts.cg.code_model {
-        Some(ref s) => s.index(&FullRange),
-        None => sess.target.target.options.code_model.index(&FullRange)
+        Some(ref s) => &s[],
+        None => &sess.target.target.options.code_model[]
     };
 
     let code_model = match code_model_arg {
@@ -209,16 +209,16 @@ fn create_target_machine(sess: &Session) -> TargetMachineRef {
         "medium" => llvm::CodeModelMedium,
         "large" => llvm::CodeModelLarge,
         _ => {
-            sess.err(format!("{:?} is not a valid code model",
+            sess.err(&format!("{:?} is not a valid code model",
                              sess.opts
                                  .cg
-                                 .code_model).index(&FullRange));
+                                 .code_model)[]);
             sess.abort_if_errors();
             unreachable!();
         }
     };
 
-    let triple = sess.target.target.llvm_target.index(&FullRange);
+    let triple = &sess.target.target.llvm_target[];
 
     let tm = unsafe {
         let triple = CString::from_slice(triple.as_bytes());
@@ -350,13 +350,13 @@ unsafe extern "C" fn inline_asm_handler(diag: SMDiagnosticRef,
     match cgcx.lto_ctxt {
         Some((sess, _)) => {
             sess.codemap().with_expn_info(ExpnId::from_llvm_cookie(cookie), |info| match info {
-                Some(ei) => sess.span_err(ei.call_site, msg.index(&FullRange)),
-                None     => sess.err(msg.index(&FullRange)),
+                Some(ei) => sess.span_err(ei.call_site, &msg[]),
+                None     => sess.err(&msg[]),
             });
         }
 
         None => {
-            cgcx.handler.err(msg.index(&FullRange));
+            cgcx.handler.err(&msg[]);
             cgcx.handler.note("build without -C codegen-units for more exact errors");
         }
     }
@@ -518,14 +518,14 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
         }
 
         if config.emit_asm {
-            let path = output_names.with_extension(format!("{}.s", name_extra).index(&FullRange));
+            let path = output_names.with_extension(&format!("{}.s", name_extra)[]);
             with_codegen(tm, llmod, config.no_builtins, |cpm| {
                 write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFileType);
             });
         }
 
         if config.emit_obj {
-            let path = output_names.with_extension(format!("{}.o", name_extra).index(&FullRange));
+            let path = output_names.with_extension(&format!("{}.o", name_extra)[]);
             with_codegen(tm, llmod, config.no_builtins, |cpm| {
                 write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFileType);
             });
@@ -639,7 +639,7 @@ pub fn run_passes(sess: &Session,
 
     // Process the work items, optionally using worker threads.
     if sess.opts.cg.codegen_units == 1 {
-        run_work_singlethreaded(sess, trans.reachable.index(&FullRange), work_items);
+        run_work_singlethreaded(sess, &trans.reachable[], work_items);
     } else {
         run_work_multithreaded(sess, work_items, sess.opts.cg.codegen_units);
     }
@@ -666,8 +666,8 @@ pub fn run_passes(sess: &Session,
             if crate_output.single_output_file.is_some() {
                 // 2) Multiple codegen units, with `-o some_name`.  We have
                 //    no good solution for this case, so warn the user.
-                sess.warn(format!("ignoring -o because multiple .{} files were produced",
-                                  ext).index(&FullRange));
+                sess.warn(&format!("ignoring -o because multiple .{} files were produced",
+                                  ext)[]);
             } else {
                 // 3) Multiple codegen units, but no `-o some_name`.  We
                 //    just leave the `foo.0.x` files in place.
@@ -700,20 +700,20 @@ pub fn run_passes(sess: &Session,
             };
 
         let pname = get_cc_prog(sess);
-        let mut cmd = Command::new(pname.index(&FullRange));
+        let mut cmd = Command::new(&pname[]);
 
-        cmd.args(sess.target.target.options.pre_link_args.index(&FullRange));
+        cmd.args(&sess.target.target.options.pre_link_args[]);
         cmd.arg("-nostdlib");
 
         for index in range(0, trans.modules.len()) {
-            cmd.arg(crate_output.with_extension(format!("{}.o", index).index(&FullRange)));
+            cmd.arg(crate_output.with_extension(&format!("{}.o", index)[]));
         }
 
         cmd.arg("-r")
            .arg("-o")
            .arg(windows_output_path.as_ref().unwrap_or(output_path));
 
-        cmd.args(sess.target.target.options.post_link_args.index(&FullRange));
+        cmd.args(&sess.target.target.options.post_link_args[]);
 
         if (sess.opts.debugging_opts & config::PRINT_LINK_ARGS) != 0 {
             println!("{}", &cmd);
@@ -725,15 +725,15 @@ pub fn run_passes(sess: &Session,
         match cmd.status() {
             Ok(status) => {
                 if !status.success() {
-                    sess.err(format!("linking of {} with `{}` failed",
-                                     output_path.display(), cmd).index(&FullRange));
+                    sess.err(&format!("linking of {} with `{}` failed",
+                                     output_path.display(), cmd)[]);
                     sess.abort_if_errors();
                 }
             },
             Err(e) => {
-                sess.err(format!("could not exec the linker `{}`: {}",
+                sess.err(&format!("could not exec the linker `{}`: {}",
                                  pname,
-                                 e).index(&FullRange));
+                                 e)[]);
                 sess.abort_if_errors();
             },
         }
@@ -818,12 +818,12 @@ pub fn run_passes(sess: &Session,
         for i in range(0, trans.modules.len()) {
             if modules_config.emit_obj {
                 let ext = format!("{}.o", i);
-                remove(sess, &crate_output.with_extension(ext.index(&FullRange)));
+                remove(sess, &crate_output.with_extension(&ext[]));
             }
 
             if modules_config.emit_bc && !keep_numbered_bitcode {
                 let ext = format!("{}.bc", i);
-                remove(sess, &crate_output.with_extension(ext.index(&FullRange)));
+                remove(sess, &crate_output.with_extension(&ext[]));
             }
         }
 
@@ -949,7 +949,7 @@ fn run_work_multithreaded(sess: &Session,
 
 pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) {
     let pname = get_cc_prog(sess);
-    let mut cmd = Command::new(pname.index(&FullRange));
+    let mut cmd = Command::new(&pname[]);
 
     cmd.arg("-c").arg("-o").arg(outputs.path(config::OutputTypeObject))
                            .arg(outputs.temp_path(config::OutputTypeAssembly));
@@ -958,20 +958,20 @@ pub fn run_assembler(sess: &Session, outputs: &OutputFilenames) {
     match cmd.output() {
         Ok(prog) => {
             if !prog.status.success() {
-                sess.err(format!("linking with `{}` failed: {}",
+                sess.err(&format!("linking with `{}` failed: {}",
                                  pname,
-                                 prog.status).index(&FullRange));
-                sess.note(format!("{}", &cmd).index(&FullRange));
+                                 prog.status)[]);
+                sess.note(&format!("{}", &cmd)[]);
                 let mut note = prog.error.clone();
-                note.push_all(prog.output.index(&FullRange));
-                sess.note(str::from_utf8(note.index(&FullRange)).unwrap());
+                note.push_all(&prog.output[]);
+                sess.note(str::from_utf8(&note[]).unwrap());
                 sess.abort_if_errors();
             }
         },
         Err(e) => {
-            sess.err(format!("could not exec the linker `{}`: {}",
+            sess.err(&format!("could not exec the linker `{}`: {}",
                              pname,
-                             e).index(&FullRange));
+                             e)[]);
             sess.abort_if_errors();
         }
     }
@@ -1004,7 +1004,7 @@ unsafe fn configure_llvm(sess: &Session) {
         if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
 
         for arg in sess.opts.cg.llvm_args.iter() {
-            add((*arg).index(&FullRange));
+            add(&(*arg)[]);
         }
     }
 
diff --git a/src/librustc_trans/lib.rs b/src/librustc_trans/lib.rs
index b6f90a4c2f52a..5da51697d2fee 100644
--- a/src/librustc_trans/lib.rs
+++ b/src/librustc_trans/lib.rs
@@ -16,14 +16,17 @@
 
 #![crate_name = "rustc_trans"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
+#![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 
 extern crate arena;
diff --git a/src/librustc_trans/save/mod.rs b/src/librustc_trans/save/mod.rs
index 35f168f092a70..eb163ed7406f2 100644
--- a/src/librustc_trans/save/mod.rs
+++ b/src/librustc_trans/save/mod.rs
@@ -94,7 +94,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
 
         // dump info about all the external crates referenced from this crate
         self.sess.cstore.iter_crate_data(|n, cmd| {
-            self.fmt.external_crate_str(krate.span, cmd.name.index(&FullRange), n);
+            self.fmt.external_crate_str(krate.span, &cmd.name[], n);
         });
         self.fmt.recorder.record("end_external_crates\n");
     }
@@ -143,7 +143,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         for &(ref span, ref qualname) in sub_paths.iter() {
             self.fmt.sub_mod_ref_str(path.span,
                                      *span,
-                                     qualname.index(&FullRange),
+                                     &qualname[],
                                      self.cur_scope);
         }
     }
@@ -161,7 +161,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         for &(ref span, ref qualname) in sub_paths.iter() {
             self.fmt.sub_mod_ref_str(path.span,
                                      *span,
-                                     qualname.index(&FullRange),
+                                     &qualname[],
                                      self.cur_scope);
         }
     }
@@ -180,17 +180,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         let (ref span, ref qualname) = sub_paths[len-2];
         self.fmt.sub_type_ref_str(path.span,
                                   *span,
-                                  qualname.index(&FullRange));
+                                  &qualname[]);
 
         // write the other sub-paths
         if len <= 2 {
             return;
         }
-        let sub_paths = sub_paths.index(&(0..(len-2)));
+        let sub_paths = &sub_paths[0..(len-2)];
         for &(ref span, ref qualname) in sub_paths.iter() {
             self.fmt.sub_mod_ref_str(path.span,
                                      *span,
-                                     qualname.index(&FullRange),
+                                     &qualname[],
                                      self.cur_scope);
         }
     }
@@ -198,8 +198,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
     // looks up anything, not just a type
     fn lookup_type_ref(&self, ref_id: NodeId) -> Option<DefId> {
         if !self.analysis.ty_cx.def_map.borrow().contains_key(&ref_id) {
-            self.sess.bug(format!("def_map has no key for {} in lookup_type_ref",
-                                  ref_id).index(&FullRange));
+            self.sess.bug(&format!("def_map has no key for {} in lookup_type_ref",
+                                  ref_id)[]);
         }
         let def = (*self.analysis.ty_cx.def_map.borrow())[ref_id];
         match def {
@@ -211,8 +211,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
     fn lookup_def_kind(&self, ref_id: NodeId, span: Span) -> Option<recorder::Row> {
         let def_map = self.analysis.ty_cx.def_map.borrow();
         if !def_map.contains_key(&ref_id) {
-            self.sess.span_bug(span, format!("def_map has no key for {} in lookup_def_kind",
-                                             ref_id).index(&FullRange));
+            self.sess.span_bug(span, &format!("def_map has no key for {} in lookup_def_kind",
+                                             ref_id)[]);
         }
         let def = (*def_map)[ref_id];
         match def {
@@ -240,8 +240,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
             def::DefUse(_) |
             def::DefMethod(..) |
             def::DefPrimTy(_) => {
-                self.sess.span_bug(span, format!("lookup_def_kind for unexpected item: {:?}",
-                                                 def).index(&FullRange));
+                self.sess.span_bug(span, &format!("lookup_def_kind for unexpected item: {:?}",
+                                                 def)[]);
             },
         }
     }
@@ -262,8 +262,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                                     span_utils.span_for_last_ident(p.span),
                                     id,
                                     qualname,
-                                    path_to_string(p).index(&FullRange),
-                                    typ.index(&FullRange));
+                                    &path_to_string(p)[],
+                                    &typ[]);
             }
             self.collected_paths.clear();
         }
@@ -285,7 +285,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                     match item.node {
                         ast::ItemImpl(_, _, _, _, ref ty, _) => {
                             let mut result = String::from_str("<");
-                            result.push_str(ty_to_string(&**ty).index(&FullRange));
+                            result.push_str(&ty_to_string(&**ty)[]);
 
                             match ty::trait_of_item(&self.analysis.ty_cx,
                                                     ast_util::local_def(method.id)) {
@@ -301,18 +301,18 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                         }
                         _ => {
                             self.sess.span_bug(method.span,
-                                               format!("Container {} for method {} not an impl?",
-                                                       impl_id.node, method.id).index(&FullRange));
+                                               &format!("Container {} for method {} not an impl?",
+                                                       impl_id.node, method.id)[]);
                         },
                     }
                 },
                 _ => {
                     self.sess.span_bug(method.span,
-                                       format!("Container {} for method {} is not a node item {:?}",
-                                               impl_id.node,
-                                               method.id,
-                                               self.analysis.ty_cx.map.get(impl_id.node)
-                                              ).index(&FullRange));
+                                       &format!(
+                                           "Container {} for method {} is not a node item {:?}",
+                                           impl_id.node,
+                                           method.id,
+                                           self.analysis.ty_cx.map.get(impl_id.node))[]);
                 },
             },
             None => match ty::trait_of_item(&self.analysis.ty_cx,
@@ -327,21 +327,21 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                         }
                         _ => {
                             self.sess.span_bug(method.span,
-                                               format!("Could not find container {} for method {}",
-                                                       def_id.node, method.id).index(&FullRange));
+                                               &format!("Could not find container {} for method {}",
+                                                       def_id.node, method.id)[]);
                         }
                     }
                 },
                 None => {
                     self.sess.span_bug(method.span,
-                                       format!("Could not find container for method {}",
-                                               method.id).index(&FullRange));
+                                       &format!("Could not find container for method {}",
+                                               method.id)[]);
                 },
             },
         };
 
         qualname.push_str(get_ident(method.pe_ident()).get());
-        let qualname = qualname.index(&FullRange);
+        let qualname = &qualname[];
 
         // record the decl for this def (if it has one)
         let decl_id = ty::trait_item_of_item(&self.analysis.ty_cx,
@@ -430,13 +430,13 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                     Some(sub_span) => self.fmt.field_str(field.span,
                                                          Some(sub_span),
                                                          field.node.id,
-                                                         name.get().index(&FullRange),
-                                                         qualname.index(&FullRange),
-                                                         typ.index(&FullRange),
+                                                         &name.get()[],
+                                                         &qualname[],
+                                                         &typ[],
                                                          scope_id),
                     None => self.sess.span_bug(field.span,
-                                               format!("Could not find sub-span for field {}",
-                                                       qualname).index(&FullRange)),
+                                               &format!("Could not find sub-span for field {}",
+                                                       qualname)[]),
                 }
             },
             _ => (),
@@ -463,7 +463,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
             self.fmt.typedef_str(full_span,
                                  Some(*param_ss),
                                  param.id,
-                                 name.index(&FullRange),
+                                 &name[],
                                  "");
         }
         self.visit_generics(generics);
@@ -480,10 +480,10 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         self.fmt.fn_str(item.span,
                         sub_span,
                         item.id,
-                        qualname.index(&FullRange),
+                        &qualname[],
                         self.cur_scope);
 
-        self.process_formals(&decl.inputs, qualname.index(&FullRange));
+        self.process_formals(&decl.inputs, &qualname[]);
 
         // walk arg and return types
         for arg in decl.inputs.iter() {
@@ -497,7 +497,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         // walk the body
         self.nest(item.id, |v| v.visit_block(&*body));
 
-        self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id);
+        self.process_generic_params(ty_params, item.span, &qualname[], item.id);
     }
 
     fn process_static(&mut self,
@@ -519,9 +519,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                             sub_span,
                             item.id,
                             get_ident(item.ident).get(),
-                            qualname.index(&FullRange),
-                            value.index(&FullRange),
-                            ty_to_string(&*typ).index(&FullRange),
+                            &qualname[],
+                            &value[],
+                            &ty_to_string(&*typ)[],
                             self.cur_scope);
 
         // walk type and init value
@@ -542,9 +542,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                             sub_span,
                             item.id,
                             get_ident(item.ident).get(),
-                            qualname.index(&FullRange),
+                            &qualname[],
                             "",
-                            ty_to_string(&*typ).index(&FullRange),
+                            &ty_to_string(&*typ)[],
                             self.cur_scope);
 
         // walk type and init value
@@ -568,17 +568,17 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                             sub_span,
                             item.id,
                             ctor_id,
-                            qualname.index(&FullRange),
+                            &qualname[],
                             self.cur_scope,
-                            val.index(&FullRange));
+                            &val[]);
 
         // fields
         for field in def.fields.iter() {
-            self.process_struct_field_def(field, qualname.index(&FullRange), item.id);
+            self.process_struct_field_def(field, &qualname[], item.id);
             self.visit_ty(&*field.node.ty);
         }
 
-        self.process_generic_params(ty_params, item.span, qualname.index(&FullRange), item.id);
+        self.process_generic_params(ty_params, item.span, &qualname[], item.id);
     }
 
     fn process_enum(&mut self,
@@ -591,12 +591,12 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
             Some(sub_span) => self.fmt.enum_str(item.span,
                                                 Some(sub_span),
                                                 item.id,
-                                                enum_name.index(&FullRange),
+                                                &enum_name[],
                                                 self.cur_scope,
-                                                val.index(&FullRange)),
+                                                &val[]),
             None => self.sess.span_bug(item.span,
-                                       format!("Could not find subspan for enum {}",
-                                               enum_name).index(&FullRange)),
+                                       &format!("Could not find subspan for enum {}",
+                                               enum_name)[]),
         }
         for variant in enum_definition.variants.iter() {
             let name = get_ident(variant.node.name);
@@ -612,9 +612,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                                                self.span.span_for_first_ident(variant.span),
                                                variant.node.id,
                                                name,
-                                               qualname.index(&FullRange),
-                                               enum_name.index(&FullRange),
-                                               val.index(&FullRange),
+                                               &qualname[],
+                                               &enum_name[],
+                                               &val[],
                                                item.id);
                     for arg in args.iter() {
                         self.visit_ty(&*arg.ty);
@@ -630,9 +630,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                         self.span.span_for_first_ident(variant.span),
                         variant.node.id,
                         ctor_id,
-                        qualname.index(&FullRange),
-                        enum_name.index(&FullRange),
-                        val.index(&FullRange),
+                        &qualname[],
+                        &enum_name[],
+                        &val[],
                         item.id);
 
                     for field in struct_def.fields.iter() {
@@ -643,7 +643,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
             }
         }
 
-        self.process_generic_params(ty_params, item.span, enum_name.index(&FullRange), item.id);
+        self.process_generic_params(ty_params, item.span, &enum_name[], item.id);
     }
 
     fn process_impl(&mut self,
@@ -703,9 +703,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         self.fmt.trait_str(item.span,
                            sub_span,
                            item.id,
-                           qualname.index(&FullRange),
+                           &qualname[],
                            self.cur_scope,
-                           val.index(&FullRange));
+                           &val[]);
 
         // super-traits
         for super_bound in trait_refs.iter() {
@@ -737,7 +737,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         }
 
         // walk generics and methods
-        self.process_generic_params(generics, item.span, qualname.index(&FullRange), item.id);
+        self.process_generic_params(generics, item.span, &qualname[], item.id);
         for method in methods.iter() {
             self.visit_trait_item(method)
         }
@@ -755,9 +755,9 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
         self.fmt.mod_str(item.span,
                          sub_span,
                          item.id,
-                         qualname.index(&FullRange),
+                         &qualname[],
                          self.cur_scope,
-                         filename.index(&FullRange));
+                         &filename[]);
 
         self.nest(item.id, |v| visit::walk_mod(v, m));
     }
@@ -840,8 +840,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                                                           def_id,
                                                           self.cur_scope),
             _ => self.sess.span_bug(span,
-                                    format!("Unexpected def kind while looking up path in '{}'",
-                                            self.span.snippet(span)).index(&FullRange)),
+                                    &format!("Unexpected def kind while looking up path in '{}'",
+                                            self.span.snippet(span))[]),
         }
         // modules or types in the path prefix
         match *def {
@@ -959,7 +959,7 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                                self.cur_scope);
 
         // walk receiver and args
-        visit::walk_exprs(self, args.index(&FullRange));
+        visit::walk_exprs(self, &args[]);
     }
 
     fn process_pat(&mut self, p:&ast::Pat) {
@@ -975,8 +975,8 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
                     Some(sd) => sd,
                     None => {
                         self.sess.span_bug(p.span,
-                                           format!("Could not find struct_def for `{}`",
-                                                   self.span.snippet(p.span)).index(&FullRange));
+                                           &format!("Could not find struct_def for `{}`",
+                                                   self.span.snippet(p.span))[]);
                     }
                 };
                 for &Spanned { node: ref field, span } in fields.iter() {
@@ -1061,8 +1061,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                 self.fmt.typedef_str(item.span,
                                      sub_span,
                                      item.id,
-                                     qualname.index(&FullRange),
-                                     value.index(&FullRange));
+                                     &qualname[],
+                                     &value[]);
 
                 self.visit_ty(&**ty);
                 self.process_generic_params(ty_params, item.span, qualname.as_slice(), item.id);
@@ -1121,13 +1121,13 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                     },
                     None => {
                         self.sess.span_bug(method_type.span,
-                                           format!("Could not find trait for method {}",
-                                                   method_type.id).index(&FullRange));
+                                           &format!("Could not find trait for method {}",
+                                                   method_type.id)[]);
                     },
                 };
 
                 qualname.push_str(get_ident(method_type.ident).get());
-                let qualname = qualname.index(&FullRange);
+                let qualname = &qualname[];
 
                 let sub_span = self.span.sub_span_after_keyword(method_type.span, keywords::Fn);
                 self.fmt.method_decl_str(method_type.span,
@@ -1262,7 +1262,7 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                                           id,
                                           cnum,
                                           name,
-                                          s.index(&FullRange),
+                                          &s[],
                                           self.cur_scope);
             },
         }
@@ -1371,8 +1371,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                 }
 
                 let mut id = String::from_str("$");
-                id.push_str(ex.id.to_string().index(&FullRange));
-                self.process_formals(&decl.inputs, id.index(&FullRange));
+                id.push_str(&ex.id.to_string()[]);
+                self.process_formals(&decl.inputs, &id[]);
 
                 // walk arg and return types
                 for arg in decl.inputs.iter() {
@@ -1418,8 +1418,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
             let def_map = self.analysis.ty_cx.def_map.borrow();
             if !def_map.contains_key(&id) {
                 self.sess.span_bug(p.span,
-                                   format!("def_map has no key for {} in visit_arm",
-                                           id).index(&FullRange));
+                                   &format!("def_map has no key for {} in visit_arm",
+                                           id)[]);
             }
             let def = &(*def_map)[id];
             match *def {
@@ -1434,8 +1434,8 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
                     self.fmt.variable_str(p.span,
                                           Some(p.span),
                                           id,
-                                          path_to_string(p).index(&FullRange),
-                                          value.index(&FullRange),
+                                          &path_to_string(p)[],
+                                          &value[],
                                           "")
                 }
                 def::DefVariant(..) => {
@@ -1490,9 +1490,9 @@ impl<'l, 'tcx, 'v> Visitor<'v> for DxrVisitor<'l, 'tcx> {
             self.fmt.variable_str(p.span,
                                   sub_span,
                                   id,
-                                  path_to_string(p).index(&FullRange),
-                                  value.index(&FullRange),
-                                  typ.index(&FullRange));
+                                  &path_to_string(p)[],
+                                  &value[],
+                                  &typ[]);
         }
         self.collected_paths.clear();
 
@@ -1511,7 +1511,7 @@ pub fn process_crate(sess: &Session,
     }
 
     assert!(analysis.glob_map.is_some());
-    let cratename = match attr::find_crate_name(krate.attrs.index(&FullRange)) {
+    let cratename = match attr::find_crate_name(&krate.attrs[]) {
         Some(name) => name.get().to_string(),
         None => {
             info!("Could not find crate name, using 'unknown_crate'");
@@ -1531,8 +1531,8 @@ pub fn process_crate(sess: &Session,
     };
 
     match fs::mkdir_recursive(&root_path, io::USER_RWX) {
-        Err(e) => sess.err(format!("Could not create directory {}: {}",
-                           root_path.display(), e).index(&FullRange)),
+        Err(e) => sess.err(&format!("Could not create directory {}: {}",
+                           root_path.display(), e)[]),
         _ => (),
     }
 
@@ -1549,7 +1549,7 @@ pub fn process_crate(sess: &Session,
         Ok(f) => box f,
         Err(e) => {
             let disp = root_path.display();
-            sess.fatal(format!("Could not open {}: {}", disp, e).index(&FullRange));
+            sess.fatal(&format!("Could not open {}: {}", disp, e)[]);
         }
     };
     root_path.pop();
@@ -1575,7 +1575,7 @@ pub fn process_crate(sess: &Session,
         cur_scope: 0
     };
 
-    visitor.dump_crate_info(cratename.index(&FullRange), krate);
+    visitor.dump_crate_info(&cratename[], krate);
 
     visit::walk_crate(&mut visitor, krate);
 }
diff --git a/src/librustc_trans/save/recorder.rs b/src/librustc_trans/save/recorder.rs
index bb0fb38700208..23598751c08d7 100644
--- a/src/librustc_trans/save/recorder.rs
+++ b/src/librustc_trans/save/recorder.rs
@@ -41,7 +41,7 @@ impl Recorder {
         assert!(self.dump_spans);
         let result = format!("span,kind,{},{},text,\"{}\"\n",
                              kind, su.extent_str(span), escape(su.snippet(span)));
-        self.record(result.index(&FullRange));
+        self.record(&result[]);
     }
 }
 
@@ -158,17 +158,17 @@ impl<'a> FmtStrs<'a> {
                            values: Vec<String>,
                            span: Span) -> Option<String> {
         if values.len() != fields.len() {
-            self.span.sess.span_bug(span, format!(
+            self.span.sess.span_bug(span, &format!(
                 "Mismatch between length of fields for '{}', expected '{}', found '{}'",
-                kind, fields.len(), values.len()).index(&FullRange));
+                kind, fields.len(), values.len())[]);
         }
 
         let values = values.iter().map(|s| {
             // Never take more than 1020 chars
             if s.len() > 1020 {
-                s.index(&(0..1020))
+                &s[0..1020]
             } else {
-                s.index(&FullRange)
+                &s[]
             }
         });
 
@@ -184,7 +184,7 @@ impl<'a> FmtStrs<'a> {
             }
         )));
         Some(strs.fold(String::new(), |mut s, ss| {
-            s.push_str(ss.index(&FullRange));
+            s.push_str(&ss[]);
             s
         }))
     }
@@ -196,9 +196,9 @@ impl<'a> FmtStrs<'a> {
         let (label, ref fields, needs_span, dump_spans) = FmtStrs::lookup_row(kind);
 
         if needs_span {
-            self.span.sess.span_bug(span, format!(
+            self.span.sess.span_bug(span, &format!(
                 "Called record_without_span for '{}' which does requires a span",
-                label).index(&FullRange));
+                label)[]);
         }
         assert!(!dump_spans);
 
@@ -212,9 +212,9 @@ impl<'a> FmtStrs<'a> {
         };
 
         let mut result = String::from_str(label);
-        result.push_str(values_str.index(&FullRange));
+        result.push_str(&values_str[]);
         result.push_str("\n");
-        self.recorder.record(result.index(&FullRange));
+        self.recorder.record(&result[]);
     }
 
     pub fn record_with_span(&mut self,
@@ -245,7 +245,7 @@ impl<'a> FmtStrs<'a> {
             None => return,
         };
         let result = format!("{},{}{}\n", label, self.span.extent_str(sub_span), values_str);
-        self.recorder.record(result.index(&FullRange));
+        self.recorder.record(&result[]);
     }
 
     pub fn check_and_record(&mut self,
@@ -275,7 +275,7 @@ impl<'a> FmtStrs<'a> {
         // variable def's node id
         let mut qualname = String::from_str(name);
         qualname.push_str("$");
-        qualname.push_str(id.to_string().index(&FullRange));
+        qualname.push_str(&id.to_string()[]);
         self.check_and_record(Variable,
                               span,
                               sub_span,
diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs
index 8d249b8bfe903..77343612ac88b 100644
--- a/src/librustc_trans/save/span_utils.rs
+++ b/src/librustc_trans/save/span_utils.rs
@@ -217,8 +217,8 @@ impl<'a> SpanUtils<'a> {
         if bracket_count != 0 {
             let loc = self.sess.codemap().lookup_char_pos(span.lo);
             self.sess.span_bug(span,
-                format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
-                        self.snippet(span), loc.file.name, loc.line).index(&FullRange));
+                &format!("Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
+                        self.snippet(span), loc.file.name, loc.line)[]);
         }
         if result.is_none() && prev.tok.is_ident() && bracket_count == 0 {
             return self.make_sub_span(span, Some(prev.sp));
@@ -242,9 +242,9 @@ impl<'a> SpanUtils<'a> {
             if ts.tok == token::Eof {
                 if bracket_count != 0 {
                     let loc = self.sess.codemap().lookup_char_pos(span.lo);
-                    self.sess.span_bug(span, format!(
+                    self.sess.span_bug(span, &format!(
                         "Mis-counted brackets when breaking path? Parsing '{}' in {}, line {}",
-                         self.snippet(span), loc.file.name, loc.line).index(&FullRange));
+                         self.snippet(span), loc.file.name, loc.line)[]);
                 }
                 return result
             }
diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs
index 49b9ef5a40ade..fc19a582db2f5 100644
--- a/src/librustc_trans/trans/_match.rs
+++ b/src/librustc_trans/trans/_match.rs
@@ -427,7 +427,7 @@ fn enter_match<'a, 'b, 'p, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
     let _indenter = indenter();
 
     m.iter().filter_map(|br| {
-        e(br.pats.index(&FullRange)).map(|pats| {
+        e(&br.pats[]).map(|pats| {
             let this = br.pats[col];
             let mut bound_ptrs = br.bound_ptrs.clone();
             match this.node {
@@ -471,8 +471,8 @@ fn enter_default<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     // Collect all of the matches that can match against anything.
     enter_match(bcx, dm, m, col, val, |pats| {
         if pat_is_binding_or_wild(dm, &*pats[col]) {
-            let mut r = pats.index(&(0..col)).to_vec();
-            r.push_all(pats.index(&((col + 1)..)));
+            let mut r = pats[0..col].to_vec();
+            r.push_all(&pats[(col + 1)..]);
             Some(r)
         } else {
             None
@@ -548,7 +548,7 @@ fn enter_opt<'a, 'p, 'blk, 'tcx>(
         param_env: param_env,
     };
     enter_match(bcx, dm, m, col, val, |pats|
-        check_match::specialize(&mcx, pats.index(&FullRange), &ctor, col, variant_size)
+        check_match::specialize(&mcx, &pats[], &ctor, col, variant_size)
     )
 }
 
@@ -789,8 +789,8 @@ fn compare_values<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
                                -> Result<'blk, 'tcx> {
         let did = langcall(cx,
                            None,
-                           format!("comparison of `{}`",
-                                   cx.ty_to_string(rhs_t)).index(&FullRange),
+                           &format!("comparison of `{}`",
+                                   cx.ty_to_string(rhs_t))[],
                            StrEqFnLangItem);
         callee::trans_lang_call(cx, did, &[lhs, rhs], None)
     }
@@ -945,7 +945,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             if has_nested_bindings(m, col) {
                 let expanded = expand_nested_bindings(bcx, m, col, val);
                 compile_submatch_continue(bcx,
-                                          expanded.index(&FullRange),
+                                          &expanded[],
                                           vals,
                                           chk,
                                           col,
@@ -967,7 +967,7 @@ fn compile_submatch<'a, 'p, 'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     bcx = compile_guard(bcx,
                                         &**guard_expr,
                                         m[0].data,
-                                        m.index(&(1..m.len())),
+                                        &m[1..m.len()],
                                         vals,
                                         chk,
                                         has_genuine_default);
@@ -990,8 +990,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
     let tcx = bcx.tcx();
     let dm = &tcx.def_map;
 
-    let mut vals_left = vals.index(&(0u..col)).to_vec();
-    vals_left.push_all(vals.index(&((col + 1u)..)));
+    let mut vals_left = vals[0u..col].to_vec();
+    vals_left.push_all(&vals[(col + 1u)..]);
     let ccx = bcx.fcx.ccx;
 
     // Find a real id (we're adding placeholder wildcard patterns, but
@@ -1191,10 +1191,10 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
         }
         let opt_ms = enter_opt(opt_cx, pat_id, dm, m, opt, col, size, val);
         let mut opt_vals = unpacked;
-        opt_vals.push_all(vals_left.index(&FullRange));
+        opt_vals.push_all(&vals_left[]);
         compile_submatch(opt_cx,
-                         opt_ms.index(&FullRange),
-                         opt_vals.index(&FullRange),
+                         &opt_ms[],
+                         &opt_vals[],
                          branch_chk.as_ref().unwrap_or(chk),
                          has_genuine_default);
     }
@@ -1213,8 +1213,8 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             }
             _ => {
                 compile_submatch(else_cx,
-                                 defaults.index(&FullRange),
-                                 vals_left.index(&FullRange),
+                                 &defaults[],
+                                 &vals_left[],
                                  chk,
                                  has_genuine_default);
             }
@@ -1333,7 +1333,7 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat,
                                  "__llmatch");
                 trmode = TrByCopy(alloca_no_lifetime(bcx,
                                          llvariable_ty,
-                                         bcx.ident(ident).index(&FullRange)));
+                                         &bcx.ident(ident)[]));
             }
             ast::BindByValue(_) => {
                 // in this case, the final type of the variable will be T,
@@ -1341,13 +1341,13 @@ fn create_bindings_map<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, pat: &ast::Pat,
                 // above
                 llmatch = alloca_no_lifetime(bcx,
                                  llvariable_ty.ptr_to(),
-                                 bcx.ident(ident).index(&FullRange));
+                                 &bcx.ident(ident)[]);
                 trmode = TrByMove;
             }
             ast::BindByRef(_) => {
                 llmatch = alloca_no_lifetime(bcx,
                                  llvariable_ty,
-                                 bcx.ident(ident).index(&FullRange));
+                                 &bcx.ident(ident)[]);
                 trmode = TrByRef;
             }
         };
@@ -1415,7 +1415,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
         && arm.pats.last().unwrap().node == ast::PatWild(ast::PatWildSingle)
     });
 
-    compile_submatch(bcx, matches.index(&FullRange), &[discr_datum.val], &chk, has_default);
+    compile_submatch(bcx, &matches[], &[discr_datum.val], &chk, has_default);
 
     let mut arm_cxs = Vec::new();
     for arm_data in arm_datas.iter() {
@@ -1429,7 +1429,7 @@ fn trans_match_inner<'blk, 'tcx>(scope_cx: Block<'blk, 'tcx>,
         arm_cxs.push(bcx);
     }
 
-    bcx = scope_cx.fcx.join_blocks(match_id, arm_cxs.index(&FullRange));
+    bcx = scope_cx.fcx.join_blocks(match_id, &arm_cxs[]);
     return bcx;
 }
 
@@ -1582,7 +1582,7 @@ fn mk_binding_alloca<'blk, 'tcx, A, F>(bcx: Block<'blk, 'tcx>,
     let var_ty = node_id_type(bcx, p_id);
 
     // Allocate memory on stack for the binding.
-    let llval = alloc_ty(bcx, var_ty, bcx.ident(*ident).index(&FullRange));
+    let llval = alloc_ty(bcx, var_ty, &bcx.ident(*ident)[]);
 
     // Subtle: be sure that we *populate* the memory *before*
     // we schedule the cleanup.
@@ -1619,8 +1619,8 @@ fn bind_irrefutable_pat<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
            pat.repr(bcx.tcx()));
 
     if bcx.sess().asm_comments() {
-        add_comment(bcx, format!("bind_irrefutable_pat(pat={})",
-                                 pat.repr(bcx.tcx())).index(&FullRange));
+        add_comment(bcx, &format!("bind_irrefutable_pat(pat={})",
+                                 pat.repr(bcx.tcx()))[]);
     }
 
     let _indenter = indenter();
diff --git a/src/librustc_trans/trans/adt.rs b/src/librustc_trans/trans/adt.rs
index 231de71848a1d..92883371ec9db 100644
--- a/src/librustc_trans/trans/adt.rs
+++ b/src/librustc_trans/trans/adt.rs
@@ -51,7 +51,11 @@ use std::rc::Rc;
 use llvm::{ValueRef, True, IntEQ, IntNE};
 use back::abi::FAT_PTR_ADDR;
 use middle::subst;
-use middle::subst::Subst;
+use middle::ty::{self, Ty, UnboxedClosureTyper};
+use middle::ty::Disr;
+use syntax::ast;
+use syntax::attr;
+use syntax::attr::IntType;
 use trans::_match;
 use trans::build::*;
 use trans::cleanup;
@@ -59,13 +63,9 @@ use trans::cleanup::CleanupMethods;
 use trans::common::*;
 use trans::datum;
 use trans::machine;
+use trans::monomorphize;
 use trans::type_::Type;
 use trans::type_of;
-use middle::ty::{self, Ty, UnboxedClosureTyper};
-use middle::ty::Disr;
-use syntax::ast;
-use syntax::attr;
-use syntax::attr::IntType;
 use util::ppaux::ty_to_string;
 
 type Hint = attr::ReprAttr;
@@ -154,28 +154,29 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                      t: Ty<'tcx>) -> Repr<'tcx> {
     match t.sty {
         ty::ty_tup(ref elems) => {
-            Univariant(mk_struct(cx, elems.index(&FullRange), false, t), false)
+            Univariant(mk_struct(cx, &elems[], false, t), false)
         }
         ty::ty_struct(def_id, substs) => {
             let fields = ty::lookup_struct_fields(cx.tcx(), def_id);
             let mut ftys = fields.iter().map(|field| {
-                ty::lookup_field_type(cx.tcx(), def_id, field.id, substs)
+                let fty = ty::lookup_field_type(cx.tcx(), def_id, field.id, substs);
+                monomorphize::normalize_associated_type(cx.tcx(), &fty)
             }).collect::<Vec<_>>();
             let packed = ty::lookup_packed(cx.tcx(), def_id);
             let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag();
             if dtor { ftys.push(cx.tcx().types.bool); }
 
-            Univariant(mk_struct(cx, ftys.index(&FullRange), packed, t), dtor)
+            Univariant(mk_struct(cx, &ftys[], packed, t), dtor)
         }
         ty::ty_unboxed_closure(def_id, _, substs) => {
             let typer = NormalizingUnboxedClosureTyper::new(cx.tcx());
             let upvars = typer.unboxed_closure_upvars(def_id, substs).unwrap();
             let upvar_types = upvars.iter().map(|u| u.ty).collect::<Vec<_>>();
-            Univariant(mk_struct(cx, upvar_types.index(&FullRange), false, t), false)
+            Univariant(mk_struct(cx, &upvar_types[], false, t), false)
         }
         ty::ty_enum(def_id, substs) => {
             let cases = get_cases(cx.tcx(), def_id, substs);
-            let hint = *ty::lookup_repr_hints(cx.tcx(), def_id).index(&FullRange).get(0)
+            let hint = *ty::lookup_repr_hints(cx.tcx(), def_id)[].get(0)
                 .unwrap_or(&attr::ReprAny);
 
             let dtor = ty::ty_dtor(cx.tcx(), def_id).has_drop_flag();
@@ -185,7 +186,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 // (Typechecking will reject discriminant-sizing attrs.)
                 assert_eq!(hint, attr::ReprAny);
                 let ftys = if dtor { vec!(cx.tcx().types.bool) } else { vec!() };
-                return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t),
+                return Univariant(mk_struct(cx, &ftys[], false, t),
                                   dtor);
             }
 
@@ -205,10 +206,10 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             // non-empty body, explicit discriminants should have
             // been rejected by a checker before this point.
             if !cases.iter().enumerate().all(|(i,c)| c.discr == (i as Disr)) {
-                cx.sess().bug(format!("non-C-like enum {} with specified \
+                cx.sess().bug(&format!("non-C-like enum {} with specified \
                                       discriminants",
                                       ty::item_path_str(cx.tcx(),
-                                                        def_id)).index(&FullRange));
+                                                        def_id))[]);
             }
 
             if cases.len() == 1 {
@@ -217,7 +218,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 assert_eq!(hint, attr::ReprAny);
                 let mut ftys = cases[0].tys.clone();
                 if dtor { ftys.push(cx.tcx().types.bool); }
-                return Univariant(mk_struct(cx, ftys.index(&FullRange), false, t),
+                return Univariant(mk_struct(cx, &ftys[], false, t),
                                   dtor);
             }
 
@@ -226,7 +227,7 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 let mut discr = 0;
                 while discr < 2 {
                     if cases[1 - discr].is_zerolen(cx, t) {
-                        let st = mk_struct(cx, cases[discr].tys.index(&FullRange),
+                        let st = mk_struct(cx, &cases[discr].tys[],
                                            false, t);
                         match cases[discr].find_ptr(cx) {
                             Some(ref df) if df.len() == 1 && st.fields.len() == 1 => {
@@ -316,17 +317,17 @@ fn represent_type_uncached<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
             let fields : Vec<_> = cases.iter().map(|c| {
                 let mut ftys = vec!(ty_of_inttype(cx.tcx(), ity));
-                ftys.push_all(c.tys.index(&FullRange));
+                ftys.push_all(&c.tys[]);
                 if dtor { ftys.push(cx.tcx().types.bool); }
-                mk_struct(cx, ftys.index(&FullRange), false, t)
+                mk_struct(cx, &ftys[], false, t)
             }).collect();
 
-            ensure_enum_fits_in_address_space(cx, ity, fields.index(&FullRange), t);
+            ensure_enum_fits_in_address_space(cx, ity, &fields[], t);
 
             General(ity, fields, dtor)
         }
-        _ => cx.sess().bug(format!("adt::represent_type called on non-ADT type: {}",
-                           ty_to_string(cx.tcx(), t)).index(&FullRange))
+        _ => cx.sess().bug(&format!("adt::represent_type called on non-ADT type: {}",
+                           ty_to_string(cx.tcx(), t))[])
     }
 }
 
@@ -412,7 +413,7 @@ fn find_discr_field_candidate<'tcx>(tcx: &ty::ctxt<'tcx>,
 
 impl<'tcx> Case<'tcx> {
     fn is_zerolen<'a>(&self, cx: &CrateContext<'a, 'tcx>, scapegoat: Ty<'tcx>) -> bool {
-        mk_struct(cx, self.tys.index(&FullRange), false, scapegoat).size == 0
+        mk_struct(cx, &self.tys[], false, scapegoat).size == 0
     }
 
     fn find_ptr<'a>(&self, cx: &CrateContext<'a, 'tcx>) -> Option<DiscrField> {
@@ -432,7 +433,7 @@ fn get_cases<'tcx>(tcx: &ty::ctxt<'tcx>,
                    -> Vec<Case<'tcx>> {
     ty::enum_variants(tcx, def_id).iter().map(|vi| {
         let arg_tys = vi.args.iter().map(|&raw_ty| {
-            raw_ty.subst(tcx, substs)
+            monomorphize::apply_param_substs(tcx, substs, &raw_ty)
         }).collect();
         Case { discr: vi.disr_val, tys: arg_tys }
     }).collect()
@@ -451,9 +452,9 @@ fn mk_struct<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
            .map(|&ty| type_of::sizing_type_of(cx, ty)).collect()
     };
 
-    ensure_struct_fits_in_address_space(cx, lltys.index(&FullRange), packed, scapegoat);
+    ensure_struct_fits_in_address_space(cx, &lltys[], packed, scapegoat);
 
-    let llty_rec = Type::struct_(cx, lltys.index(&FullRange), packed);
+    let llty_rec = Type::struct_(cx, &lltys[], packed);
     Struct {
         size: machine::llsize_of_alloc(cx, llty_rec),
         align: machine::llalign_of_min(cx, llty_rec),
@@ -502,7 +503,7 @@ fn range_to_inttype(cx: &CrateContext, hint: Hint, bounds: &IntBounds) -> IntTyp
             return ity;
         }
         attr::ReprExtern => {
-            attempts = match cx.sess().target.target.arch.index(&FullRange) {
+            attempts = match &cx.sess().target.target.arch[] {
                 // WARNING: the ARM EABI has two variants; the one corresponding to `at_least_32`
                 // appears to be used on Linux and NetBSD, but some systems may use the variant
                 // corresponding to `choose_shortest`.  However, we don't run on those yet...?
@@ -628,7 +629,7 @@ pub fn finish_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     match *r {
         CEnum(..) | General(..) | RawNullablePointer { .. } => { }
         Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } =>
-            llty.set_struct_body(struct_llfields(cx, st, false, false).index(&FullRange),
+            llty.set_struct_body(&struct_llfields(cx, st, false, false)[],
                                  st.packed)
     }
 }
@@ -644,7 +645,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => {
             match name {
                 None => {
-                    Type::struct_(cx, struct_llfields(cx, st, sizing, dst).index(&FullRange),
+                    Type::struct_(cx, &struct_llfields(cx, st, sizing, dst)[],
                                   st.packed)
                 }
                 Some(name) => { assert_eq!(sizing, false); Type::named_struct(cx, name) }
@@ -663,7 +664,7 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             // of the size.
             //
             // FIXME #10604: this breaks when vector types are present.
-            let (size, align) = union_size_and_align(sts.index(&FullRange));
+            let (size, align) = union_size_and_align(&sts[]);
             let align_s = align as u64;
             let discr_ty = ll_inttype(cx, ity);
             let discr_size = machine::llsize_of_alloc(cx, discr_ty);
@@ -684,10 +685,10 @@ fn generic_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                           Type::array(&discr_ty, align_s / discr_size - 1),
                           fill_ty];
             match name {
-                None => Type::struct_(cx, fields.index(&FullRange), false),
+                None => Type::struct_(cx, &fields[], false),
                 Some(name) => {
                     let mut llty = Type::named_struct(cx, name);
-                    llty.set_struct_body(fields.index(&FullRange), false);
+                    llty.set_struct_body(&fields[], false);
                     llty
                 }
             }
@@ -765,7 +766,7 @@ pub fn trans_get_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>,
 
 fn struct_wrapped_nullable_bitdiscr(bcx: Block, nndiscr: Disr, discrfield: &DiscrField,
                                     scrutinee: ValueRef) -> ValueRef {
-    let llptrptr = GEPi(bcx, scrutinee, discrfield.index(&FullRange));
+    let llptrptr = GEPi(bcx, scrutinee, &discrfield[]);
     let llptr = Load(bcx, llptrptr);
     let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
     ICmp(bcx, cmp, llptr, C_null(val_ty(llptr)))
@@ -853,7 +854,7 @@ pub fn trans_set_discr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, r: &Repr<'tcx>,
         }
         StructWrappedNullablePointer { nndiscr, ref discrfield, .. } => {
             if discr != nndiscr {
-                let llptrptr = GEPi(bcx, val, discrfield.index(&FullRange));
+                let llptrptr = GEPi(bcx, val, &discrfield[]);
                 let llptrty = val_ty(llptrptr).element_type();
                 Store(bcx, C_null(llptrty), llptrptr)
             }
@@ -935,7 +936,7 @@ pub fn struct_field_ptr<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, st: &Struct<'tcx>, v
     let val = if needs_cast {
         let ccx = bcx.ccx();
         let fields = st.fields.iter().map(|&ty| type_of::type_of(ccx, ty)).collect::<Vec<_>>();
-        let real_ty = Type::struct_(ccx, fields.index(&FullRange), st.packed);
+        let real_ty = Type::struct_(ccx, &fields[], st.packed);
         PointerCast(bcx, val, real_ty.ptr_to())
     } else {
         val
@@ -967,14 +968,14 @@ pub fn fold_variants<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
 
             for (discr, case) in cases.iter().enumerate() {
                 let mut variant_cx = fcx.new_temp_block(
-                    format!("enum-variant-iter-{}", discr.to_string()).index(&FullRange)
+                    &format!("enum-variant-iter-{}", &discr.to_string())[]
                 );
                 let rhs_val = C_integral(ll_inttype(ccx, ity), discr as u64, true);
                 AddCase(llswitch, rhs_val, variant_cx.llbb);
 
                 let fields = case.fields.iter().map(|&ty|
                     type_of::type_of(bcx.ccx(), ty)).collect::<Vec<_>>();
-                let real_ty = Type::struct_(ccx, fields.index(&FullRange), case.packed);
+                let real_ty = Type::struct_(ccx, &fields[], case.packed);
                 let variant_value = PointerCast(variant_cx, value, real_ty.ptr_to());
 
                 variant_cx = f(variant_cx, case, variant_value);
@@ -1051,14 +1052,14 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr
             let lldiscr = C_integral(ll_inttype(ccx, ity), discr as u64, true);
             let mut f = vec![lldiscr];
             f.push_all(vals);
-            let mut contents = build_const_struct(ccx, case, f.index(&FullRange));
+            let mut contents = build_const_struct(ccx, case, &f[]);
             contents.push_all(&[padding(ccx, max_sz - case.size)]);
-            C_struct(ccx, contents.index(&FullRange), false)
+            C_struct(ccx, &contents[], false)
         }
         Univariant(ref st, _dro) => {
             assert!(discr == 0);
             let contents = build_const_struct(ccx, st, vals);
-            C_struct(ccx, contents.index(&FullRange), st.packed)
+            C_struct(ccx, &contents[], st.packed)
         }
         RawNullablePointer { nndiscr, nnty, .. } => {
             if discr == nndiscr {
@@ -1070,9 +1071,9 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr
         }
         StructWrappedNullablePointer { ref nonnull, nndiscr, .. } => {
             if discr == nndiscr {
-                C_struct(ccx, build_const_struct(ccx,
+                C_struct(ccx, &build_const_struct(ccx,
                                                  nonnull,
-                                                 vals).index(&FullRange),
+                                                 vals)[],
                          false)
             } else {
                 let vals = nonnull.fields.iter().map(|&ty| {
@@ -1080,9 +1081,9 @@ pub fn trans_const<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, r: &Repr<'tcx>, discr
                     // field; see #8506.
                     C_null(type_of::sizing_type_of(ccx, ty))
                 }).collect::<Vec<ValueRef>>();
-                C_struct(ccx, build_const_struct(ccx,
+                C_struct(ccx, &build_const_struct(ccx,
                                                  nonnull,
-                                                 vals.index(&FullRange)).index(&FullRange),
+                                                 &vals[])[],
                          false)
             }
         }
diff --git a/src/librustc_trans/trans/asm.rs b/src/librustc_trans/trans/asm.rs
index 890f046be1b2e..9b6fa32405ffb 100644
--- a/src/librustc_trans/trans/asm.rs
+++ b/src/librustc_trans/trans/asm.rs
@@ -71,7 +71,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
                                     callee::DontAutorefArg)
         })
     }).collect::<Vec<_>>();
-    inputs.push_all(ext_inputs.index(&FullRange));
+    inputs.push_all(&ext_inputs[]);
 
     // no failure occurred preparing operands, no need to cleanup
     fcx.pop_custom_cleanup_scope(temp_scope);
@@ -91,18 +91,18 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
         if !clobbers.is_empty() {
             clobbers.push(',');
         }
-        clobbers.push_str(more_clobbers.index(&FullRange));
+        clobbers.push_str(&more_clobbers[]);
     }
 
     // Add the clobbers to our constraints list
     if clobbers.len() != 0 && constraints.len() != 0 {
         constraints.push(',');
-        constraints.push_str(clobbers.index(&FullRange));
+        constraints.push_str(&clobbers[]);
     } else {
-        constraints.push_str(clobbers.index(&FullRange));
+        constraints.push_str(&clobbers[]);
     }
 
-    debug!("Asm Constraints: {}", constraints.index(&FullRange));
+    debug!("Asm Constraints: {}", &constraints[]);
 
     let num_outputs = outputs.len();
 
@@ -112,7 +112,7 @@ pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
     } else if num_outputs == 1 {
         output_types[0]
     } else {
-        Type::struct_(bcx.ccx(), output_types.index(&FullRange), false)
+        Type::struct_(bcx.ccx(), &output_types[], false)
     };
 
     let dialect = match ia.dialect {
diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
index 057d0f378e6f4..74071a1de4c3d 100644
--- a/src/librustc_trans/trans/base.rs
+++ b/src/librustc_trans/trans/base.rs
@@ -249,7 +249,7 @@ fn get_extern_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<'tcx>,
     let f = decl_rust_fn(ccx, fn_ty, name);
 
     csearch::get_item_attrs(&ccx.sess().cstore, did, |attrs| {
-        set_llvm_fn_attrs(ccx, attrs.index(&FullRange), f)
+        set_llvm_fn_attrs(ccx, &attrs[], f)
     });
 
     ccx.externs().borrow_mut().insert(name.to_string(), f);
@@ -281,8 +281,15 @@ pub fn kind_for_unboxed_closure(ccx: &CrateContext, closure_id: ast::DefId)
 
 pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                               fn_ty: Ty<'tcx>, name: &str) -> ValueRef {
+    debug!("decl_rust_fn(fn_ty={}, name={:?})",
+           fn_ty.repr(ccx.tcx()),
+           name);
+
     let fn_ty = monomorphize::normalize_associated_type(ccx.tcx(), &fn_ty);
 
+    debug!("decl_rust_fn: fn_ty={} (after normalized associated types)",
+           fn_ty.repr(ccx.tcx()));
+
     let function_type; // placeholder so that the memory ownership works out ok
 
     let (sig, abi, env) = match fn_ty.sty {
@@ -305,10 +312,12 @@ pub fn decl_rust_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let sig = ty::erase_late_bound_regions(ccx.tcx(), sig);
     let sig = ty::Binder(sig);
 
+    debug!("decl_rust_fn: sig={} (after erasing regions)",
+           sig.repr(ccx.tcx()));
+
     let llfty = type_of_rust_fn(ccx, env, &sig, abi);
 
-    debug!("decl_rust_fn(sig={}, type={})",
-           sig.repr(ccx.tcx()),
+    debug!("decl_rust_fn: llfty={}",
            ccx.tn().type_to_string(llfty));
 
     let llfn = decl_fn(ccx, name, llvm::CCallConv, llfty, sig.0.output /* (1) */);
@@ -372,9 +381,9 @@ fn require_alloc_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     match bcx.tcx().lang_items.require(it) {
         Ok(id) => id,
         Err(s) => {
-            bcx.sess().fatal(format!("allocation of `{}` {}",
+            bcx.sess().fatal(&format!("allocation of `{}` {}",
                                      bcx.ty_to_string(info_ty),
-                                     s).index(&FullRange));
+                                     s)[]);
         }
     }
 }
@@ -493,7 +502,7 @@ pub fn unset_split_stack(f: ValueRef) {
 // silently mangles such symbols, breaking our linkage model.
 pub fn note_unique_llvm_symbol(ccx: &CrateContext, sym: String) {
     if ccx.all_llvm_symbols().borrow().contains(&sym) {
-        ccx.sess().bug(format!("duplicate LLVM symbol: {}", sym).index(&FullRange));
+        ccx.sess().bug(&format!("duplicate LLVM symbol: {}", sym)[]);
     }
     ccx.all_llvm_symbols().borrow_mut().insert(sym);
 }
@@ -530,7 +539,7 @@ pub fn get_res_dtor<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                      ty::mk_nil(ccx.tcx()));
         get_extern_fn(ccx,
                       &mut *ccx.externs().borrow_mut(),
-                      name.index(&FullRange),
+                      &name[],
                       llvm::CCallConv,
                       llty,
                       dtor_ty)
@@ -778,9 +787,9 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
                   for variant in (*variants).iter() {
                       let variant_cx =
                           fcx.new_temp_block(
-                              format!("enum-iter-variant-{}",
-                                      variant.disr_val.to_string().index(&FullRange))
-                                     .index(&FullRange));
+                              &format!("enum-iter-variant-{}",
+                                      &variant.disr_val.to_string()[])
+                              []);
                       match adt::trans_case(cx, &*repr, variant.disr_val) {
                           _match::SingleResult(r) => {
                               AddCase(llswitch, r.val, variant_cx.llbb)
@@ -804,8 +813,8 @@ pub fn iter_structural_ty<'blk, 'tcx, F>(cx: Block<'blk, 'tcx>,
           }
       }
       _ => {
-          cx.sess().unimpl(format!("type in iter_structural_ty: {}",
-                                   ty_to_string(cx.tcx(), t)).index(&FullRange))
+          cx.sess().unimpl(&format!("type in iter_structural_ty: {}",
+                                   ty_to_string(cx.tcx(), t))[])
       }
     }
     return cx;
@@ -886,8 +895,8 @@ pub fn fail_if_zero_or_overflows<'blk, 'tcx>(
             (ICmp(cx, llvm::IntEQ, rhs, zero), false)
         }
         _ => {
-            cx.sess().bug(format!("fail-if-zero on unexpected type: {}",
-                                  ty_to_string(cx.tcx(), rhs_t)).index(&FullRange));
+            cx.sess().bug(&format!("fail-if-zero on unexpected type: {}",
+                                  ty_to_string(cx.tcx(), rhs_t))[]);
         }
     };
     let bcx = with_cond(cx, is_zero, |bcx| {
@@ -941,14 +950,14 @@ pub fn trans_external_path<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         ty::ty_bare_fn(_, ref fn_ty) => {
             match ccx.sess().target.target.adjust_abi(fn_ty.abi) {
                 Rust | RustCall => {
-                    get_extern_rust_fn(ccx, t, name.index(&FullRange), did)
+                    get_extern_rust_fn(ccx, t, &name[], did)
                 }
                 RustIntrinsic => {
                     ccx.sess().bug("unexpected intrinsic in trans_external_path")
                 }
                 _ => {
                     foreign::register_foreign_item_fn(ccx, fn_ty.abi, t,
-                                                      name.index(&FullRange))
+                                                      &name[])
                 }
             }
         }
@@ -995,7 +1004,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
         let llresult = Invoke(bcx,
                               llfn,
-                              llargs.index(&FullRange),
+                              &llargs[],
                               normal_bcx.llbb,
                               landing_pad,
                               Some(attributes));
@@ -1011,7 +1020,7 @@ pub fn invoke<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             None => debuginfo::clear_source_location(bcx.fcx)
         };
 
-        let llresult = Call(bcx, llfn, llargs.index(&FullRange), Some(attributes));
+        let llresult = Call(bcx, llfn, &llargs[], Some(attributes));
         return (llresult, bcx);
     }
 }
@@ -1128,7 +1137,7 @@ pub fn call_lifetime_end(cx: Block, ptr: ValueRef) {
 pub fn call_memcpy(cx: Block, dst: ValueRef, src: ValueRef, n_bytes: ValueRef, align: u32) {
     let _icx = push_ctxt("call_memcpy");
     let ccx = cx.ccx();
-    let key = match ccx.sess().target.target.target_word_size.index(&FullRange) {
+    let key = match &ccx.sess().target.target.target_pointer_width[] {
         "32" => "llvm.memcpy.p0i8.p0i8.i32",
         "64" => "llvm.memcpy.p0i8.p0i8.i64",
         tws => panic!("Unsupported target word size for memcpy: {}", tws),
@@ -1175,7 +1184,7 @@ fn memzero<'a, 'tcx>(b: &Builder<'a, 'tcx>, llptr: ValueRef, ty: Ty<'tcx>) {
 
     let llty = type_of::type_of(ccx, ty);
 
-    let intrinsic_key = match ccx.sess().target.target.target_word_size.index(&FullRange) {
+    let intrinsic_key = match &ccx.sess().target.target.target_pointer_width[] {
         "32" => "llvm.memset.p0i8.i32",
         "64" => "llvm.memset.p0i8.i64",
         tws => panic!("Unsupported target word size for memset: {}", tws),
@@ -1663,7 +1672,7 @@ fn copy_unboxed_closure_args_to_allocas<'blk, 'tcx>(
                                                          "argtuple",
                                                          arg_scope_id));
     let untupled_arg_types = match monomorphized_arg_types[0].sty {
-        ty::ty_tup(ref types) => types.index(&FullRange),
+        ty::ty_tup(ref types) => &types[],
         _ => {
             bcx.tcx().sess.span_bug(args[0].pat.span,
                                     "first arg to `rust-call` ABI function \
@@ -1851,12 +1860,12 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
     let arg_datums = if abi != RustCall {
         create_datums_for_fn_args(&fcx,
-                                  monomorphized_arg_types.index(&FullRange))
+                                  &monomorphized_arg_types[])
     } else {
         create_datums_for_fn_args_under_call_abi(
             bcx,
             arg_scope,
-            monomorphized_arg_types.index(&FullRange))
+            &monomorphized_arg_types[])
     };
 
     bcx = match closure_env.kind {
@@ -1864,16 +1873,16 @@ pub fn trans_closure<'a, 'b, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             copy_args_to_allocas(&fcx,
                                  arg_scope,
                                  bcx,
-                                 decl.inputs.index(&FullRange),
+                                 &decl.inputs[],
                                  arg_datums)
         }
         closure::UnboxedClosure(..) => {
             copy_unboxed_closure_args_to_allocas(
                 bcx,
                 arg_scope,
-                decl.inputs.index(&FullRange),
+                &decl.inputs[],
                 arg_datums,
-                monomorphized_arg_types.index(&FullRange))
+                &monomorphized_arg_types[])
         }
     };
 
@@ -1990,9 +1999,9 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
             ty::erase_late_bound_regions(bcx.tcx(), &bft.sig.output()).unwrap()
         }
         _ => ccx.sess().bug(
-            format!("trans_enum_variant_constructor: \
+            &format!("trans_enum_variant_constructor: \
                      unexpected ctor return type {}",
-                     ctor_ty.repr(tcx)).index(&FullRange))
+                     ctor_ty.repr(tcx))[])
     };
 
     // Get location to store the result. If the user does not care about
@@ -2015,7 +2024,7 @@ pub fn trans_named_tuple_constructor<'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
                 bcx = expr::trans_adt(bcx,
                                       result_ty,
                                       disr,
-                                      fields.index(&FullRange),
+                                      &fields[],
                                       None,
                                       expr::SaveIn(llresult),
                                       call_info);
@@ -2064,9 +2073,9 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx
             ty::erase_late_bound_regions(ccx.tcx(), &bft.sig.output())
         }
         _ => ccx.sess().bug(
-            format!("trans_enum_variant_or_tuple_like_struct: \
+            &format!("trans_enum_variant_or_tuple_like_struct: \
                      unexpected ctor return type {}",
-                    ty_to_string(ccx.tcx(), ctor_ty)).index(&FullRange))
+                    ty_to_string(ccx.tcx(), ctor_ty))[])
     };
 
     let arena = TypedArena::new();
@@ -2080,7 +2089,7 @@ fn trans_enum_variant_or_tuple_like_struct<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx
         ty::erase_late_bound_regions(
             ccx.tcx(), &ty::ty_fn_args(ctor_ty));
 
-    let arg_datums = create_datums_for_fn_args(&fcx, arg_tys.index(&FullRange));
+    let arg_datums = create_datums_for_fn_args(&fcx, &arg_tys[]);
 
     if !type_is_zero_size(fcx.ccx, result_ty.unwrap()) {
         let dest = fcx.get_ret_slot(bcx, result_ty, "eret_slot");
@@ -2164,9 +2173,9 @@ fn enum_variant_size_lint(ccx: &CrateContext, enum_def: &ast::EnumDef, sp: Span,
         // pass for the latter already ran.
         lint::raw_emit_lint(&ccx.tcx().sess, lint::builtin::VARIANT_SIZE_DIFFERENCES,
                             *lvlsrc.unwrap(), Some(sp),
-                            format!("enum variant is more than three times larger \
+                            &format!("enum variant is more than three times larger \
                                      ({} bytes) than the next largest (ignoring padding)",
-                                    largest).index(&FullRange));
+                                    largest)[]);
 
         ccx.sess().span_note(enum_def.variants[largest_index].span,
                              "this variant is the largest");
@@ -2284,7 +2293,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
     match item.node {
       ast::ItemFn(ref decl, _fn_style, abi, ref generics, ref body) => {
         if !generics.is_type_parameterized() {
-            let trans_everywhere = attr::requests_inline(item.attrs.index(&FullRange));
+            let trans_everywhere = attr::requests_inline(&item.attrs[]);
             // Ignore `trans_everywhere` for cross-crate inlined items
             // (`from_external`).  `trans_item` will be called once for each
             // compilation unit that references the item, so it will still get
@@ -2295,7 +2304,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
                     foreign::trans_rust_fn_with_foreign_abi(ccx,
                                                             &**decl,
                                                             &**body,
-                                                            item.attrs.index(&FullRange),
+                                                            &item.attrs[],
                                                             llfn,
                                                             &Substs::trans_empty(),
                                                             item.id,
@@ -2307,7 +2316,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
                              llfn,
                              &Substs::trans_empty(),
                              item.id,
-                             item.attrs.index(&FullRange));
+                             &item.attrs[]);
                 }
                 update_linkage(ccx,
                                llfn,
@@ -2324,7 +2333,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
       ast::ItemImpl(_, _, ref generics, _, _, ref impl_items) => {
         meth::trans_impl(ccx,
                          item.ident,
-                         impl_items.index(&FullRange),
+                         &impl_items[],
                          generics,
                          item.id);
       }
@@ -2354,7 +2363,7 @@ pub fn trans_item(ccx: &CrateContext, item: &ast::Item) {
 
           // Do static_assert checking. It can't really be done much earlier
           // because we need to get the value of the bool out of LLVM
-          if attr::contains_name(item.attrs.index(&FullRange), "static_assert") {
+          if attr::contains_name(&item.attrs[], "static_assert") {
               if m == ast::MutMutable {
                   ccx.sess().span_fatal(expr.span,
                                         "cannot have static_assert on a mutable \
@@ -2431,7 +2440,7 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         _ => panic!("expected bare rust fn")
     };
 
-    let llfn = decl_rust_fn(ccx, node_type, sym.index(&FullRange));
+    let llfn = decl_rust_fn(ccx, node_type, &sym[]);
     finish_register_fn(ccx, sp, sym, node_id, llfn);
     llfn
 }
@@ -2476,7 +2485,7 @@ pub fn get_fn_llvm_attributes<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn_ty: Ty<
 
             match fn_sig.inputs[1].sty {
                 ty::ty_tup(ref t_in) => {
-                    inputs.push_all(t_in.index(&FullRange));
+                    inputs.push_all(&t_in[]);
                     inputs
                 }
                 _ => ccx.sess().bug("expected tuple'd inputs")
@@ -2612,7 +2621,7 @@ pub fn register_fn_llvmty(ccx: &CrateContext,
     debug!("register_fn_llvmty id={} sym={}", node_id, sym);
 
     let llfn = decl_fn(ccx,
-                       sym.index(&FullRange),
+                       &sym[],
                        cc,
                        llfty,
                        ty::FnConverging(ty::mk_nil(ccx.tcx())));
@@ -2668,7 +2677,7 @@ pub fn create_entry_wrapper(ccx: &CrateContext,
             let (start_fn, args) = if use_start_lang_item {
                 let start_def_id = match ccx.tcx().lang_items.require(StartFnLangItem) {
                     Ok(id) => id,
-                    Err(s) => { ccx.sess().fatal(s.index(&FullRange)); }
+                    Err(s) => { ccx.sess().fatal(&s[]); }
                 };
                 let start_fn = if start_def_id.krate == ast::LOCAL_CRATE {
                     get_item_val(ccx, start_def_id.node)
@@ -2760,7 +2769,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
     let val = match item {
         ast_map::NodeItem(i) => {
             let ty = ty::node_id_to_type(ccx.tcx(), i.id);
-            let sym = |&:| exported_name(ccx, id, ty, i.attrs.index(&FullRange));
+            let sym = |&:| exported_name(ccx, id, ty, &i.attrs[]);
 
             let v = match i.node {
                 ast::ItemStatic(_, _, ref expr) => {
@@ -2783,16 +2792,16 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                         } else {
                             llvm::LLVMTypeOf(v)
                         };
-                        if contains_null(sym.index(&FullRange)) {
+                        if contains_null(&sym[]) {
                             ccx.sess().fatal(
-                                format!("Illegal null byte in export_name \
-                                         value: `{}`", sym).index(&FullRange));
+                                &format!("Illegal null byte in export_name \
+                                         value: `{}`", sym)[]);
                         }
                         let buf = CString::from_slice(sym.as_bytes());
                         let g = llvm::LLVMAddGlobal(ccx.llmod(), llty,
                                                     buf.as_ptr());
 
-                        if attr::contains_name(i.attrs.index(&FullRange),
+                        if attr::contains_name(&i.attrs[],
                                                "thread_local") {
                             llvm::set_thread_local(g, true);
                         }
@@ -2817,19 +2826,19 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                                                                    sym,
                                                                    i.id)
                     };
-                    set_llvm_fn_attrs(ccx, i.attrs.index(&FullRange), llfn);
+                    set_llvm_fn_attrs(ccx, &i.attrs[], llfn);
                     llfn
                 }
 
                 _ => panic!("get_item_val: weird result in table")
             };
 
-            match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange),
+            match attr::first_attr_value_str_by_name(&i.attrs[],
                                                      "link_section") {
                 Some(sect) => {
                     if contains_null(sect.get()) {
-                        ccx.sess().fatal(format!("Illegal null byte in link_section value: `{}`",
-                                                 sect.get()).index(&FullRange));
+                        ccx.sess().fatal(&format!("Illegal null byte in link_section value: `{}`",
+                                                 sect.get())[]);
                     }
                     unsafe {
                         let buf = CString::from_slice(sect.get().as_bytes());
@@ -2872,7 +2881,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
                     let abi = ccx.tcx().map.get_foreign_abi(id);
                     let ty = ty::node_id_to_type(ccx.tcx(), ni.id);
                     let name = foreign::link_name(&*ni);
-                    foreign::register_foreign_item_fn(ccx, abi, ty, name.get().index(&FullRange))
+                    foreign::register_foreign_item_fn(ccx, abi, ty, &name.get()[])
                 }
                 ast::ForeignItemStatic(..) => {
                     foreign::register_static(ccx, &*ni)
@@ -2895,7 +2904,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
             let sym = exported_name(ccx,
                                     id,
                                     ty,
-                                    enm.attrs.index(&FullRange));
+                                    &enm.attrs[]);
 
             llfn = match enm.node {
                 ast::ItemEnum(_, _) => {
@@ -2922,8 +2931,7 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
             let sym = exported_name(ccx,
                                     id,
                                     ty,
-                                    struct_item.attrs
-                                               .index(&FullRange));
+                                    &struct_item.attrs[]);
             let llfn = register_fn(ccx, struct_item.span,
                                    sym, ctor_id, ty);
             set_inline_hint(llfn);
@@ -2931,8 +2939,8 @@ pub fn get_item_val(ccx: &CrateContext, id: ast::NodeId) -> ValueRef {
         }
 
         ref variant => {
-            ccx.sess().bug(format!("get_item_val(): unexpected variant: {:?}",
-                                   variant).index(&FullRange))
+            ccx.sess().bug(&format!("get_item_val(): unexpected variant: {:?}",
+                                   variant)[])
         }
     };
 
@@ -2953,10 +2961,10 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId,
                    m: &ast::Method) -> ValueRef {
     let mty = ty::node_id_to_type(ccx.tcx(), id);
 
-    let sym = exported_name(ccx, id, mty, m.attrs.index(&FullRange));
+    let sym = exported_name(ccx, id, mty, &m.attrs[]);
 
     let llfn = register_fn(ccx, m.span, sym, id, mty);
-    set_llvm_fn_attrs(ccx, m.attrs.index(&FullRange), llfn);
+    set_llvm_fn_attrs(ccx, &m.attrs[], llfn);
     llfn
 }
 
@@ -2995,7 +3003,7 @@ pub fn write_metadata(cx: &SharedCrateContext, krate: &ast::Crate) -> Vec<u8> {
         Some(compressed) => compressed,
         None => cx.sess().fatal("failed to compress metadata"),
     }.as_slice());
-    let llmeta = C_bytes_in_context(cx.metadata_llcx(), compressed.index(&FullRange));
+    let llmeta = C_bytes_in_context(cx.metadata_llcx(), &compressed[]);
     let llconst = C_struct_in_context(cx.metadata_llcx(), &[llmeta], false);
     let name = format!("rust_metadata_{}_{}",
                        cx.link_meta().crate_name,
@@ -3124,7 +3132,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
     let link_meta = link::build_link_meta(&tcx.sess, krate, name);
 
     let codegen_units = tcx.sess.opts.cg.codegen_units;
-    let shared_ccx = SharedCrateContext::new(link_meta.crate_name.index(&FullRange),
+    let shared_ccx = SharedCrateContext::new(&link_meta.crate_name[],
                                              codegen_units,
                                              tcx,
                                              export_map,
@@ -3226,7 +3234,7 @@ pub fn trans_crate<'tcx>(analysis: ty::CrateAnalysis<'tcx>)
         llmod: shared_ccx.metadata_llmod(),
     };
     let formats = shared_ccx.tcx().dependency_formats.borrow().clone();
-    let no_builtins = attr::contains_name(krate.attrs.index(&FullRange), "no_builtins");
+    let no_builtins = attr::contains_name(&krate.attrs[], "no_builtins");
 
     let translation = CrateTranslation {
         modules: modules,
diff --git a/src/librustc_trans/trans/builder.rs b/src/librustc_trans/trans/builder.rs
index d0eaf799af1bd..b80088e4690c9 100644
--- a/src/librustc_trans/trans/builder.rs
+++ b/src/librustc_trans/trans/builder.rs
@@ -552,11 +552,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             for (small_vec_e, &ix) in small_vec.iter_mut().zip(ixs.iter()) {
                 *small_vec_e = C_i32(self.ccx, ix as i32);
             }
-            self.inbounds_gep(base, small_vec.index(&(0..ixs.len())))
+            self.inbounds_gep(base, &small_vec[0..ixs.len()])
         } else {
             let v = ixs.iter().map(|i| C_i32(self.ccx, *i as i32)).collect::<Vec<ValueRef>>();
             self.count_insn("gepi");
-            self.inbounds_gep(base, v.index(&FullRange))
+            self.inbounds_gep(base, &v[])
         }
     }
 
@@ -764,8 +764,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let s = format!("{} ({})",
                             text,
                             self.ccx.sess().codemap().span_to_string(sp));
-            debug!("{}", s.index(&FullRange));
-            self.add_comment(s.index(&FullRange));
+            debug!("{}", &s[]);
+            self.add_comment(&s[]);
         }
     }
 
@@ -802,7 +802,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }).collect::<Vec<_>>();
 
         debug!("Asm Output Type: {}", self.ccx.tn().type_to_string(output));
-        let fty = Type::func(argtys.index(&FullRange), &output);
+        let fty = Type::func(&argtys[], &output);
         unsafe {
             let v = llvm::LLVMInlineAsm(
                 fty.to_ref(), asm, cons, volatile, alignstack, dia as c_uint);
diff --git a/src/librustc_trans/trans/cabi.rs b/src/librustc_trans/trans/cabi.rs
index a901142467b8d..8a2a2534cabd2 100644
--- a/src/librustc_trans/trans/cabi.rs
+++ b/src/librustc_trans/trans/cabi.rs
@@ -108,7 +108,7 @@ pub fn compute_abi_info(ccx: &CrateContext,
                         atys: &[Type],
                         rty: Type,
                         ret_def: bool) -> FnType {
-    match ccx.sess().target.target.arch.index(&FullRange) {
+    match &ccx.sess().target.target.arch[] {
         "x86" => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def),
         "x86_64" => if ccx.sess().target.target.options.is_like_windows {
             cabi_x86_win64::compute_abi_info(ccx, atys, rty, ret_def)
@@ -118,7 +118,7 @@ pub fn compute_abi_info(ccx: &CrateContext,
         "arm" => cabi_arm::compute_abi_info(ccx, atys, rty, ret_def),
         "aarch64" => cabi_aarch64::compute_abi_info(ccx, atys, rty, ret_def),
         "mips" => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),
-        a => ccx.sess().fatal((format!("unrecognized arch \"{}\" in target specification", a))
-                              .index(&FullRange)),
+        a => ccx.sess().fatal(&format!("unrecognized arch \"{}\" in target specification", a)
+                              []),
     }
 }
diff --git a/src/librustc_trans/trans/cabi_x86_64.rs b/src/librustc_trans/trans/cabi_x86_64.rs
index f40072d1cba3e..86190b1e56639 100644
--- a/src/librustc_trans/trans/cabi_x86_64.rs
+++ b/src/librustc_trans/trans/cabi_x86_64.rs
@@ -318,7 +318,7 @@ fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type {
                 tys.push(Type::i64(ccx));
             }
             SSEFv => {
-                let vec_len = llvec_len(cls.index(&((i + 1u)..)));
+                let vec_len = llvec_len(&cls[(i + 1u)..]);
                 let vec_ty = Type::vector(&Type::f32(ccx), (vec_len * 2u) as u64);
                 tys.push(vec_ty);
                 i += vec_len;
diff --git a/src/librustc_trans/trans/callee.rs b/src/librustc_trans/trans/callee.rs
index b7b486f1d0a52..6196f9e5eab65 100644
--- a/src/librustc_trans/trans/callee.rs
+++ b/src/librustc_trans/trans/callee.rs
@@ -112,9 +112,9 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
             _ => {
                 bcx.tcx().sess.span_bug(
                     expr.span,
-                    format!("type of callee is neither bare-fn nor closure: \
+                    &format!("type of callee is neither bare-fn nor closure: \
                              {}",
-                            bcx.ty_to_string(datum.ty)).index(&FullRange));
+                            bcx.ty_to_string(datum.ty))[]);
             }
         }
     }
@@ -206,8 +206,8 @@ fn trans<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, expr: &ast::Expr)
             def::DefSelfTy(..) | def::DefAssociatedPath(..) => {
                 bcx.tcx().sess.span_bug(
                     ref_expr.span,
-                    format!("cannot translate def {:?} \
-                             to a callable thing!", def).index(&FullRange));
+                    &format!("cannot translate def {:?} \
+                             to a callable thing!", def)[]);
             }
         }
     }
@@ -265,7 +265,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
     let _icx = push_ctxt("trans_fn_pointer_shim");
     let tcx = ccx.tcx();
 
-    let bare_fn_ty = normalize_ty(tcx, bare_fn_ty);
+    let bare_fn_ty = erase_regions(tcx, &bare_fn_ty);
     match ccx.fn_pointer_shims().borrow().get(&bare_fn_ty) {
         Some(&llval) => { return llval; }
         None => { }
@@ -289,8 +289,8 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
             }
 
             _ => {
-                tcx.sess.bug(format!("trans_fn_pointer_shim invoked on invalid type: {}",
-                                           bare_fn_ty.repr(tcx)).index(&FullRange));
+                tcx.sess.bug(&format!("trans_fn_pointer_shim invoked on invalid type: {}",
+                                           bare_fn_ty.repr(tcx))[]);
             }
         };
     let sig = ty::erase_late_bound_regions(tcx, sig);
@@ -315,7 +315,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
     let llfn =
         decl_internal_rust_fn(ccx,
                               tuple_fn_ty,
-                              function_name.index(&FullRange));
+                              &function_name[]);
 
     //
     let block_arena = TypedArena::new();
@@ -350,7 +350,7 @@ pub fn trans_fn_pointer_shim<'a, 'tcx>(
                            None,
                            bare_fn_ty,
                            |bcx, _| Callee { bcx: bcx, data: Fn(llfnpointer) },
-                           ArgVals(llargs.index(&FullRange)),
+                           ArgVals(&llargs[]),
                            dest).bcx;
 
     finish_fn(&fcx, bcx, sig.output);
@@ -776,7 +776,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
         // Invoke the actual rust fn and update bcx/llresult.
         let (llret, b) = base::invoke(bcx,
                                       llfn,
-                                      llargs.index(&FullRange),
+                                      &llargs[],
                                       callee_ty,
                                       call_info);
         bcx = b;
@@ -815,7 +815,7 @@ pub fn trans_call_inner<'a, 'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
 
         bcx = foreign::trans_native_call(bcx, callee_ty,
                                          llfn, opt_llretslot.unwrap(),
-                                         llargs.index(&FullRange), arg_tys);
+                                         &llargs[], arg_tys);
     }
 
     fcx.pop_and_trans_custom_cleanup_scope(bcx, arg_cleanup_scope);
diff --git a/src/librustc_trans/trans/cleanup.rs b/src/librustc_trans/trans/cleanup.rs
index 92a96cd02b501..5658889aaf368 100644
--- a/src/librustc_trans/trans/cleanup.rs
+++ b/src/librustc_trans/trans/cleanup.rs
@@ -403,8 +403,8 @@ impl<'blk, 'tcx> CleanupMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx> {
         }
 
         self.ccx.sess().bug(
-            format!("no cleanup scope {} found",
-                    self.ccx.tcx().map.node_to_string(cleanup_scope)).index(&FullRange));
+            &format!("no cleanup scope {} found",
+                    self.ccx.tcx().map.node_to_string(cleanup_scope))[]);
     }
 
     /// Schedules a cleanup to occur in the top-most scope, which must be a temporary scope.
@@ -584,9 +584,9 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
                     }
 
                     LoopExit(id, _) => {
-                        self.ccx.sess().bug(format!(
+                        self.ccx.sess().bug(&format!(
                                 "cannot exit from scope {}, \
-                                not in scope", id).index(&FullRange));
+                                not in scope", id)[]);
                     }
                 }
             }
@@ -655,7 +655,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
                 let name = scope.block_name("clean");
                 debug!("generating cleanups for {}", name);
                 let bcx_in = self.new_block(label.is_unwind(),
-                                            name.index(&FullRange),
+                                            &name[],
                                             None);
                 let mut bcx_out = bcx_in;
                 for cleanup in scope.cleanups.iter().rev() {
@@ -702,7 +702,7 @@ impl<'blk, 'tcx> CleanupHelperMethods<'blk, 'tcx> for FunctionContext<'blk, 'tcx
                 Some(llbb) => { return llbb; }
                 None => {
                     let name = last_scope.block_name("unwind");
-                    pad_bcx = self.new_block(true, name.index(&FullRange), None);
+                    pad_bcx = self.new_block(true, &name[], None);
                     last_scope.cached_landing_pad = Some(pad_bcx.llbb);
                 }
             }
@@ -1022,8 +1022,8 @@ pub fn temporary_scope(tcx: &ty::ctxt,
             r
         }
         None => {
-            tcx.sess.bug(format!("no temporary scope available for expr {}",
-                                 id).index(&FullRange))
+            tcx.sess.bug(&format!("no temporary scope available for expr {}",
+                                 id)[])
         }
     }
 }
diff --git a/src/librustc_trans/trans/closure.rs b/src/librustc_trans/trans/closure.rs
index ad2ed67b22c9a..8989dfd493236 100644
--- a/src/librustc_trans/trans/closure.rs
+++ b/src/librustc_trans/trans/closure.rs
@@ -154,7 +154,7 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let tcx = ccx.tcx();
 
     // compute the type of the closure
-    let cdata_ty = mk_closure_tys(tcx, bound_values.index(&FullRange));
+    let cdata_ty = mk_closure_tys(tcx, &bound_values[]);
 
     // cbox_ty has the form of a tuple: (a, b, c) we want a ptr to a
     // tuple.  This could be a ptr in uniq or a box or on stack,
@@ -182,8 +182,8 @@ pub fn store_environment<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         debug!("Copy {} into closure", bv.to_string(ccx));
 
         if ccx.sess().asm_comments() {
-            add_comment(bcx, format!("Copy {} into closure",
-                                     bv.to_string(ccx)).index(&FullRange));
+            add_comment(bcx, &format!("Copy {} into closure",
+                                     bv.to_string(ccx))[]);
         }
 
         let bound_data = GEPi(bcx, llbox, &[0u, abi::BOX_FIELD_BODY, i]);
@@ -420,7 +420,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let s = tcx.map.with_path(id, |path| {
         mangle_internal_name_by_path_and_seq(path, "closure")
     });
-    let llfn = decl_internal_rust_fn(ccx, fty, s.index(&FullRange));
+    let llfn = decl_internal_rust_fn(ccx, fty, &s[]);
 
     // set an inline hint for all closures
     set_inline_hint(llfn);
@@ -444,7 +444,7 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                   &[],
                   ty::erase_late_bound_regions(ccx.tcx(), &ty::ty_fn_ret(fty)),
                   ty::ty_fn_abi(fty),
-                  ClosureEnv::new(freevars.index(&FullRange),
+                  ClosureEnv::new(&freevars[],
                                   BoxedClosure(cdata_ty, store)));
     fill_fn_pair(bcx, dest_addr, llfn, llbox);
     bcx
@@ -466,7 +466,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext
 
     // Normalize type so differences in regions and typedefs don't cause
     // duplicate declarations
-    let function_type = normalize_ty(ccx.tcx(), function_type);
+    let function_type = erase_regions(ccx.tcx(), &function_type);
     let params = match function_type.sty {
         ty::ty_unboxed_closure(_, _, ref substs) => substs.types.clone(),
         _ => unreachable!()
@@ -489,7 +489,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'a, 'tcx>(ccx: &CrateContext
         mangle_internal_name_by_path_and_seq(path, "unboxed_closure")
     });
 
-    let llfn = decl_internal_rust_fn(ccx, function_type, symbol.index(&FullRange));
+    let llfn = decl_internal_rust_fn(ccx, function_type, &symbol[]);
 
     // set an inline hint for all closures
     set_inline_hint(llfn);
@@ -544,7 +544,7 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
                   &[],
                   sig.output,
                   function_type.abi,
-                  ClosureEnv::new(freevars.index(&FullRange),
+                  ClosureEnv::new(&freevars[],
                                   UnboxedClosure(freevar_mode)));
 
     // Don't hoist this to the top of the function. It's perfectly legitimate
diff --git a/src/librustc_trans/trans/common.rs b/src/librustc_trans/trans/common.rs
index 237fc1856369b..ab5b563b99c72 100644
--- a/src/librustc_trans/trans/common.rs
+++ b/src/librustc_trans/trans/common.rs
@@ -50,7 +50,7 @@ use std::vec::Vec;
 use syntax::ast::Ident;
 use syntax::ast;
 use syntax::ast_map::{PathElem, PathName};
-use syntax::codemap::Span;
+use syntax::codemap::{DUMMY_SP, Span};
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
 use util::common::memoized;
@@ -58,16 +58,21 @@ use util::nodemap::FnvHashSet;
 
 pub use trans::context::CrateContext;
 
-/// Returns an equivalent type with all the typedefs and self regions removed.
-pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
-    let u = TypeNormalizer(cx).fold_ty(ty);
-    debug!("normalize_ty({}) = {}",
-           ty.repr(cx), u.repr(cx));
-    return u;
+/// Returns an equivalent value with all free regions removed (note
+/// that late-bound regions remain, because they are important for
+/// subtyping, but they are anonymized and normalized as well). This
+/// is a stronger, caching version of `ty_fold::erase_regions`.
+pub fn erase_regions<'tcx,T>(cx: &ty::ctxt<'tcx>, value: &T) -> T
+    where T : TypeFoldable<'tcx> + Repr<'tcx>
+{
+    let value1 = value.fold_with(&mut RegionEraser(cx));
+    debug!("erase_regions({}) = {}",
+           value.repr(cx), value1.repr(cx));
+    return value1;
 
-    struct TypeNormalizer<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>);
+    struct RegionEraser<'a, 'tcx: 'a>(&'a ty::ctxt<'tcx>);
 
-    impl<'a, 'tcx> TypeFolder<'tcx> for TypeNormalizer<'a, 'tcx> {
+    impl<'a, 'tcx> TypeFolder<'tcx> for RegionEraser<'a, 'tcx> {
         fn tcx(&self) -> &ty::ctxt<'tcx> { self.0 }
 
         fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
@@ -84,7 +89,6 @@ pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
         fn fold_binder<T>(&mut self, t: &ty::Binder<T>) -> ty::Binder<T>
             where T : TypeFoldable<'tcx> + Repr<'tcx>
         {
-            // FIXME(#20526) this should replace `enter_region_binder`/`exit_region_binder`.
             let u = ty::anonymize_late_bound_regions(self.tcx(), t);
             ty_fold::super_fold_binder(self, &u)
         }
@@ -114,8 +118,9 @@ pub fn normalize_ty<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
 }
 
 // Is the type's representation size known at compile time?
-pub fn type_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
-ty::type_contents(cx, ty).is_sized(cx)
+pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
+    let param_env = ty::empty_parameter_environment(tcx);
+    ty::type_is_sized(&param_env, DUMMY_SP, ty)
 }
 
 pub fn lltype_is_sized<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
@@ -273,7 +278,7 @@ pub fn gensym_name(name: &str) -> PathElem {
 let num = token::gensym(name).uint();
 // use one colon which will get translated to a period by the mangler, and
 // we're guaranteed that `num` is globally unique for this crate.
-PathName(token::gensym(format!("{}:{}", name, num).index(&FullRange)))
+PathName(token::gensym(&format!("{}:{}", name, num)[]))
 }
 
 #[derive(Copy)]
@@ -600,8 +605,8 @@ pub fn def(&self, nid: ast::NodeId) -> def::Def {
     match self.tcx().def_map.borrow().get(&nid) {
         Some(v) => v.clone(),
         None => {
-            self.tcx().sess.bug(format!(
-                "no def associated with node id {}", nid).index(&FullRange));
+            self.tcx().sess.bug(&format!(
+                "no def associated with node id {}", nid)[]);
         }
     }
 }
@@ -988,7 +993,7 @@ pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 let tcx = ccx.tcx();
 
 // Remove any references to regions; this helps improve caching.
-let trait_ref = ty_fold::erase_regions(tcx, trait_ref);
+let trait_ref = erase_regions(tcx, &trait_ref);
 
 // First check the cache.
 match ccx.trait_cache().borrow().get(&trait_ref) {
@@ -1029,9 +1034,9 @@ let selection = match selcx.select(&obligation) {
     Err(e) => {
         tcx.sess.span_bug(
             span,
-            format!("Encountered error `{}` selecting `{}` during trans",
+            &format!("Encountered error `{}` selecting `{}` during trans",
                     e.repr(tcx),
-                    trait_ref.repr(tcx)).index(&FullRange))
+                    trait_ref.repr(tcx))[])
     }
 };
 
@@ -1123,8 +1128,8 @@ match fulfill_cx.select_all_or_error(infcx, &typer) {
         } else {
             infcx.tcx.sess.span_bug(
                 span,
-                format!("Encountered errors `{}` fulfilling during trans",
-                        errors.repr(infcx.tcx)).index(&FullRange));
+                &format!("Encountered errors `{}` fulfilling during trans",
+                        errors.repr(infcx.tcx))[]);
         }
     }
 }
@@ -1163,8 +1168,8 @@ let substs = match node {
 };
 
 if substs.types.any(|t| ty::type_needs_infer(*t)) {
-        tcx.sess.bug(format!("type parameters for node {:?} include inference types: {:?}",
-                             node, substs.repr(tcx)).index(&FullRange));
+        tcx.sess.bug(&format!("type parameters for node {:?} include inference types: {:?}",
+                             node, substs.repr(tcx))[]);
     }
 
     monomorphize::apply_param_substs(tcx,
@@ -1182,8 +1187,8 @@ pub fn langcall(bcx: Block,
         Err(s) => {
             let msg = format!("{} {}", msg, s);
             match span {
-                Some(span) => bcx.tcx().sess.span_fatal(span, msg.index(&FullRange)),
-                None => bcx.tcx().sess.fatal(msg.index(&FullRange)),
+                Some(span) => bcx.tcx().sess.span_fatal(span, &msg[]),
+                None => bcx.tcx().sess.fatal(&msg[]),
             }
         }
     }
diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs
index b0474d7e011a5..00b97286de367 100644
--- a/src/librustc_trans/trans/consts.rs
+++ b/src/librustc_trans/trans/consts.rs
@@ -52,9 +52,9 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit)
                     C_integral(Type::uint_from_ty(cx, t), i as u64, false)
                 }
                 _ => cx.sess().span_bug(lit.span,
-                        format!("integer literal has type {} (expected int \
+                        &format!("integer literal has type {} (expected int \
                                  or uint)",
-                                ty_to_string(cx.tcx(), lit_int_ty)).index(&FullRange))
+                                ty_to_string(cx.tcx(), lit_int_ty))[])
             }
         }
         ast::LitFloat(ref fs, t) => {
@@ -74,7 +74,7 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: &ast::Lit)
         }
         ast::LitBool(b) => C_bool(cx, b),
         ast::LitStr(ref s, _) => C_str_slice(cx, (*s).clone()),
-        ast::LitBinary(ref data) => C_binary_slice(cx, data.index(&FullRange)),
+        ast::LitBinary(ref data) => C_binary_slice(cx, &data[]),
     }
 }
 
@@ -93,9 +93,9 @@ fn const_vec(cx: &CrateContext, e: &ast::Expr,
                       .collect::<Vec<_>>();
     // If the vector contains enums, an LLVM array won't work.
     let v = if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
-        C_struct(cx, vs.index(&FullRange), false)
+        C_struct(cx, &vs[], false)
     } else {
-        C_array(llunitty, vs.index(&FullRange))
+        C_array(llunitty, &vs[])
     };
     (v, llunitty)
 }
@@ -148,14 +148,14 @@ fn const_deref<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, v: ValueRef,
                     (const_deref_newtype(cx, v, t), mt.ty)
                 }
                 _ => {
-                    cx.sess().bug(format!("unexpected dereferenceable type {}",
-                                          ty_to_string(cx.tcx(), t)).index(&FullRange))
+                    cx.sess().bug(&format!("unexpected dereferenceable type {}",
+                                          ty_to_string(cx.tcx(), t))[])
                 }
             }
         }
         None => {
-            cx.sess().bug(format!("cannot dereference const of type {}",
-                                  ty_to_string(cx.tcx(), t)).index(&FullRange))
+            cx.sess().bug(&format!("cannot dereference const of type {}",
+                                  ty_to_string(cx.tcx(), t))[])
         }
     }
 }
@@ -251,16 +251,16 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr)
                                             ], false);
                                         }
                                         _ => cx.sess().span_bug(e.span,
-                                            format!("unimplemented type in const unsize: {}",
-                                                    ty_to_string(cx.tcx(), ty)).index(&FullRange))
+                                            &format!("unimplemented type in const unsize: {}",
+                                                    ty_to_string(cx.tcx(), ty))[])
                                     }
                                 }
                                 _ => {
                                     cx.sess()
                                       .span_bug(e.span,
-                                                format!("unimplemented const \
+                                                &format!("unimplemented const \
                                                          autoref {:?}",
-                                                        autoref).index(&FullRange))
+                                                        autoref)[])
                                 }
                             }
                         }
@@ -279,9 +279,9 @@ pub fn const_expr<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, e: &ast::Expr)
             llvm::LLVMDumpValue(llconst);
             llvm::LLVMDumpValue(C_undef(llty));
         }
-        cx.sess().bug(format!("const {} of type {} has size {} instead of {}",
+        cx.sess().bug(&format!("const {} of type {} has size {} instead of {}",
                          e.repr(cx.tcx()), ty_to_string(cx.tcx(), ety),
-                         csize, tsize).index(&FullRange));
+                         csize, tsize)[]);
     }
     (llconst, ety_adjusted)
 }
@@ -429,23 +429,23 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                           (const_deref_ptr(cx, e1), const_get_elt(cx, bv, &[1]))
                       },
                       _ => cx.sess().span_bug(base.span,
-                                              format!("index-expr base must be a vector \
+                                              &format!("index-expr base must be a vector \
                                                        or string type, found {}",
-                                                      ty_to_string(cx.tcx(), bt)).index(&FullRange))
+                                                      ty_to_string(cx.tcx(), bt))[])
                   },
                   ty::ty_rptr(_, mt) => match mt.ty.sty {
                       ty::ty_vec(_, Some(u)) => {
                           (const_deref_ptr(cx, bv), C_uint(cx, u))
                       },
                       _ => cx.sess().span_bug(base.span,
-                                              format!("index-expr base must be a vector \
+                                              &format!("index-expr base must be a vector \
                                                        or string type, found {}",
-                                                      ty_to_string(cx.tcx(), bt)).index(&FullRange))
+                                                      ty_to_string(cx.tcx(), bt))[])
                   },
                   _ => cx.sess().span_bug(base.span,
-                                          format!("index-expr base must be a vector \
+                                          &format!("index-expr base must be a vector \
                                                    or string type, found {}",
-                                                  ty_to_string(cx.tcx(), bt)).index(&FullRange))
+                                                  ty_to_string(cx.tcx(), bt))[])
               };
 
               let len = llvm::LLVMConstIntGetZExtValue(len) as u64;
@@ -546,8 +546,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
           ast::ExprTup(ref es) => {
               let ety = ty::expr_ty(cx.tcx(), e);
               let repr = adt::represent_type(cx, ety);
-              let vals = map_list(es.index(&FullRange));
-              adt::trans_const(cx, &*repr, 0, vals.index(&FullRange))
+              let vals = map_list(&es[]);
+              adt::trans_const(cx, &*repr, 0, &vals[])
           }
           ast::ExprStruct(_, ref fs, ref base_opt) => {
               let ety = ty::expr_ty(cx.tcx(), e);
@@ -578,7 +578,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                           }
                       }
                   }).collect::<Vec<_>>();
-                  adt::trans_const(cx, &*repr, discr, cs.index(&FullRange))
+                  adt::trans_const(cx, &*repr, discr, &cs[])
               })
           }
           ast::ExprVec(ref es) => {
@@ -595,9 +595,9 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
             };
             let vs: Vec<_> = repeat(const_expr(cx, &**elem).0).take(n).collect();
             if vs.iter().any(|vi| val_ty(*vi) != llunitty) {
-                C_struct(cx, vs.index(&FullRange), false)
+                C_struct(cx, &vs[], false)
             } else {
-                C_array(llunitty, vs.index(&FullRange))
+                C_array(llunitty, &vs[])
             }
           }
           ast::ExprPath(_) => {
@@ -645,8 +645,8 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                   Some(def::DefStruct(_)) => {
                       let ety = ty::expr_ty(cx.tcx(), e);
                       let repr = adt::represent_type(cx, ety);
-                      let arg_vals = map_list(args.index(&FullRange));
-                      adt::trans_const(cx, &*repr, 0, arg_vals.index(&FullRange))
+                      let arg_vals = map_list(&args[]);
+                      adt::trans_const(cx, &*repr, 0, &arg_vals[])
                   }
                   Some(def::DefVariant(enum_did, variant_did, _)) => {
                       let ety = ty::expr_ty(cx.tcx(), e);
@@ -654,11 +654,11 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr) -> ValueRef {
                       let vinfo = ty::enum_variant_with_id(cx.tcx(),
                                                            enum_did,
                                                            variant_did);
-                      let arg_vals = map_list(args.index(&FullRange));
+                      let arg_vals = map_list(&args[]);
                       adt::trans_const(cx,
                                        &*repr,
                                        vinfo.disr_val,
-                                       arg_vals.index(&FullRange))
+                                       &arg_vals[])
                   }
                   _ => cx.sess().span_bug(e.span, "expected a struct or variant def")
               }
diff --git a/src/librustc_trans/trans/context.rs b/src/librustc_trans/trans/context.rs
index 35fb34eafb4d0..1abf3b0b886cc 100644
--- a/src/librustc_trans/trans/context.rs
+++ b/src/librustc_trans/trans/context.rs
@@ -284,7 +284,7 @@ impl<'tcx> SharedCrateContext<'tcx> {
             // such as a function name in the module.
             // 1. http://llvm.org/bugs/show_bug.cgi?id=11479
             let llmod_id = format!("{}.{}.rs", crate_name, i);
-            let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id.index(&FullRange));
+            let local_ccx = LocalCrateContext::new(&shared_ccx, &llmod_id[]);
             shared_ccx.local_ccxs.push(local_ccx);
         }
 
@@ -369,12 +369,12 @@ impl<'tcx> LocalCrateContext<'tcx> {
         unsafe {
             let (llcx, llmod) = create_context_and_module(&shared.tcx.sess, name);
 
-            let td = mk_target_data(shared.tcx
+            let td = mk_target_data(&shared.tcx
                                           .sess
                                           .target
                                           .target
                                           .data_layout
-                                          .index(&FullRange));
+                                          []);
 
             let dbg_cx = if shared.tcx.sess.opts.debuginfo != NoDebugInfo {
                 Some(debuginfo::CrateDebugContext::new(llmod))
@@ -721,7 +721,7 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
     /// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable
     /// address space on 64-bit ARMv8 and x86_64.
     pub fn obj_size_bound(&self) -> u64 {
-        match self.sess().target.target.target_word_size.index(&FullRange) {
+        match &self.sess().target.target.target_pointer_width[] {
             "32" => 1 << 31,
             "64" => 1 << 47,
             _ => unreachable!() // error handled by config::build_target_config
@@ -730,8 +730,8 @@ impl<'b, 'tcx> CrateContext<'b, 'tcx> {
 
     pub fn report_overbig_object(&self, obj: Ty<'tcx>) -> ! {
         self.sess().fatal(
-            format!("the type `{}` is too big for the current architecture",
-                    obj.repr(self.tcx())).index(&FullRange))
+            &format!("the type `{}` is too big for the current architecture",
+                    obj.repr(self.tcx()))[])
     }
 }
 
diff --git a/src/librustc_trans/trans/controlflow.rs b/src/librustc_trans/trans/controlflow.rs
index 38d40a8322f90..adf302501cd1f 100644
--- a/src/librustc_trans/trans/controlflow.rs
+++ b/src/librustc_trans/trans/controlflow.rs
@@ -48,7 +48,7 @@ pub fn trans_stmt<'blk, 'tcx>(cx: Block<'blk, 'tcx>,
     debug!("trans_stmt({})", s.repr(cx.tcx()));
 
     if cx.sess().asm_comments() {
-        add_span_comment(cx, s.span, s.repr(cx.tcx()).index(&FullRange));
+        add_span_comment(cx, s.span, &s.repr(cx.tcx())[]);
     }
 
     let mut bcx = cx;
@@ -188,7 +188,7 @@ pub fn trans_if<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     }
 
     let name = format!("then-block-{}-", thn.id);
-    let then_bcx_in = bcx.fcx.new_id_block(name.index(&FullRange), thn.id);
+    let then_bcx_in = bcx.fcx.new_id_block(&name[], thn.id);
     let then_bcx_out = trans_block(then_bcx_in, &*thn, dest);
     trans::debuginfo::clear_source_location(bcx.fcx);
 
@@ -439,8 +439,8 @@ pub fn trans_break_cont<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             match bcx.tcx().def_map.borrow().get(&expr_id) {
                 Some(&def::DefLabel(loop_id)) => loop_id,
                 ref r => {
-                    bcx.tcx().sess.bug(format!("{:?} in def-map for label",
-                                               r).index(&FullRange))
+                    bcx.tcx().sess.bug(&format!("{:?} in def-map for label",
+                                               r)[])
                 }
             }
         }
@@ -504,7 +504,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     let v_str = C_str_slice(ccx, fail_str);
     let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
-    let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
+    let filename = token::intern_and_get_ident(&loc.file.name[]);
     let filename = C_str_slice(ccx, filename);
     let line = C_uint(ccx, loc.line);
     let expr_file_line_const = C_struct(ccx, &[v_str, filename, line], false);
@@ -513,7 +513,7 @@ pub fn trans_fail<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let did = langcall(bcx, Some(sp), "", PanicFnLangItem);
     let bcx = callee::trans_lang_call(bcx,
                                       did,
-                                      args.index(&FullRange),
+                                      &args[],
                                       Some(expr::Ignore)).bcx;
     Unreachable(bcx);
     return bcx;
@@ -529,7 +529,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     // Extract the file/line from the span
     let loc = bcx.sess().codemap().lookup_char_pos(sp.lo);
-    let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
+    let filename = token::intern_and_get_ident(&loc.file.name[]);
 
     // Invoke the lang item
     let filename = C_str_slice(ccx,  filename);
@@ -540,7 +540,7 @@ pub fn trans_fail_bounds_check<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let did = langcall(bcx, Some(sp), "", PanicBoundsCheckFnLangItem);
     let bcx = callee::trans_lang_call(bcx,
                                       did,
-                                      args.index(&FullRange),
+                                      &args[],
                                       Some(expr::Ignore)).bcx;
     Unreachable(bcx);
     return bcx;
diff --git a/src/librustc_trans/trans/datum.rs b/src/librustc_trans/trans/datum.rs
index 26518d4092fa3..8b52732f4ee97 100644
--- a/src/librustc_trans/trans/datum.rs
+++ b/src/librustc_trans/trans/datum.rs
@@ -463,8 +463,8 @@ impl<'tcx> Datum<'tcx, Lvalue> {
                 gep(base)
             }
             _ => bcx.tcx().sess.bug(
-                format!("Unexpected unsized type in get_element: {}",
-                        bcx.ty_to_string(self.ty)).index(&FullRange))
+                &format!("Unexpected unsized type in get_element: {}",
+                        bcx.ty_to_string(self.ty))[])
         };
         Datum {
             val: val,
diff --git a/src/librustc_trans/trans/debuginfo.rs b/src/librustc_trans/trans/debuginfo.rs
index e2e1b3a799bfc..3a6f4b47e4e1e 100644
--- a/src/librustc_trans/trans/debuginfo.rs
+++ b/src/librustc_trans/trans/debuginfo.rs
@@ -284,8 +284,8 @@ impl<'tcx> TypeMap<'tcx> {
                                        type_: Ty<'tcx>,
                                        metadata: DIType) {
         if self.type_to_metadata.insert(type_, metadata).is_some() {
-            cx.sess().bug(format!("Type metadata for Ty '{}' is already in the TypeMap!",
-                                   ppaux::ty_to_string(cx.tcx(), type_)).index(&FullRange));
+            cx.sess().bug(&format!("Type metadata for Ty '{}' is already in the TypeMap!",
+                                   ppaux::ty_to_string(cx.tcx(), type_))[]);
         }
     }
 
@@ -297,8 +297,8 @@ impl<'tcx> TypeMap<'tcx> {
                                         metadata: DIType) {
         if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() {
             let unique_type_id_str = self.get_unique_type_id_as_string(unique_type_id);
-            cx.sess().bug(format!("Type metadata for unique id '{}' is already in the TypeMap!",
-                                  unique_type_id_str.index(&FullRange)).index(&FullRange));
+            cx.sess().bug(&format!("Type metadata for unique id '{}' is already in the TypeMap!",
+                                  &unique_type_id_str[])[]);
         }
     }
 
@@ -335,13 +335,13 @@ impl<'tcx> TypeMap<'tcx> {
         // unique ptr (~)       -> {~ :pointee-uid:}
         // @-ptr (@)            -> {@ :pointee-uid:}
         // sized vec ([T; x])   -> {[:size:] :element-uid:}
-        // unsized vec ([T])    -> {.index(&FullRange) :element-uid:}
+        // unsized vec ([T])    -> {[] :element-uid:}
         // trait (T)            -> {trait_:svh: / :node-id:_<(:param-uid:),*> }
         // closure              -> {<unsafe_> <once_> :store-sigil: |(:param-uid:),* <,_...>| -> \
         //                             :return-type-uid: : (:bounds:)*}
         // function             -> {<unsafe_> <abi_> fn( (:param-uid:)* <,_...> ) -> \
         //                             :return-type-uid:}
-        // unique vec box (~.index(&FullRange)) -> {HEAP_VEC_BOX<:pointee-uid:>}
+        // unique vec box (~[]) -> {HEAP_VEC_BOX<:pointee-uid:>}
         // gc box               -> {GC_BOX<:pointee-uid:>}
 
         match self.type_to_unique_id.get(&type_).cloned() {
@@ -379,14 +379,14 @@ impl<'tcx> TypeMap<'tcx> {
                         self.get_unique_type_id_of_type(cx, component_type);
                     let component_type_id =
                         self.get_unique_type_id_as_string(component_type_id);
-                    unique_type_id.push_str(component_type_id.index(&FullRange));
+                    unique_type_id.push_str(&component_type_id[]);
                 }
             },
             ty::ty_uniq(inner_type) => {
                 unique_type_id.push('~');
                 let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
                 let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
-                unique_type_id.push_str(inner_type_id.index(&FullRange));
+                unique_type_id.push_str(&inner_type_id[]);
             },
             ty::ty_ptr(ty::mt { ty: inner_type, mutbl } ) => {
                 unique_type_id.push('*');
@@ -396,7 +396,7 @@ impl<'tcx> TypeMap<'tcx> {
 
                 let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
                 let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
-                unique_type_id.push_str(inner_type_id.index(&FullRange));
+                unique_type_id.push_str(&inner_type_id[]);
             },
             ty::ty_rptr(_, ty::mt { ty: inner_type, mutbl }) => {
                 unique_type_id.push('&');
@@ -406,12 +406,12 @@ impl<'tcx> TypeMap<'tcx> {
 
                 let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
                 let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
-                unique_type_id.push_str(inner_type_id.index(&FullRange));
+                unique_type_id.push_str(&inner_type_id[]);
             },
             ty::ty_vec(inner_type, optional_length) => {
                 match optional_length {
                     Some(len) => {
-                        unique_type_id.push_str(format!("[{}]", len).index(&FullRange));
+                        unique_type_id.push_str(&format!("[{}]", len)[]);
                     }
                     None => {
                         unique_type_id.push_str("[]");
@@ -420,7 +420,7 @@ impl<'tcx> TypeMap<'tcx> {
 
                 let inner_type_id = self.get_unique_type_id_of_type(cx, inner_type);
                 let inner_type_id = self.get_unique_type_id_as_string(inner_type_id);
-                unique_type_id.push_str(inner_type_id.index(&FullRange));
+                unique_type_id.push_str(&inner_type_id[]);
             },
             ty::ty_trait(ref trait_data) => {
                 unique_type_id.push_str("trait ");
@@ -451,7 +451,7 @@ impl<'tcx> TypeMap<'tcx> {
                         self.get_unique_type_id_of_type(cx, parameter_type);
                     let parameter_type_id =
                         self.get_unique_type_id_as_string(parameter_type_id);
-                    unique_type_id.push_str(parameter_type_id.index(&FullRange));
+                    unique_type_id.push_str(&parameter_type_id[]);
                     unique_type_id.push(',');
                 }
 
@@ -464,7 +464,7 @@ impl<'tcx> TypeMap<'tcx> {
                     ty::FnConverging(ret_ty) => {
                         let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
                         let return_type_id = self.get_unique_type_id_as_string(return_type_id);
-                        unique_type_id.push_str(return_type_id.index(&FullRange));
+                        unique_type_id.push_str(&return_type_id[]);
                     }
                     ty::FnDiverging => {
                         unique_type_id.push_str("!");
@@ -479,9 +479,9 @@ impl<'tcx> TypeMap<'tcx> {
                                                         &mut unique_type_id);
             },
             _ => {
-                cx.sess().bug(format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
-                                      ppaux::ty_to_string(cx.tcx(), type_).index(&FullRange),
-                                      type_.sty).index(&FullRange))
+                cx.sess().bug(&format!("get_unique_type_id_of_type() - unexpected type: {}, {:?}",
+                                      &ppaux::ty_to_string(cx.tcx(), type_)[],
+                                      type_.sty)[])
             }
         };
 
@@ -524,7 +524,7 @@ impl<'tcx> TypeMap<'tcx> {
 
             output.push_str(crate_hash.as_str());
             output.push_str("/");
-            output.push_str(format!("{:x}", def_id.node).index(&FullRange));
+            output.push_str(&format!("{:x}", def_id.node)[]);
 
             // Maybe check that there is no self type here.
 
@@ -537,7 +537,7 @@ impl<'tcx> TypeMap<'tcx> {
                         type_map.get_unique_type_id_of_type(cx, type_parameter);
                     let param_type_id =
                         type_map.get_unique_type_id_as_string(param_type_id);
-                    output.push_str(param_type_id.index(&FullRange));
+                    output.push_str(&param_type_id[]);
                     output.push(',');
                 }
 
@@ -581,7 +581,7 @@ impl<'tcx> TypeMap<'tcx> {
                 self.get_unique_type_id_of_type(cx, parameter_type);
             let parameter_type_id =
                 self.get_unique_type_id_as_string(parameter_type_id);
-            unique_type_id.push_str(parameter_type_id.index(&FullRange));
+            unique_type_id.push_str(&parameter_type_id[]);
             unique_type_id.push(',');
         }
 
@@ -595,7 +595,7 @@ impl<'tcx> TypeMap<'tcx> {
             ty::FnConverging(ret_ty) => {
                 let return_type_id = self.get_unique_type_id_of_type(cx, ret_ty);
                 let return_type_id = self.get_unique_type_id_as_string(return_type_id);
-                unique_type_id.push_str(return_type_id.index(&FullRange));
+                unique_type_id.push_str(&return_type_id[]);
             }
             ty::FnDiverging => {
                 unique_type_id.push_str("!");
@@ -625,8 +625,7 @@ impl<'tcx> TypeMap<'tcx> {
                                               -> UniqueTypeId {
         let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type);
         let enum_variant_type_id = format!("{}::{}",
-                                           self.get_unique_type_id_as_string(enum_type_id)
-                                               .index(&FullRange),
+                                           &self.get_unique_type_id_as_string(enum_type_id)[],
                                            variant_name);
         let interner_key = self.unique_id_interner.intern(Rc::new(enum_variant_type_id));
         UniqueTypeId(interner_key)
@@ -803,23 +802,23 @@ pub fn create_global_var_metadata(cx: &CrateContext,
                 _ => {
                     cx.sess()
                       .span_bug(item.span,
-                                format!("debuginfo::\
+                                &format!("debuginfo::\
                                          create_global_var_metadata() -
                                          Captured var-id refers to \
                                          unexpected ast_item variant: {:?}",
-                                        var_item).index(&FullRange))
+                                        var_item)[])
                 }
             }
         },
-        _ => cx.sess().bug(format!("debuginfo::create_global_var_metadata() \
+        _ => cx.sess().bug(&format!("debuginfo::create_global_var_metadata() \
                                     - Captured var-id refers to unexpected \
                                     ast_map variant: {:?}",
-                                   var_item).index(&FullRange))
+                                   var_item)[])
     };
 
     let (file_metadata, line_number) = if span != codemap::DUMMY_SP {
         let loc = span_start(cx, span);
-        (file_metadata(cx, loc.file.name.index(&FullRange)), loc.line as c_uint)
+        (file_metadata(cx, &loc.file.name[]), loc.line as c_uint)
     } else {
         (UNKNOWN_FILE_METADATA, UNKNOWN_LINE_NUMBER)
     };
@@ -830,7 +829,7 @@ pub fn create_global_var_metadata(cx: &CrateContext,
     let namespace_node = namespace_for_item(cx, ast_util::local_def(node_id));
     let var_name = token::get_ident(ident).get().to_string();
     let linkage_name =
-        namespace_node.mangled_name_of_contained_item(var_name.index(&FullRange));
+        namespace_node.mangled_name_of_contained_item(&var_name[]);
     let var_scope = namespace_node.scope;
 
     let var_name = CString::from_slice(var_name.as_bytes());
@@ -868,8 +867,8 @@ pub fn create_local_var_metadata(bcx: Block, local: &ast::Local) {
             Some(datum) => datum,
             None => {
                 bcx.sess().span_bug(span,
-                    format!("no entry in lllocals table for {}",
-                            node_id).index(&FullRange));
+                    &format!("no entry in lllocals table for {}",
+                            node_id)[]);
             }
         };
 
@@ -919,21 +918,21 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 _ => {
                     cx.sess()
                       .span_bug(span,
-                                format!(
+                                &format!(
                                 "debuginfo::create_captured_var_metadata() - \
                                  Captured var-id refers to unexpected \
                                  ast_map variant: {:?}",
-                                 ast_item).index(&FullRange));
+                                 ast_item)[]);
                 }
             }
         }
         _ => {
             cx.sess()
               .span_bug(span,
-                        format!("debuginfo::create_captured_var_metadata() - \
+                        &format!("debuginfo::create_captured_var_metadata() - \
                                  Captured var-id refers to unexpected \
                                  ast_map variant: {:?}",
-                                ast_item).index(&FullRange));
+                                ast_item)[]);
         }
     };
 
@@ -963,7 +962,7 @@ pub fn create_captured_var_metadata<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     let variable_access = IndirectVariable {
         alloca: env_pointer,
-        address_operations: address_operations.index(&(0..address_op_count))
+        address_operations: &address_operations[0..address_op_count]
     };
 
     declare_local(bcx,
@@ -1039,8 +1038,8 @@ pub fn create_argument_metadata(bcx: Block, arg: &ast::Arg) {
             Some(v) => v,
             None => {
                 bcx.sess().span_bug(span,
-                    format!("no entry in lllocals table for {}",
-                            node_id).index(&FullRange));
+                    &format!("no entry in lllocals table for {}",
+                            node_id)[]);
             }
         };
 
@@ -1154,7 +1153,7 @@ pub fn get_cleanup_debug_loc_for_ast_node<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         if let Some(code_snippet) = code_snippet {
             let bytes = code_snippet.as_bytes();
 
-            if bytes.len() > 0 && bytes.index(&((bytes.len()-1)..)) == b"}" {
+            if bytes.len() > 0 && &bytes[(bytes.len()-1)..] == b"}" {
                 cleanup_span = Span {
                     lo: node_span.hi - codemap::BytePos(1),
                     hi: node_span.hi,
@@ -1298,7 +1297,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             match expr.node {
                 ast::ExprClosure(_, _, ref fn_decl, ref top_level_block) => {
                     let name = format!("fn{}", token::gensym("fn"));
-                    let name = token::str_to_ident(name.index(&FullRange));
+                    let name = token::str_to_ident(&name[]);
                     (name, &**fn_decl,
                         // This is not quite right. It should actually inherit
                         // the generics of the enclosing function.
@@ -1328,9 +1327,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 }
                 _ => {
                     cx.sess()
-                      .bug(format!("create_function_debug_context: \
+                      .bug(&format!("create_function_debug_context: \
                                     unexpected sort of node: {:?}",
-                                    fnitem).index(&FullRange))
+                                    fnitem)[])
                 }
             }
         }
@@ -1339,9 +1338,9 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ast_map::NodeStructCtor(..) => {
             return FunctionDebugContext::FunctionWithoutDebugInfo;
         }
-        _ => cx.sess().bug(format!("create_function_debug_context: \
+        _ => cx.sess().bug(&format!("create_function_debug_context: \
                                     unexpected sort of node: {:?}",
-                                   fnitem).index(&FullRange))
+                                   fnitem)[])
     };
 
     // This can be the case for functions inlined from another crate
@@ -1350,7 +1349,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     }
 
     let loc = span_start(cx, span);
-    let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
+    let file_metadata = file_metadata(cx, &loc.file.name[]);
 
     let function_type_metadata = unsafe {
         let fn_signature = get_function_signature(cx,
@@ -1377,7 +1376,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     let (linkage_name, containing_scope) = if has_path {
         let namespace_node = namespace_for_item(cx, ast_util::local_def(fn_ast_id));
         let linkage_name = namespace_node.mangled_name_of_contained_item(
-            function_name.index(&FullRange));
+            &function_name[]);
         let containing_scope = namespace_node.scope;
         (linkage_name, containing_scope)
     } else {
@@ -1465,7 +1464,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             signature.push(type_metadata(cx, arg_type, codemap::DUMMY_SP));
         }
 
-        return create_DIArray(DIB(cx), signature.index(&FullRange));
+        return create_DIArray(DIB(cx), &signature[]);
     }
 
     fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
@@ -1500,7 +1499,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                 actual_self_type,
                 true);
 
-            name_to_append_suffix_to.push_str(actual_self_type_name.index(&FullRange));
+            name_to_append_suffix_to.push_str(&actual_self_type_name[]);
 
             if generics.is_type_parameterized() {
                 name_to_append_suffix_to.push_str(",");
@@ -1539,7 +1538,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             let actual_type_name = compute_debuginfo_type_name(cx,
                                                                actual_type,
                                                                true);
-            name_to_append_suffix_to.push_str(actual_type_name.index(&FullRange));
+            name_to_append_suffix_to.push_str(&actual_type_name[]);
 
             if index != generics.ty_params.len() - 1 {
                 name_to_append_suffix_to.push_str(",");
@@ -1566,7 +1565,7 @@ pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
         name_to_append_suffix_to.push('>');
 
-        return create_DIArray(DIB(cx), template_params.index(&FullRange));
+        return create_DIArray(DIB(cx), &template_params[]);
     }
 }
 
@@ -1660,7 +1659,7 @@ fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     let cx: &CrateContext = bcx.ccx();
 
     let filename = span_start(cx, span).file.name.clone();
-    let file_metadata = file_metadata(cx, filename.index(&FullRange));
+    let file_metadata = file_metadata(cx, &filename[]);
 
     let name = token::get_ident(variable_ident);
     let loc = span_start(cx, span);
@@ -1746,7 +1745,7 @@ fn file_metadata(cx: &CrateContext, full_path: &str) -> DIFile {
     let work_dir = cx.sess().working_dir.as_str().unwrap();
     let file_name =
         if full_path.starts_with(work_dir) {
-            full_path.index(&((work_dir.len() + 1u)..full_path.len()))
+            &full_path[(work_dir.len() + 1u)..full_path.len()]
         } else {
             full_path
         };
@@ -1777,8 +1776,8 @@ fn scope_metadata(fcx: &FunctionContext,
             let node = fcx.ccx.tcx().map.get(node_id);
 
             fcx.ccx.sess().span_bug(error_reporting_span,
-                format!("debuginfo: Could not find scope info for node {:?}",
-                        node).index(&FullRange));
+                &format!("debuginfo: Could not find scope info for node {:?}",
+                        node)[]);
         }
     }
 }
@@ -1971,10 +1970,10 @@ impl<'tcx> RecursiveTypeDescription<'tcx> {
                     let type_map = debug_context(cx).type_map.borrow();
                     if type_map.find_metadata_for_unique_id(unique_type_id).is_none() ||
                        type_map.find_metadata_for_type(unfinished_type).is_none() {
-                        cx.sess().bug(format!("Forward declaration of potentially recursive type \
+                        cx.sess().bug(&format!("Forward declaration of potentially recursive type \
                                               '{}' was not found in TypeMap!",
                                               ppaux::ty_to_string(cx.tcx(), unfinished_type))
-                                      .index(&FullRange));
+                                      []);
                     }
                 }
 
@@ -1986,7 +1985,7 @@ impl<'tcx> RecursiveTypeDescription<'tcx> {
                 set_members_of_composite_type(cx,
                                               metadata_stub,
                                               llvm_type,
-                                              member_descriptions.index(&FullRange));
+                                              &member_descriptions[]);
                 return MetadataCreationResult::new(metadata_stub, true);
             }
         }
@@ -2058,7 +2057,7 @@ fn prepare_struct_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     let struct_metadata_stub = create_struct_stub(cx,
                                                   struct_llvm_type,
-                                                  struct_name.index(&FullRange),
+                                                  &struct_name[],
                                                   unique_type_id,
                                                   containing_scope);
 
@@ -2119,7 +2118,7 @@ fn prepare_tuple_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         unique_type_id,
         create_struct_stub(cx,
                            tuple_llvm_type,
-                           tuple_name.index(&FullRange),
+                           &tuple_name[],
                            unique_type_id,
                            UNKNOWN_SCOPE_METADATA),
         tuple_llvm_type,
@@ -2179,7 +2178,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                         set_members_of_composite_type(cx,
                                                       variant_type_metadata,
                                                       variant_llvm_type,
-                                                      member_descriptions.index(&FullRange));
+                                                      &member_descriptions[]);
                         MemberDescription {
                             name: "".to_string(),
                             llvm_type: variant_llvm_type,
@@ -2212,7 +2211,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                     set_members_of_composite_type(cx,
                                                   variant_type_metadata,
                                                   variant_llvm_type,
-                                                  member_descriptions.index(&FullRange));
+                                                  &member_descriptions[]);
                     vec![
                         MemberDescription {
                             name: "".to_string(),
@@ -2312,7 +2311,7 @@ impl<'tcx> EnumMemberDescriptionFactory<'tcx> {
                 set_members_of_composite_type(cx,
                                               variant_type_metadata,
                                               variant_llvm_type,
-                                              variant_member_descriptions.index(&FullRange));
+                                              &variant_member_descriptions[]);
 
                 // Encode the information about the null variant in the union
                 // member's name.
@@ -2387,11 +2386,11 @@ fn describe_enum_variant<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                    span: Span)
                                    -> (DICompositeType, Type, MemberDescriptionFactory<'tcx>) {
     let variant_llvm_type =
-        Type::struct_(cx, struct_def.fields
+        Type::struct_(cx, &struct_def.fields
                                     .iter()
                                     .map(|&t| type_of::type_of(cx, t))
                                     .collect::<Vec<_>>()
-                                    .index(&FullRange),
+                                    [],
                       struct_def.packed);
     // Could do some consistency checks here: size, align, field count, discr type
 
@@ -2458,7 +2457,7 @@ fn prepare_enum_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     let (containing_scope, definition_span) = get_namespace_and_span_for_item(cx, enum_def_id);
     let loc = span_start(cx, definition_span);
-    let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
+    let file_metadata = file_metadata(cx, &loc.file.name[]);
 
     let variants = ty::enum_variants(cx.tcx(), enum_def_id);
 
@@ -2638,14 +2637,14 @@ fn set_members_of_composite_type(cx: &CrateContext,
             let min_supported_llvm_version = 3 * 1000000 + 4 * 1000;
 
             if actual_llvm_version < min_supported_llvm_version {
-                cx.sess().warn(format!("This version of rustc was built with LLVM \
+                cx.sess().warn(&format!("This version of rustc was built with LLVM \
                                         {}.{}. Rustc just ran into a known \
                                         debuginfo corruption problem thatoften \
                                         occurs with LLVM versions below 3.4. \
                                         Please use a rustc built with anewer \
                                         version of LLVM.",
                                        llvm_version_major,
-                                       llvm_version_minor).index(&FullRange));
+                                       llvm_version_minor)[]);
             } else {
                 cx.sess().bug("debuginfo::set_members_of_composite_type() - \
                                Already completed forward declaration re-encountered.");
@@ -2683,7 +2682,7 @@ fn set_members_of_composite_type(cx: &CrateContext,
         .collect();
 
     unsafe {
-        let type_array = create_DIArray(DIB(cx), member_metadata.index(&FullRange));
+        let type_array = create_DIArray(DIB(cx), &member_metadata[]);
         llvm::LLVMDICompositeTypeSetTypeArray(composite_type_metadata, type_array);
     }
 }
@@ -2782,7 +2781,7 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     let member_llvm_types = slice_llvm_type.field_types();
     assert!(slice_layout_is_correct(cx,
-                                    member_llvm_types.index(&FullRange),
+                                    &member_llvm_types[],
                                     element_type));
     let member_descriptions = [
         MemberDescription {
@@ -2804,11 +2803,11 @@ fn vec_slice_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     assert!(member_descriptions.len() == member_llvm_types.len());
 
     let loc = span_start(cx, span);
-    let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
+    let file_metadata = file_metadata(cx, &loc.file.name[]);
 
     let metadata = composite_type_metadata(cx,
                                            slice_llvm_type,
-                                           slice_type_name.index(&FullRange),
+                                           &slice_type_name[],
                                            unique_type_id,
                                            &member_descriptions,
                                            UNKNOWN_SCOPE_METADATA,
@@ -2857,7 +2856,7 @@ fn subroutine_type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
             llvm::LLVMDIBuilderCreateSubroutineType(
                 DIB(cx),
                 UNKNOWN_FILE_METADATA,
-                create_DIArray(DIB(cx), signature_metadata.index(&FullRange)))
+                create_DIArray(DIB(cx), &signature_metadata[]))
         },
         false);
 }
@@ -2881,9 +2880,9 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::ty_trait(ref data) => data.principal_def_id(),
         _ => {
             let pp_type_name = ppaux::ty_to_string(cx.tcx(), trait_type);
-            cx.sess().bug(format!("debuginfo: Unexpected trait-object type in \
+            cx.sess().bug(&format!("debuginfo: Unexpected trait-object type in \
                                    trait_pointer_metadata(): {}",
-                                   pp_type_name.index(&FullRange)).index(&FullRange));
+                                   &pp_type_name[])[]);
         }
     };
 
@@ -2897,7 +2896,7 @@ fn trait_pointer_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 
     composite_type_metadata(cx,
                             trait_llvm_type,
-                            trait_type_name.index(&FullRange),
+                            &trait_type_name[],
                             unique_type_id,
                             &[],
                             containing_scope,
@@ -3017,13 +3016,13 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::ty_tup(ref elements) => {
             prepare_tuple_metadata(cx,
                                    t,
-                                   elements.index(&FullRange),
+                                   &elements[],
                                    unique_type_id,
                                    usage_site_span).finalize(cx)
         }
         _ => {
-            cx.sess().bug(format!("debuginfo: unexpected type in type_metadata: {:?}",
-                                  sty).index(&FullRange))
+            cx.sess().bug(&format!("debuginfo: unexpected type in type_metadata: {:?}",
+                                  sty)[])
         }
     };
 
@@ -3041,9 +3040,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                                  type id '{}' to already be in \
                                                  the debuginfo::TypeMap but it \
                                                  was not. (Ty = {})",
-                                                unique_type_id_str.index(&FullRange),
+                                                &unique_type_id_str[],
                                                 ppaux::ty_to_string(cx.tcx(), t));
-                    cx.sess().span_bug(usage_site_span, error_message.index(&FullRange));
+                    cx.sess().span_bug(usage_site_span, &error_message[]);
                 }
             };
 
@@ -3056,9 +3055,9 @@ fn type_metadata<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
                                                      UniqueTypeId maps in \
                                                      debuginfo::TypeMap. \
                                                      UniqueTypeId={}, Ty={}",
-                            unique_type_id_str.index(&FullRange),
+                            &unique_type_id_str[],
                             ppaux::ty_to_string(cx.tcx(), t));
-                        cx.sess().span_bug(usage_site_span, error_message.index(&FullRange));
+                        cx.sess().span_bug(usage_site_span, &error_message[]);
                     }
                 }
                 None => {
@@ -3264,7 +3263,7 @@ fn create_scope_map(cx: &CrateContext,
     {
         // Create a new lexical scope and push it onto the stack
         let loc = cx.sess().codemap().lookup_char_pos(scope_span.lo);
-        let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
+        let file_metadata = file_metadata(cx, &loc.file.name[]);
         let parent_scope = scope_stack.last().unwrap().scope_metadata;
 
         let scope_metadata = unsafe {
@@ -3386,7 +3385,7 @@ fn create_scope_map(cx: &CrateContext,
                     if need_new_scope {
                         // Create a new lexical scope and push it onto the stack
                         let loc = cx.sess().codemap().lookup_char_pos(pat.span.lo);
-                        let file_metadata = file_metadata(cx, loc.file.name.index(&FullRange));
+                        let file_metadata = file_metadata(cx, &loc.file.name[]);
                         let parent_scope = scope_stack.last().unwrap().scope_metadata;
 
                         let scope_metadata = unsafe {
@@ -3861,8 +3860,8 @@ fn push_debuginfo_type_name<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
         ty::ty_open(_) |
         ty::ty_projection(..) |
         ty::ty_param(_) => {
-            cx.sess().bug(format!("debuginfo: Trying to create type name for \
-                unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange));
+            cx.sess().bug(&format!("debuginfo: Trying to create type name for \
+                unexpected type: {}", ppaux::ty_to_string(cx.tcx(), t))[]);
         }
     }
 
@@ -3945,13 +3944,13 @@ impl NamespaceTreeNode {
                 None => {}
             }
             let string = token::get_name(node.name);
-            output.push_str(format!("{}", string.get().len()).index(&FullRange));
+            output.push_str(&format!("{}", string.get().len())[]);
             output.push_str(string.get());
         }
 
         let mut name = String::from_str("_ZN");
         fill_nested(self, &mut name);
-        name.push_str(format!("{}", item_name.len()).index(&FullRange));
+        name.push_str(&format!("{}", item_name.len())[]);
         name.push_str(item_name);
         name.push('E');
         name
@@ -3959,7 +3958,7 @@ impl NamespaceTreeNode {
 }
 
 fn crate_root_namespace<'a>(cx: &'a CrateContext) -> &'a str {
-    cx.link_meta().crate_name.index(&FullRange)
+    &cx.link_meta().crate_name[]
 }
 
 fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTreeNode> {
@@ -4034,9 +4033,9 @@ fn namespace_for_item(cx: &CrateContext, def_id: ast::DefId) -> Rc<NamespaceTree
         match parent_node {
             Some(node) => node,
             None => {
-                cx.sess().bug(format!("debuginfo::namespace_for_item(): \
+                cx.sess().bug(&format!("debuginfo::namespace_for_item(): \
                                        path too short for {:?}",
-                                      def_id).index(&FullRange));
+                                      def_id)[]);
             }
         }
     })
diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs
index 120e2e955e4be..ac50445be2f9b 100644
--- a/src/librustc_trans/trans/expr.rs
+++ b/src/librustc_trans/trans/expr.rs
@@ -50,6 +50,7 @@ use trans::debuginfo;
 use trans::glue;
 use trans::machine;
 use trans::meth;
+use trans::monomorphize;
 use trans::inline;
 use trans::tvec;
 use trans::type_of;
@@ -317,8 +318,8 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                     // should just be the identity function.
                     unsized_info(bcx, k, id, ty_substs[tp_index], identity)
                 }
-                _ => bcx.sess().bug(format!("UnsizeStruct with bad sty: {}",
-                                          bcx.ty_to_string(unadjusted_ty)).index(&FullRange))
+                _ => bcx.sess().bug(&format!("UnsizeStruct with bad sty: {}",
+                                          bcx.ty_to_string(unadjusted_ty))[])
             },
             &ty::UnsizeVtable(ty::TyTrait { ref principal, .. }, _) => {
                 // Note that we preserve binding levels here:
@@ -450,8 +451,8 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         let datum_ty = datum.ty;
         let unboxed_ty = match datum_ty.sty {
             ty::ty_uniq(t) => t,
-            _ => bcx.sess().bug(format!("Expected ty_uniq, found {}",
-                                        bcx.ty_to_string(datum_ty)).index(&FullRange))
+            _ => bcx.sess().bug(&format!("Expected ty_uniq, found {}",
+                                        bcx.ty_to_string(datum_ty))[])
         };
         let result_ty = ty::mk_uniq(tcx, ty::unsize_ty(tcx, unboxed_ty, k, expr.span));
 
@@ -622,9 +623,9 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => {
             bcx.tcx().sess.span_bug(
                 expr.span,
-                format!("trans_rvalue_datum_unadjusted reached \
+                &format!("trans_rvalue_datum_unadjusted reached \
                          fall-through case: {:?}",
-                        expr.node).index(&FullRange));
+                        expr.node)[]);
         }
     }
 }
@@ -975,9 +976,9 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => {
             bcx.tcx().sess.span_bug(
                 expr.span,
-                format!("trans_rvalue_stmt_unadjusted reached \
+                &format!("trans_rvalue_stmt_unadjusted reached \
                          fall-through case: {:?}",
-                        expr.node).index(&FullRange));
+                        expr.node)[]);
         }
     }
 }
@@ -1003,14 +1004,14 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             controlflow::trans_if(bcx, expr.id, &**cond, &**thn, els.as_ref().map(|e| &**e), dest)
         }
         ast::ExprMatch(ref discr, ref arms, _) => {
-            _match::trans_match(bcx, expr, &**discr, arms.index(&FullRange), dest)
+            _match::trans_match(bcx, expr, &**discr, &arms[], dest)
         }
         ast::ExprBlock(ref blk) => {
             controlflow::trans_block(bcx, &**blk, dest)
         }
         ast::ExprStruct(_, ref fields, ref base) => {
             trans_struct(bcx,
-                         fields.index(&FullRange),
+                         &fields[],
                          base.as_ref().map(|e| &**e),
                          expr.span,
                          expr.id,
@@ -1075,7 +1076,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             trans_adt(bcx,
                       expr_ty(bcx, expr),
                       0,
-                      numbered_fields.index(&FullRange),
+                      &numbered_fields[],
                       None,
                       dest,
                       Some(NodeInfo { id: expr.id, span: expr.span }))
@@ -1119,13 +1120,13 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 trans_overloaded_call(bcx,
                                       expr,
                                       &**f,
-                                      args.index(&FullRange),
+                                      &args[],
                                       Some(dest))
             } else {
                 callee::trans_call(bcx,
                                    expr,
                                    &**f,
-                                   callee::ArgExprs(args.index(&FullRange)),
+                                   callee::ArgExprs(&args[]),
                                    dest)
             }
         }
@@ -1133,7 +1134,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             callee::trans_method_call(bcx,
                                       expr,
                                       &*args[0],
-                                      callee::ArgExprs(args.index(&FullRange)),
+                                      callee::ArgExprs(&args[]),
                                       dest)
         }
         ast::ExprBinary(op, ref lhs, ref rhs) => {
@@ -1180,9 +1181,9 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => {
             bcx.tcx().sess.span_bug(
                 expr.span,
-                format!("trans_rvalue_dps_unadjusted reached fall-through \
+                &format!("trans_rvalue_dps_unadjusted reached fall-through \
                          case: {:?}",
-                        expr.node).index(&FullRange));
+                        expr.node)[]);
         }
     }
 }
@@ -1230,9 +1231,9 @@ fn trans_def_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             bcx
         }
         _ => {
-            bcx.tcx().sess.span_bug(ref_expr.span, format!(
+            bcx.tcx().sess.span_bug(ref_expr.span, &format!(
                 "Non-DPS def {:?} referened by {}",
-                def, bcx.node_id_to_string(ref_expr.id)).index(&FullRange));
+                def, bcx.node_id_to_string(ref_expr.id))[]);
         }
     }
 }
@@ -1258,10 +1259,10 @@ pub fn trans_def_fn_unadjusted<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                              param_substs)
         }
         _ => {
-            ccx.tcx().sess.span_bug(ref_expr.span, format!(
+            ccx.tcx().sess.span_bug(ref_expr.span, &format!(
                     "trans_def_fn_unadjusted invoked on: {:?} for {}",
                     def,
-                    ref_expr.repr(ccx.tcx())).index(&FullRange));
+                    ref_expr.repr(ccx.tcx()))[]);
         }
     }
 }
@@ -1279,9 +1280,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             match bcx.fcx.llupvars.borrow().get(&nid) {
                 Some(&val) => Datum::new(val, local_ty, Lvalue),
                 None => {
-                    bcx.sess().bug(format!(
+                    bcx.sess().bug(&format!(
                         "trans_local_var: no llval for upvar {} found",
-                        nid).index(&FullRange));
+                        nid)[]);
                 }
             }
         }
@@ -1289,9 +1290,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             let datum = match bcx.fcx.lllocals.borrow().get(&nid) {
                 Some(&v) => v,
                 None => {
-                    bcx.sess().bug(format!(
+                    bcx.sess().bug(&format!(
                         "trans_local_var: no datum for local/arg {} found",
-                        nid).index(&FullRange));
+                        nid)[]);
                 }
             };
             debug!("take_local(nid={}, v={}, ty={})",
@@ -1299,9 +1300,9 @@ pub fn trans_local_var<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             datum
         }
         _ => {
-            bcx.sess().unimpl(format!(
+            bcx.sess().unimpl(&format!(
                 "unsupported def type in trans_local_var: {:?}",
-                def).index(&FullRange));
+                def)[]);
         }
     }
 }
@@ -1318,21 +1319,23 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>,
 {
     match ty.sty {
         ty::ty_struct(did, substs) => {
-            op(0, struct_fields(tcx, did, substs).index(&FullRange))
+            let fields = struct_fields(tcx, did, substs);
+            let fields = monomorphize::normalize_associated_type(tcx, &fields);
+            op(0, &fields[])
         }
 
         ty::ty_tup(ref v) => {
-            op(0, tup_fields(v.index(&FullRange)).index(&FullRange))
+            op(0, &tup_fields(&v[])[])
         }
 
         ty::ty_enum(_, substs) => {
             // We want the *variant* ID here, not the enum ID.
             match node_id_opt {
                 None => {
-                    tcx.sess.bug(format!(
+                    tcx.sess.bug(&format!(
                         "cannot get field types from the enum type {} \
                          without a node ID",
-                        ty.repr(tcx)).index(&FullRange));
+                        ty.repr(tcx))[]);
                 }
                 Some(node_id) => {
                     let def = tcx.def_map.borrow()[node_id].clone();
@@ -1340,10 +1343,9 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>,
                         def::DefVariant(enum_id, variant_id, _) => {
                             let variant_info = ty::enum_variant_with_id(
                                 tcx, enum_id, variant_id);
-                            op(variant_info.disr_val,
-                               struct_fields(tcx,
-                                             variant_id,
-                                             substs).index(&FullRange))
+                            let fields = struct_fields(tcx, variant_id, substs);
+                            let fields = monomorphize::normalize_associated_type(tcx, &fields);
+                            op(variant_info.disr_val, &fields[])
                         }
                         _ => {
                             tcx.sess.bug("resolve didn't map this expr to a \
@@ -1355,9 +1357,9 @@ pub fn with_field_tys<'tcx, R, F>(tcx: &ty::ctxt<'tcx>,
         }
 
         _ => {
-            tcx.sess.bug(format!(
+            tcx.sess.bug(&format!(
                 "cannot get field types from the type {}",
-                ty.repr(tcx)).index(&FullRange));
+                ty.repr(tcx))[]);
         }
     }
 }
@@ -2045,21 +2047,21 @@ fn trans_imm_cast<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                           lldiscrim_a, true),
                 cast_float => SIToFP(bcx, lldiscrim_a, ll_t_out),
                 _ => {
-                    ccx.sess().bug(format!("translating unsupported cast: \
+                    ccx.sess().bug(&format!("translating unsupported cast: \
                                             {} ({:?}) -> {} ({:?})",
                                             t_in.repr(bcx.tcx()),
                                             k_in,
                                             t_out.repr(bcx.tcx()),
-                                            k_out).index(&FullRange))
+                                            k_out)[])
                 }
             }
         }
-        _ => ccx.sess().bug(format!("translating unsupported cast: \
+        _ => ccx.sess().bug(&format!("translating unsupported cast: \
                                     {} ({:?}) -> {} ({:?})",
                                     t_in.repr(bcx.tcx()),
                                     k_in,
                                     t_out.repr(bcx.tcx()),
-                                    k_out).index(&FullRange))
+                                    k_out)[])
     };
     return immediate_rvalue_bcx(bcx, newval, t_out).to_expr_datumblock();
 }
@@ -2224,8 +2226,8 @@ fn deref_once<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => {
             bcx.tcx().sess.span_bug(
                 expr.span,
-                format!("deref invoked on expr of illegal type {}",
-                        datum.ty.repr(bcx.tcx())).index(&FullRange));
+                &format!("deref invoked on expr of illegal type {}",
+                        datum.ty.repr(bcx.tcx()))[]);
         }
     };
 
diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs
index 25eb66ab2eb73..3dfb36c854b72 100644
--- a/src/librustc_trans/trans/foreign.rs
+++ b/src/librustc_trans/trans/foreign.rs
@@ -109,7 +109,7 @@ pub fn register_static(ccx: &CrateContext,
     let llty = type_of::type_of(ccx, ty);
 
     let ident = link_name(foreign_item);
-    match attr::first_attr_value_str_by_name(foreign_item.attrs.index(&FullRange),
+    match attr::first_attr_value_str_by_name(&foreign_item.attrs[],
                                              "linkage") {
         // If this is a static with a linkage specified, then we need to handle
         // it a little specially. The typesystem prevents things like &T and
@@ -235,13 +235,13 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         _ => ccx.sess().bug("trans_native_call called on non-function type")
     };
     let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig);
-    let llsig = foreign_signature(ccx, &fn_sig, passed_arg_tys.index(&FullRange));
+    let llsig = foreign_signature(ccx, &fn_sig, &passed_arg_tys[]);
     let fn_type = cabi::compute_abi_info(ccx,
-                                         llsig.llarg_tys.index(&FullRange),
+                                         &llsig.llarg_tys[],
                                          llsig.llret_ty,
                                          llsig.ret_def);
 
-    let arg_tys: &[cabi::ArgType] = fn_type.arg_tys.index(&FullRange);
+    let arg_tys: &[cabi::ArgType] = &fn_type.arg_tys[];
 
     let mut llargs_foreign = Vec::new();
 
@@ -367,7 +367,7 @@ pub fn trans_native_call<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
     let llforeign_retval = CallWithConv(bcx,
                                         llfn,
-                                        llargs_foreign.index(&FullRange),
+                                        &llargs_foreign[],
                                         cc,
                                         Some(attrs));
 
@@ -437,7 +437,7 @@ pub fn trans_foreign_mod(ccx: &CrateContext, foreign_mod: &ast::ForeignMod) {
                 abi => {
                     let ty = ty::node_id_to_type(ccx.tcx(), foreign_item.id);
                     register_foreign_item_fn(ccx, abi, ty,
-                                             lname.get().index(&FullRange));
+                                             &lname.get()[]);
                     // Unlike for other items, we shouldn't call
                     // `base::update_linkage` here.  Foreign items have
                     // special linkage requirements, which are handled
@@ -566,10 +566,10 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                 assert!(f.abi != Rust && f.abi != RustIntrinsic);
             }
             _ => {
-                ccx.sess().bug(format!("build_rust_fn: extern fn {} has ty {}, \
+                ccx.sess().bug(&format!("build_rust_fn: extern fn {} has ty {}, \
                                         expected a bare fn ty",
                                        ccx.tcx().map.path_to_string(id),
-                                       t.repr(tcx)).index(&FullRange));
+                                       t.repr(tcx))[]);
             }
         };
 
@@ -577,7 +577,7 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                ccx.tcx().map.path_to_string(id),
                id, t.repr(tcx));
 
-        let llfn = base::decl_internal_rust_fn(ccx, t, ps.index(&FullRange));
+        let llfn = base::decl_internal_rust_fn(ccx, t, &ps[]);
         base::set_llvm_fn_attrs(ccx, attrs, llfn);
         base::trans_fn(ccx, decl, body, llfn, param_substs, id, &[]);
         llfn
@@ -817,9 +817,9 @@ pub fn trans_rust_fn_with_foreign_abi<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 // the massive simplifications that have occurred.
 
 pub fn link_name(i: &ast::ForeignItem) -> InternedString {
-    match attr::first_attr_value_str_by_name(i.attrs.index(&FullRange), "link_name") {
+    match attr::first_attr_value_str_by_name(&i.attrs[], "link_name") {
         Some(ln) => ln.clone(),
-        None => match weak_lang_items::link_name(i.attrs.index(&FullRange)) {
+        None => match weak_lang_items::link_name(&i.attrs[]) {
             Some(name) => name,
             None => token::get_ident(i.ident),
         }
@@ -862,7 +862,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let fn_sig = ty::erase_late_bound_regions(ccx.tcx(), fn_sig);
     let llsig = foreign_signature(ccx, &fn_sig, fn_sig.inputs.as_slice());
     let fn_ty = cabi::compute_abi_info(ccx,
-                                       llsig.llarg_tys.index(&FullRange),
+                                       &llsig.llarg_tys[],
                                        llsig.llret_ty,
                                        llsig.ret_def);
     debug!("foreign_types_for_fn_ty(\
@@ -871,7 +871,7 @@ fn foreign_types_for_fn_ty<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
            fn_ty={} -> {}, \
            ret_def={}",
            ty.repr(ccx.tcx()),
-           ccx.tn().types_to_str(llsig.llarg_tys.index(&FullRange)),
+           ccx.tn().types_to_str(&llsig.llarg_tys[]),
            ccx.tn().type_to_string(llsig.llret_ty),
            ccx.tn().types_to_str(fn_ty.arg_tys.iter().map(|t| t.ty).collect::<Vec<_>>().as_slice()),
            ccx.tn().type_to_string(fn_ty.ret_ty.ty),
@@ -923,7 +923,7 @@ fn lltype_for_fn_from_foreign_types(ccx: &CrateContext, tys: &ForeignTypes) -> T
     if tys.fn_sig.variadic {
         Type::variadic_func(llargument_tys.as_slice(), &llreturn_ty)
     } else {
-        Type::func(llargument_tys.index(&FullRange), &llreturn_ty)
+        Type::func(&llargument_tys[], &llreturn_ty)
     }
 }
 
diff --git a/src/librustc_trans/trans/glue.rs b/src/librustc_trans/trans/glue.rs
index 52e7a986d7e98..2219cd59263cc 100644
--- a/src/librustc_trans/trans/glue.rs
+++ b/src/librustc_trans/trans/glue.rs
@@ -161,7 +161,7 @@ pub fn get_drop_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Val
 
     let (glue, new_sym) = match ccx.available_drop_glues().borrow().get(&t) {
         Some(old_sym) => {
-            let glue = decl_cdecl_fn(ccx, old_sym.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx()));
+            let glue = decl_cdecl_fn(ccx, &old_sym[], llfnty, ty::mk_nil(ccx.tcx()));
             (glue, None)
         },
         None => {
@@ -233,8 +233,8 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             assert!(sig.inputs.len() == 1);
             sig.inputs[0]
         }
-        _ => bcx.sess().bug(format!("Expected function type, found {}",
-                                    bcx.ty_to_string(fty)).index(&FullRange))
+        _ => bcx.sess().bug(&format!("Expected function type, found {}",
+                                    bcx.ty_to_string(fty))[])
     };
 
     let (struct_data, info) = if type_is_sized(bcx.tcx(), t) {
@@ -295,7 +295,7 @@ fn trans_struct_drop<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                                      class_did,
                                      &[get_drop_glue_type(bcx.ccx(), t)],
                                      ty::mk_nil(bcx.tcx()));
-        let (_, variant_cx) = invoke(variant_cx, dtor_addr, args.index(&FullRange), dtor_ty, None);
+        let (_, variant_cx) = invoke(variant_cx, dtor_addr, &args[], dtor_ty, None);
 
         variant_cx.fcx.pop_and_trans_custom_cleanup_scope(variant_cx, field_scope);
         variant_cx
@@ -353,8 +353,8 @@ fn size_and_align_of_dst<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, t: Ty<'tcx>, info:
             let unit_size = llsize_of_alloc(bcx.ccx(), llunit_ty);
             (Mul(bcx, info, C_uint(bcx.ccx(), unit_size)), C_uint(bcx.ccx(), 8u))
         }
-        _ => bcx.sess().bug(format!("Unexpected unsized type, found {}",
-                                    bcx.ty_to_string(t)).index(&FullRange))
+        _ => bcx.sess().bug(&format!("Unexpected unsized type, found {}",
+                                    bcx.ty_to_string(t))[])
     }
 }
 
@@ -423,10 +423,10 @@ fn make_drop_glue<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, v0: ValueRef, t: Ty<'tcx>)
                     } else {
                         // Give the user a heads up that we are doing something
                         // stupid and dangerous.
-                        bcx.sess().warn(format!("Ignoring drop flag in destructor for {}\
+                        bcx.sess().warn(&format!("Ignoring drop flag in destructor for {}\
                                                  because the struct is unsized. See issue\
                                                  #16758",
-                                                bcx.ty_to_string(t)).index(&FullRange));
+                                                bcx.ty_to_string(t))[]);
                         trans_struct_drop(bcx, t, v0, dtor, did, substs)
                     }
                 }
@@ -496,7 +496,7 @@ pub fn declare_tydesc<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>)
     note_unique_llvm_symbol(ccx, name);
 
     let ty_name = token::intern_and_get_ident(
-        ppaux::ty_to_string(ccx.tcx(), t).index(&FullRange));
+        &ppaux::ty_to_string(ccx.tcx(), t)[]);
     let ty_name = C_str_slice(ccx, ty_name);
 
     debug!("--- declare_tydesc {}", ppaux::ty_to_string(ccx.tcx(), t));
@@ -515,8 +515,8 @@ fn declare_generic_glue<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>,
     let fn_nm = mangle_internal_name_by_type_and_seq(
         ccx,
         t,
-        format!("glue_{}", name).index(&FullRange));
-    let llfn = decl_cdecl_fn(ccx, fn_nm.index(&FullRange), llfnty, ty::mk_nil(ccx.tcx()));
+        &format!("glue_{}", name)[]);
+    let llfn = decl_cdecl_fn(ccx, &fn_nm[], llfnty, ty::mk_nil(ccx.tcx()));
     note_unique_llvm_symbol(ccx, fn_nm.clone());
     return (fn_nm, llfn);
 }
diff --git a/src/librustc_trans/trans/intrinsic.rs b/src/librustc_trans/trans/intrinsic.rs
index ed75445b9939b..b22c7f763f035 100644
--- a/src/librustc_trans/trans/intrinsic.rs
+++ b/src/librustc_trans/trans/intrinsic.rs
@@ -313,7 +313,7 @@ pub fn trans_intrinsic_call<'a, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>,
         (_, "size_of") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
             let lltp_ty = type_of::type_of(ccx, tp_ty);
-            C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty))
+            C_uint(ccx, machine::llsize_of_alloc(ccx, lltp_ty))
         }
         (_, "min_align_of") => {
             let tp_ty = *substs.types.get(FnSpace, 0);
diff --git a/src/librustc_trans/trans/machine.rs b/src/librustc_trans/trans/machine.rs
index 41738f1e58f3e..95d67cd54c124 100644
--- a/src/librustc_trans/trans/machine.rs
+++ b/src/librustc_trans/trans/machine.rs
@@ -43,8 +43,10 @@ pub fn llsize_of_alloc(cx: &CrateContext, ty: Type) -> llsize {
 
 // Returns, as near as we can figure, the "real" size of a type. As in, the
 // bits in this number of bytes actually carry data related to the datum
-// with the type. Not junk, padding, accidentally-damaged words, or
-// whatever. Rounds up to the nearest byte though, so if you have a 1-bit
+// with the type. Not junk, accidentally-damaged words, or whatever.
+// Note that padding of the type will be included for structs, but not for the
+// other types (i.e. SIMD types).
+// Rounds up to the nearest byte though, so if you have a 1-bit
 // value, we return 1 here, not 0. Most of rustc works in bytes. Be warned
 // that LLVM *does* distinguish between e.g. a 1-bit value and an 8-bit value
 // at the codegen level! In general you should prefer `llbitsize_of_real`
diff --git a/src/librustc_trans/trans/meth.rs b/src/librustc_trans/trans/meth.rs
index 28718ffa980a0..7ac062108f3fb 100644
--- a/src/librustc_trans/trans/meth.rs
+++ b/src/librustc_trans/trans/meth.rs
@@ -77,7 +77,7 @@ pub fn trans_impl(ccx: &CrateContext,
         match *impl_item {
             ast::MethodImplItem(ref method) => {
                 if method.pe_generics().ty_params.len() == 0u {
-                    let trans_everywhere = attr::requests_inline(method.attrs.index(&FullRange));
+                    let trans_everywhere = attr::requests_inline(&method.attrs[]);
                     for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) {
                         let llfn = get_item_val(ccx, method.id);
                         trans_fn(ccx,
@@ -229,7 +229,7 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     // Here, in this call, which I've written with explicit UFCS
     // notation, the set of type parameters will be:
     //
-    //     rcvr_type: .index(&FullRange) <-- nothing declared on the trait itself
+    //     rcvr_type: [] <-- nothing declared on the trait itself
     //     rcvr_self: [Vec<int>] <-- the self type
     //     rcvr_method: [String] <-- method type parameter
     //
@@ -268,11 +268,11 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             //
             // Recall that we matched `<Vec<int> as Convert>`. Trait
             // resolution will have given us a substitution
-            // containing `impl_substs=[[T=int],.index(&FullRange),.index(&FullRange)]` (the type
+            // containing `impl_substs=[[T=int],[],[]]` (the type
             // parameters defined on the impl). We combine
             // that with the `rcvr_method` from before, which tells us
             // the type parameters from the *method*, to yield
-            // `callee_substs=[[T=int],.index(&FullRange),[U=String]]`.
+            // `callee_substs=[[T=int],[],[U=String]]`.
             let subst::SeparateVecsPerParamSpace {
                 types: impl_type,
                 selfs: impl_self,
@@ -289,8 +289,8 @@ pub fn trans_static_method_callee<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                      callee_substs)
         }
         _ => {
-            tcx.sess.bug(format!("static call to invalid vtable: {}",
-                                 vtbl.repr(tcx)).index(&FullRange));
+            tcx.sess.bug(&format!("static call to invalid vtable: {}",
+                                 vtbl.repr(tcx))[]);
         }
     }
 }
@@ -377,8 +377,8 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
         traits::VtableBuiltin(..) |
         traits::VtableParam(..) => {
             bcx.sess().bug(
-                format!("resolved vtable bad vtable {} in trans",
-                        vtable.repr(bcx.tcx())).index(&FullRange));
+                &format!("resolved vtable bad vtable {} in trans",
+                        vtable.repr(bcx.tcx()))[]);
         }
     }
 }
@@ -738,9 +738,9 @@ pub fn get_vtable<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
             }
             traits::VtableParam => {
                 bcx.sess().bug(
-                    format!("resolved vtable for {} to bad vtable {} in trans",
+                    &format!("resolved vtable for {} to bad vtable {} in trans",
                             trait_ref.repr(bcx.tcx()),
-                            vtable.repr(bcx.tcx())).index(&FullRange));
+                            vtable.repr(bcx.tcx()))[]);
             }
         }
     });
@@ -772,7 +772,7 @@ pub fn make_vtable<I: Iterator<Item=ValueRef>>(ccx: &CrateContext,
     let components: Vec<_> = head.into_iter().chain(ptrs).collect();
 
     unsafe {
-        let tbl = C_struct(ccx, components.index(&FullRange), false);
+        let tbl = C_struct(ccx, &components[], false);
         let sym = token::gensym("vtable");
         let buf = CString::from_vec(format!("vtable{}", sym.uint()).into_bytes());
         let vt_gvar = llvm::LLVMAddGlobal(ccx.llmod(), val_ty(tbl).to_ref(),
diff --git a/src/librustc_trans/trans/monomorphize.rs b/src/librustc_trans/trans/monomorphize.rs
index e2594765f4fda..93076260349ab 100644
--- a/src/librustc_trans/trans/monomorphize.rs
+++ b/src/librustc_trans/trans/monomorphize.rs
@@ -32,7 +32,7 @@ use syntax::ast_map;
 use syntax::ast_util::{local_def, PostExpansionMethod};
 use syntax::attr;
 use syntax::codemap::DUMMY_SP;
-use std::hash::{sip, Hash};
+use std::hash::{Hasher, Hash, SipHasher};
 
 pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                                 fn_id: ast::DefId,
@@ -125,13 +125,13 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 
     let hash;
     let s = {
-        let mut state = sip::SipState::new();
+        let mut state = SipHasher::new();
         hash_id.hash(&mut state);
         mono_ty.hash(&mut state);
 
-        hash = format!("h{}", state.result());
+        hash = format!("h{}", state.finish());
         ccx.tcx().map.with_path(fn_id.node, |path| {
-            exported_name(path, hash.index(&FullRange))
+            exported_name(path, &hash[])
         })
     };
 
@@ -141,9 +141,9 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
     let mut hash_id = Some(hash_id);
     let mut mk_lldecl = |&mut : abi: abi::Abi| {
         let lldecl = if abi != abi::Rust {
-            foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, s.index(&FullRange))
+            foreign::decl_rust_fn_with_foreign_abi(ccx, mono_ty, &s[])
         } else {
-            decl_internal_rust_fn(ccx, mono_ty, s.index(&FullRange))
+            decl_internal_rust_fn(ccx, mono_ty, &s[])
         };
 
         ccx.monomorphized().borrow_mut().insert(hash_id.take().unwrap(), lldecl);
@@ -177,12 +177,12 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                   ..
               } => {
                   let d = mk_lldecl(abi);
-                  let needs_body = setup_lldecl(d, i.attrs.index(&FullRange));
+                  let needs_body = setup_lldecl(d, &i.attrs[]);
                   if needs_body {
                       if abi != abi::Rust {
                           foreign::trans_rust_fn_with_foreign_abi(
                               ccx, &**decl, &**body, &[], d, psubsts, fn_id.node,
-                              Some(hash.index(&FullRange)));
+                              Some(&hash[]));
                       } else {
                           trans_fn(ccx, &**decl, &**body, d, psubsts, fn_id.node, &[]);
                       }
@@ -206,7 +206,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                     trans_enum_variant(ccx,
                                        parent,
                                        &*v,
-                                       args.index(&FullRange),
+                                       &args[],
                                        this_tv.disr_val,
                                        psubsts,
                                        d);
@@ -220,7 +220,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             match *ii {
                 ast::MethodImplItem(ref mth) => {
                     let d = mk_lldecl(abi::Rust);
-                    let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange));
+                    let needs_body = setup_lldecl(d, &mth.attrs[]);
                     if needs_body {
                         trans_fn(ccx,
                                  mth.pe_fn_decl(),
@@ -241,7 +241,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             match *method {
                 ast::ProvidedMethod(ref mth) => {
                     let d = mk_lldecl(abi::Rust);
-                    let needs_body = setup_lldecl(d, mth.attrs.index(&FullRange));
+                    let needs_body = setup_lldecl(d, &mth.attrs[]);
                     if needs_body {
                         trans_fn(ccx, mth.pe_fn_decl(), mth.pe_body(), d,
                                  psubsts, mth.id, &[]);
@@ -249,8 +249,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                     d
                 }
                 _ => {
-                    ccx.sess().bug(format!("can't monomorphize a {:?}",
-                                           map_node).index(&FullRange))
+                    ccx.sess().bug(&format!("can't monomorphize a {:?}",
+                                           map_node)[])
                 }
             }
         }
@@ -258,7 +258,7 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
             let d = mk_lldecl(abi::Rust);
             set_inline_hint(d);
             base::trans_tuple_struct(ccx,
-                                     struct_def.fields.index(&FullRange),
+                                     &struct_def.fields[],
                                      struct_def.ctor_id.expect("ast-mapped tuple struct \
                                                                 didn't have a ctor id"),
                                      psubsts,
@@ -275,8 +275,8 @@ pub fn monomorphic_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
         ast_map::NodeBlock(..) |
         ast_map::NodePat(..) |
         ast_map::NodeLocal(..) => {
-            ccx.sess().bug(format!("can't monomorphize a {:?}",
-                                   map_node).index(&FullRange))
+            ccx.sess().bug(&format!("can't monomorphize a {:?}",
+                                   map_node)[])
         }
     };
 
@@ -300,8 +300,6 @@ pub fn apply_param_substs<'tcx,T>(tcx: &ty::ctxt<'tcx>,
                                   -> T
     where T : TypeFoldable<'tcx> + Repr<'tcx> + HasProjectionTypes + Clone
 {
-    assert!(param_substs.regions.is_erased());
-
     let substituted = value.subst(tcx, param_substs);
     normalize_associated_type(tcx, &substituted)
 }
@@ -315,8 +313,10 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T
 {
     debug!("normalize_associated_type(t={})", value.repr(tcx));
 
+    let value = erase_regions(tcx, value);
+
     if !value.has_projection_types() {
-        return value.clone();
+        return value;
     }
 
     // FIXME(#20304) -- cache
@@ -326,7 +326,7 @@ pub fn normalize_associated_type<'tcx,T>(tcx: &ty::ctxt<'tcx>, value: &T) -> T
     let mut selcx = traits::SelectionContext::new(&infcx, &typer);
     let cause = traits::ObligationCause::dummy();
     let traits::Normalized { value: result, obligations } =
-        traits::normalize(&mut selcx, cause, value);
+        traits::normalize(&mut selcx, cause, &value);
 
     debug!("normalize_associated_type: result={} obligations={}",
            result.repr(tcx),
diff --git a/src/librustc_trans/trans/type_.rs b/src/librustc_trans/trans/type_.rs
index 66e27ed1188f3..e2ed275d4c0cc 100644
--- a/src/librustc_trans/trans/type_.rs
+++ b/src/librustc_trans/trans/type_.rs
@@ -103,7 +103,7 @@ impl Type {
     }
 
     pub fn int(ccx: &CrateContext) -> Type {
-        match ccx.tcx().sess.target.target.target_word_size.index(&FullRange) {
+        match &ccx.tcx().sess.target.target.target_pointer_width[] {
             "32" => Type::i32(ccx),
             "64" => Type::i64(ccx),
             tws => panic!("Unsupported target word size for int: {}", tws),
diff --git a/src/librustc_trans/trans/type_of.rs b/src/librustc_trans/trans/type_of.rs
index 19d50cdd48320..034a1ee8be592 100644
--- a/src/librustc_trans/trans/type_of.rs
+++ b/src/librustc_trans/trans/type_of.rs
@@ -140,7 +140,7 @@ pub fn type_of_rust_fn<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
     let input_tys = inputs.iter().map(|&arg_ty| type_of_explicit_arg(cx, arg_ty));
     atys.extend(input_tys);
 
-    Type::func(atys.index(&FullRange), &lloutputtype)
+    Type::func(&atys[], &lloutputtype)
 }
 
 // Given a function type and a count of ty params, construct an llvm type
@@ -180,8 +180,8 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ
 
     let llsizingty = match t.sty {
         _ if !lltype_is_sized(cx.tcx(), t) => {
-            cx.sess().bug(format!("trying to take the sizing type of {}, an unsized type",
-                                  ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
+            cx.sess().bug(&format!("trying to take the sizing type of {}, an unsized type",
+                                  ppaux::ty_to_string(cx.tcx(), t))[])
         }
 
         ty::ty_bool => Type::bool(cx),
@@ -233,8 +233,8 @@ pub fn sizing_type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Typ
         }
 
         ty::ty_projection(..) | ty::ty_infer(..) | ty::ty_param(..) | ty::ty_err(..) => {
-            cx.sess().bug(format!("fictitious type {} in sizing_type_of()",
-                                  ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
+            cx.sess().bug(&format!("fictitious type {} in sizing_type_of()",
+                                  ppaux::ty_to_string(cx.tcx(), t))[])
         }
         ty::ty_vec(_, None) | ty::ty_trait(..) | ty::ty_str => panic!("unreachable")
     };
@@ -285,7 +285,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
     // Rust types are defined as the same LLVM types.  If we don't do
     // this then, e.g. `Option<{myfield: bool}>` would be a different
     // type than `Option<myrec>`.
-    let t_norm = normalize_ty(cx.tcx(), t);
+    let t_norm = erase_regions(cx.tcx(), &t);
 
     if t != t_norm {
         let llty = type_of(cx, t_norm);
@@ -313,7 +313,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
           let repr = adt::represent_type(cx, t);
           let tps = substs.types.get_slice(subst::TypeSpace);
           let name = llvm_type_name(cx, an_enum, did, tps);
-          adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
+          adt::incomplete_type_of(cx, &*repr, &name[])
       }
       ty::ty_unboxed_closure(did, _, ref substs) => {
           // Only create the named struct, but don't fill it in. We
@@ -324,7 +324,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
           // contents of the VecPerParamSpace to to construct the llvm
           // name
           let name = llvm_type_name(cx, an_unboxed_closure, did, substs.types.as_slice());
-          adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
+          adt::incomplete_type_of(cx, &*repr, &name[])
       }
 
       ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) | ty::ty_ptr(ty::mt{ty, ..}) => {
@@ -380,7 +380,7 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
               let repr = adt::represent_type(cx, t);
               let tps = substs.types.get_slice(subst::TypeSpace);
               let name = llvm_type_name(cx, a_struct, did, tps);
-              adt::incomplete_type_of(cx, &*repr, name.index(&FullRange))
+              adt::incomplete_type_of(cx, &*repr, &name[])
           }
       }
 
@@ -398,8 +398,8 @@ pub fn type_of<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> Type {
               Type::struct_(cx, &[p_ty, type_of_unsize_info(cx, t)], false)
           }
           ty::ty_trait(..) => Type::opaque_trait(cx),
-          _ => cx.sess().bug(format!("ty_open with sized type: {}",
-                                     ppaux::ty_to_string(cx.tcx(), t)).index(&FullRange))
+          _ => cx.sess().bug(&format!("ty_open with sized type: {}",
+                                     ppaux::ty_to_string(cx.tcx(), t))[])
       },
 
       ty::ty_infer(..) => cx.sess().bug("type_of with ty_infer"),
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index 265ebe00d539f..2046ee015f685 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -52,7 +52,6 @@ use middle::const_eval;
 use middle::def;
 use middle::resolve_lifetime as rl;
 use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs};
-use middle::subst::{VecPerParamSpace};
 use middle::traits;
 use middle::ty::{self, RegionEscape, ToPolyTraitRef, Ty};
 use rscope::{self, UnelidableRscope, RegionScope, SpecificRscope,
@@ -193,11 +192,11 @@ pub fn opt_ast_region_to_region<'tcx>(
                                     format!("`{}`", name)
                                 };
 
-                                m.push_str(if n == 1 {
+                                m.push_str(&(if n == 1 {
                                     help_name
                                 } else {
                                     format!("one of {}'s {} elided lifetimes", help_name, n)
-                                }.index(&FullRange));
+                                })[]);
 
                                 if len == 2 && i == 0 {
                                     m.push_str(" or ");
@@ -244,7 +243,7 @@ pub fn opt_ast_region_to_region<'tcx>(
 
 /// Given a path `path` that refers to an item `I` with the declared generics `decl_generics`,
 /// returns an appropriate set of substitutions for this particular reference to `I`.
-fn ast_path_substs_for_ty<'tcx>(
+pub fn ast_path_substs_for_ty<'tcx>(
     this: &AstConv<'tcx>,
     rscope: &RegionScope,
     decl_generics: &ty::Generics<'tcx>,
@@ -344,10 +343,10 @@ fn create_substs_for_ast_path<'tcx>(
             "expected"
         };
         this.tcx().sess.span_fatal(span,
-                                   format!("wrong number of type arguments: {} {}, found {}",
+                                   &format!("wrong number of type arguments: {} {}, found {}",
                                            expected,
                                            required_ty_param_count,
-                                           supplied_ty_param_count).index(&FullRange));
+                                           supplied_ty_param_count)[]);
     } else if supplied_ty_param_count > formal_ty_param_count {
         let expected = if required_ty_param_count < formal_ty_param_count {
             "expected at most"
@@ -355,10 +354,10 @@ fn create_substs_for_ast_path<'tcx>(
             "expected"
         };
         this.tcx().sess.span_fatal(span,
-                                   format!("wrong number of type arguments: {} {}, found {}",
+                                   &format!("wrong number of type arguments: {} {}, found {}",
                                            expected,
                                            formal_ty_param_count,
-                                           supplied_ty_param_count).index(&FullRange));
+                                           supplied_ty_param_count)[]);
     }
 
     let mut substs = Substs::new_type(types, regions);
@@ -377,7 +376,7 @@ fn create_substs_for_ast_path<'tcx>(
         }
     }
 
-    for param in ty_param_defs.index(&(supplied_ty_param_count..)).iter() {
+    for param in ty_param_defs[supplied_ty_param_count..].iter() {
         match param.default {
             Some(default) => {
                 // This is a default type parameter.
@@ -556,8 +555,8 @@ pub fn instantiate_trait_ref<'tcx>(
         _ => {
             this.tcx().sess.span_fatal(
                 ast_trait_ref.path.span,
-                format!("`{}` is not a trait",
-                        ast_trait_ref.path.user_string(this.tcx())).index(&FullRange));
+                &format!("`{}` is not a trait",
+                        ast_trait_ref.path.user_string(this.tcx()))[]);
         }
     }
 }
@@ -762,50 +761,6 @@ pub fn ast_path_to_ty<'tcx>(
     TypeAndSubsts { substs: substs, ty: ty }
 }
 
-/// Returns the type that this AST path refers to. If the path has no type
-/// parameters and the corresponding type has type parameters, fresh type
-/// and/or region variables are substituted.
-///
-/// This is used when checking the constructor in struct literals.
-pub fn ast_path_to_ty_relaxed<'tcx>(
-    this: &AstConv<'tcx>,
-    rscope: &RegionScope,
-    did: ast::DefId,
-    path: &ast::Path)
-    -> TypeAndSubsts<'tcx>
-{
-    let tcx = this.tcx();
-    let ty::TypeScheme {
-        generics,
-        ty: decl_ty
-    } = this.get_item_type_scheme(did);
-
-    let wants_params =
-        generics.has_type_params(TypeSpace) || generics.has_region_params(TypeSpace);
-
-    let needs_defaults =
-        wants_params &&
-        path.segments.iter().all(|s| s.parameters.is_empty());
-
-    let substs = if needs_defaults {
-        let type_params: Vec<_> = range(0, generics.types.len(TypeSpace))
-                                      .map(|_| this.ty_infer(path.span)).collect();
-        let region_params =
-            rscope.anon_regions(path.span, generics.regions.len(TypeSpace))
-                  .unwrap();
-        Substs::new(VecPerParamSpace::params_from_type(type_params),
-                    VecPerParamSpace::params_from_type(region_params))
-    } else {
-        ast_path_substs_for_ty(this, rscope, &generics, path)
-    };
-
-    let ty = decl_ty.subst(tcx, &substs);
-    TypeAndSubsts {
-        substs: substs,
-        ty: ty,
-    }
-}
-
 /// Converts the given AST type to a built-in type. A "built-in type" is, at
 /// present, either a core numeric type, a string, or `Box`.
 pub fn ast_ty_to_builtin_ty<'tcx>(
@@ -825,8 +780,8 @@ pub fn ast_ty_to_builtin_ty<'tcx>(
                     this.tcx()
                         .sess
                         .span_bug(ast_ty.span,
-                                  format!("unbound path {}",
-                                          path.repr(this.tcx())).index(&FullRange))
+                                  &format!("unbound path {}",
+                                          path.repr(this.tcx()))[])
                 }
                 Some(&d) => d
             };
@@ -847,8 +802,8 @@ pub fn ast_ty_to_builtin_ty<'tcx>(
                         _ => {
                             this.tcx().sess.span_bug(
                                 path.span,
-                                format!("converting `Box` to `{}`",
-                                        ty.repr(this.tcx())).index(&FullRange));
+                                &format!("converting `Box` to `{}`",
+                                        ty.repr(this.tcx()))[]);
                         }
                     }
                 }
@@ -1068,14 +1023,14 @@ pub fn ast_ty_to_ty<'tcx>(
                 ty::mk_vec(tcx, ast_ty_to_ty(this, rscope, &**ty), None)
             }
             ast::TyObjectSum(ref ty, ref bounds) => {
-                match ast_ty_to_trait_ref(this, rscope, &**ty, bounds.index(&FullRange)) {
+                match ast_ty_to_trait_ref(this, rscope, &**ty, &bounds[]) {
                     Ok((trait_ref, projection_bounds)) => {
                         trait_ref_to_object_type(this,
                                                  rscope,
                                                  ast_ty.span,
                                                  trait_ref,
                                                  projection_bounds,
-                                                 bounds.index(&FullRange))
+                                                 &bounds[])
                     }
                     Err(ErrorReported) => {
                         this.tcx().types.err
@@ -1110,15 +1065,15 @@ pub fn ast_ty_to_ty<'tcx>(
                 ty::mk_bare_fn(tcx, None, tcx.mk_bare_fn(bare_fn))
             }
             ast::TyPolyTraitRef(ref bounds) => {
-                conv_ty_poly_trait_ref(this, rscope, ast_ty.span, bounds.index(&FullRange))
+                conv_ty_poly_trait_ref(this, rscope, ast_ty.span, &bounds[])
             }
             ast::TyPath(ref path, id) => {
                 let a_def = match tcx.def_map.borrow().get(&id) {
                     None => {
                         tcx.sess
                            .span_bug(ast_ty.span,
-                                     format!("unbound path {}",
-                                             path.repr(tcx)).index(&FullRange))
+                                     &format!("unbound path {}",
+                                             path.repr(tcx))[])
                     }
                     Some(&d) => d
                 };
@@ -1156,8 +1111,8 @@ pub fn ast_ty_to_ty<'tcx>(
                     }
                     def::DefMod(id) => {
                         tcx.sess.span_fatal(ast_ty.span,
-                            format!("found module name used as a type: {}",
-                                    tcx.map.node_to_string(id.node)).index(&FullRange));
+                            &format!("found module name used as a type: {}",
+                                    tcx.map.node_to_string(id.node))[]);
                     }
                     def::DefPrimTy(_) => {
                         panic!("DefPrimTy arm missed in previous ast_ty_to_prim_ty call");
@@ -1166,7 +1121,7 @@ pub fn ast_ty_to_ty<'tcx>(
                         let path_str = tcx.map.path_to_string(
                             tcx.map.get_parent(trait_type_id.node));
                         tcx.sess.span_err(ast_ty.span,
-                                          format!("ambiguous associated \
+                                          &format!("ambiguous associated \
                                                    type; specify the type \
                                                    using the syntax `<Type \
                                                    as {}>::{}`",
@@ -1176,7 +1131,7 @@ pub fn ast_ty_to_ty<'tcx>(
                                                           .last()
                                                           .unwrap()
                                                           .identifier)
-                                                  .get()).index(&FullRange));
+                                                  .get())[]);
                         this.tcx().types.err
                     }
                     def::DefAssociatedPath(provenance, assoc_ident) => {
@@ -1184,9 +1139,9 @@ pub fn ast_ty_to_ty<'tcx>(
                     }
                     _ => {
                         tcx.sess.span_fatal(ast_ty.span,
-                                            format!("found value name used \
+                                            &format!("found value name used \
                                                      as a type: {:?}",
-                                                    a_def).index(&FullRange));
+                                                    a_def)[]);
                     }
                 }
             }
@@ -1212,9 +1167,9 @@ pub fn ast_ty_to_ty<'tcx>(
                     Err(ref r) => {
                         tcx.sess.span_fatal(
                             ast_ty.span,
-                            format!("expected constant expr for array \
+                            &format!("expected constant expr for array \
                                      length: {}",
-                                    *r).index(&FullRange));
+                                    *r)[]);
                     }
                 }
             }
@@ -1336,7 +1291,7 @@ fn ty_of_method_or_bare_fn<'a, 'tcx>(this: &AstConv<'tcx>,
     let input_params = if self_ty.is_some() {
         decl.inputs.slice_from(1)
     } else {
-        decl.inputs.index(&FullRange)
+        &decl.inputs[]
     };
     let input_tys = input_params.iter().map(|a| ty_of_arg(this, &rb, a, None));
     let input_pats: Vec<String> = input_params.iter()
@@ -1551,7 +1506,7 @@ fn conv_ty_poly_trait_ref<'tcx>(
     ast_bounds: &[ast::TyParamBound])
     -> Ty<'tcx>
 {
-    let mut partitioned_bounds = partition_bounds(this.tcx(), span, ast_bounds.index(&FullRange));
+    let mut partitioned_bounds = partition_bounds(this.tcx(), span, &ast_bounds[]);
 
     let mut projection_bounds = Vec::new();
     let main_trait_bound = if !partitioned_bounds.trait_bounds.is_empty() {
@@ -1600,8 +1555,8 @@ pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>(
         let b = &trait_bounds[0];
         this.tcx().sess.span_err(
             b.trait_ref.path.span,
-            format!("only the builtin traits can be used \
-                     as closure or object bounds").index(&FullRange));
+            &format!("only the builtin traits can be used \
+                     as closure or object bounds")[]);
     }
 
     let region_bound = compute_region_bound(this,
@@ -1673,8 +1628,8 @@ fn compute_opt_region_bound<'tcx>(tcx: &ty::ctxt<'tcx>,
     if derived_region_bounds.slice_from(1).iter().any(|r1| r != *r1) {
         tcx.sess.span_err(
             span,
-            format!("ambiguous lifetime bound, \
-                     explicit lifetime bound required").index(&FullRange));
+            &format!("ambiguous lifetime bound, \
+                     explicit lifetime bound required")[]);
     }
     return Some(r);
 }
@@ -1700,7 +1655,7 @@ fn compute_region_bound<'tcx>(
                 None => {
                     this.tcx().sess.span_err(
                         span,
-                        format!("explicit lifetime bound required").index(&FullRange));
+                        &format!("explicit lifetime bound required")[]);
                     ty::ReStatic
                 }
             }
diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs
index d9829fd14168c..cacf9bb19d20f 100644
--- a/src/librustc_typeck/check/_match.rs
+++ b/src/librustc_typeck/check/_match.rs
@@ -195,14 +195,6 @@ pub fn check_pat<'a, 'tcx>(pcx: &pat_ctxt<'a, 'tcx>,
         ast::PatRegion(ref inner, mutbl) => {
             let inner_ty = fcx.infcx().next_ty_var();
 
-            // SNAP 340ac04 remove this `if`-`else` entirely after next snapshot
-            let mutbl = if mutbl == ast::MutImmutable {
-                ty::deref(fcx.infcx().shallow_resolve(expected), true)
-                   .map(|mt| mt.mutbl).unwrap_or(ast::MutImmutable)
-            } else {
-                mutbl
-            };
-
             let mt = ty::mt { ty: inner_ty, mutbl: mutbl };
             let region = fcx.infcx().next_region_var(infer::PatternRegion(pat.span));
             let rptr_ty = ty::mk_rptr(tcx, tcx.mk_region(region), mt);
diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs
index cd27c20db45b4..7e72f300f4178 100644
--- a/src/librustc_typeck/check/method/confirm.rs
+++ b/src/librustc_typeck/check/method/confirm.rs
@@ -314,8 +314,8 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
             None => {
                 self.tcx().sess.span_bug(
                     self.span,
-                    format!("self-type `{}` for ObjectPick never dereferenced to an object",
-                            self_ty.repr(self.tcx())).index(&FullRange))
+                    &format!("self-type `{}` for ObjectPick never dereferenced to an object",
+                            self_ty.repr(self.tcx()))[])
             }
         }
     }
@@ -367,10 +367,10 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
             Err(_) => {
                 self.tcx().sess.span_bug(
                     self.span,
-                    format!(
+                    &format!(
                         "{} was a subtype of {} but now is not?",
                         self_ty.repr(self.tcx()),
-                        method_self_ty.repr(self.tcx())).index(&FullRange));
+                        method_self_ty.repr(self.tcx()))[]);
             }
         }
     }
diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs
index 87ea082b6b20b..bb000742def92 100644
--- a/src/librustc_typeck/check/method/mod.rs
+++ b/src/librustc_typeck/check/method/mod.rs
@@ -264,9 +264,9 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
                         _ => {
                             fcx.tcx().sess.span_bug(
                                 span,
-                                format!(
+                                &format!(
                                     "trait method is &self but first arg is: {}",
-                                    transformed_self_ty.repr(fcx.tcx())).index(&FullRange));
+                                    transformed_self_ty.repr(fcx.tcx()))[]);
                         }
                     }
                 }
@@ -274,9 +274,9 @@ pub fn lookup_in_trait_adjusted<'a, 'tcx>(fcx: &'a FnCtxt<'a, 'tcx>,
                 _ => {
                     fcx.tcx().sess.span_bug(
                         span,
-                        format!(
+                        &format!(
                             "unexpected explicit self type in operator method: {:?}",
-                            method_ty.explicit_self).index(&FullRange));
+                            method_ty.explicit_self)[]);
                 }
             }
         }
@@ -329,8 +329,8 @@ pub fn report_error<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
             // If the method has the name of a field, give a help note
             if is_field {
                 cx.sess.span_note(span,
-                    format!("use `(s.{0})(...)` if you meant to call the \
-                            function stored in the `{0}` field", method_ustring).index(&FullRange));
+                    &format!("use `(s.{0})(...)` if you meant to call the \
+                            function stored in the `{0}` field", method_ustring)[]);
             }
 
             if static_sources.len() > 0 {
diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index 4ba161fa83563..dc4d6c9a826c9 100644
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -18,7 +18,7 @@ use middle::fast_reject;
 use middle::subst;
 use middle::subst::Subst;
 use middle::traits;
-use middle::ty::{self, Ty, ToPolyTraitRef};
+use middle::ty::{self, RegionEscape, Ty, ToPolyTraitRef};
 use middle::ty_fold::TypeFoldable;
 use middle::infer;
 use middle::infer::InferCtxt;
@@ -62,6 +62,7 @@ enum CandidateKind<'tcx> {
                            subst::Substs<'tcx>, MethodIndex),
     UnboxedClosureCandidate(/* Trait */ ast::DefId, MethodIndex),
     WhereClauseCandidate(ty::PolyTraitRef<'tcx>, MethodIndex),
+    ProjectionCandidate(ast::DefId, MethodIndex),
 }
 
 pub struct Pick<'tcx> {
@@ -309,18 +310,20 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         // argument type like `&Trait`.
         let trait_ref = data.principal_trait_ref_with_self_ty(self.tcx(), self_ty);
         self.elaborate_bounds(&[trait_ref.clone()], false, |this, new_trait_ref, m, method_num| {
+            let new_trait_ref = this.erase_late_bound_regions(&new_trait_ref);
+
             let vtable_index =
                 traits::get_vtable_index_of_object_method(tcx,
                                                           trait_ref.clone(),
-                                                          new_trait_ref.def_id(),
+                                                          new_trait_ref.def_id,
                                                           method_num);
 
-            let xform_self_ty = this.xform_self_ty(&m, new_trait_ref.substs());
+            let xform_self_ty = this.xform_self_ty(&m, new_trait_ref.substs);
 
             this.inherent_candidates.push(Candidate {
                 xform_self_ty: xform_self_ty,
                 method_ty: m,
-                kind: ObjectCandidate(new_trait_ref.def_id(), method_num, vtable_index)
+                kind: ObjectCandidate(new_trait_ref.def_id, method_num, vtable_index)
             });
         });
     }
@@ -353,34 +356,37 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
             })
             .collect();
 
-        self.elaborate_bounds(bounds.as_slice(), true, |this, trait_ref, m, method_num| {
+        self.elaborate_bounds(bounds.as_slice(), true, |this, poly_trait_ref, m, method_num| {
+            let trait_ref =
+                this.erase_late_bound_regions(&poly_trait_ref);
+
             let xform_self_ty =
-                this.xform_self_ty(&m, trait_ref.substs());
+                this.xform_self_ty(&m, trait_ref.substs);
 
             debug!("found match: trait_ref={} substs={} m={}",
                    trait_ref.repr(this.tcx()),
-                   trait_ref.substs().repr(this.tcx()),
+                   trait_ref.substs.repr(this.tcx()),
                    m.repr(this.tcx()));
             assert_eq!(m.generics.types.get_slice(subst::TypeSpace).len(),
-                       trait_ref.substs().types.get_slice(subst::TypeSpace).len());
+                       trait_ref.substs.types.get_slice(subst::TypeSpace).len());
             assert_eq!(m.generics.regions.get_slice(subst::TypeSpace).len(),
-                       trait_ref.substs().regions().get_slice(subst::TypeSpace).len());
+                       trait_ref.substs.regions().get_slice(subst::TypeSpace).len());
             assert_eq!(m.generics.types.get_slice(subst::SelfSpace).len(),
-                       trait_ref.substs().types.get_slice(subst::SelfSpace).len());
+                       trait_ref.substs.types.get_slice(subst::SelfSpace).len());
             assert_eq!(m.generics.regions.get_slice(subst::SelfSpace).len(),
-                       trait_ref.substs().regions().get_slice(subst::SelfSpace).len());
+                       trait_ref.substs.regions().get_slice(subst::SelfSpace).len());
 
             // Because this trait derives from a where-clause, it
             // should not contain any inference variables or other
             // artifacts. This means it is safe to put into the
             // `WhereClauseCandidate` and (eventually) into the
             // `WhereClausePick`.
-            assert!(trait_ref.substs().types.iter().all(|&t| !ty::type_needs_infer(t)));
+            assert!(trait_ref.substs.types.iter().all(|&t| !ty::type_needs_infer(t)));
 
             this.inherent_candidates.push(Candidate {
                 xform_self_ty: xform_self_ty,
                 method_ty: m,
-                kind: WhereClauseCandidate(trait_ref, method_num)
+                kind: WhereClauseCandidate(poly_trait_ref, method_num)
             });
         });
     }
@@ -474,6 +480,10 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                                                  method.clone(),
                                                  matching_index);
 
+        self.assemble_projection_candidates(trait_def_id,
+                                            method.clone(),
+                                            matching_index);
+
         self.assemble_where_clause_candidates(trait_def_id,
                                               method,
                                               matching_index);
@@ -575,8 +585,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                 None => {
                     self.tcx().sess.span_bug(
                         self.span,
-                        format!("No entry for unboxed closure: {}",
-                                closure_def_id.repr(self.tcx())).index(&FullRange));
+                        &format!("No entry for unboxed closure: {}",
+                                closure_def_id.repr(self.tcx()))[]);
                 }
             };
 
@@ -603,6 +613,64 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         }
     }
 
+    fn assemble_projection_candidates(&mut self,
+                                      trait_def_id: ast::DefId,
+                                      method: Rc<ty::Method<'tcx>>,
+                                      method_index: uint)
+    {
+        debug!("assemble_projection_candidates(\
+               trait_def_id={}, \
+               method={}, \
+               method_index={})",
+               trait_def_id.repr(self.tcx()),
+               method.repr(self.tcx()),
+               method_index);
+
+        for step in self.steps.iter() {
+            debug!("assemble_projection_candidates: step={}",
+                   step.repr(self.tcx()));
+
+            let projection_trait_ref = match step.self_ty.sty {
+                ty::ty_projection(ref data) => &data.trait_ref,
+                _ => continue,
+            };
+
+            debug!("assemble_projection_candidates: projection_trait_ref={}",
+                   projection_trait_ref.repr(self.tcx()));
+
+            let trait_def = ty::lookup_trait_def(self.tcx(), projection_trait_ref.def_id);
+            let bounds = trait_def.generics.to_bounds(self.tcx(), projection_trait_ref.substs);
+            let predicates = bounds.predicates.into_vec();
+            debug!("assemble_projection_candidates: predicates={}",
+                   predicates.repr(self.tcx()));
+            for poly_bound in
+                traits::elaborate_predicates(self.tcx(), predicates)
+                .filter_map(|p| p.to_opt_poly_trait_ref())
+                .filter(|b| b.def_id() == trait_def_id)
+            {
+                let bound = self.erase_late_bound_regions(&poly_bound);
+
+                debug!("assemble_projection_candidates: projection_trait_ref={} bound={}",
+                       projection_trait_ref.repr(self.tcx()),
+                       bound.repr(self.tcx()));
+
+                if self.infcx().can_equate(&step.self_ty, &bound.self_ty()).is_ok() {
+                    let xform_self_ty = self.xform_self_ty(&method, bound.substs);
+
+                    debug!("assemble_projection_candidates: bound={} xform_self_ty={}",
+                           bound.repr(self.tcx()),
+                           xform_self_ty.repr(self.tcx()));
+
+                    self.extension_candidates.push(Candidate {
+                        xform_self_ty: xform_self_ty,
+                        method_ty: method.clone(),
+                        kind: ProjectionCandidate(trait_def_id, method_index)
+                    });
+                }
+            }
+        }
+    }
+
     fn assemble_where_clause_candidates(&mut self,
                                         trait_def_id: ast::DefId,
                                         method_ty: Rc<ty::Method<'tcx>>,
@@ -611,14 +679,14 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         debug!("assemble_where_clause_candidates(trait_def_id={})",
                trait_def_id.repr(self.tcx()));
 
-        // Check whether there are any where-clauses pertaining to this trait.
         let caller_predicates =
             self.fcx.inh.param_env.caller_bounds.predicates.as_slice().to_vec();
-        for bound in traits::elaborate_predicates(self.tcx(), caller_predicates)
-                     .filter_map(|p| p.to_opt_poly_trait_ref())
-                     .filter(|b| b.def_id() == trait_def_id)
+        for poly_bound in traits::elaborate_predicates(self.tcx(), caller_predicates)
+                          .filter_map(|p| p.to_opt_poly_trait_ref())
+                          .filter(|b| b.def_id() == trait_def_id)
         {
-            let xform_self_ty = self.xform_self_ty(&method_ty, bound.substs());
+            let bound = self.erase_late_bound_regions(&poly_bound);
+            let xform_self_ty = self.xform_self_ty(&method_ty, bound.substs);
 
             debug!("assemble_where_clause_candidates: bound={} xform_self_ty={}",
                    bound.repr(self.tcx()),
@@ -627,7 +695,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
             self.extension_candidates.push(Candidate {
                 xform_self_ty: xform_self_ty,
                 method_ty: method_ty.clone(),
-                kind: WhereClauseCandidate(bound, method_index)
+                kind: WhereClauseCandidate(poly_bound, method_index)
             });
         }
     }
@@ -745,7 +813,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         debug!("pick_method(self_ty={})", self.infcx().ty_to_string(self_ty));
 
         debug!("searching inherent candidates");
-        match self.consider_candidates(self_ty, self.inherent_candidates.index(&FullRange)) {
+        match self.consider_candidates(self_ty, &self.inherent_candidates[]) {
             None => {}
             Some(pick) => {
                 return Some(pick);
@@ -753,7 +821,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         }
 
         debug!("searching extension candidates");
-        self.consider_candidates(self_ty, self.extension_candidates.index(&FullRange))
+        self.consider_candidates(self_ty, &self.extension_candidates[])
     }
 
     fn consider_candidates(&self,
@@ -768,7 +836,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         debug!("applicable_candidates: {}", applicable_candidates.repr(self.tcx()));
 
         if applicable_candidates.len() > 1 {
-            match self.collapse_candidates_to_trait_pick(applicable_candidates.index(&FullRange)) {
+            match self.collapse_candidates_to_trait_pick(&applicable_candidates[]) {
                 Some(pick) => { return Some(Ok(pick)); }
                 None => { }
             }
@@ -829,6 +897,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                         norm_obligations.iter().all(|o| selcx.evaluate_obligation(o))
                 }
 
+                ProjectionCandidate(..) |
                 ObjectCandidate(..) |
                 UnboxedClosureCandidate(..) |
                 WhereClauseCandidate(..) => {
@@ -864,7 +933,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
             Some(data) => data,
             None => return None,
         };
-        if probes.index(&(1..)).iter().any(|p| p.to_trait_data() != Some(trait_data)) {
+        if probes[1..].iter().any(|p| p.to_trait_data() != Some(trait_data)) {
             return None;
         }
 
@@ -920,6 +989,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                method.fty.sig.0.inputs[0].repr(self.tcx()),
                substs.repr(self.tcx()));
 
+        assert!(!substs.has_escaping_regions());
+
         // It is possible for type parameters or early-bound lifetimes
         // to appear in the signature of `self`. The substitutions we
         // are given do not include type/lifetime parameters for the
@@ -949,14 +1020,13 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
             substs = &placeholder;
         }
 
-        // Replace early-bound regions and types.
-        let xform_self_ty = method.fty.sig.0.inputs[0].subst(self.tcx(), substs);
+        // Erase any late-bound regions from the method and substitute
+        // in the values from the substitution.
+        let xform_self_ty = method.fty.sig.input(0);
+        let xform_self_ty = self.erase_late_bound_regions(&xform_self_ty);
+        let xform_self_ty = xform_self_ty.subst(self.tcx(), substs);
 
-        // Replace late-bound regions bound in the impl or
-        // where-clause (2 levels of binding) and method (1 level of binding).
-        self.erase_late_bound_regions(
-            &self.erase_late_bound_regions(
-                &ty::Binder(ty::Binder(xform_self_ty))))
+        xform_self_ty
     }
 
     fn impl_substs(&self,
@@ -1065,6 +1135,9 @@ impl<'tcx> Candidate<'tcx> {
 
                     WhereClausePick((*trait_ref).clone(), index)
                 }
+                ProjectionCandidate(def_id, index) => {
+                    TraitPick(def_id, index)
+                }
             }
         }
     }
@@ -1076,6 +1149,7 @@ impl<'tcx> Candidate<'tcx> {
             ExtensionImplCandidate(def_id, _, _, _) => ImplSource(def_id),
             UnboxedClosureCandidate(trait_def_id, _) => TraitSource(trait_def_id),
             WhereClauseCandidate(ref trait_ref, _) => TraitSource(trait_ref.def_id()),
+            ProjectionCandidate(trait_def_id, _) => TraitSource(trait_def_id),
         }
     }
 
@@ -1094,6 +1168,9 @@ impl<'tcx> Candidate<'tcx> {
             WhereClauseCandidate(ref trait_ref, method_num) => {
                 Some((trait_ref.def_id(), method_num))
             }
+            ProjectionCandidate(trait_def_id, method_num) => {
+                Some((trait_def_id, method_num))
+            }
         }
     }
 }
@@ -1120,6 +1197,8 @@ impl<'tcx> Repr<'tcx> for CandidateKind<'tcx> {
                 format!("UnboxedClosureCandidate({},{})", a.repr(tcx), b),
             WhereClauseCandidate(ref a, ref b) =>
                 format!("WhereClauseCandidate({},{})", a.repr(tcx), b),
+            ProjectionCandidate(ref a, ref b) =>
+                format!("ProjectionCandidate({},{})", a.repr(tcx), b),
         }
     }
 }
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index 9563dd45ca234..b98b327100cdb 100644
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -90,7 +90,7 @@ use middle::mem_categorization as mc;
 use middle::mem_categorization::McResult;
 use middle::pat_util::{self, pat_id_map};
 use middle::region::CodeExtent;
-use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace};
+use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace};
 use middle::traits;
 use middle::ty::{FnSig, VariantInfo, TypeScheme};
 use middle::ty::{Disr, ParamTy, ParameterEnvironment};
@@ -593,7 +593,7 @@ fn check_fn<'a, 'tcx>(ccx: &'a CrateCtxt<'a, 'tcx>,
     let tcx = ccx.tcx;
     let err_count_on_creation = tcx.sess.err_count();
 
-    let arg_tys = fn_sig.inputs.index(&FullRange);
+    let arg_tys = &fn_sig.inputs[];
     let ret_ty = fn_sig.output;
 
     debug!("check_fn(arg_tys={}, ret_ty={}, fn_id={})",
@@ -691,7 +691,7 @@ pub fn check_item(ccx: &CrateCtxt, it: &ast::Item) {
       ast::ItemEnum(ref enum_definition, _) => {
         check_enum_variants(ccx,
                             it.span,
-                            enum_definition.variants.index(&FullRange),
+                            &enum_definition.variants[],
                             it.id);
       }
       ast::ItemFn(ref decl, _, _, _, ref body) => {
@@ -985,21 +985,21 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
         (&ty::StaticExplicitSelfCategory, _) => {
             tcx.sess.span_err(
                 impl_m_span,
-                format!("method `{}` has a `{}` declaration in the impl, \
+                &format!("method `{}` has a `{}` declaration in the impl, \
                         but not in the trait",
                         token::get_name(trait_m.name),
                         ppaux::explicit_self_category_to_str(
-                            &impl_m.explicit_self)).index(&FullRange));
+                            &impl_m.explicit_self))[]);
             return;
         }
         (_, &ty::StaticExplicitSelfCategory) => {
             tcx.sess.span_err(
                 impl_m_span,
-                format!("method `{}` has a `{}` declaration in the trait, \
+                &format!("method `{}` has a `{}` declaration in the trait, \
                         but not in the impl",
                         token::get_name(trait_m.name),
                         ppaux::explicit_self_category_to_str(
-                            &trait_m.explicit_self)).index(&FullRange));
+                            &trait_m.explicit_self))[]);
             return;
         }
         _ => {
@@ -1358,9 +1358,9 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
         if trait_params.len() != impl_params.len() {
             tcx.sess.span_err(
                 span,
-                format!("lifetime parameters or bounds on method `{}` do \
+                &format!("lifetime parameters or bounds on method `{}` do \
                          not match the trait declaration",
-                        token::get_name(impl_m.name)).index(&FullRange));
+                        token::get_name(impl_m.name))[]);
             return false;
         }
 
@@ -1406,13 +1406,13 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
             let err = if missing.len() != 0 || extra.len() != 0 {
                 tcx.sess.span_err(
                     span,
-                    format!(
+                    &format!(
                         "the lifetime parameter `{}` declared in the impl \
                          has a distinct set of bounds \
                          from its counterpart `{}` \
                          declared in the trait",
                         impl_param.name.user_string(tcx),
-                        trait_param.name.user_string(tcx)).index(&FullRange));
+                        trait_param.name.user_string(tcx))[]);
                 true
             } else {
                 false
@@ -1421,15 +1421,15 @@ fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>,
             if missing.len() != 0 {
                 tcx.sess.span_note(
                     span,
-                    format!("the impl is missing the following bounds: `{}`",
-                            missing.user_string(tcx)).index(&FullRange));
+                    &format!("the impl is missing the following bounds: `{}`",
+                            missing.user_string(tcx))[]);
             }
 
             if extra.len() != 0 {
                 tcx.sess.span_note(
                     span,
-                    format!("the impl has the following extra bounds: `{}`",
-                            extra.user_string(tcx)).index(&FullRange));
+                    &format!("the impl has the following extra bounds: `{}`",
+                            extra.user_string(tcx))[]);
             }
 
             if err {
@@ -1699,8 +1699,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             None => {
                 self.tcx().sess.span_bug(
                     span,
-                    format!("no type for local variable {}",
-                            nid).index(&FullRange));
+                    &format!("no type for local variable {}",
+                            nid)[]);
             }
         }
     }
@@ -1709,7 +1709,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// ! gets replaced with (), unconstrained ints with i32, and unconstrained floats with f64.
     pub fn default_type_parameters(&self) {
         use middle::ty::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat, Neither};
-        for (_, &ref ty) in self.inh.node_types.borrow_mut().iter_mut() {
+        for (_, &mut ref ty) in self.inh.node_types.borrow_mut().iter_mut() {
             let resolved = self.infcx().resolve_type_vars_if_possible(ty);
             if self.infcx().type_var_diverges(resolved) {
                 demand::eqtype(self, codemap::DUMMY_SP, *ty, ty::mk_nil(self.tcx()));
@@ -1947,6 +1947,43 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    /// Returns the type that this AST path refers to. If the path has no type
+    /// parameters and the corresponding type has type parameters, fresh type
+    /// and/or region variables are substituted.
+    ///
+    /// This is used when checking the constructor in struct literals.
+    fn instantiate_struct_literal_ty(&self,
+                                     did: ast::DefId,
+                                     path: &ast::Path)
+                                     -> TypeAndSubsts<'tcx>
+    {
+        let tcx = self.tcx();
+
+        let ty::TypeScheme { generics, ty: decl_ty } = ty::lookup_item_type(tcx, did);
+
+        let wants_params =
+            generics.has_type_params(TypeSpace) || generics.has_region_params(TypeSpace);
+
+        let needs_defaults =
+            wants_params &&
+            path.segments.iter().all(|s| s.parameters.is_empty());
+
+        let substs = if needs_defaults {
+            let tps =
+                self.infcx().next_ty_vars(generics.types.len(TypeSpace));
+            let rps =
+                self.infcx().region_vars_for_defs(path.span,
+                                                  generics.regions.get_slice(TypeSpace));
+            Substs::new_type(tps, rps)
+        } else {
+            astconv::ast_path_substs_for_ty(self, self, &generics, path)
+        };
+
+        let ty = self.instantiate_type_scheme(path.span, &substs, &decl_ty);
+
+        TypeAndSubsts { substs: substs, ty: ty }
+    }
+
     pub fn write_nil(&self, node_id: ast::NodeId) {
         self.write_ty(node_id, ty::mk_nil(self.tcx()));
     }
@@ -2033,8 +2070,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match self.inh.node_types.borrow().get(&ex.id) {
             Some(&t) => t,
             None => {
-                self.tcx().sess.bug(format!("no type for expr in fcx {}",
-                                            self.tag()).index(&FullRange));
+                self.tcx().sess.bug(&format!("no type for expr in fcx {}",
+                                            self.tag())[]);
             }
         }
     }
@@ -2062,9 +2099,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             Some(&t) => t,
             None => {
                 self.tcx().sess.bug(
-                    format!("no type for node {}: {} in fcx {}",
+                    &format!("no type for node {}: {} in fcx {}",
                             id, self.tcx().map.node_to_string(id),
-                            self.tag()).index(&FullRange));
+                            self.tag())[]);
             }
         }
     }
@@ -2466,7 +2503,7 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         Ok(trait_did) => trait_did,
         Err(ref err_string) => {
             fcx.tcx().sess.span_err(iterator_expr.span,
-                                    err_string.index(&FullRange));
+                                    &err_string[]);
             return fcx.tcx().types.err
         }
     };
@@ -2490,10 +2527,10 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
             if !ty::type_is_error(true_expr_type) {
                 let ty_string = fcx.infcx().ty_to_string(true_expr_type);
                 fcx.tcx().sess.span_err(iterator_expr.span,
-                                        format!("`for` loop expression has type `{}` which does \
+                                        &format!("`for` loop expression has type `{}` which does \
                                                 not implement the `Iterator` trait; \
                                                 maybe try .iter()",
-                                                ty_string).index(&FullRange));
+                                                ty_string)[]);
             }
             fcx.tcx().types.err
         }
@@ -2528,10 +2565,10 @@ fn lookup_method_for_for_loop<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                 }
                 _ => {
                     fcx.tcx().sess.span_err(iterator_expr.span,
-                                            format!("`next` method of the `Iterator` \
+                                            &format!("`next` method of the `Iterator` \
                                                     trait has an unexpected type `{}`",
                                                     fcx.infcx().ty_to_string(return_type))
-                                            .index(&FullRange));
+                                            []);
                     fcx.tcx().types.err
                 }
             }
@@ -2558,7 +2595,7 @@ fn check_method_argument_types<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
 
         check_argument_types(fcx,
                              sp,
-                             err_inputs.index(&FullRange),
+                             &err_inputs[],
                              args_no_rcvr,
                              autoref_args,
                              false,
@@ -3010,7 +3047,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         };
 
         // Call the generic checker.
-        let args: Vec<_> = args.index(&(1..)).iter().map(|x| x).collect();
+        let args: Vec<_> = args[1..].iter().map(|x| x).collect();
         let ret_ty = check_method_argument_types(fcx,
                                                  method_name.span,
                                                  fn_ty,
@@ -3328,7 +3365,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     ty::ty_struct(base_id, substs) => {
                         debug!("struct named {}", ppaux::ty_to_string(tcx, base_t));
                         let fields = ty::lookup_struct_fields(tcx, base_id);
-                        lookup_field_ty(tcx, base_id, fields.index(&FullRange),
+                        lookup_field_ty(tcx, base_id, &fields[],
                                         field.node.name, &(*substs))
                     }
                     _ => None
@@ -3391,7 +3428,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                         if tuple_like {
                             debug!("tuple struct named {}", ppaux::ty_to_string(tcx, base_t));
                             let fields = ty::lookup_struct_fields(tcx, base_id);
-                            lookup_tup_field_ty(tcx, base_id, fields.index(&FullRange),
+                            lookup_tup_field_ty(tcx, base_id, &fields[],
                                                 idx.node, &(*substs))
                         } else {
                             None
@@ -3490,17 +3527,18 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     expected_field_type =
                         ty::lookup_field_type(
                             tcx, class_id, field_id, substitutions);
+                    expected_field_type =
+                        fcx.normalize_associated_types_in(
+                            field.span, &expected_field_type);
                     class_field_map.insert(
                         field.ident.node.name, (field_id, true));
                     fields_found += 1;
                 }
             }
+
             // Make sure to give a type to the field even if there's
             // an error, so we can continue typechecking
-            check_expr_coercable_to_type(
-                    fcx,
-                    &*field.expr,
-                    expected_field_type);
+            check_expr_coercable_to_type(fcx, &*field.expr, expected_field_type);
         }
 
         if error_happened {
@@ -3556,7 +3594,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                        class_id,
                                        id,
                                        fcx.ccx.tcx.mk_substs(struct_substs),
-                                       class_fields.index(&FullRange),
+                                       &class_fields[],
                                        fields,
                                        base_expr.is_none(),
                                        None);
@@ -3599,7 +3637,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                        variant_id,
                                        id,
                                        fcx.ccx.tcx.mk_substs(substitutions),
-                                       variant_fields.index(&FullRange),
+                                       &variant_fields[],
                                        fields,
                                        true,
                                        Some(enum_id));
@@ -4066,7 +4104,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         let expected = expected.only_has_type();
         let flds = expected.map_to_option(fcx, |ty| {
             match ty.sty {
-                ty::ty_tup(ref flds) => Some(flds.index(&FullRange)),
+                ty::ty_tup(ref flds) => Some(&flds[]),
                 _ => None
             }
         });
@@ -4100,7 +4138,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         let struct_id = match def {
             Some(def::DefVariant(enum_id, variant_id, true)) => {
                 check_struct_enum_variant(fcx, id, expr.span, enum_id,
-                                          variant_id, fields.index(&FullRange));
+                                          variant_id, &fields[]);
                 enum_id
             }
             Some(def::DefTrait(def_id)) => {
@@ -4109,7 +4147,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     pprust::path_to_string(path));
                 check_struct_fields_on_error(fcx,
                                              id,
-                                             fields.index(&FullRange),
+                                             &fields[],
                                              base_expr);
                 def_id
             },
@@ -4122,7 +4160,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                                  id,
                                                  expr.span,
                                                  struct_did,
-                                                 fields.index(&FullRange),
+                                                 &fields[],
                                                  base_expr.as_ref().map(|e| &**e));
                     }
                     _ => {
@@ -4131,7 +4169,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                             pprust::path_to_string(path));
                         check_struct_fields_on_error(fcx,
                                                      id,
-                                                     fields.index(&FullRange),
+                                                     &fields[],
                                                      base_expr);
                     }
                 }
@@ -4149,10 +4187,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
         // parameters correctly.
         let actual_structure_type = fcx.expr_ty(&*expr);
         if !ty::type_is_error(actual_structure_type) {
-            let type_and_substs = astconv::ast_path_to_ty_relaxed(fcx,
-                                                                  fcx,
-                                                                  struct_id,
-                                                                  path);
+            let type_and_substs = fcx.instantiate_struct_literal_ty(struct_id, path);
             match fcx.mk_subty(false,
                                infer::Misc(path.span),
                                actual_structure_type,
@@ -4164,7 +4199,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                     fcx.tcx()
                        .sess
                        .span_err(path.span,
-                                 format!("structure constructor specifies a \
+                                 &format!("structure constructor specifies a \
                                          structure of type `{}`, but this \
                                          structure has type `{}`: {}",
                                          fcx.infcx()
@@ -4172,7 +4207,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
                                          fcx.infcx()
                                             .ty_to_string(
                                                 actual_structure_type),
-                                         type_error_description).index(&FullRange));
+                                         type_error_description)[]);
                     ty::note_and_explain_type_err(tcx, &type_error);
                 }
             }
@@ -4847,7 +4882,7 @@ pub fn check_enum_variants(ccx: &CrateCtxt,
     }
 
     let hint = *ty::lookup_repr_hints(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id })
-                    .index(&FullRange).get(0).unwrap_or(&attr::ReprAny);
+        [].get(0).unwrap_or(&attr::ReprAny);
 
     if hint != attr::ReprAny && vs.len() <= 1 {
         if vs.len() == 1 {
@@ -5518,7 +5553,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
             "get_tydesc" => {
               let tydesc_ty = match ty::get_tydesc_ty(ccx.tcx) {
                   Ok(t) => t,
-                  Err(s) => { tcx.sess.span_fatal(it.span, s.index(&FullRange)); }
+                  Err(s) => { tcx.sess.span_fatal(it.span, &s[]); }
               };
               let td_ptr = ty::mk_ptr(ccx.tcx, ty::mt {
                   ty: tydesc_ty,
@@ -5534,7 +5569,7 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
                                 ty::mk_struct(ccx.tcx, did,
                                               ccx.tcx.mk_substs(subst::Substs::empty()))),
                     Err(msg) => {
-                        tcx.sess.span_fatal(it.span, msg.index(&FullRange));
+                        tcx.sess.span_fatal(it.span, &msg[]);
                     }
                 }
             },
diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs
index 11ad7bcb09159..112e00536422c 100644
--- a/src/librustc_typeck/check/regionck.rs
+++ b/src/librustc_typeck/check/regionck.rs
@@ -188,8 +188,8 @@ fn region_of_def(fcx: &FnCtxt, def: def::Def) -> ty::Region {
             }
         }
         _ => {
-            tcx.sess.bug(format!("unexpected def in region_of_def: {:?}",
-                                 def).index(&FullRange))
+            tcx.sess.bug(&format!("unexpected def in region_of_def: {:?}",
+                                 def)[])
         }
     }
 }
@@ -282,13 +282,13 @@ impl<'a, 'tcx> Rcx<'a, 'tcx> {
             Some(f) => f,
             None => {
                 self.tcx().sess.bug(
-                    format!("No fn-sig entry for id={}", id).index(&FullRange));
+                    &format!("No fn-sig entry for id={}", id)[]);
             }
         };
 
         let len = self.region_bound_pairs.len();
-        self.relate_free_regions(fn_sig.index(&FullRange), body.id);
-        link_fn_args(self, CodeExtent::from_node_id(body.id), fn_decl.inputs.index(&FullRange));
+        self.relate_free_regions(&fn_sig[], body.id);
+        link_fn_args(self, CodeExtent::from_node_id(body.id), &fn_decl.inputs[]);
         self.visit_block(body);
         self.visit_region_obligations(body.id);
         self.region_bound_pairs.truncate(len);
@@ -629,7 +629,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
         }
 
         ast::ExprMatch(ref discr, ref arms, _) => {
-            link_match(rcx, &**discr, arms.index(&FullRange));
+            link_match(rcx, &**discr, &arms[]);
 
             visit::walk_expr(rcx, expr);
         }
@@ -953,8 +953,8 @@ fn constrain_autoderefs<'a, 'tcx>(rcx: &mut Rcx<'a, 'tcx>,
                 let (m, r) = match self_ty.sty {
                     ty::ty_rptr(r, ref m) => (m.mutbl, r),
                     _ => rcx.tcx().sess.span_bug(deref_expr.span,
-                            format!("bad overloaded deref type {}",
-                                    method.ty.repr(rcx.tcx())).index(&FullRange))
+                            &format!("bad overloaded deref type {}",
+                                    method.ty.repr(rcx.tcx()))[])
                 };
                 {
                     let mc = mc::MemCategorizationContext::new(rcx.fcx);
@@ -1318,9 +1318,9 @@ fn link_reborrowed_region<'a, 'tcx>(rcx: &Rcx<'a, 'tcx>,
                 None => {
                     rcx.tcx().sess.span_bug(
                         span,
-                        format!("Illegal upvar id: {}",
+                        &format!("Illegal upvar id: {}",
                                 upvar_id.repr(
-                                    rcx.tcx())).index(&FullRange));
+                                    rcx.tcx()))[]);
                 }
             }
         }
diff --git a/src/librustc_typeck/check/regionmanip.rs b/src/librustc_typeck/check/regionmanip.rs
index 84d94b0392e9d..8730858f66e7c 100644
--- a/src/librustc_typeck/check/regionmanip.rs
+++ b/src/librustc_typeck/check/regionmanip.rs
@@ -146,8 +146,8 @@ impl<'a, 'tcx> Wf<'a, 'tcx> {
 
             ty::ty_open(_) => {
                 self.tcx.sess.bug(
-                    format!("Unexpected type encountered while doing wf check: {}",
-                            ty.repr(self.tcx)).index(&FullRange));
+                    &format!("Unexpected type encountered while doing wf check: {}",
+                            ty.repr(self.tcx))[]);
             }
         }
     }
diff --git a/src/librustc_typeck/check/vtable.rs b/src/librustc_typeck/check/vtable.rs
index e302609bf228b..3940092eb7291 100644
--- a/src/librustc_typeck/check/vtable.rs
+++ b/src/librustc_typeck/check/vtable.rs
@@ -72,17 +72,17 @@ pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         (_, &ty::ty_uniq(..)) => {
             fcx.ccx.tcx.sess.span_err(
                 source_expr.span,
-                format!("can only cast an boxed pointer \
+                &format!("can only cast an boxed pointer \
                          to a boxed object, not a {}",
-                        ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange));
+                        ty::ty_sort_string(fcx.tcx(), source_ty))[]);
         }
 
         (_, &ty::ty_rptr(..)) => {
             fcx.ccx.tcx.sess.span_err(
                 source_expr.span,
-                format!("can only cast a &-pointer \
+                &format!("can only cast a &-pointer \
                          to an &-object, not a {}",
-                        ty::ty_sort_string(fcx.tcx(), source_ty)).index(&FullRange));
+                        ty::ty_sort_string(fcx.tcx(), source_ty))[]);
         }
 
         _ => {
diff --git a/src/librustc_typeck/check/wf.rs b/src/librustc_typeck/check/wf.rs
index 898a5f9fe0c3a..b17ecdaf59c61 100644
--- a/src/librustc_typeck/check/wf.rs
+++ b/src/librustc_typeck/check/wf.rs
@@ -24,6 +24,7 @@ use syntax::ast;
 use syntax::ast_util::{local_def};
 use syntax::attr;
 use syntax::codemap::Span;
+use syntax::parse::token;
 use syntax::visit;
 use syntax::visit::Visitor;
 
@@ -77,6 +78,14 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
                     enum_variants(fcx, enum_def)
                 });
             }
+            ast::ItemTrait(..) => {
+                let trait_def =
+                    ty::lookup_trait_def(ccx.tcx, local_def(item.id));
+                reject_non_type_param_bounds(
+                    ccx.tcx,
+                    item.span,
+                    &trait_def.generics);
+            }
             _ => {}
         }
     }
@@ -237,21 +246,32 @@ impl<'ccx, 'tcx> CheckTypeWellFormedVisitor<'ccx, 'tcx> {
 fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>,
                                       span: Span,
                                       generics: &ty::Generics<'tcx>) {
+
     for predicate in generics.predicates.iter() {
         match predicate {
             &ty::Predicate::Trait(ty::Binder(ref tr)) => {
-                let self_ty = tr.self_ty();
-                if !self_ty.walk().any(|t| is_ty_param(t)) {
-                    tcx.sess.span_err(
-                        span,
-                        format!("cannot bound type `{}`, where clause \
-                                 bounds may only be attached to types involving \
-                                 type parameters",
-                                 self_ty.repr(tcx)).as_slice())
-                }
+                let found_param = tr.input_types().iter()
+                                    .flat_map(|ty| ty.walk())
+                                    .any(is_ty_param);
+                if !found_param { report_bound_error(tcx, span, tr.self_ty() )}
+            }
+            &ty::Predicate::TypeOutlives(ty::Binder(ty::OutlivesPredicate(ty, _))) => {
+                let found_param = ty.walk().any(|t| is_ty_param(t));
+                if !found_param { report_bound_error(tcx, span, ty) }
             }
             _ => {}
-        }
+        };
+    }
+
+    fn report_bound_error<'t>(tcx: &ty::ctxt<'t>,
+                          span: Span,
+                          bounded_ty: ty::Ty<'t>) {
+        tcx.sess.span_err(
+            span,
+            format!("cannot bound type `{}`, where clause \
+                bounds may only be attached to types involving \
+                type parameters",
+                bounded_ty.repr(tcx)).as_slice())
     }
 
     fn is_ty_param(ty: ty::Ty) -> bool {
@@ -262,11 +282,68 @@ fn reject_non_type_param_bounds<'tcx>(tcx: &ty::ctxt<'tcx>,
     }
 }
 
+fn reject_shadowing_type_parameters<'tcx>(tcx: &ty::ctxt<'tcx>,
+                                          span: Span,
+                                          generics: &ty::Generics<'tcx>) {
+    let impl_params = generics.types.get_slice(subst::TypeSpace).iter()
+        .map(|tp| tp.name).collect::<HashSet<_>>();
+
+    for method_param in generics.types.get_slice(subst::FnSpace).iter() {
+        if impl_params.contains(&method_param.name) {
+            tcx.sess.span_err(
+                span,
+                &*format!("type parameter `{}` shadows another type parameter of the same name",
+                          token::get_name(method_param.name)));
+        }
+    }
+}
+
 impl<'ccx, 'tcx, 'v> Visitor<'v> for CheckTypeWellFormedVisitor<'ccx, 'tcx> {
     fn visit_item(&mut self, i: &ast::Item) {
         self.check_item_well_formed(i);
         visit::walk_item(self, i);
     }
+
+    fn visit_fn(&mut self,
+                fk: visit::FnKind<'v>, fd: &'v ast::FnDecl,
+                b: &'v ast::Block, span: Span, id: ast::NodeId) {
+        match fk {
+            visit::FkFnBlock | visit::FkItemFn(..) => {}
+            visit::FkMethod(..) => {
+                match ty::impl_or_trait_item(self.ccx.tcx, local_def(id)) {
+                    ty::ImplOrTraitItem::MethodTraitItem(ty_method) => {
+                        reject_shadowing_type_parameters(self.ccx.tcx, span, &ty_method.generics)
+                    }
+                    _ => {}
+                }
+            }
+        }
+        visit::walk_fn(self, fk, fd, b, span)
+    }
+
+    fn visit_trait_item(&mut self, t: &'v ast::TraitItem) {
+        match t {
+            &ast::TraitItem::ProvidedMethod(_) |
+            &ast::TraitItem::TypeTraitItem(_) => {},
+            &ast::TraitItem::RequiredMethod(ref method) => {
+                match ty::impl_or_trait_item(self.ccx.tcx, local_def(method.id)) {
+                    ty::ImplOrTraitItem::MethodTraitItem(ty_method) => {
+                        reject_non_type_param_bounds(
+                            self.ccx.tcx,
+                            method.span,
+                            &ty_method.generics);
+                        reject_shadowing_type_parameters(
+                            self.ccx.tcx,
+                            method.span,
+                            &ty_method.generics);
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        visit::walk_trait_item(self, t)
+    }
 }
 
 pub struct BoundsChecker<'cx,'tcx:'cx> {
@@ -455,7 +532,6 @@ fn enum_variants<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                     let arg_tys =
                         ty::assert_no_late_bound_regions(
                             fcx.tcx(), &ty::ty_fn_args(ctor_ty));
-
                     AdtVariant {
                         fields: args.iter().enumerate().map(|(index, arg)| {
                             let arg_ty = arg_tys[index];
diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs
index a0f30788bbddc..9d4aa23960db9 100644
--- a/src/librustc_typeck/coherence/mod.rs
+++ b/src/librustc_typeck/coherence/mod.rs
@@ -68,9 +68,13 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>,
             Some(t.principal_def_id())
         }
 
+        ty_uniq(_) => {
+            inference_context.tcx.lang_items.owned_box()
+        }
+
         ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) |
         ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_tup(..) |
-        ty_param(..) | ty_err | ty_open(..) | ty_uniq(_) |
+        ty_param(..) | ty_err | ty_open(..) |
         ty_ptr(_) | ty_rptr(_, _) | ty_projection(..) => {
             None
         }
@@ -80,8 +84,8 @@ fn get_base_type_def_id<'a, 'tcx>(inference_context: &InferCtxt<'a, 'tcx>,
             // that the user can type
             inference_context.tcx.sess.span_bug(
                 span,
-                format!("coherence encountered unexpected type searching for base type: {}",
-                        ty.repr(inference_context.tcx)).index(&FullRange));
+                &format!("coherence encountered unexpected type searching for base type: {}",
+                        ty.repr(inference_context.tcx))[]);
         }
     }
 }
@@ -487,18 +491,18 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
                 Err(ty::FieldDoesNotImplementCopy(name)) => {
                     tcx.sess
                        .span_err(span,
-                                 format!("the trait `Copy` may not be \
+                                 &format!("the trait `Copy` may not be \
                                           implemented for this type; field \
                                           `{}` does not implement `Copy`",
-                                         token::get_name(name)).index(&FullRange))
+                                         token::get_name(name))[])
                 }
                 Err(ty::VariantDoesNotImplementCopy(name)) => {
                     tcx.sess
                        .span_err(span,
-                                 format!("the trait `Copy` may not be \
+                                 &format!("the trait `Copy` may not be \
                                           implemented for this type; variant \
                                           `{}` does not implement `Copy`",
-                                         token::get_name(name)).index(&FullRange))
+                                         token::get_name(name))[])
                 }
                 Err(ty::TypeIsStructural) => {
                     tcx.sess
@@ -507,6 +511,11 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
                                   for this type; type is not a structure or \
                                   enumeration")
                 }
+                Err(ty::TypeHasDestructor) => {
+                    span_err!(tcx.sess, span, E0184,
+                              "the trait `Copy` may not be implemented for this type; \
+                               the type has a destructor");
+                }
             }
         }
     }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 5852a34560c9f..c56952abc4419 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -212,7 +212,7 @@ fn get_enum_variant_types<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
             ast::TupleVariantKind(ref args) if args.len() > 0 => {
                 let rs = ExplicitRscope;
                 let input_tys: Vec<_> = args.iter().map(|va| ccx.to_ty(&rs, &*va.ty)).collect();
-                ty::mk_ctor_fn(tcx, variant_def_id, input_tys.index(&FullRange), enum_ty)
+                ty::mk_ctor_fn(tcx, variant_def_id, &input_tys[], enum_ty)
             }
 
             ast::TupleVariantKind(_) => {
@@ -259,7 +259,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
                                     ccx,
                                     trait_id,
                                     &trait_def.generics,
-                                    trait_items.index(&FullRange),
+                                    &trait_items[],
                                     &m.id,
                                     &m.ident.name,
                                     &m.explicit_self,
@@ -273,7 +273,7 @@ fn collect_trait_methods<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
                                     ccx,
                                     trait_id,
                                     &trait_def.generics,
-                                    trait_items.index(&FullRange),
+                                    &trait_items[],
                                     &m.id,
                                     &m.pe_ident().name,
                                     m.pe_explicit_self(),
@@ -784,7 +784,7 @@ fn convert_struct<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
                             local_def(field.node.id)].ty).collect();
                 let ctor_fn_ty = ty::mk_ctor_fn(tcx,
                                                 local_def(ctor_id),
-                                                inputs.index(&FullRange),
+                                                &inputs[],
                                                 selfty);
                 write_ty_to_tcx(tcx, ctor_id, ctor_fn_ty);
                 tcx.tcache.borrow_mut().insert(local_def(ctor_id),
@@ -824,8 +824,8 @@ fn get_trait_def<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
     match ccx.tcx.map.get(trait_id.node) {
         ast_map::NodeItem(item) => trait_def_of_item(ccx, &*item),
         _ => {
-            ccx.tcx.sess.bug(format!("get_trait_def({}): not an item",
-                                     trait_id.node).index(&FullRange))
+            ccx.tcx.sess.bug(&format!("get_trait_def({}): not an item",
+                                     trait_id.node)[])
         }
     }
 }
@@ -850,7 +850,7 @@ fn trait_def_of_item<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
         ref s => {
             tcx.sess.span_bug(
                 it.span,
-                format!("trait_def_of_item invoked on {:?}", s).index(&FullRange));
+                &format!("trait_def_of_item invoked on {:?}", s)[]);
         }
     };
 
@@ -1035,8 +1035,8 @@ fn ty_generics_for_type_or_impl<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
                                           -> ty::Generics<'tcx> {
     ty_generics(ccx,
                 subst::TypeSpace,
-                generics.lifetimes.index(&FullRange),
-                generics.ty_params.index(&FullRange),
+                &generics.lifetimes[],
+                &generics.ty_params[],
                 ty::Generics::empty(),
                 &generics.where_clause)
 }
@@ -1054,8 +1054,8 @@ fn ty_generics_for_trait<'a, 'tcx>(ccx: &CollectCtxt<'a, 'tcx>,
     let mut generics =
         ty_generics(ccx,
                     subst::TypeSpace,
-                    ast_generics.lifetimes.index(&FullRange),
-                    ast_generics.ty_params.index(&FullRange),
+                    &ast_generics.lifetimes[],
+                    &ast_generics.ty_params[],
                     ty::Generics::empty(),
                     &ast_generics.where_clause);
 
@@ -1140,8 +1140,8 @@ fn ty_generics_for_fn_or_method<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>,
     let early_lifetimes = resolve_lifetime::early_bound_lifetimes(generics);
     ty_generics(ccx,
                 subst::FnSpace,
-                early_lifetimes.index(&FullRange),
-                generics.ty_params.index(&FullRange),
+                &early_lifetimes[],
+                &generics.ty_params[],
                 base_generics,
                 &generics.where_clause)
 }
@@ -1328,7 +1328,7 @@ fn get_or_create_type_parameter_def<'a,'tcx>(ccx: &CollectCtxt<'a,'tcx>,
     let param_ty = ty::ParamTy::new(space, index, param.ident.name);
     let bounds = compute_bounds(ccx,
                                 param_ty.to_ty(ccx.tcx),
-                                param.bounds.index(&FullRange),
+                                &param.bounds[],
                                 SizedByDefault::Yes,
                                 param.span);
     let default = match param.default {
@@ -1409,7 +1409,7 @@ fn check_bounds_compatible<'tcx>(tcx: &ty::ctxt<'tcx>,
     if !param_bounds.builtin_bounds.contains(&ty::BoundSized) {
         ty::each_bound_trait_and_supertraits(
             tcx,
-            param_bounds.trait_bounds.index(&FullRange),
+            &param_bounds.trait_bounds[],
             |trait_ref| {
                 let trait_def = ty::lookup_trait_def(tcx, trait_ref.def_id());
                 if trait_def.bounds.builtin_bounds.contains(&ty::BoundSized) {
diff --git a/src/librustc_typeck/diagnostics.rs b/src/librustc_typeck/diagnostics.rs
index 9657bf82a8b81..c9e15b93ad4c5 100644
--- a/src/librustc_typeck/diagnostics.rs
+++ b/src/librustc_typeck/diagnostics.rs
@@ -157,5 +157,6 @@ register_diagnostics! {
     E0180,
     E0181,
     E0182,
-    E0183
+    E0183,
+    E0184
 }
diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index ae8731dfa476b..76ac4b2e8af4c 100644
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -65,14 +65,17 @@ This API is completely unstable and subject to change.
 
 #![crate_name = "rustc_typeck"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
       html_favicon_url = "http://www.rust-lang.org/favicon.ico",
       html_root_url = "http://doc.rust-lang.org/nightly/")]
 
+#![allow(unknown_features)]
 #![feature(quote)]
 #![feature(slicing_syntax, unsafe_destructor)]
+#![feature(box_syntax)]
 #![feature(rustc_diagnostic_macros)]
 #![allow(non_camel_case_types)]
 
@@ -190,10 +193,10 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>,
         Ok(_) => true,
         Err(ref terr) => {
             tcx.sess.span_err(span,
-                              format!("{}: {}",
+                              &format!("{}: {}",
                                       msg(),
                                       ty::type_err_to_str(tcx,
-                                                          terr)).index(&FullRange));
+                                                          terr))[]);
             ty::note_and_explain_type_err(tcx, terr);
             false
         }
@@ -239,10 +242,10 @@ fn check_main_fn_ty(ccx: &CrateCtxt,
         }
         _ => {
             tcx.sess.span_bug(main_span,
-                              format!("main has a non-function type: found \
+                              &format!("main has a non-function type: found \
                                        `{}`",
                                       ppaux::ty_to_string(tcx,
-                                                       main_t)).index(&FullRange));
+                                                       main_t))[]);
         }
     }
 }
@@ -291,9 +294,9 @@ fn check_start_fn_ty(ccx: &CrateCtxt,
         }
         _ => {
             tcx.sess.span_bug(start_span,
-                              format!("start has a non-function type: found \
+                              &format!("start has a non-function type: found \
                                        `{}`",
-                                      ppaux::ty_to_string(tcx, start_t)).index(&FullRange));
+                                      ppaux::ty_to_string(tcx, start_t))[]);
         }
     }
 }
diff --git a/src/librustc_typeck/variance.rs b/src/librustc_typeck/variance.rs
index 393ba19ba182a..b33921e07e8dd 100644
--- a/src/librustc_typeck/variance.rs
+++ b/src/librustc_typeck/variance.rs
@@ -562,9 +562,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
         match self.terms_cx.inferred_map.get(&param_id) {
             Some(&index) => index,
             None => {
-                self.tcx().sess.bug(format!(
+                self.tcx().sess.bug(&format!(
                         "no inferred index entry for {}",
-                        self.tcx().map.node_to_string(param_id)).index(&FullRange));
+                        self.tcx().map.node_to_string(param_id))[]);
             }
         }
     }
@@ -837,9 +837,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
 
             ty::ty_infer(..) | ty::ty_err => {
                 self.tcx().sess.bug(
-                    format!("unexpected type encountered in \
+                    &format!("unexpected type encountered in \
                             variance inference: {}",
-                            ty.repr(self.tcx())).index(&FullRange));
+                            ty.repr(self.tcx()))[]);
             }
         }
     }
@@ -917,9 +917,9 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 // regions when visiting member types or method types.
                 self.tcx()
                     .sess
-                    .bug(format!("unexpected region encountered in variance \
+                    .bug(&format!("unexpected region encountered in variance \
                                   inference: {}",
-                                 region.repr(self.tcx())).index(&FullRange));
+                                 region.repr(self.tcx()))[]);
             }
         }
     }
@@ -1055,7 +1055,7 @@ impl<'a, 'tcx> SolveContext<'a, 'tcx> {
             // attribute and report an error with various results if found.
             if ty::has_attr(tcx, item_def_id, "rustc_variance") {
                 let found = item_variances.repr(tcx);
-                tcx.sess.span_err(tcx.map.span(item_id), found.index(&FullRange));
+                tcx.sess.span_err(tcx.map.span(item_id), &found[]);
             }
 
             let newly_added = tcx.item_variance_map.borrow_mut()
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index bf2664bba6ad3..fbb3c40ee99f6 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -530,7 +530,8 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>,
                 _ => {
                     return PathParameters::AngleBracketed {
                         lifetimes: lifetimes,
-                        types: types.clean(cx)
+                        types: types.clean(cx),
+                        bindings: vec![]
                     }
                 }
             };
@@ -547,6 +548,7 @@ fn external_path_params(cx: &DocContext, trait_did: Option<ast::DefId>,
             PathParameters::AngleBracketed {
                 lifetimes: lifetimes,
                 types: types.clean(cx),
+                bindings: vec![] // FIXME(#20646)
             }
         }
     }
@@ -798,7 +800,7 @@ impl Clean<Item> for ast::Method {
         let all_inputs = &self.pe_fn_decl().inputs;
         let inputs = match self.pe_explicit_self().node {
             ast::SelfStatic => all_inputs.as_slice(),
-            _ => all_inputs.index(&(1..))
+            _ => &all_inputs[1..]
         };
         let decl = FnDecl {
             inputs: Arguments {
@@ -836,7 +838,7 @@ impl Clean<Item> for ast::TypeMethod {
     fn clean(&self, cx: &DocContext) -> Item {
         let inputs = match self.explicit_self.node {
             ast::SelfStatic => self.decl.inputs.as_slice(),
-            _ => self.decl.inputs.index(&(1..))
+            _ => &self.decl.inputs[1..]
         };
         let decl = FnDecl {
             inputs: Arguments {
@@ -1132,7 +1134,7 @@ impl<'tcx> Clean<Item> for ty::Method<'tcx> {
                                                self.fty.sig.clone()),
             s => {
                 let sig = ty::Binder(ty::FnSig {
-                    inputs: self.fty.sig.0.inputs.index(&(1..)).to_vec(),
+                    inputs: self.fty.sig.0.inputs[1..].to_vec(),
                     ..self.fty.sig.0.clone()
                 });
                 let s = match s {
@@ -1766,6 +1768,7 @@ pub enum PathParameters {
     AngleBracketed {
         lifetimes: Vec<Lifetime>,
         types: Vec<Type>,
+        bindings: Vec<TypeBinding>
     },
     Parenthesized {
         inputs: Vec<Type>,
@@ -1779,7 +1782,8 @@ impl Clean<PathParameters> for ast::PathParameters {
             ast::AngleBracketedParameters(ref data) => {
                 PathParameters::AngleBracketed {
                     lifetimes: data.lifetimes.clean(cx),
-                    types: data.types.clean(cx)
+                    types: data.types.clean(cx),
+                    bindings: data.bindings.clean(cx)
                 }
             }
 
@@ -2442,8 +2446,25 @@ fn lang_struct(cx: &DocContext, did: Option<ast::DefId>,
                 params: PathParameters::AngleBracketed {
                     lifetimes: vec![],
                     types: vec![t.clean(cx)],
+                    bindings: vec![]
                 }
             }],
         },
     }
 }
+
+/// An equality constraint on an associated type, e.g. `A=Bar` in `Foo<A=Bar>`
+#[derive(Clone, PartialEq, RustcDecodable, RustcEncodable, Show)]
+pub struct TypeBinding {
+    pub name: String,
+    pub ty: Type
+}
+
+impl Clean<TypeBinding> for ast::TypeBinding {
+    fn clean(&self, cx: &DocContext) -> TypeBinding {
+        TypeBinding {
+            name: self.ident.clean(cx),
+            ty: self.ty.clean(cx)
+        }
+    }
+}
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 46c212a9f2dbc..4885bd373eb1d 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -11,6 +11,7 @@ pub use self::MaybeTyped::*;
 
 use rustc_driver::driver;
 use rustc::session::{self, config};
+use rustc::session::config::UnstableFeatures;
 use rustc::session::search_paths::SearchPaths;
 use rustc::middle::{privacy, ty};
 use rustc::lint;
@@ -95,10 +96,11 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
         externs: externs,
         target_triple: triple.unwrap_or(config::host_triple().to_string()),
         cfg: config::parse_cfgspecs(cfgs),
+        // Ensure that rustdoc works even if rustc is feature-staged
+        unstable_features: UnstableFeatures::Default,
         ..config::basic_options().clone()
     };
 
-
     let codemap = codemap::CodeMap::new();
     let diagnostic_handler = diagnostic::default_handler(diagnostic::Auto, None);
     let span_diagnostic_handler =
diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs
index 99cd467cdfccc..6fb78d9a8334b 100644
--- a/src/librustdoc/html/escape.rs
+++ b/src/librustdoc/html/escape.rs
@@ -19,14 +19,6 @@ use std::fmt;
 /// string when passed to a format string.
 pub struct Escape<'a>(pub &'a str);
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Escape<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Escape<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Because the internet is always right, turns out there's not that many
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index b24e7a7a4cf81..2ae22b8fc0d81 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -51,6 +51,8 @@ pub struct ConciseStability<'a>(pub &'a Option<clean::Stability>);
 pub struct WhereClause<'a>(pub &'a clean::Generics);
 /// Wrapper struct for emitting type parameter bounds.
 pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
+/// Wrapper struct for emitting a comma-separated list of items
+pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
 
 impl VisSpace {
     pub fn get(&self) -> Option<ast::Visibility> {
@@ -64,11 +66,13 @@ impl UnsafetySpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for TyParamBounds<'a> {
+impl<'a, T: fmt::String> fmt::String for CommaSep<'a, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
+        for (i, item) in self.0.iter().enumerate() {
+            if i != 0 { try!(write!(f, ", ")); }
+            try!(write!(f, "{}", item));
+        }
+        Ok(())
     }
 }
 
@@ -85,14 +89,6 @@ impl<'a> fmt::String for TyParamBounds<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Generic {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Generics {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.lifetimes.len() == 0 && self.type_params.len() == 0 { return Ok(()) }
@@ -130,14 +126,6 @@ impl fmt::String for clean::Generics {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for WhereClause<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for WhereClause<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let &WhereClause(gens) = self;
@@ -175,14 +163,6 @@ impl<'a> fmt::String for WhereClause<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Lifetime {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Lifetime {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(f.write_str(self.get_ref()));
@@ -190,14 +170,6 @@ impl fmt::String for clean::Lifetime {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PolyTrait {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PolyTrait {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.lifetimes.len() > 0 {
@@ -214,14 +186,6 @@ impl fmt::String for clean::PolyTrait {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::TyParamBound {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::TyParamBound {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -239,19 +203,13 @@ impl fmt::String for clean::TyParamBound {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PathParameters {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PathParameters {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            clean::PathParameters::AngleBracketed { ref lifetimes, ref types } => {
-                if lifetimes.len() > 0 || types.len() > 0 {
+            clean::PathParameters::AngleBracketed {
+                ref lifetimes, ref types, ref bindings
+            } => {
+                if lifetimes.len() > 0 || types.len() > 0 || bindings.len() > 0 {
                     try!(f.write_str("&lt;"));
                     let mut comma = false;
                     for lifetime in lifetimes.iter() {
@@ -268,6 +226,13 @@ impl fmt::String for clean::PathParameters {
                         comma = true;
                         try!(write!(f, "{}", *ty));
                     }
+                    for binding in bindings.iter() {
+                        if comma {
+                            try!(f.write_str(", "));
+                        }
+                        comma = true;
+                        try!(write!(f, "{}", *binding));
+                    }
                     try!(f.write_str("&gt;"));
                 }
             }
@@ -292,14 +257,6 @@ impl fmt::String for clean::PathParameters {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::PathSegment {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::PathSegment {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(f.write_str(self.name.as_slice()));
@@ -307,14 +264,6 @@ impl fmt::String for clean::PathSegment {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Path {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Path {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if self.global {
@@ -383,7 +332,7 @@ fn path<F, G>(w: &mut fmt::Formatter,
         match rel_root {
             Some(root) => {
                 let mut root = String::from_str(root.as_slice());
-                for seg in path.segments.index(&(0..amt)).iter() {
+                for seg in path.segments[0..amt].iter() {
                     if "super" == seg.name ||
                             "self" == seg.name {
                         try!(write!(w, "{}::", seg.name));
@@ -398,7 +347,7 @@ fn path<F, G>(w: &mut fmt::Formatter,
                 }
             }
             None => {
-                for seg in path.segments.index(&(0..amt)).iter() {
+                for seg in path.segments[0..amt].iter() {
                     try!(write!(w, "{}::", seg.name));
                 }
             }
@@ -501,14 +450,6 @@ fn tybounds(w: &mut fmt::Formatter,
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Type {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -530,7 +471,8 @@ impl fmt::String for clean::Type {
                        lifetimes = if decl.lifetimes.len() == 0 {
                            "".to_string()
                        } else {
-                           format!("for &lt;{:#}&gt;", decl.lifetimes)
+                           format!("for &lt;{}&gt;",
+                                   CommaSep(decl.lifetimes.as_slice()))
                        },
                        args = decl.decl.inputs,
                        arrow = decl.decl.output,
@@ -562,7 +504,8 @@ impl fmt::String for clean::Type {
                        lifetimes = if decl.lifetimes.len() == 0 {
                            "".to_string()
                        } else {
-                           format!("for &lt;{:#}&gt;", decl.lifetimes)
+                           format!("for &lt;{}&gt;",
+                                   CommaSep(decl.lifetimes.as_slice()))
                        },
                        args = decl.decl.inputs,
                        bounds = if decl.bounds.len() == 0 {
@@ -592,7 +535,8 @@ impl fmt::String for clean::Type {
                 primitive_link(f, clean::PrimitiveTuple,
                                match typs.as_slice() {
                                     [ref one] => format!("({},)", one),
-                                    many => format!("({:#})", many)
+                                    many => format!("({})",
+                                                    CommaSep(many.as_slice()))
                                }.as_slice())
             }
             clean::Vector(ref t) => {
@@ -650,15 +594,6 @@ impl fmt::String for clean::Type {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::Arguments {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
-
 impl fmt::String for clean::Arguments {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for (i, input) in self.values.iter().enumerate() {
@@ -672,14 +607,6 @@ impl fmt::String for clean::Arguments {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::FunctionRetTy {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::FunctionRetTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -690,28 +617,12 @@ impl fmt::String for clean::FunctionRetTy {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::FnDecl {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::FnDecl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "({args}){arrow}", args = self.inputs, arrow = self.output)
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Method<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Method<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Method(selfty, d) = *self;
@@ -742,14 +653,6 @@ impl<'a> fmt::String for Method<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for VisSpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for VisSpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.get() {
@@ -759,14 +662,6 @@ impl fmt::String for VisSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for UnsafetySpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for UnsafetySpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.get() {
@@ -776,14 +671,6 @@ impl fmt::String for UnsafetySpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ViewPath {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ViewPath {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -811,14 +698,6 @@ impl fmt::String for clean::ViewPath {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ImportSource {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ImportSource {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.did {
@@ -836,14 +715,6 @@ impl fmt::String for clean::ImportSource {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for clean::ViewListIdent {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for clean::ViewListIdent {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.source {
@@ -855,6 +726,7 @@ impl fmt::String for clean::ViewListIdent {
                         params: clean::PathParameters::AngleBracketed {
                             lifetimes: Vec::new(),
                             types: Vec::new(),
+                            bindings: Vec::new()
                         }
                     })
                 };
@@ -865,11 +737,9 @@ impl fmt::String for clean::ViewListIdent {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for MutableSpace {
+impl fmt::String for clean::TypeBinding {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
+        write!(f, "{}={}", self.name, self.ty)
     }
 }
 
@@ -882,14 +752,6 @@ impl fmt::String for MutableSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for RawMutableSpace {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for RawMutableSpace {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
@@ -899,14 +761,6 @@ impl fmt::String for RawMutableSpace {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Stability<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Stability<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Stability(stab) = *self;
@@ -921,14 +775,6 @@ impl<'a> fmt::String for Stability<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for ConciseStability<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for ConciseStability<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let ConciseStability(stab) = *self;
@@ -946,14 +792,6 @@ impl<'a> fmt::String for ConciseStability<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for ModuleSummary {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for ModuleSummary {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fn fmt_inner<'a>(f: &mut fmt::Formatter,
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
index 3d2c5e2cbb5fb..885017152de4f 100644
--- a/src/librustdoc/html/highlight.rs
+++ b/src/librustdoc/html/highlight.rs
@@ -34,7 +34,7 @@ pub fn highlight(src: &str, class: Option<&str>, id: Option<&str>) -> String {
          class,
          id,
          &mut out).unwrap();
-    String::from_utf8_lossy(out.index(&FullRange)).into_owned()
+    String::from_utf8_lossy(&out[]).into_owned()
 }
 
 /// Exhausts the `lexer` writing the output into `out`.
diff --git a/src/librustdoc/html/item_type.rs b/src/librustdoc/html/item_type.rs
index 13a06f842a276..db3319eb7659c 100644
--- a/src/librustdoc/html/item_type.rs
+++ b/src/librustdoc/html/item_type.rs
@@ -103,14 +103,6 @@ impl ItemType {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl fmt::Show for ItemType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for ItemType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.to_static_str().fmt(f)
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index f4660a81be496..a063191a12fd6 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -435,14 +435,6 @@ pub fn reset_headers() {
     TEST_IDX.with(|s| s.set(0));
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Markdown<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Markdown<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let Markdown(md) = *self;
@@ -452,14 +444,6 @@ impl<'a> fmt::String for Markdown<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for MarkdownWithToc<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for MarkdownWithToc<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let MarkdownWithToc(md) = *self;
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 08abdc2af18dc..839dfa339b328 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -1351,14 +1351,6 @@ impl<'a> Item<'a> {
 }
 
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Item<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Item<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Write the breadcrumb trail header for the top
@@ -1634,14 +1626,6 @@ fn item_module(w: &mut fmt::Formatter, cx: &Context,
 
 struct Initializer<'a>(&'a str);
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Initializer<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Initializer<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let Initializer(s) = *self;
@@ -2204,14 +2188,6 @@ fn item_typedef(w: &mut fmt::Formatter, it: &clean::Item,
     document(w, it)
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Sidebar<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Sidebar<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let cx = self.cx;
@@ -2267,14 +2243,6 @@ impl<'a> fmt::String for Sidebar<'a> {
     }
 }
 
-//NOTE(stage0): remove impl after snapshot
-#[cfg(stage0)]
-impl<'a> fmt::Show for Source<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a> fmt::String for Source<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let Source(s) = *self;
diff --git a/src/librustdoc/html/static/main.css b/src/librustdoc/html/static/main.css
index a5a4825414109..5951ac2bae71a 100644
--- a/src/librustdoc/html/static/main.css
+++ b/src/librustdoc/html/static/main.css
@@ -157,7 +157,6 @@ nav.sub {
     left: 0;
     top: 0;
     min-height: 100%;
-    z-index: -1;
 }
 
 .content, nav { max-width: 960px; }
@@ -221,6 +220,7 @@ nav.sub {
 .content pre.line-numbers {
     float: left;
     border: none;
+    position: relative;
 
     -webkit-user-select: none;
     -moz-user-select: none;
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index ee65ef0662305..56f5c23f6f1bb 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -10,6 +10,7 @@
 
 #![crate_name = "rustdoc"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -17,6 +18,7 @@
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 
 extern crate arena;
 extern crate getopts;
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index bbe35eb0e9ccc..8e0f4b2d44364 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -22,6 +22,7 @@ use std::collections::{HashSet, HashMap};
 use testing;
 use rustc::session::{self, config};
 use rustc::session::search_paths::{SearchPaths, PathKind};
+use rustc_driver::get_unstable_features_setting;
 use rustc_driver::driver;
 use syntax::ast;
 use syntax::codemap::{CodeMap, dummy_spanned};
@@ -52,6 +53,7 @@ pub fn run(input: &str,
         search_paths: libs.clone(),
         crate_types: vec!(config::CrateTypeDylib),
         externs: externs.clone(),
+        unstable_features: get_unstable_features_setting(),
         ..config::basic_options().clone()
     };
 
@@ -128,6 +130,7 @@ fn runtest(test: &str, cratename: &str, libs: SearchPaths,
             .. config::basic_codegen_options()
         },
         test: as_test_harness,
+        unstable_features: get_unstable_features_setting(),
         ..config::basic_options().clone()
     };
 
diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs
index d89a4754d2efe..1069825973999 100644
--- a/src/libserialize/collection_impls.rs
+++ b/src/libserialize/collection_impls.rs
@@ -13,6 +13,7 @@
 use std::uint;
 use std::default::Default;
 use std::hash::{Hash, Hasher};
+use std::collections::hash_state::HashState;
 
 use {Decodable, Encodable, Decoder, Encoder};
 use std::collections::{DList, RingBuf, BTreeMap, BTreeSet, HashMap, HashSet, VecMap};
@@ -156,14 +157,13 @@ impl<
     }
 }
 
-#[old_impl_check]
-impl<
-    K: Encodable + Hash<X> + Eq,
-    V: Encodable,
-    X,
-    H: Hasher<X>
-> Encodable for HashMap<K, V, H> {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
+impl<K, V, S> Encodable for HashMap<K, V, S>
+    where K: Encodable + Hash< <S as HashState>::Hasher> + Eq,
+          V: Encodable,
+          S: HashState,
+          <S as HashState>::Hasher: Hasher<Output=u64>
+{
+    fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
         e.emit_map(self.len(), |e| {
             let mut i = 0;
             for (key, val) in self.iter() {
@@ -176,17 +176,16 @@ impl<
     }
 }
 
-#[old_impl_check]
-impl<
-    K: Decodable + Hash<S> + Eq,
-    V: Decodable,
-    S,
-    H: Hasher<S> + Default
-> Decodable for HashMap<K, V, H> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, H>, D::Error> {
+impl<K, V, S> Decodable for HashMap<K, V, S>
+    where K: Decodable + Hash< <S as HashState>::Hasher> + Eq,
+          V: Decodable,
+          S: HashState + Default,
+          <S as HashState>::Hasher: Hasher<Output=u64>
+{
+    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V, S>, D::Error> {
         d.read_map(|d, len| {
-            let hasher = Default::default();
-            let mut map = HashMap::with_capacity_and_hasher(len, hasher);
+            let state = Default::default();
+            let mut map = HashMap::with_capacity_and_hash_state(len, state);
             for i in range(0u, len) {
                 let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
                 let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
@@ -197,13 +196,12 @@ impl<
     }
 }
 
-#[old_impl_check]
-impl<
-    T: Encodable + Hash<X> + Eq,
-    X,
-    H: Hasher<X>
-> Encodable for HashSet<T, H> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+impl<T, S> Encodable for HashSet<T, S>
+    where T: Encodable + Hash< <S as HashState>::Hasher> + Eq,
+          S: HashState,
+          <S as HashState>::Hasher: Hasher<Output=u64>
+{
+    fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
         s.emit_seq(self.len(), |s| {
             let mut i = 0;
             for e in self.iter() {
@@ -215,15 +213,15 @@ impl<
     }
 }
 
-#[old_impl_check]
-impl<
-    T: Decodable + Hash<S> + Eq,
-    S,
-    H: Hasher<S> + Default
-> Decodable for HashSet<T, H> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, H>, D::Error> {
+impl<T, S> Decodable for HashSet<T, S>
+    where T: Decodable + Hash< <S as HashState>::Hasher> + Eq,
+          S: HashState + Default,
+          <S as HashState>::Hasher: Hasher<Output=u64>
+{
+    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T, S>, D::Error> {
         d.read_seq(|d, len| {
-            let mut set = HashSet::with_capacity_and_hasher(len, Default::default());
+            let state = Default::default();
+            let mut set = HashSet::with_capacity_and_hash_state(len, state);
             for i in range(0u, len) {
                 set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index b7bf40a6ec52d..62acef2ca1cc7 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -383,7 +383,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result {
         };
 
         if start < i {
-            try!(wr.write_str(v.index(&(start..i))));
+            try!(wr.write_str(&v[start..i]));
         }
 
         try!(wr.write_str(escaped));
@@ -392,7 +392,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result {
     }
 
     if start != v.len() {
-        try!(wr.write_str(v.index(&(start..))));
+        try!(wr.write_str(&v[start..]));
     }
 
     wr.write_str("\"")
@@ -401,7 +401,7 @@ fn escape_str(wr: &mut fmt::Writer, v: &str) -> fmt::Result {
 fn escape_char(writer: &mut fmt::Writer, v: char) -> fmt::Result {
     let mut buf = [0; 4];
     let n = v.encode_utf8(&mut buf).unwrap();
-    let buf = unsafe { str::from_utf8_unchecked(buf.index(&(0..n))) };
+    let buf = unsafe { str::from_utf8_unchecked(&buf[0..n]) };
     escape_str(writer, buf)
 }
 
@@ -414,7 +414,7 @@ fn spaces(wr: &mut fmt::Writer, mut n: uint) -> fmt::Result {
     }
 
     if n > 0 {
-        wr.write_str(BUF.index(&(0..n)))
+        wr.write_str(&BUF[0..n])
     } else {
         Ok(())
     }
@@ -623,7 +623,7 @@ impl<'a> ::Encoder for Encoder<'a> {
             let mut check_encoder = Encoder::new(&mut buf);
             try!(f(transmute(&mut check_encoder)));
         }
-        let out = str::from_utf8(buf.index(&FullRange)).unwrap();
+        let out = str::from_utf8(&buf[]).unwrap();
         let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
         if needs_wrapping { try!(write!(self.writer, "\"")); }
         try!(f(self));
@@ -894,7 +894,7 @@ impl<'a> ::Encoder for PrettyEncoder<'a> {
             let mut check_encoder = PrettyEncoder::new(&mut buf);
             try!(f(transmute(&mut check_encoder)));
         }
-        let out = str::from_utf8(buf.index(&FullRange)).unwrap();
+        let out = str::from_utf8(&buf[]).unwrap();
         let needs_wrapping = out.char_at(0) != '"' && out.char_at_reverse(out.len()) != '"';
         if needs_wrapping { try!(write!(self.writer, "\"")); }
         try!(f(self));
@@ -1027,7 +1027,7 @@ impl Json {
     /// Returns None otherwise.
     pub fn as_string<'a>(&'a self) -> Option<&'a str> {
         match *self {
-            Json::String(ref s) => Some(s.index(&FullRange)),
+            Json::String(ref s) => Some(&s[]),
             _ => None
         }
     }
@@ -1137,7 +1137,7 @@ impl Index<uint> for Json {
 
     fn index<'a>(&'a self, idx: &uint) -> &'a Json {
         match self {
-            &Json::Array(ref v) => v.index(idx),
+            &Json::Array(ref v) => &v[*idx],
             _ => panic!("can only index Json with uint if it is an array")
         }
     }
@@ -1222,7 +1222,7 @@ impl Stack {
             InternalIndex(i) => StackElement::Index(i),
             InternalKey(start, size) => {
                 StackElement::Key(str::from_utf8(
-                    self.str_buffer.index(&((start as uint) .. (start as uint + size as uint))))
+                    &self.str_buffer[(start as uint) .. (start as uint + size as uint)])
                         .unwrap())
             }
         }
@@ -1265,7 +1265,7 @@ impl Stack {
             Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
             Some(&InternalKey(start, size)) => {
                 Some(StackElement::Key(str::from_utf8(
-                    self.str_buffer.index(&((start as uint) .. (start+size) as uint))
+                    &self.str_buffer[(start as uint) .. (start+size) as uint]
                 ).unwrap()))
             }
         }
@@ -1396,7 +1396,7 @@ impl<T: Iterator<Item=char>> Parser<T> {
         self.ch == Some(c)
     }
 
-    fn error<T>(&self, reason: ErrorCode) -> Result<T, ParserError> {
+    fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> {
         Err(SyntaxError(reason, self.line, self.col))
     }
 
@@ -2144,7 +2144,7 @@ impl ::Decoder for Decoder {
                 return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
             }
         };
-        let idx = match names.iter().position(|n| *n == name.index(&FullRange)) {
+        let idx = match names.iter().position(|n| *n == &name[]) {
             Some(idx) => idx,
             None => return Err(UnknownVariantError(name))
         };
@@ -2458,14 +2458,6 @@ impl<'a> fmt::String for PrettyJson<'a> {
     }
 }
 
-#[cfg(stage0)]
-//NOTE(stage0): remove impl after snapshot
-impl<'a, T: Encodable> fmt::Show for AsJson<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl<'a, T: Encodable> fmt::String for AsJson<'a, T> {
     /// Encodes a json value into a string
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -2519,7 +2511,6 @@ mod tests {
     use std::{i64, u64, f32, f64, io};
     use std::collections::BTreeMap;
     use std::num::Float;
-    use std::ops::Index;
     use std::string;
 
     #[derive(RustcDecodable, Eq, PartialEq, Show)]
@@ -3361,7 +3352,7 @@ mod tests {
         hm.insert(1, true);
         let mut mem_buf = Vec::new();
         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
-        let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap();
+        let json_str = from_utf8(&mem_buf[]).unwrap();
         match from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3377,7 +3368,7 @@ mod tests {
         hm.insert(1, true);
         let mut mem_buf = Vec::new();
         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
-        let json_str = from_utf8(mem_buf.index(&FullRange)).unwrap();
+        let json_str = from_utf8(&mem_buf[]).unwrap();
         match from_str(json_str) {
             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
             _ => {} // it parsed and we are good to go
@@ -3417,7 +3408,7 @@ mod tests {
             write!(&mut writer, "{}",
                    super::as_pretty_json(&json).indent(i)).unwrap();
 
-            let printed = from_utf8(writer.index(&FullRange)).unwrap();
+            let printed = from_utf8(&writer[]).unwrap();
 
             // Check for indents at each line
             let lines: Vec<&str> = printed.lines().collect();
@@ -3481,7 +3472,7 @@ mod tests {
         }
     }
     #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
+    #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
     fn test_streaming_parser() {
         assert_stream_equal(
             r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
@@ -3520,7 +3511,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
+    #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
     fn test_read_object_streaming() {
         assert_eq!(last_event("{ "),      Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
         assert_eq!(last_event("{1"),      Error(SyntaxError(KeyMustBeAString,      1, 2)));
@@ -3604,7 +3595,7 @@ mod tests {
         );
     }
     #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
+    #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
     fn test_read_array_streaming() {
         assert_stream_equal(
             "[]",
diff --git a/src/libserialize/lib.rs b/src/libserialize/lib.rs
index 139170fc012cb..b3c4cec2ef13f 100644
--- a/src/libserialize/lib.rs
+++ b/src/libserialize/lib.rs
@@ -16,6 +16,7 @@ Core encoding and decoding interfaces.
 
 #![crate_name = "serialize"]
 #![unstable = "deprecated in favor of rustc-serialize on crates.io"]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -23,9 +24,10 @@ Core encoding and decoding interfaces.
        html_root_url = "http://doc.rust-lang.org/nightly/",
        html_playground_url = "http://play.rust-lang.org/")]
 #![allow(unknown_features)]
-#![feature(slicing_syntax)]
-#![feature(old_impl_check)]
 #![cfg_attr(stage0, allow(unused_attributes))]
+#![feature(box_syntax)]
+#![feature(old_impl_check)]
+#![feature(slicing_syntax)]
 
 // test harness access
 #[cfg(test)] extern crate test;
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
index 7b6ca10669df6..fe2d57486a88e 100644
--- a/src/libserialize/serialize.rs
+++ b/src/libserialize/serialize.rs
@@ -326,7 +326,7 @@ impl Encodable for str {
 
 impl Encodable for String {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self.index(&FullRange))
+        s.emit_str(&self[])
     }
 }
 
diff --git a/src/libstd/bitflags.rs b/src/libstd/bitflags.rs
index 5764962b51b02..8dc41368e7f92 100644
--- a/src/libstd/bitflags.rs
+++ b/src/libstd/bitflags.rs
@@ -273,7 +273,7 @@ macro_rules! bitflags {
 #[cfg(test)]
 #[allow(non_upper_case_globals)]
 mod tests {
-    use hash;
+    use hash::{self, SipHasher};
     use option::Option::{Some, None};
 
     bitflags! {
@@ -467,9 +467,9 @@ mod tests {
     fn test_hash() {
       let mut x = Flags::empty();
       let mut y = Flags::empty();
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<Flags, SipHasher>(&x) == hash::hash::<Flags, SipHasher>(&y));
       x = Flags::all();
       y = FlagABC;
-      assert!(hash::hash(&x) == hash::hash(&y));
+      assert!(hash::hash::<Flags, SipHasher>(&x) == hash::hash::<Flags, SipHasher>(&y));
     }
 }
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index c3381d5cd64a0..c3bdfbb12d88d 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -19,16 +19,15 @@ use clone::Clone;
 use cmp::{max, Eq, PartialEq};
 use default::Default;
 use fmt::{self, Show};
-use hash::{Hash, Hasher, RandomSipHasher};
+use hash::{self, Hash, SipHasher};
 use iter::{self, Iterator, IteratorExt, FromIterator, Extend, Map};
 use marker::Sized;
 use mem::{self, replace};
 use num::{Int, UnsignedInt};
 use ops::{Deref, FnMut, Index, IndexMut};
-use option::Option;
-use option::Option::{Some, None};
-use result::Result;
-use result::Result::{Ok, Err};
+use option::Option::{self, Some, None};
+use rand::{self, Rng};
+use result::Result::{self, Ok, Err};
 
 use super::table::{
     self,
@@ -44,6 +43,7 @@ use super::table::BucketState::{
     Empty,
     Full,
 };
+use super::state::HashState;
 
 const INITIAL_LOG2_CAP: uint = 5;
 pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
@@ -297,9 +297,9 @@ fn test_resize_policy() {
 /// ```
 #[derive(Clone)]
 #[stable]
-pub struct HashMap<K, V, H = RandomSipHasher> {
+pub struct HashMap<K, V, S = RandomState> {
     // All hashes are keyed on these values, to prevent hash collision attacks.
-    hasher: H,
+    hash_state: S,
 
     table: RawTable<K, V>,
 
@@ -439,17 +439,20 @@ impl<K, V, M> SearchResult<K, V, M> {
     }
 }
 
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
-    fn make_hash<X: ?Sized + Hash<S>>(&self, x: &X) -> SafeHash {
-        table::make_hash(&self.hasher, x)
+impl<K, V, S, H> HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
+    fn make_hash<X: ?Sized>(&self, x: &X) -> SafeHash where X: Hash<H> {
+        table::make_hash(&self.hash_state, x)
     }
 
     /// Search for a key, yielding the index if it's found in the hashtable.
     /// If you already have the hash for the key lying around, use
     /// search_hashed.
     fn search<'a, Q: ?Sized>(&'a self, q: &Q) -> Option<FullBucketImm<'a, K, V>>
-        where Q: BorrowFrom<K> + Eq + Hash<S>
+        where Q: BorrowFrom<K> + Eq + Hash<H>
     {
         let hash = self.make_hash(q);
         search_hashed(&self.table, hash, |k| q.eq(BorrowFrom::borrow_from(k)))
@@ -457,7 +460,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     }
 
     fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q) -> Option<FullBucketMut<'a, K, V>>
-        where Q: BorrowFrom<K> + Eq + Hash<S>
+        where Q: BorrowFrom<K> + Eq + Hash<H>
     {
         let hash = self.make_hash(q);
         search_hashed(&mut self.table, hash, |k| q.eq(BorrowFrom::borrow_from(k)))
@@ -486,7 +489,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     }
 }
 
-impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> {
+impl<K: Hash<Hasher> + Eq, V> HashMap<K, V, RandomState> {
     /// Create an empty HashMap.
     ///
     /// # Example
@@ -497,9 +500,8 @@ impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> {
     /// ```
     #[inline]
     #[stable]
-    pub fn new() -> HashMap<K, V, RandomSipHasher> {
-        let hasher = RandomSipHasher::new();
-        HashMap::with_hasher(hasher)
+    pub fn new() -> HashMap<K, V, RandomState> {
+        Default::default()
     }
 
     /// Creates an empty hash map with the given initial capacity.
@@ -512,14 +514,16 @@ impl<K: Hash + Eq, V> HashMap<K, V, RandomSipHasher> {
     /// ```
     #[inline]
     #[stable]
-    pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomSipHasher> {
-        let hasher = RandomSipHasher::new();
-        HashMap::with_capacity_and_hasher(capacity, hasher)
+    pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomState> {
+        HashMap::with_capacity_and_hash_state(capacity, Default::default())
     }
 }
 
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
+impl<K, V, S, H> HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     /// Creates an empty hashmap which will use the given hasher to hash keys.
     ///
     /// The creates map has the default initial capacity.
@@ -528,17 +532,17 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     ///
     /// ```
     /// use std::collections::HashMap;
-    /// use std::hash::sip::SipHasher;
+    /// use std::collections::hash_map::RandomState;
     ///
-    /// let h = SipHasher::new();
-    /// let mut map = HashMap::with_hasher(h);
+    /// let s = RandomState::new();
+    /// let mut map = HashMap::with_hash_state(s);
     /// map.insert(1i, 2u);
     /// ```
     #[inline]
     #[unstable = "hasher stuff is unclear"]
-    pub fn with_hasher(hasher: H) -> HashMap<K, V, H> {
+    pub fn with_hash_state(hash_state: S) -> HashMap<K, V, S> {
         HashMap {
-            hasher:        hasher,
+            hash_state:    hash_state,
             resize_policy: DefaultResizePolicy::new(),
             table:         RawTable::new(0),
         }
@@ -556,21 +560,22 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     ///
     /// ```
     /// use std::collections::HashMap;
-    /// use std::hash::sip::SipHasher;
+    /// use std::collections::hash_map::RandomState;
     ///
-    /// let h = SipHasher::new();
-    /// let mut map = HashMap::with_capacity_and_hasher(10, h);
+    /// let s = RandomState::new();
+    /// let mut map = HashMap::with_capacity_and_hash_state(10, s);
     /// map.insert(1i, 2u);
     /// ```
     #[inline]
     #[unstable = "hasher stuff is unclear"]
-    pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashMap<K, V, H> {
+    pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+                                        -> HashMap<K, V, S> {
         let resize_policy = DefaultResizePolicy::new();
         let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity));
         let internal_cap = min_cap.checked_next_power_of_two().expect("capacity overflow");
         assert!(internal_cap >= capacity, "capacity overflow");
         HashMap {
-            hasher:        hasher,
+            hash_state:    hash_state,
             resize_policy: resize_policy,
             table:         RawTable::new(internal_cap),
         }
@@ -1031,7 +1036,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// ```
     #[stable]
     pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
-        where Q: Hash<S> + Eq + BorrowFrom<K>
+        where Q: Hash<H> + Eq + BorrowFrom<K>
     {
         self.search(k).map(|bucket| bucket.into_refs().1)
     }
@@ -1054,7 +1059,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// ```
     #[stable]
     pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
-        where Q: Hash<S> + Eq + BorrowFrom<K>
+        where Q: Hash<H> + Eq + BorrowFrom<K>
     {
         self.search(k).is_some()
     }
@@ -1080,7 +1085,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// ```
     #[stable]
     pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
-        where Q: Hash<S> + Eq + BorrowFrom<K>
+        where Q: Hash<H> + Eq + BorrowFrom<K>
     {
         self.search_mut(k).map(|bucket| bucket.into_mut_refs().1)
     }
@@ -1132,7 +1137,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     /// ```
     #[stable]
     pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
-        where Q: Hash<S> + Eq + BorrowFrom<K>
+        where Q: Hash<H> + Eq + BorrowFrom<K>
     {
         if self.table.size() == 0 {
             return None
@@ -1189,10 +1194,12 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas
     }
 }
 
-#[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> {
-    fn eq(&self, other: &HashMap<K, V, H>) -> bool {
+impl<K, V, S, H> PartialEq for HashMap<K, V, S>
+    where K: Eq + Hash<H>, V: PartialEq,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
+    fn eq(&self, other: &HashMap<K, V, S>) -> bool {
         if self.len() != other.len() { return false; }
 
         self.iter().all(|(key, value)|
@@ -1202,12 +1209,18 @@ impl<K: Eq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V,
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {}
+impl<K, V, S, H> Eq for HashMap<K, V, S>
+    where K: Eq + Hash<H>, V: Eq,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{}
 
 #[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> {
+impl<K, V, S, H> Show for HashMap<K, V, S>
+    where K: Eq + Hash<H> + Show, V: Show,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f, "HashMap {{"));
 
@@ -1221,18 +1234,22 @@ impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H>
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> {
-    #[stable]
-    fn default() -> HashMap<K, V, H> {
-        HashMap::with_hasher(Default::default())
+impl<K, V, S, H> Default for HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    fn default() -> HashMap<K, V, S> {
+        HashMap::with_hash_state(Default::default())
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V, H>
-    where Q: BorrowFrom<K> + Hash<S> + Eq
+impl<K, Q: ?Sized, V, S, H> Index<Q> for HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          Q: Eq + Hash<H> + BorrowFrom<K>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Output = V;
 
@@ -1243,9 +1260,11 @@ impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> Index<Q> for HashMap<K, V,
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Hash<S> + Eq, Q: ?Sized, V, S, H: Hasher<S>> IndexMut<Q> for HashMap<K, V, H>
-    where Q: BorrowFrom<K> + Hash<S> + Eq
+impl<K, V, S, H, Q: ?Sized> IndexMut<Q> for HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          Q: Eq + Hash<H> + BorrowFrom<K>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Output = V;
 
@@ -1473,19 +1492,26 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
-    fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, H> {
+impl<K, V, S, H> FromIterator<(K, V)> for HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, S> {
         let lower = iter.size_hint().0;
-        let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
+        let mut map = HashMap::with_capacity_and_hash_state(lower,
+                                                            Default::default());
         map.extend(iter);
         map
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Extend<(K, V)> for HashMap<K, V, H> {
+impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S>
+    where K: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     fn extend<T: Iterator<Item=(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {
             self.insert(k, v);
@@ -1493,6 +1519,64 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Extend<(K, V)> for HashMap<K, V, H> {
     }
 }
 
+
+/// `RandomState` is the default state for `HashMap` types.
+///
+/// A particular instance `RandomState` will create the same instances of
+/// `Hasher`, but the hashers created by two different `RandomState`
+/// instances are unlikely to produce the same result for the same values.
+#[derive(Clone)]
+#[allow(missing_copy_implementations)]
+#[unstable = "hashing an hash maps may be altered"]
+pub struct RandomState {
+    k0: u64,
+    k1: u64,
+}
+
+#[unstable = "hashing an hash maps may be altered"]
+impl RandomState {
+    /// Construct a new `RandomState` that is initialized with random keys.
+    #[inline]
+    pub fn new() -> RandomState {
+        let mut r = rand::thread_rng();
+        RandomState { k0: r.gen(), k1: r.gen() }
+    }
+}
+
+#[unstable = "hashing an hash maps may be altered"]
+impl HashState for RandomState {
+    type Hasher = Hasher;
+    fn hasher(&self) -> Hasher {
+        Hasher { inner: SipHasher::new_with_keys(self.k0, self.k1) }
+    }
+}
+
+#[unstable = "hashing an hash maps may be altered"]
+impl Default for RandomState {
+    #[inline]
+    fn default() -> RandomState {
+        RandomState::new()
+    }
+}
+
+/// A hasher implementation which is generated from `RandomState` instances.
+///
+/// This is the default hasher used in a `HashMap` to hash keys. Types do not
+/// typically declare an ability to explicitly hash into this particular type,
+/// but rather in a `H: hash::Writer` type parameter.
+#[allow(missing_copy_implementations)]
+pub struct Hasher { inner: SipHasher }
+
+impl hash::Writer for Hasher {
+    fn write(&mut self, data: &[u8]) { self.inner.write(data) }
+}
+
+impl hash::Hasher for Hasher {
+    type Output = u64;
+    fn reset(&mut self) { self.inner.reset() }
+    fn finish(&self) -> u64 { self.inner.finish() }
+}
+
 #[cfg(test)]
 mod test_map {
     use prelude::v1::*;
diff --git a/src/libstd/collections/hash/mod.rs b/src/libstd/collections/hash/mod.rs
index ee3fc1e6ac362..47e300af26981 100644
--- a/src/libstd/collections/hash/mod.rs
+++ b/src/libstd/collections/hash/mod.rs
@@ -11,6 +11,7 @@
 //! Unordered containers, implemented as hash-tables
 
 mod bench;
+mod table;
 pub mod map;
 pub mod set;
-mod table;
+pub mod state;
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index f66e538494248..4003d3addf139 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -17,12 +17,13 @@ use core::marker::Sized;
 use default::Default;
 use fmt::Show;
 use fmt;
-use hash::{Hash, Hasher, RandomSipHasher};
+use hash::{self, Hash};
 use iter::{Iterator, IteratorExt, FromIterator, Map, Chain, Extend};
 use ops::{BitOr, BitAnd, BitXor, Sub};
 use option::Option::{Some, None, self};
 
-use super::map::{self, HashMap, Keys, INITIAL_CAPACITY};
+use super::map::{self, HashMap, Keys, INITIAL_CAPACITY, RandomState, Hasher};
+use super::state::HashState;
 
 // Future Optimization (FIXME!)
 // =============================
@@ -90,11 +91,11 @@ use super::map::{self, HashMap, Keys, INITIAL_CAPACITY};
 /// ```
 #[derive(Clone)]
 #[stable]
-pub struct HashSet<T, H = RandomSipHasher> {
-    map: HashMap<T, (), H>
+pub struct HashSet<T, S = RandomState> {
+    map: HashMap<T, (), S>
 }
 
-impl<T: Hash + Eq> HashSet<T, RandomSipHasher> {
+impl<T: Hash<Hasher> + Eq> HashSet<T, RandomState> {
     /// Create an empty HashSet.
     ///
     /// # Example
@@ -105,7 +106,7 @@ impl<T: Hash + Eq> HashSet<T, RandomSipHasher> {
     /// ```
     #[inline]
     #[stable]
-    pub fn new() -> HashSet<T, RandomSipHasher> {
+    pub fn new() -> HashSet<T, RandomState> {
         HashSet::with_capacity(INITIAL_CAPACITY)
     }
 
@@ -120,13 +121,16 @@ impl<T: Hash + Eq> HashSet<T, RandomSipHasher> {
     /// ```
     #[inline]
     #[stable]
-    pub fn with_capacity(capacity: uint) -> HashSet<T, RandomSipHasher> {
+    pub fn with_capacity(capacity: uint) -> HashSet<T, RandomState> {
         HashSet { map: HashMap::with_capacity(capacity) }
     }
 }
 
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
+impl<T, S, H> HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     /// Creates a new empty hash set which will use the given hasher to hash
     /// keys.
     ///
@@ -136,16 +140,16 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     ///
     /// ```
     /// use std::collections::HashSet;
-    /// use std::hash::sip::SipHasher;
+    /// use std::collections::hash_map::RandomState;
     ///
-    /// let h = SipHasher::new();
-    /// let mut set = HashSet::with_hasher(h);
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_hash_state(s);
     /// set.insert(2u);
     /// ```
     #[inline]
     #[unstable = "hasher stuff is unclear"]
-    pub fn with_hasher(hasher: H) -> HashSet<T, H> {
-        HashSet::with_capacity_and_hasher(INITIAL_CAPACITY, hasher)
+    pub fn with_hash_state(hash_state: S) -> HashSet<T, S> {
+        HashSet::with_capacity_and_hash_state(INITIAL_CAPACITY, hash_state)
     }
 
     /// Create an empty HashSet with space for at least `capacity`
@@ -160,16 +164,19 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     ///
     /// ```
     /// use std::collections::HashSet;
-    /// use std::hash::sip::SipHasher;
+    /// use std::collections::hash_map::RandomState;
     ///
-    /// let h = SipHasher::new();
-    /// let mut set = HashSet::with_capacity_and_hasher(10u, h);
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_capacity_and_hash_state(10u, s);
     /// set.insert(1i);
     /// ```
     #[inline]
     #[unstable = "hasher stuff is unclear"]
-    pub fn with_capacity_and_hasher(capacity: uint, hasher: H) -> HashSet<T, H> {
-        HashSet { map: HashMap::with_capacity_and_hasher(capacity, hasher) }
+    pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+                                        -> HashSet<T, S> {
+        HashSet {
+            map: HashMap::with_capacity_and_hash_state(capacity, hash_state),
+        }
     }
 
     /// Returns the number of elements the set can hold without reallocating.
@@ -300,7 +307,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(diff, [4i].iter().map(|&x| x).collect());
     /// ```
     #[stable]
-    pub fn difference<'a>(&'a self, other: &'a HashSet<T, H>) -> Difference<'a, T, H> {
+    pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> {
         Difference {
             iter: self.iter(),
             other: other,
@@ -328,8 +335,8 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(diff1, [1i, 4].iter().map(|&x| x).collect());
     /// ```
     #[stable]
-    pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, H>)
-        -> SymmetricDifference<'a, T, H> {
+    pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, S>)
+        -> SymmetricDifference<'a, T, S> {
         SymmetricDifference { iter: self.difference(other).chain(other.difference(self)) }
     }
 
@@ -351,7 +358,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(diff, [2i, 3].iter().map(|&x| x).collect());
     /// ```
     #[stable]
-    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, H>) -> Intersection<'a, T, H> {
+    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> {
         Intersection {
             iter: self.iter(),
             other: other,
@@ -376,7 +383,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(diff, [1i, 2, 3, 4].iter().map(|&x| x).collect());
     /// ```
     #[stable]
-    pub fn union<'a>(&'a self, other: &'a HashSet<T, H>) -> Union<'a, T, H> {
+    pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> {
         Union { iter: self.iter().chain(other.difference(self)) }
     }
 
@@ -452,7 +459,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// ```
     #[stable]
     pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
-        where Q: BorrowFrom<T> + Hash<S> + Eq
+        where Q: BorrowFrom<T> + Hash<H> + Eq
     {
         self.map.contains_key(value)
     }
@@ -475,7 +482,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(a.is_disjoint(&b), false);
     /// ```
     #[stable]
-    pub fn is_disjoint(&self, other: &HashSet<T, H>) -> bool {
+    pub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool {
         self.iter().all(|v| !other.contains(v))
     }
 
@@ -496,7 +503,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// assert_eq!(set.is_subset(&sup), false);
     /// ```
     #[stable]
-    pub fn is_subset(&self, other: &HashSet<T, H>) -> bool {
+    pub fn is_subset(&self, other: &HashSet<T, S>) -> bool {
         self.iter().all(|v| other.contains(v))
     }
 
@@ -521,7 +528,7 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// ```
     #[inline]
     #[stable]
-    pub fn is_superset(&self, other: &HashSet<T, H>) -> bool {
+    pub fn is_superset(&self, other: &HashSet<T, S>) -> bool {
         other.is_subset(self)
     }
 
@@ -562,16 +569,19 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
     /// ```
     #[stable]
     pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
-        where Q: BorrowFrom<T> + Hash<S> + Eq
+        where Q: BorrowFrom<T> + Hash<H> + Eq
     {
         self.map.remove(value).is_some()
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
-    fn eq(&self, other: &HashSet<T, H>) -> bool {
+impl<T, S, H> PartialEq for HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
+    fn eq(&self, other: &HashSet<T, S>) -> bool {
         if self.len() != other.len() { return false; }
 
         self.iter().all(|key| other.contains(key))
@@ -579,12 +589,18 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
 }
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {}
+impl<T, S, H> Eq for HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{}
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
+impl<T, S, H> fmt::Show for HashSet<T, S>
+    where T: Eq + Hash<H> + fmt::Show,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f, "HashSet {{"));
 
@@ -598,19 +614,25 @@ impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
 }
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
-    fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, H> {
+impl<T, S, H> FromIterator<T> for HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, S> {
         let lower = iter.size_hint().0;
-        let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());
+        let mut set = HashSet::with_capacity_and_hash_state(lower, Default::default());
         set.extend(iter);
         set
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S>> Extend<T> for HashSet<T, H> {
+impl<T, S, H> Extend<T> for HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
+{
     fn extend<I: Iterator<Item=T>>(&mut self, mut iter: I) {
         for k in iter {
             self.insert(k);
@@ -619,21 +641,26 @@ impl<T: Eq + Hash<S>, S, H: Hasher<S>> Extend<T> for HashSet<T, H> {
 }
 
 #[stable]
-#[old_impl_check]
-impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> Default for HashSet<T, H> {
+impl<T, S, H> Default for HashSet<T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
     #[stable]
-    fn default() -> HashSet<T, H> {
-        HashSet::with_hasher(Default::default())
+    fn default() -> HashSet<T, S> {
+        HashSet::with_hash_state(Default::default())
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
-BitOr<&'b HashSet<T, H>> for &'a HashSet<T, H> {
-    type Output = HashSet<T, H>;
+impl<'a, 'b, T, S, H> BitOr<&'b HashSet<T, S>> for &'a HashSet<T, S>
+    where T: Eq + Hash<H> + Clone,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    type Output = HashSet<T, S>;
 
-    /// Returns the union of `self` and `rhs` as a new `HashSet<T, H>`.
+    /// Returns the union of `self` and `rhs` as a new `HashSet<T, S>`.
     ///
     /// # Examples
     ///
@@ -653,18 +680,20 @@ BitOr<&'b HashSet<T, H>> for &'a HashSet<T, H> {
     /// }
     /// assert_eq!(i, expected.len());
     /// ```
-    fn bitor(self, rhs: &HashSet<T, H>) -> HashSet<T, H> {
+    fn bitor(self, rhs: &HashSet<T, S>) -> HashSet<T, S> {
         self.union(rhs).cloned().collect()
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
-BitAnd<&'b HashSet<T, H>> for &'a HashSet<T, H> {
-    type Output = HashSet<T, H>;
+impl<'a, 'b, T, S, H> BitAnd<&'b HashSet<T, S>> for &'a HashSet<T, S>
+    where T: Eq + Hash<H> + Clone,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    type Output = HashSet<T, S>;
 
-    /// Returns the intersection of `self` and `rhs` as a new `HashSet<T, H>`.
+    /// Returns the intersection of `self` and `rhs` as a new `HashSet<T, S>`.
     ///
     /// # Examples
     ///
@@ -684,18 +713,20 @@ BitAnd<&'b HashSet<T, H>> for &'a HashSet<T, H> {
     /// }
     /// assert_eq!(i, expected.len());
     /// ```
-    fn bitand(self, rhs: &HashSet<T, H>) -> HashSet<T, H> {
+    fn bitand(self, rhs: &HashSet<T, S>) -> HashSet<T, S> {
         self.intersection(rhs).cloned().collect()
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
-BitXor<&'b HashSet<T, H>> for &'a HashSet<T, H> {
-    type Output = HashSet<T, H>;
+impl<'a, 'b, T, S, H> BitXor<&'b HashSet<T, S>> for &'a HashSet<T, S>
+    where T: Eq + Hash<H> + Clone,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    type Output = HashSet<T, S>;
 
-    /// Returns the symmetric difference of `self` and `rhs` as a new `HashSet<T, H>`.
+    /// Returns the symmetric difference of `self` and `rhs` as a new `HashSet<T, S>`.
     ///
     /// # Examples
     ///
@@ -715,18 +746,20 @@ BitXor<&'b HashSet<T, H>> for &'a HashSet<T, H> {
     /// }
     /// assert_eq!(i, expected.len());
     /// ```
-    fn bitxor(self, rhs: &HashSet<T, H>) -> HashSet<T, H> {
+    fn bitxor(self, rhs: &HashSet<T, S>) -> HashSet<T, S> {
         self.symmetric_difference(rhs).cloned().collect()
     }
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, 'b, T: Eq + Hash<S> + Clone, S, H: Hasher<S> + Default>
-Sub<&'b HashSet<T, H>> for &'a HashSet<T, H> {
-    type Output = HashSet<T, H>;
+impl<'a, 'b, T, S, H> Sub<&'b HashSet<T, S>> for &'a HashSet<T, S>
+    where T: Eq + Hash<H> + Clone,
+          S: HashState<Hasher=H> + Default,
+          H: hash::Hasher<Output=u64>
+{
+    type Output = HashSet<T, S>;
 
-    /// Returns the difference of `self` and `rhs` as a new `HashSet<T, H>`.
+    /// Returns the difference of `self` and `rhs` as a new `HashSet<T, S>`.
     ///
     /// # Examples
     ///
@@ -746,7 +779,7 @@ Sub<&'b HashSet<T, H>> for &'a HashSet<T, H> {
     /// }
     /// assert_eq!(i, expected.len());
     /// ```
-    fn sub(self, rhs: &HashSet<T, H>) -> HashSet<T, H> {
+    fn sub(self, rhs: &HashSet<T, S>) -> HashSet<T, S> {
         self.difference(rhs).cloned().collect()
     }
 }
@@ -771,32 +804,32 @@ pub struct Drain<'a, K: 'a> {
 
 /// Intersection iterator
 #[stable]
-pub struct Intersection<'a, T: 'a, H: 'a> {
+pub struct Intersection<'a, T: 'a, S: 'a> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, H>,
+    other: &'a HashSet<T, S>,
 }
 
 /// Difference iterator
 #[stable]
-pub struct Difference<'a, T: 'a, H: 'a> {
+pub struct Difference<'a, T: 'a, S: 'a> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, H>,
+    other: &'a HashSet<T, S>,
 }
 
 /// Symmetric difference iterator.
 #[stable]
-pub struct SymmetricDifference<'a, T: 'a, H: 'a> {
-    iter: Chain<Difference<'a, T, H>, Difference<'a, T, H>>
+pub struct SymmetricDifference<'a, T: 'a, S: 'a> {
+    iter: Chain<Difference<'a, T, S>, Difference<'a, T, S>>
 }
 
 /// Set union iterator.
 #[stable]
-pub struct Union<'a, T: 'a, H: 'a> {
-    iter: Chain<Iter<'a, T>, Difference<'a, T, H>>
+pub struct Union<'a, T: 'a, S: 'a> {
+    iter: Chain<Iter<'a, T>, Difference<'a, T, S>>
 }
 
 #[stable]
@@ -824,9 +857,10 @@ impl<'a, K: 'a> Iterator for Drain<'a, K> {
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, T, S, H> Iterator for Intersection<'a, T, H>
-    where T: Eq + Hash<S>, H: Hasher<S>
+impl<'a, T, S, H> Iterator for Intersection<'a, T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Item = &'a T;
 
@@ -848,9 +882,10 @@ impl<'a, T, S, H> Iterator for Intersection<'a, T, H>
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, T, S, H> Iterator for Difference<'a, T, H>
-    where T: Eq + Hash<S>, H: Hasher<S>
+impl<'a, T, S, H> Iterator for Difference<'a, T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Item = &'a T;
 
@@ -872,9 +907,10 @@ impl<'a, T, S, H> Iterator for Difference<'a, T, H>
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H>
-    where T: Eq + Hash<S>, H: Hasher<S>
+impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Item = &'a T;
 
@@ -883,9 +919,10 @@ impl<'a, T, S, H> Iterator for SymmetricDifference<'a, T, H>
 }
 
 #[stable]
-#[old_impl_check]
-impl<'a, T, S, H> Iterator for Union<'a, T, H>
-    where T: Eq + Hash<S>, H: Hasher<S>
+impl<'a, T, S, H> Iterator for Union<'a, T, S>
+    where T: Eq + Hash<H>,
+          S: HashState<Hasher=H>,
+          H: hash::Hasher<Output=u64>
 {
     type Item = &'a T;
 
diff --git a/src/libstd/collections/hash/state.rs b/src/libstd/collections/hash/state.rs
new file mode 100644
index 0000000000000..ffbc958f179f5
--- /dev/null
+++ b/src/libstd/collections/hash/state.rs
@@ -0,0 +1,51 @@
+// 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.
+
+use clone::Clone;
+use default::Default;
+use hash;
+
+/// A trait representing stateful hashes which can be used to hash keys in a
+/// `HashMap`.
+///
+/// A HashState is used as a factory for instances of `Hasher` which a `HashMap`
+/// can then use to hash keys independently. A `HashMap` by default uses a state
+/// which will create instances of a `SipHasher`, but a custom state factory can
+/// be provided to the `with_hash_state` function.
+///
+/// If a hashing algorithm has no initial state, then the `Hasher` type for that
+/// algorithm can implement the `Default` trait and create hash maps with the
+/// `DefaultState` structure. This state is 0-sized and will simply delegate
+/// to `Default` when asked to create a hasher.
+pub trait HashState {
+    type Hasher: hash::Hasher;
+
+    /// Creates a new hasher based on the given state of this object.
+    fn hasher(&self) -> Self::Hasher;
+}
+
+/// A structure which is a factory for instances of `Hasher` which implement the
+/// default trait.
+///
+/// This struct has is 0-sized and does not need construction.
+pub struct DefaultState<H>;
+
+impl<H: Default + hash::Hasher> HashState for DefaultState<H> {
+    type Hasher = H;
+    fn hasher(&self) -> H { Default::default() }
+}
+
+impl<H> Clone for DefaultState<H> {
+    fn clone(&self) -> DefaultState<H> { DefaultState }
+}
+
+impl<H> Default for DefaultState<H> {
+    fn default() -> DefaultState<H> { DefaultState }
+}
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index 6eb98da4da46e..e43cc053ba079 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -26,6 +26,7 @@ use option::Option::{Some, None};
 use ptr::{Unique, PtrExt, copy_nonoverlapping_memory, zero_memory};
 use ptr;
 use rt::heap::{allocate, deallocate};
+use collections::hash_state::HashState;
 
 const EMPTY_BUCKET: u64 = 0u64;
 
@@ -138,12 +139,18 @@ impl SafeHash {
 /// We need to remove hashes of 0. That's reserved for empty buckets.
 /// This function wraps up `hash_keyed` to be the only way outside this
 /// module to generate a SafeHash.
-pub fn make_hash<T: ?Sized + Hash<S>, S, H: Hasher<S>>(hasher: &H, t: &T) -> SafeHash {
+pub fn make_hash<T: ?Sized, S, H>(hash_state: &S, t: &T) -> SafeHash
+    where T: Hash<H>,
+          S: HashState<Hasher=H>,
+          H: Hasher<Output=u64>
+{
+    let mut state = hash_state.hasher();
+    t.hash(&mut state);
     // We need to avoid 0u64 in order to prevent collisions with
     // EMPTY_HASH. We can maintain our precious uniform distribution
     // of initial indexes by unconditionally setting the MSB,
     // effectively reducing 64-bits hashes to 63 bits.
-    SafeHash { hash: 0x8000_0000_0000_0000 | hasher.hash(t) }
+    SafeHash { hash: 0x8000_0000_0000_0000 | state.finish() }
 }
 
 // `replace` casts a `*u64` to a `*SafeHash`. Since we statically
diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index 9b2a4926bcb92..71ab89027ff4c 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -333,3 +333,10 @@ pub mod hash_set {
     //! A hashset
     pub use super::hash::set::*;
 }
+
+/// Experimental support for providing custom hash algorithms to a HashMap and
+/// HashSet.
+#[unstable = "module was recently added"]
+pub mod hash_state {
+    pub use super::hash::state::*;
+}
diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs
index 50538d3e43def..dbc88ddf0a040 100644
--- a/src/libstd/failure.rs
+++ b/src/libstd/failure.rs
@@ -37,7 +37,7 @@ pub fn on_fail(obj: &(Any+Send), file: &'static str, line: uint) {
     let msg = match obj.downcast_ref::<&'static str>() {
         Some(s) => *s,
         None => match obj.downcast_ref::<String>() {
-            Some(s) => s.index(&FullRange),
+            Some(s) => &s[],
             None => "Box<Any>",
         }
     };
diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 1623b6452b716..96fff64d2214d 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -175,7 +175,7 @@
 //! use std::f64;
 //! use std::num::Float;
 //!
-//! #[deriving(Show)]
+//! #[derive(Show)]
 //! struct Vector2D {
 //!     x: int,
 //!     y: int,
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
deleted file mode 100644
index 69e7e429d07da..0000000000000
--- a/src/libstd/hash.rs
+++ /dev/null
@@ -1,105 +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.
-
-//! Generic hashing support.
-//!
-//! This module provides a generic way to compute the hash of a value. The
-//! simplest way to make a type hashable is to use `#[derive(Hash)]`:
-//!
-//! # Example
-//!
-//! ```rust
-//! use std::hash;
-//! use std::hash::Hash;
-//!
-//! #[derive(Hash)]
-//! struct Person {
-//!     id: uint,
-//!     name: String,
-//!     phone: u64,
-//! }
-//!
-//! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 };
-//! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 };
-//!
-//! assert!(hash::hash(&person1) != hash::hash(&person2));
-//! ```
-//!
-//! If you need more control over how a value is hashed, you need to implement
-//! the trait `Hash`:
-//!
-//! ```rust
-//! use std::hash;
-//! use std::hash::Hash;
-//! use std::hash::sip::SipState;
-//!
-//! struct Person {
-//!     id: uint,
-//!     name: String,
-//!     phone: u64,
-//! }
-//!
-//! impl Hash for Person {
-//!     fn hash(&self, state: &mut SipState) {
-//!         self.id.hash(state);
-//!         self.phone.hash(state);
-//!     }
-//! }
-//!
-//! let person1 = Person { id: 5, name: "Janet".to_string(), phone: 555_666_7777 };
-//! let person2 = Person { id: 5, name: "Bob".to_string(), phone: 555_666_7777 };
-//!
-//! assert!(hash::hash(&person1) == hash::hash(&person2));
-//! ```
-
-#![experimental]
-
-pub use core::hash::{Hash, Hasher, Writer, hash, sip};
-
-use core::marker::Sized;
-use default::Default;
-use rand::Rng;
-use rand;
-
-/// `RandomSipHasher` computes the SipHash algorithm from a stream of bytes
-/// initialized with random keys.
-#[derive(Clone)]
-pub struct RandomSipHasher {
-    hasher: sip::SipHasher,
-}
-
-impl RandomSipHasher {
-    /// Construct a new `RandomSipHasher` that is initialized with random keys.
-    #[inline]
-    pub fn new() -> RandomSipHasher {
-        let mut r = rand::thread_rng();
-        let r0 = r.gen();
-        let r1 = r.gen();
-        RandomSipHasher {
-            hasher: sip::SipHasher::new_with_keys(r0, r1),
-        }
-    }
-}
-
-impl Hasher<sip::SipState> for RandomSipHasher {
-    #[inline]
-    fn hash<T: ?Sized + Hash<sip::SipState>>(&self, value: &T) -> u64 {
-        self.hasher.hash(value)
-    }
-}
-
-#[stable]
-impl Default for RandomSipHasher {
-    #[stable]
-    #[inline]
-    fn default() -> RandomSipHasher {
-        RandomSipHasher::new()
-    }
-}
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 74c503e6f2ba8..ba13bd05dc5dc 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -15,7 +15,7 @@
 use cmp;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::{IteratorExt, ExactSizeIterator};
-use ops::{Drop, Index};
+use ops::Drop;
 use option::Option;
 use option::Option::{Some, None};
 use result::Result::Ok;
@@ -97,7 +97,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
             self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
             self.pos = 0;
         }
-        Ok(self.buf.index(&(self.pos..self.cap)))
+        Ok(&self.buf[self.pos..self.cap])
     }
 
     fn consume(&mut self, amt: uint) {
@@ -114,7 +114,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
         let nread = {
             let available = try!(self.fill_buf());
             let nread = cmp::min(available.len(), buf.len());
-            slice::bytes::copy_memory(buf, available.index(&(0..nread)));
+            slice::bytes::copy_memory(buf, &available[0..nread]);
             nread
         };
         self.pos += nread;
@@ -168,7 +168,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos)));
+            let ret = self.inner.as_mut().unwrap().write(&self.buf[0..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -260,9 +260,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == b'\n') {
             Some(i) => {
-                try!(self.inner.write(buf.index(&(0..(i + 1)))));
+                try!(self.inner.write(&buf[0..(i + 1)]));
                 try!(self.inner.flush());
-                try!(self.inner.write(buf.index(&((i + 1)..))));
+                try!(self.inner.write(&buf[(i + 1)..]));
                 Ok(())
             }
             None => self.inner.write(buf),
@@ -510,7 +510,7 @@ mod test {
         assert_eq!(a, &w.get_ref()[]);
         let w = w.into_inner();
         let a: &[_] = &[0, 1];
-        assert_eq!(a, w.index(&FullRange));
+        assert_eq!(a, &w[]);
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -607,14 +607,14 @@ mod test {
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &buf[]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &buf[]);
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index bce097e17ef0f..b578f4d5adcba 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -13,7 +13,6 @@ use cmp;
 use sync::mpsc::{Sender, Receiver};
 use io;
 use option::Option::{None, Some};
-use ops::Index;
 use result::Result::{Ok, Err};
 use slice::{bytes, SliceExt};
 use super::{Buffer, Reader, Writer, IoResult};
@@ -91,7 +90,7 @@ impl Reader for ChanReader {
                 Some(src) => {
                     let dst = buf.slice_from_mut(num_read);
                     let count = cmp::min(src.len(), dst.len());
-                    bytes::copy_memory(dst, src.index(&(0..count)));
+                    bytes::copy_memory(dst, &src[0..count]);
                     count
                 },
                 None => 0,
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index eadca8e42e550..dbccc81c4cc72 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -889,7 +889,7 @@ mod test {
             let mut read_buf = [0; 1028];
             let read_str = match check!(read_stream.read(&mut read_buf)) {
                 -1|0 => panic!("shouldn't happen"),
-                n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string()
+                n => str::from_utf8(&read_buf[0..n]).unwrap().to_string()
             };
             assert_eq!(read_str.as_slice(), message);
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 9a6ad04fdbc3e..c5e289398e046 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -13,7 +13,6 @@
 //! Readers and Writers for in-memory buffers
 
 use cmp::min;
-use ops::Index;
 use option::Option::None;
 use result::Result::{Err, Ok};
 use io;
@@ -160,7 +159,7 @@ impl Reader for MemReader {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -188,7 +187,7 @@ impl Buffer for MemReader {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -205,7 +204,7 @@ impl<'a> Reader for &'a [u8] {
 
         let write_len = min(buf.len(), self.len());
         {
-            let input = self.index(&(0..write_len));
+            let input = &self[0..write_len];
             let output = buf.slice_to_mut(write_len);
             slice::bytes::copy_memory(output, input);
         }
@@ -228,7 +227,7 @@ impl<'a> Buffer for &'a [u8] {
 
     #[inline]
     fn consume(&mut self, amt: uint) {
-        *self = self.index(&(amt..));
+        *self = &self[amt..];
     }
 }
 
@@ -287,7 +286,7 @@ impl<'a> Writer for BufWriter<'a> {
 
             Ok(())
         } else {
-            slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
+            slice::bytes::copy_memory(dst, &src[0..dst_len]);
 
             self.pos += dst_len;
 
@@ -350,7 +349,7 @@ impl<'a> Reader for BufReader<'a> {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -378,7 +377,7 @@ impl<'a> Buffer for BufReader<'a> {
     #[inline]
     fn fill_buf(&mut self) -> IoResult<&[u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -393,7 +392,7 @@ mod test {
     extern crate "test" as test_crate;
     use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
     use prelude::v1::{Ok, Err, range,  Vec, Buffer,  AsSlice, SliceExt};
-    use prelude::v1::{IteratorExt, Index};
+    use prelude::v1::IteratorExt;
     use io;
     use iter::repeat;
     use self::test_crate::Bencher;
@@ -499,7 +498,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -525,7 +524,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = &mut in_buf.as_slice();
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -552,7 +551,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 9ef9081bc3c84..1c48b20c4447f 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -236,7 +236,7 @@ use int;
 use iter::{Iterator, IteratorExt};
 use marker::Sized;
 use mem::transmute;
-use ops::{FnOnce, Index};
+use ops::FnOnce;
 use option::Option;
 use option::Option::{Some, None};
 use os;
@@ -1069,7 +1069,7 @@ pub trait Writer {
     fn write_char(&mut self, c: char) -> IoResult<()> {
         let mut buf = [0u8; 4];
         let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        self.write(buf.index(&(0..n)))
+        self.write(&buf[0..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1284,7 +1284,7 @@ impl<'a> Writer for &'a mut (Writer+'a) {
 ///     process_input(tee);
 /// }
 ///
-/// println!("input processed: {}", output);
+/// println!("input processed: {:?}", output);
 /// # }
 /// ```
 pub struct RefWriter<'a, W:'a> {
@@ -1454,7 +1454,7 @@ pub trait Buffer: Reader {
                 };
                 match available.iter().position(|&b| b == byte) {
                     Some(i) => {
-                        res.push_all(available.index(&(0..(i + 1))));
+                        res.push_all(&available[0..(i + 1)]);
                         used = i + 1;
                         break
                     }
@@ -1493,7 +1493,7 @@ pub trait Buffer: Reader {
                 }
             }
         }
-        match str::from_utf8(buf.index(&(0..width))).ok() {
+        match str::from_utf8(&buf[0..width]).ok() {
             Some(s) => Ok(s.char_at(0)),
             None => Err(standard_error(InvalidInput))
         }
@@ -1783,9 +1783,8 @@ pub struct UnstableFileStat {
 }
 
 
-// NOTE(stage0): change this one last #[doc=..] to /// after the next snapshot
 bitflags! {
-    #[doc = "A set of permissions for a file or directory is represented by a set of"]
+    /// A set of permissions for a file or directory is represented by a set of
     /// flags which are or'd together.
     flags FilePermission: u32 {
         const USER_READ     = 0o400,
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index b9f653f86c2b0..d09afea94dcc1 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -22,7 +22,7 @@ use fmt;
 use io::{self, IoResult, IoError};
 use io::net;
 use iter::{Iterator, IteratorExt};
-use ops::{FnOnce, FnMut, Index};
+use ops::{FnOnce, FnMut};
 use option::Option;
 use option::Option::{None, Some};
 use result::Result::{Ok, Err};
@@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
 
         let mut tail = [0u16; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
-        Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size))))
+        Some(ipv6_addr_from_head_tail(&head[0..head_size], &tail[0..tail_size]))
     }
 
     fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index 55df6330dd33c..f824d82160125 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -34,7 +34,7 @@ use sys::process::Process as ProcessImp;
 use sys;
 use thread::Thread;
 
-#[cfg(windows)] use std::hash::sip::SipState;
+#[cfg(windows)] use hash;
 #[cfg(windows)] use str;
 
 /// Signal a process to exit, without forcibly killing it. Corresponds to
@@ -98,7 +98,7 @@ pub struct Process {
 /// A representation of environment variable name
 /// It compares case-insensitive on Windows and case-sensitive everywhere else.
 #[cfg(not(windows))]
-#[derive(PartialEq, Eq, Hash, Clone, Show)]
+#[derive(Hash, PartialEq, Eq, Clone, Show)]
 struct EnvKey(CString);
 
 #[doc(hidden)]
@@ -107,8 +107,8 @@ struct EnvKey(CString);
 struct EnvKey(CString);
 
 #[cfg(windows)]
-impl Hash for EnvKey {
-    fn hash(&self, state: &mut SipState) {
+impl<H: hash::Writer + hash::Hasher> hash::Hash<H> for EnvKey {
+    fn hash(&self, state: &mut H) {
         let &EnvKey(ref x) = self;
         match str::from_utf8(x.as_bytes()) {
             Ok(s) => for ch in s.chars() {
@@ -395,13 +395,6 @@ impl Command {
     }
 }
 
-#[cfg(stage0)]
-impl fmt::Show for Command {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for Command {
     /// Format the program and arguments of a Command for display. Any
     /// non-utf8 data is lossily converted using the utf8 replacement
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index c0254a3e7a205..5a7219495f562 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> {
 impl<R: Buffer> Buffer for LimitReader<R> {
     fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
         let amt = try!(self.inner.fill_buf());
-        let buf = amt.index(&(0..cmp::min(amt.len(), self.limit)));
+        let buf = &amt[0..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
@@ -220,7 +220,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         self.reader.read(buf).and_then(|len| {
-            self.writer.write(buf.index_mut(&(0..len))).map(|()| len)
+            self.writer.write(&mut buf[0..len]).map(|()| len)
         })
     }
 }
@@ -234,7 +234,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        try!(w.write(buf.index(&(0..len))));
+        try!(w.write(&buf[0..len]));
     }
 }
 
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index eef5bdb60eeaa..71221a654e8c1 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -96,6 +96,7 @@
 
 #![crate_name = "std"]
 #![stable]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -107,8 +108,8 @@
 #![feature(linkage, thread_local, asm)]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(slicing_syntax, unboxed_closures)]
+#![feature(box_syntax)]
 #![feature(old_impl_check)]
-#![cfg_attr(stage0, allow(unused_attributes))]
 
 // Don't link to std. We are std.
 #![no_std]
@@ -120,8 +121,7 @@
 extern crate log;
 
 #[macro_use]
-#[macro_reexport(assert, assert_eq, debug_assert, debug_assert_eq,
-                 unreachable, unimplemented, write, writeln)]
+#[macro_reexport(write, writeln)]
 extern crate core;
 
 #[macro_use]
@@ -150,9 +150,9 @@ pub use core::clone;
 #[cfg(not(test))] pub use core::cmp;
 pub use core::default;
 pub use core::finally;
+pub use core::hash;
 pub use core::intrinsics;
 pub use core::iter;
-#[cfg(stage0)] #[cfg(not(test))] pub use core::marker as kinds;
 #[cfg(not(test))] pub use core::marker;
 pub use core::mem;
 #[cfg(not(test))] pub use core::ops;
@@ -176,7 +176,7 @@ pub use unicode::char;
 /* Exported macros */
 
 #[macro_use]
-pub mod macros;
+mod macros;
 
 #[macro_use]
 pub mod bitflags;
@@ -203,12 +203,14 @@ mod int_macros;
 mod uint_macros;
 
 #[path = "num/int.rs"]  pub mod int;
+#[path = "num/isize.rs"]  pub mod isize;
 #[path = "num/i8.rs"]   pub mod i8;
 #[path = "num/i16.rs"]  pub mod i16;
 #[path = "num/i32.rs"]  pub mod i32;
 #[path = "num/i64.rs"]  pub mod i64;
 
 #[path = "num/uint.rs"] pub mod uint;
+#[path = "num/usize.rs"] pub mod usize;
 #[path = "num/u8.rs"]   pub mod u8;
 #[path = "num/u16.rs"]  pub mod u16;
 #[path = "num/u32.rs"]  pub mod u32;
@@ -242,7 +244,6 @@ pub mod time;
 /* Common data structures */
 
 pub mod collections;
-pub mod hash;
 
 /* Threads and communication */
 
@@ -274,6 +275,7 @@ mod std {
     pub use clone;
     pub use cmp;
     pub use hash;
+    pub use default;
 
     pub use sync; // used for select!()
     pub use error; // used for try!()
@@ -284,8 +286,6 @@ mod std {
     pub use vec; // used for vec![]
     pub use cell; // used for tls!
     pub use thread_local; // used for thread_local!
-    #[cfg(stage0)]
-    pub use marker as kinds;
     pub use marker;  // used for tls!
     pub use ops; // used for bitflags!
 
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index befdc156094d1..0594b711ad62e 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -36,23 +36,27 @@
 /// panic!("this is a {} {message}", "fancy", message = "message");
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! panic {
     () => ({
         panic!("explicit panic")
     });
     ($msg:expr) => ({
-        // static requires less code at runtime, more constant data
-        static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-        ::std::rt::begin_unwind($msg, &_FILE_LINE)
+        $crate::rt::begin_unwind($msg, {
+            // static requires less code at runtime, more constant data
+            static _FILE_LINE: (&'static str, uint) = (file!(), line!());
+            &_FILE_LINE
+        })
     });
-    ($fmt:expr, $($arg:tt)*) => ({
-        // The leading _'s are to avoid dead code warnings if this is
-        // used inside a dead function. Just `#[allow(dead_code)]` is
-        // insufficient, since the user may have
-        // `#[forbid(dead_code)]` and which cannot be overridden.
-        static _FILE_LINE: (&'static str, uint) = (file!(), line!());
-        ::std::rt::begin_unwind_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE)
-
+    ($fmt:expr, $($arg:tt)+) => ({
+        $crate::rt::begin_unwind_fmt(format_args!($fmt, $($arg)+), {
+            // The leading _'s are to avoid dead code warnings if this is
+            // used inside a dead function. Just `#[allow(dead_code)]` is
+            // insufficient, since the user may have
+            // `#[forbid(dead_code)]` and which cannot be overridden.
+            static _FILE_LINE: (&'static str, uint) = (file!(), line!());
+            &_FILE_LINE
+        })
     });
 }
 
@@ -77,15 +81,16 @@ macro_rules! panic {
 /// assert!(a + b == 30, "a = {}, b = {}", a, b);
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! assert {
     ($cond:expr) => (
         if !$cond {
             panic!(concat!("assertion failed: ", stringify!($cond)))
         }
     );
-    ($cond:expr, $($arg:expr),+) => (
+    ($cond:expr, $($arg:tt)+) => (
         if !$cond {
-            panic!($($arg),+)
+            panic!($($arg)+)
         }
     );
 }
@@ -103,6 +108,7 @@ macro_rules! assert {
 /// assert_eq!(a, b);
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! assert_eq {
     ($left:expr , $right:expr) => ({
         match (&($left), &($right)) {
@@ -144,6 +150,7 @@ macro_rules! assert_eq {
 /// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);
 /// ```
 #[macro_export]
+#[stable]
 macro_rules! debug_assert {
     ($($arg:tt)*) => (if cfg!(not(ndebug)) { assert!($($arg)*); })
 }
@@ -210,6 +217,7 @@ macro_rules! debug_assert_eq {
 /// }
 /// ```
 #[macro_export]
+#[unstable = "relationship with panic is unclear"]
 macro_rules! unreachable {
     () => ({
         panic!("internal error: entered unreachable code")
@@ -225,6 +233,7 @@ macro_rules! unreachable {
 /// A standardised placeholder for marking unfinished code. It panics with the
 /// message `"not yet implemented"` when executed.
 #[macro_export]
+#[unstable = "relationship with panic is unclear"]
 macro_rules! unimplemented {
     () => (panic!("not yet implemented"))
 }
@@ -242,7 +251,7 @@ macro_rules! unimplemented {
 #[macro_export]
 #[stable]
 macro_rules! format {
-    ($($arg:tt)*) => (::std::fmt::format(format_args!($($arg)*)))
+    ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*)))
 }
 
 /// Equivalent to the `println!` macro except that a newline is not printed at
@@ -250,7 +259,7 @@ macro_rules! format {
 #[macro_export]
 #[stable]
 macro_rules! print {
-    ($($arg:tt)*) => (::std::io::stdio::print_args(format_args!($($arg)*)))
+    ($($arg:tt)*) => ($crate::io::stdio::print_args(format_args!($($arg)*)))
 }
 
 /// Macro for printing to a task's stdout handle.
@@ -268,20 +277,19 @@ macro_rules! print {
 #[macro_export]
 #[stable]
 macro_rules! println {
-    ($($arg:tt)*) => (::std::io::stdio::println_args(format_args!($($arg)*)))
+    ($($arg:tt)*) => ($crate::io::stdio::println_args(format_args!($($arg)*)))
 }
 
 /// Helper macro for unwrapping `Result` values while returning early with an
 /// error if the value of the expression is `Err`. For more information, see
 /// `std::io`.
 #[macro_export]
+#[stable]
 macro_rules! try {
-    ($expr:expr) => ({
-        use $crate::result::Result::{Ok, Err};
-
-        match $expr {
-            Ok(val) => val,
-            Err(err) => return Err($crate::error::FromError::from_error(err)),
+    ($expr:expr) => (match $expr {
+        $crate::result::Result::Ok(val) => val,
+        $crate::result::Result::Err(err) => {
+            return $crate::result::Result::Err($crate::error::FromError::from_error(err))
         }
     })
 }
@@ -412,26 +420,6 @@ pub mod builtin {
     #[macro_export]
     macro_rules! option_env { ($name:expr) => ({ /* compiler built-in */ }) }
 
-    /// Concatenate literals into a static byte slice.
-    ///
-    /// This macro takes any number of comma-separated literal expressions,
-    /// yielding an expression of type `&'static [u8]` which is the
-    /// concatenation (left to right) of all the literals in their byte format.
-    ///
-    /// This extension currently only supports string literals, character
-    /// literals, and integers less than 256. The byte slice returned is the
-    /// utf8-encoding of strings and characters.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let rust = bytes!("r", 'u', "st", 255);
-    /// assert_eq!(rust[1], b'u');
-    /// assert_eq!(rust[4], 255);
-    /// ```
-    #[macro_export]
-    macro_rules! bytes { ($($e:expr),*) => ({ /* compiler built-in */ }) }
-
     /// Concatenate identifiers into one identifier.
     ///
     /// This macro takes any number of comma-separated identifiers, and
@@ -565,10 +553,6 @@ pub mod builtin {
     #[macro_export]
     macro_rules! include_bytes { ($file:expr) => ({ /* compiler built-in */ }) }
 
-    /// Deprecated alias for `include_bytes!()`.
-    #[macro_export]
-    macro_rules! include_bin { ($file:expr) => ({ /* compiler built-in */}) }
-
     /// Expands to a string that represents the current module path.
     ///
     /// The current module path can be thought of as the hierarchy of modules
diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs
index 9ccb1544fdc66..69439f85115fa 100644
--- a/src/libstd/num/int.rs
+++ b/src/libstd/num/int.rs
@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized signed integers (`int` type)
+//! Deprecated: replaced by `isize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "int")]
+#![deprecated = "replaced by isize"]
 
 pub use core::int::{BITS, BYTES, MIN, MAX};
 
diff --git a/src/libstd/num/isize.rs b/src/libstd/num/isize.rs
new file mode 100644
index 0000000000000..22395a1c0ff5d
--- /dev/null
+++ b/src/libstd/num/isize.rs
@@ -0,0 +1,22 @@
+// Copyright 2012-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.
+
+//! Operations and constants for pointer-sized signed integers (`isize` type)
+//!
+//! This type was recently added to replace `int`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "isize")]
+
+pub use core::isize::{BITS, BYTES, MIN, MAX};
+
+int_module! { isize }
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index f433cd1e66481..9c6911cf4d14a 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -424,12 +424,14 @@ mod tests {
         assert_eq!(int::MIN.to_u32(),  None);
         assert_eq!(int::MIN.to_u64(),  None);
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32));
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(int::MIN.to_i32(), None);
         }
@@ -492,12 +494,14 @@ mod tests {
         assert_eq!(i64::MIN.to_u32(),  None);
         assert_eq!(i64::MIN.to_u64(),  None);
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(i64::MIN.to_int(), None);
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int));
         }
@@ -517,13 +521,15 @@ mod tests {
         // int::MAX.to_u32() is word-size specific
         assert_eq!(int::MAX.to_u64(),  Some(int::MAX as u64));
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32));
             assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32));
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(int::MAX.to_i32(), None);
             assert_eq!(int::MAX.to_u32(), None);
@@ -587,13 +593,15 @@ mod tests {
         assert_eq!(i64::MAX.to_u32(),  None);
         assert_eq!(i64::MAX.to_u64(),  Some(i64::MAX as u64));
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(i64::MAX.to_int(),  None);
             assert_eq!(i64::MAX.to_uint(), None);
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(i64::MAX.to_int(),  Some(i64::MAX as int));
             assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint));
@@ -684,13 +692,15 @@ mod tests {
         // uint::MAX.to_u32() is word-size specific
         assert_eq!(uint::MAX.to_u64(),  Some(uint::MAX as u64));
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32));
             assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64));
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(uint::MAX.to_u32(), None);
             assert_eq!(uint::MAX.to_i64(), None);
@@ -740,12 +750,14 @@ mod tests {
         assert_eq!(u32::MAX.to_u32(),  Some(u32::MAX as u32));
         assert_eq!(u32::MAX.to_u64(),  Some(u32::MAX as u64));
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(u32::MAX.to_int(),  None);
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(u32::MAX.to_int(),  Some(u32::MAX as int));
         }
@@ -766,12 +778,14 @@ mod tests {
         assert_eq!(u64::MAX.to_u32(),  None);
         assert_eq!(u64::MAX.to_u64(),  Some(u64::MAX as u64));
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         fn check_word_size() {
             assert_eq!(u64::MAX.to_uint(), None);
         }
 
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         fn check_word_size() {
             assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint));
         }
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 0fbc0953b20a2..0e12eff205ffd 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -8,10 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Operations and constants for architecture-sized unsigned integers (`uint` type)
+//! Deprecated: replaced by `usize`.
+//!
+//! The rollout of the new type will gradually take place over the
+//! alpha cycle along with the development of clearer conventions
+//! around integer types.
 
-#![stable]
-#![doc(primitive = "uint")]
+#![deprecated = "replaced by usize"]
 
 pub use core::uint::{BITS, BYTES, MIN, MAX};
 
diff --git a/src/libstd/num/usize.rs b/src/libstd/num/usize.rs
new file mode 100644
index 0000000000000..74dd38e13c582
--- /dev/null
+++ b/src/libstd/num/usize.rs
@@ -0,0 +1,22 @@
+// Copyright 2012-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.
+
+//! Operations and constants for pointer-sized unsigned integers (`usize` type)
+//!
+//! This type was recently added to replace `uint`. The rollout of the
+//! new type will gradually take place over the alpha cycle along with
+//! the development of clearer conventions around integer types.
+
+#![stable]
+#![doc(primitive = "usize")]
+
+pub use core::usize::{BITS, BYTES, MIN, MAX};
+
+uint_module! { usize }
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 581969e98fb8b..b474ae4e37195 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,7 +68,7 @@ use fmt;
 use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
-use ops::{FullRange, Index};
+use ops::FullRange;
 use str;
 use str::StrExt;
 use string::{String, CowString};
@@ -352,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => name,
                     Some(1) if name == b".." => name,
-                    Some(pos) => name.index(&(0..pos))
+                    Some(pos) => &name[0..pos]
                 }
             })
         }
@@ -399,7 +399,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => None,
                     Some(1) if name == b".." => None,
-                    Some(pos) => Some(name.index(&((pos+1)..)))
+                    Some(pos) => Some(&name[(pos+1)..])
                 }
             }
         }
@@ -475,7 +475,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             let extlen = extension.container_as_bytes().len();
             match (name.rposition_elem(&dot), extlen) {
                 (None, 0) | (Some(0), 0) => None,
-                (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()),
+                (Some(idx), 0) => Some(name[0..idx].to_vec()),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
@@ -484,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 
                     let mut v;
                     v = Vec::with_capacity(idx + extlen + 1);
-                    v.push_all(name.index(&(0..idx)));
+                    v.push_all(&name[0..idx]);
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
                     Some(v)
@@ -823,7 +823,6 @@ pub struct Display<'a, P:'a> {
     filename: bool
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
 impl<'a, P: GenericPath> fmt::Show for Display<'a, P> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -877,7 +876,7 @@ impl BytesContainer for String {
     }
     #[inline]
     fn container_as_str(&self) -> Option<&str> {
-        Some(self.index(&FullRange))
+        Some(&self[])
     }
     #[inline]
     fn is_str(_: Option<&String>) -> bool { true }
@@ -893,7 +892,7 @@ impl BytesContainer for [u8] {
 impl BytesContainer for Vec<u8> {
     #[inline]
     fn container_as_bytes(&self) -> &[u8] {
-        self.index(&FullRange)
+        &self[]
     }
 }
 
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 0b7dc19fcab4e..293696d5ccada 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -17,7 +17,6 @@ use hash;
 use io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
-use ops::Index;
 use marker::Sized;
 use option::Option::{self, Some, None};
 use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
@@ -60,7 +59,7 @@ pub fn is_sep(c: char) -> bool {
 
 impl fmt::Show for Path {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Path {{ {} }}", self.display())
+        fmt::Show::fmt(&self.display(), f)
     }
 }
 
@@ -91,7 +90,7 @@ impl FromStr for Path {
     }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for Path {
+impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Path {
     #[inline]
     fn hash(&self, state: &mut S) {
         self.repr.hash(state)
@@ -127,7 +126,7 @@ impl GenericPathUnsafe for Path {
             None => {
                 self.repr = Path::normalize(filename);
             }
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => {
+            Some(idx) if &self.repr[(idx+1)..] == b".." => {
                 let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
                 v.push_all(self.repr.as_slice());
                 v.push(SEP_BYTE);
@@ -137,7 +136,7 @@ impl GenericPathUnsafe for Path {
             }
             Some(idx) => {
                 let mut v = Vec::with_capacity(idx + 1 + filename.len());
-                v.push_all(self.repr.index(&(0..(idx+1))));
+                v.push_all(&self.repr[0..(idx+1)]);
                 v.push_all(filename);
                 // FIXME: this is slow
                 self.repr = Path::normalize(v.as_slice());
@@ -178,9 +177,9 @@ impl GenericPath for Path {
         match self.sepidx {
             None if b".." == self.repr => self.repr.as_slice(),
             None => dot_static,
-            Some(0) => self.repr.index(&(0..1)),
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(),
-            Some(idx) => self.repr.index(&(0..idx))
+            Some(0) => &self.repr[0..1],
+            Some(idx) if &self.repr[(idx+1)..] == b".." => self.repr.as_slice(),
+            Some(idx) => &self.repr[0..idx]
         }
     }
 
@@ -189,9 +188,9 @@ impl GenericPath for Path {
             None if b"." == self.repr ||
                 b".." == self.repr => None,
             None => Some(self.repr.as_slice()),
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None,
-            Some(0) if self.repr.index(&(1..)).is_empty() => None,
-            Some(idx) => Some(self.repr.index(&((idx+1)..)))
+            Some(idx) if &self.repr[(idx+1)..] == b".." => None,
+            Some(0) if self.repr[1..].is_empty() => None,
+            Some(idx) => Some(&self.repr[(idx+1)..])
         }
     }
 
@@ -333,7 +332,7 @@ impl Path {
         // borrowck is being very picky
         let val = {
             let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
-            let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() };
+            let v_ = if is_abs { &v.as_slice()[1..] } else { v.as_slice() };
             let comps = normalize_helper(v_, is_abs);
             match comps {
                 None => None,
@@ -372,7 +371,7 @@ impl Path {
     /// A path of "/" yields no components. A path of "." yields one component.
     pub fn components<'a>(&'a self) -> Components<'a> {
         let v = if self.repr[0] == SEP_BYTE {
-            self.repr.index(&(1..))
+            &self.repr[1..]
         } else { self.repr.as_slice() };
         let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr
         let mut ret = v.split(is_sep_byte);
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 5c4e7aa9ac27b..2a1f1794e49e7 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -25,7 +25,7 @@ use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option::{self, Some, None};
-use ops::{FullRange, Index};
+use ops::FullRange;
 use slice::{SliceExt, SliceConcatExt};
 use str::{SplitTerminator, FromStr, StrExt};
 use string::{String, ToString};
@@ -87,7 +87,7 @@ pub struct Path {
 
 impl fmt::Show for Path {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Path {{ {} }}", self.display())
+        fmt::Show::fmt(&self.display(), f)
     }
 }
 
@@ -118,7 +118,7 @@ impl FromStr for Path {
     }
 }
 
-impl<S: hash::Writer> hash::Hash<S> for Path {
+impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for Path {
     #[cfg(not(test))]
     #[inline]
     fn hash(&self, state: &mut S) {
@@ -173,30 +173,30 @@ impl GenericPathUnsafe for Path {
                 s.push_str("..");
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             None => {
                 self.update_normalized(filename);
             }
-            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
+            Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
                 let mut s = String::with_capacity(end + 1 + filename.len());
-                s.push_str(self.repr.index(&(0..end)));
+                s.push_str(&self.repr[0..end]);
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
                 let mut s = String::with_capacity(idxb + filename.len());
-                s.push_str(self.repr.index(&(0..idxb)));
+                s.push_str(&self.repr[0..idxb]);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             Some((idxb,_,_)) => {
                 let mut s = String::with_capacity(idxb + 1 + filename.len());
-                s.push_str(self.repr.index(&(0..idxb)));
+                s.push_str(&self.repr[0..idxb]);
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
         }
     }
@@ -215,12 +215,12 @@ impl GenericPathUnsafe for Path {
         let path = path.container_as_str().unwrap();
         fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
             // assume prefix is Some(DiskPrefix)
-            let rest = path.index(&(prefix_len(prefix)..));
+            let rest = &path[prefix_len(prefix)..];
             !rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
         }
         fn shares_volume(me: &Path, path: &str) -> bool {
             // path is assumed to have a prefix of Some(DiskPrefix)
-            let repr = me.repr.index(&FullRange);
+            let repr = &me.repr[];
             match me.prefix {
                 Some(DiskPrefix) => {
                     repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
@@ -252,7 +252,7 @@ impl GenericPathUnsafe for Path {
                         else { None };
             let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
             let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
-            s.push_str(me.repr.index(&FullRange));
+            s.push_str(&me.repr[]);
             let plen = me.prefix_len();
             // if me is "C:" we don't want to add a path separator
             match me.prefix {
@@ -264,9 +264,9 @@ impl GenericPathUnsafe for Path {
             }
             match path_ {
                 None => s.push_str(path),
-                Some(p) => s.push_str(p.index(&FullRange)),
+                Some(p) => s.push_str(&p[]),
             };
-            me.update_normalized(s.index(&FullRange))
+            me.update_normalized(&s[])
         }
 
         if !path.is_empty() {
@@ -274,7 +274,7 @@ impl GenericPathUnsafe for Path {
             match prefix {
                 Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
                     // cwd-relative path, self is on the same volume
-                    append_path(self, path.index(&(prefix_len(prefix)..)));
+                    append_path(self, &path[prefix_len(prefix)..]);
                 }
                 Some(_) => {
                     // absolute path, or cwd-relative and self is not same volume
@@ -320,7 +320,7 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     #[inline]
     fn as_str<'a>(&'a self) -> Option<&'a str> {
-        Some(self.repr.index(&FullRange))
+        Some(&self.repr[])
     }
 
     #[inline]
@@ -342,21 +342,21 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     fn dirname_str<'a>(&'a self) -> Option<&'a str> {
         Some(match self.sepidx_or_prefix_len() {
-            None if ".." == self.repr => self.repr.index(&FullRange),
+            None if ".." == self.repr => &self.repr[],
             None => ".",
-            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
-                self.repr.index(&FullRange)
+            Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
+                &self.repr[]
             }
-            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => {
-                self.repr.index(&FullRange)
+            Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => {
+                &self.repr[]
             }
-            Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
+            Some((0,idxa,_)) => &self.repr[0..idxa],
             Some((idxb,idxa,_)) => {
                 match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
-                        self.repr.index(&(0..idxa))
+                        &self.repr[0..idxa]
                     }
-                    _ => self.repr.index(&(0..idxb))
+                    _ => &self.repr[0..idxb]
                 }
             }
         })
@@ -370,13 +370,13 @@ impl GenericPath for Path {
     /// See `GenericPath::filename_str` for info.
     /// Always returns a `Some` value if `filename` returns a `Some` value.
     fn filename_str<'a>(&'a self) -> Option<&'a str> {
-        let repr = self.repr.index(&FullRange);
+        let repr = &self.repr[];
         match self.sepidx_or_prefix_len() {
             None if "." == repr || ".." == repr => None,
             None => Some(repr),
-            Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
+            Some((_,idxa,end)) if &repr[idxa..end] == ".." => None,
             Some((_,idxa,end)) if idxa == end => None,
-            Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
+            Some((_,idxa,end)) => Some(&repr[idxa..end])
         }
     }
 
@@ -408,7 +408,7 @@ impl GenericPath for Path {
                 true
             }
             Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
-            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
+            Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => false,
             Some((idxb,idxa,_)) => {
                 let trunc = match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
@@ -428,15 +428,15 @@ impl GenericPath for Path {
         if self.prefix.is_some() {
             Some(Path::new(match self.prefix {
                 Some(DiskPrefix) if self.is_absolute() => {
-                    self.repr.index(&(0..(self.prefix_len()+1)))
+                    &self.repr[0..(self.prefix_len()+1)]
                 }
                 Some(VerbatimDiskPrefix) => {
-                    self.repr.index(&(0..(self.prefix_len()+1)))
+                    &self.repr[0..(self.prefix_len()+1)]
                 }
-                _ => self.repr.index(&(0..self.prefix_len()))
+                _ => &self.repr[0..self.prefix_len()]
             }))
         } else if is_vol_relative(self) {
-            Some(Path::new(self.repr.index(&(0..1))))
+            Some(Path::new(&self.repr[0..1]))
         } else {
             None
         }
@@ -455,7 +455,7 @@ impl GenericPath for Path {
     fn is_absolute(&self) -> bool {
         match self.prefix {
             Some(DiskPrefix) => {
-                let rest = self.repr.index(&(self.prefix_len()..));
+                let rest = &self.repr[self.prefix_len()..];
                 rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
             }
             Some(_) => true,
@@ -630,15 +630,15 @@ impl Path {
     /// Does not distinguish between absolute and cwd-relative paths, e.g.
     /// C:\foo and C:foo.
     pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
-        let repr = self.repr.index(&FullRange);
+        let repr = &self.repr[];
         let s = match self.prefix {
             Some(_) => {
                 let plen = self.prefix_len();
                 if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
-                    repr.index(&((plen+1)..))
-                } else { repr.index(&(plen..)) }
+                    &repr[(plen+1)..]
+                } else { &repr[plen..] }
             }
-            None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
+            None if repr.as_bytes()[0] == SEP_BYTE => &repr[1..],
             None => repr
         };
         let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
@@ -658,8 +658,8 @@ impl Path {
     }
 
     fn equiv_prefix(&self, other: &Path) -> bool {
-        let s_repr = self.repr.index(&FullRange);
-        let o_repr = other.repr.index(&FullRange);
+        let s_repr = &self.repr[];
+        let o_repr = &other.repr[];
         match (self.prefix, other.prefix) {
             (Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
                 self.is_absolute() &&
@@ -676,14 +676,14 @@ impl Path {
                     o_repr.as_bytes()[4].to_ascii_lowercase()
             }
             (Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
-                s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
+                &s_repr[2..self.prefix_len()] == &o_repr[8..other.prefix_len()]
             }
             (Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
-                s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
+                &s_repr[8..self.prefix_len()] == &o_repr[2..other.prefix_len()]
             }
             (None, None) => true,
             (a, b) if a == b => {
-                s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
+                &s_repr[0..self.prefix_len()] == &o_repr[0..other.prefix_len()]
             }
             _ => false
         }
@@ -737,7 +737,7 @@ impl Path {
                         match prefix.unwrap() {
                             DiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s.index(&(0..len)));
+                                let mut s = String::from_str(&s[0..len]);
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[0] = (*v)[0].to_ascii_uppercase();
@@ -752,7 +752,7 @@ impl Path {
                             }
                             VerbatimDiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s.index(&(0..len)));
+                                let mut s = String::from_str(&s[0..len]);
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[4] = (*v)[4].to_ascii_uppercase();
@@ -762,14 +762,14 @@ impl Path {
                             _ => {
                                 let plen = prefix_len(prefix);
                                 if s.len() > plen {
-                                    Some(String::from_str(s.index(&(0..plen))))
+                                    Some(String::from_str(&s[0..plen]))
                                 } else { None }
                             }
                         }
                     } else if is_abs && comps.is_empty() {
                         Some(repeat(SEP).take(1).collect())
                     } else {
-                        let prefix_ = s.index(&(0..prefix_len(prefix)));
+                        let prefix_ = &s[0..prefix_len(prefix)];
                         let n = prefix_.len() +
                                 if is_abs { comps.len() } else { comps.len() - 1} +
                                 comps.iter().map(|v| v.len()).sum();
@@ -780,15 +780,15 @@ impl Path {
                                 s.push(':');
                             }
                             Some(VerbatimDiskPrefix) => {
-                                s.push_str(prefix_.index(&(0..4)));
+                                s.push_str(&prefix_[0..4]);
                                 s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
-                                s.push_str(prefix_.index(&(5..)));
+                                s.push_str(&prefix_[5..]);
                             }
                             Some(UNCPrefix(a,b)) => {
                                 s.push_str("\\\\");
-                                s.push_str(prefix_.index(&(2..(a+2))));
+                                s.push_str(&prefix_[2..(a+2)]);
                                 s.push(SEP);
-                                s.push_str(prefix_.index(&((3+a)..(3+a+b))));
+                                s.push_str(&prefix_[(3+a)..(3+a+b)]);
                             }
                             Some(_) => s.push_str(prefix_),
                             None => ()
@@ -813,8 +813,8 @@ impl Path {
 
     fn update_sepidx(&mut self) {
         let s = if self.has_nonsemantic_trailing_slash() {
-                    self.repr.index(&(0..(self.repr.len()-1)))
-                } else { self.repr.index(&FullRange) };
+                    &self.repr[0..(self.repr.len()-1)]
+                } else { &self.repr[] };
         let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
             is_sep
         } else {
@@ -893,17 +893,17 @@ pub fn is_verbatim(path: &Path) -> bool {
 /// non-verbatim, the non-verbatim version is returned.
 /// Otherwise, None is returned.
 pub fn make_non_verbatim(path: &Path) -> Option<Path> {
-    let repr = path.repr.index(&FullRange);
+    let repr = &path.repr[];
     let new_path = match path.prefix {
         Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
         Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
         Some(VerbatimDiskPrefix) => {
             // \\?\D:\
-            Path::new(repr.index(&(4..)))
+            Path::new(&repr[4..])
         }
         Some(VerbatimUNCPrefix(_,_)) => {
             // \\?\UNC\server\share
-            Path::new(format!(r"\{}", repr.index(&(7..))))
+            Path::new(format!(r"\{}", &repr[7..]))
         }
     };
     if new_path.prefix.is_none() {
@@ -912,8 +912,7 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> {
         return None;
     }
     // now ensure normalization didn't change anything
-    if repr.index(&(path.prefix_len()..)) ==
-        new_path.repr.index(&(new_path.prefix_len()..)) {
+    if &repr[path.prefix_len()..] == &new_path.repr[new_path.prefix_len()..] {
         Some(new_path)
     } else {
         None
@@ -978,13 +977,13 @@ pub enum PathPrefix {
 fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
     if path.starts_with("\\\\") {
         // \\
-        path = path.index(&(2..));
+        path = &path[2..];
         if path.starts_with("?\\") {
             // \\?\
-            path = path.index(&(2..));
+            path = &path[2..];
             if path.starts_with("UNC\\") {
                 // \\?\UNC\server\share
-                path = path.index(&(4..));
+                path = &path[4..];
                 let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
                     Some(x) => x,
                     None => (path.len(), 0)
@@ -1005,7 +1004,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             }
         } else if path.starts_with(".\\") {
             // \\.\path
-            path = path.index(&(2..));
+            path = &path[2..];
             let idx = path.find('\\').unwrap_or(path.len());
             return Some(DeviceNSPrefix(idx));
         }
@@ -1030,7 +1029,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             None => return None,
             Some(x) => x
         };
-        path = path.index(&((idx_a+1)..));
+        path = &path[(idx_a+1)..];
         let idx_b = path.find(f).unwrap_or(path.len());
         Some((idx_a, idx_b))
     }
@@ -1044,8 +1043,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option
         is_sep_verbatim
     };
     let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
-    let s_ = s.index(&(prefix_len(prefix)..));
-    let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
+    let s_ = &s[prefix_len(prefix)..];
+    let s_ = if is_abs { &s_[1..] } else { s_ };
 
     if is_abs && s_.is_empty() {
         return (is_abs, match prefix {
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index dcb342b9ca2c3..d9c942c018514 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -17,7 +17,7 @@
 #[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // TEMPORARY
-#[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut, FullRange};
+#[unstable] #[doc(no_inline)] pub use ops::FullRange;
 
 // Reexported functions
 #[stable] #[doc(no_inline)] pub use mem::drop;
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index d3e6cd166ecf5..3fa1efe1ccdfe 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -230,9 +230,9 @@ use rc::Rc;
 use result::Result::{Ok, Err};
 use vec::Vec;
 
-#[cfg(not(target_word_size="64"))]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 use core_rand::IsaacRng as IsaacWordRng;
-#[cfg(target_word_size="64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 use core_rand::Isaac64Rng as IsaacWordRng;
 
 pub use core_rand::{Rand, Rng, SeedableRng, Open01, Closed01};
@@ -403,7 +403,7 @@ pub fn random<T: Rand>() -> T {
 ///
 /// let mut rng = thread_rng();
 /// let sample = sample(&mut rng, range(1i, 100), 5);
-/// println!("{}", sample);
+/// println!("{:?}", sample);
 /// ```
 pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R,
                                          mut iter: I,
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index fd84f22094282..03876189da9cc 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -544,7 +544,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     // MAX_CALLBACKS, so we're sure to clamp it as necessary.
     let callbacks = {
         let amt = CALLBACK_CNT.load(Ordering::SeqCst);
-        CALLBACKS.index(&(0..cmp::min(amt, MAX_CALLBACKS)))
+        &CALLBACKS[0..cmp::min(amt, MAX_CALLBACKS)]
     };
     for cb in callbacks.iter() {
         match cb.load(Ordering::SeqCst) {
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index 59f654a95caa6..c076f0a7c6ca0 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -131,7 +131,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     impl<'a> fmt::Writer for BufWriter<'a> {
         fn write_str(&mut self, bytes: &str) -> fmt::Result {
             let left = self.buf.slice_from_mut(self.pos);
-            let to_write = bytes.as_bytes().index(&(0..cmp::min(bytes.len(), left.len())));
+            let to_write = &bytes.as_bytes()[0..cmp::min(bytes.len(), left.len())];
             slice::bytes::copy_memory(left, to_write);
             self.pos += to_write.len();
             Ok(())
@@ -142,7 +142,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     let mut msg = [0u8; 512];
     let mut w = BufWriter { buf: &mut msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
-    let msg = str::from_utf8(w.buf.index_mut(&(0..w.pos))).unwrap_or("aborted");
+    let msg = str::from_utf8(&w.buf[0..w.pos]).unwrap_or("aborted");
     let msg = if msg.is_empty() {"aborted"} else {msg};
 
     // Give some context to the message
diff --git a/src/libstd/sync/mpsc/stream.rs b/src/libstd/sync/mpsc/stream.rs
index bd1e74a33902e..f4b20c7b74235 100644
--- a/src/libstd/sync/mpsc/stream.rs
+++ b/src/libstd/sync/mpsc/stream.rs
@@ -338,7 +338,7 @@ impl<T: Send> Packet<T> {
         // upgrade pending, then go through the whole recv rigamarole to update
         // the internal state.
         match self.queue.peek() {
-            Some(&GoUp(..)) => {
+            Some(&mut GoUp(..)) => {
                 match self.recv() {
                     Err(Upgraded(port)) => Err(port),
                     _ => unreachable!(),
@@ -367,7 +367,7 @@ impl<T: Send> Packet<T> {
             Ok(()) => SelSuccess,
             Err(token) => {
                 let ret = match self.queue.peek() {
-                    Some(&GoUp(..)) => {
+                    Some(&mut GoUp(..)) => {
                         match self.queue.pop() {
                             Some(GoUp(port)) => SelUpgraded(token, port),
                             _ => unreachable!(),
@@ -457,7 +457,7 @@ impl<T: Send> Packet<T> {
         // upgraded port.
         if has_data {
             match self.queue.peek() {
-                Some(&GoUp(..)) => {
+                Some(&mut GoUp(..)) => {
                     match self.queue.pop() {
                         Some(GoUp(port)) => Err(port),
                         _ => unreachable!(),
diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs
index be44aa99f49d7..f6161ec193d52 100644
--- a/src/libstd/sys/common/backtrace.rs
+++ b/src/libstd/sys/common/backtrace.rs
@@ -12,8 +12,11 @@ use prelude::v1::*;
 
 use io::IoResult;
 
-#[cfg(target_word_size = "64")] pub const HEX_WIDTH: uint = 18;
-#[cfg(target_word_size = "32")] pub const HEX_WIDTH: uint = 10;
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
+pub const HEX_WIDTH: uint = 18;
+
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
+pub const HEX_WIDTH: uint = 10;
 
 // All rust symbols are in theory lists of "::"-separated identifiers. Some
 // assemblers, however, can't handle these characters in symbol names. To get
diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs
index 902942d7244f7..4cf891ac4985e 100644
--- a/src/libstd/sys/common/net.rs
+++ b/src/libstd/sys/common/net.rs
@@ -469,7 +469,7 @@ pub fn write<T, L, W>(fd: sock_t,
             // Also as with read(), we use MSG_DONTWAIT to guard ourselves
             // against unforeseen circumstances.
             let _guard = lock();
-            let ptr = buf.index(&(written..)).as_ptr();
+            let ptr = buf[written..].as_ptr();
             let len = buf.len() - written;
             match retry(|| write(deadline.is_some(), ptr, len)) {
                 -1 if wouldblock() => {}
diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs
index cc661877bc01e..1d523ed6eddac 100644
--- a/src/libstd/sys/unix/c.rs
+++ b/src/libstd/sys/unix/c.rs
@@ -169,13 +169,13 @@ mod signal {
     unsafe impl ::marker::Sync for sigaction { }
 
     #[repr(C)]
-    #[cfg(target_word_size = "32")]
+    #[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
     pub struct sigset_t {
         __val: [libc::c_ulong; 32],
     }
 
     #[repr(C)]
-    #[cfg(target_word_size = "64")]
+    #[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
     pub struct sigset_t {
         __val: [libc::c_ulong; 16],
     }
diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs
index 1357bbdd5a371..36bf696dba550 100644
--- a/src/libstd/sys/unix/process.rs
+++ b/src/libstd/sys/unix/process.rs
@@ -11,7 +11,8 @@
 use prelude::v1::*;
 use self::Req::*;
 
-use collections;
+use collections::HashMap;
+use collections::hash_map::Hasher;
 use ffi::CString;
 use hash::Hash;
 use io::process::{ProcessExit, ExitStatus, ExitSignal};
@@ -60,7 +61,7 @@ impl Process {
                               out_fd: Option<P>, err_fd: Option<P>)
                               -> IoResult<Process>
         where C: ProcessConfig<K, V>, P: AsInner<FileDesc>,
-              K: BytesContainer + Eq + Hash, V: BytesContainer
+              K: BytesContainer + Eq + Hash<Hasher>, V: BytesContainer
     {
         use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
         use libc::funcs::bsd44::getdtablesize;
@@ -553,11 +554,11 @@ fn with_argv<T,F>(prog: &CString, args: &[CString],
     cb(ptrs.as_ptr())
 }
 
-fn with_envp<K,V,T,F>(env: Option<&collections::HashMap<K, V>>,
+fn with_envp<K,V,T,F>(env: Option<&HashMap<K, V>>,
                       cb: F)
                       -> T
     where F : FnOnce(*const c_void) -> T,
-          K : BytesContainer + Eq + Hash,
+          K : BytesContainer + Eq + Hash<Hasher>,
           V : BytesContainer
 {
     // On posixy systems we can pass a char** for envp, which is a
diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs
index 1fd619a28db84..48a51813ba4ab 100644
--- a/src/libstd/sys/unix/stack_overflow.rs
+++ b/src/libstd/sys/unix/stack_overflow.rs
@@ -182,12 +182,14 @@ mod imp {
             sa_restorer: *mut libc::c_void,
         }
 
-        #[cfg(target_word_size = "32")]
+        #[cfg(any(all(stage0, target_word_size = "32"),
+                  all(not(stage0), target_pointer_width = "32")))]
         #[repr(C)]
         pub struct sigset_t {
             __val: [libc::c_ulong; 32],
         }
-        #[cfg(target_word_size = "64")]
+        #[cfg(any(all(stage0, target_word_size = "64"),
+                  all(not(stage0), target_pointer_width = "64")))]
         #[repr(C)]
         pub struct sigset_t {
             __val: [libc::c_ulong; 16],
diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs
index eb76f13afe721..ee2dd14955b69 100644
--- a/src/libstd/sys/windows/backtrace.rs
+++ b/src/libstd/sys/windows/backtrace.rs
@@ -362,7 +362,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> {
             let bytes = unsafe { ffi::c_str_to_bytes(&ptr) };
             match str::from_utf8(bytes) {
                 Ok(s) => try!(demangle(w, s)),
-                Err(..) => try!(w.write(bytes.index(&(..(bytes.len()-1))))),
+                Err(..) => try!(w.write(&bytes[..(bytes.len()-1)])),
             }
         }
         try!(w.write(&['\n' as u8]));
diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs
index f8c75335b35dc..a7330f7c67c91 100644
--- a/src/libstd/sys/windows/fs.rs
+++ b/src/libstd/sys/windows/fs.rs
@@ -270,7 +270,7 @@ pub fn readdir(p: &Path) -> IoResult<Vec<Path>> {
                             return Err(IoError {
                                 kind: io::InvalidInput,
                                 desc: "path was not valid UTF-16",
-                                detail: Some(format!("path was not valid UTF-16: {}", filename)),
+                                detail: Some(format!("path was not valid UTF-16: {:?}", filename)),
                             })
                         }, // FIXME #12056: Convert the UCS-2 to invalid utf-8 instead of erroring
                     }
diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index fcde5c01080fd..064633f321c19 100644
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -36,7 +36,7 @@ const BUF_BYTES : uint = 2048u;
 pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
     match v.iter().position(|c| *c == 0) {
         // don't include the 0
-        Some(i) => v.index(&(0..i)),
+        Some(i) => &v[0..i],
         None => v
     }
 }
diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs
index 016757ef63e7d..9996909f2f5bb 100644
--- a/src/libstd/sys/windows/pipe.rs
+++ b/src/libstd/sys/windows/pipe.rs
@@ -453,7 +453,7 @@ impl UnixStream {
             }
             let ret = unsafe {
                 libc::WriteFile(self.handle(),
-                                buf.index(&(offset..)).as_ptr() as libc::LPVOID,
+                                buf[offset..].as_ptr() as libc::LPVOID,
                                 (buf.len() - offset) as libc::DWORD,
                                 &mut bytes_written,
                                 &mut overlapped)
diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs
index 8e1f169b5cdcc..1b837385d1eb6 100644
--- a/src/libstd/sys/windows/process.rs
+++ b/src/libstd/sys/windows/process.rs
@@ -13,6 +13,7 @@ use prelude::v1::*;
 use collections;
 use ffi::CString;
 use hash::Hash;
+use collections::hash_map::Hasher;
 use io::fs::PathExtensions;
 use io::process::{ProcessExit, ExitStatus, ExitSignal};
 use io::{IoResult, IoError};
@@ -109,7 +110,7 @@ impl Process {
                               out_fd: Option<P>, err_fd: Option<P>)
                               -> IoResult<Process>
         where C: ProcessConfig<K, V>, P: AsInner<FileDesc>,
-              K: BytesContainer + Eq + Hash, V: BytesContainer
+              K: BytesContainer + Eq + Hash<Hasher>, V: BytesContainer
     {
         use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
         use libc::consts::os::extra::{
@@ -424,8 +425,10 @@ fn make_command_line(prog: &CString, args: &[CString]) -> String {
     }
 }
 
-fn with_envp<K, V, T, F>(env: Option<&collections::HashMap<K, V>>, cb: F) -> T where
-    K: BytesContainer + Eq + Hash, V: BytesContainer, F: FnOnce(*mut c_void) -> T,
+fn with_envp<K, V, T, F>(env: Option<&collections::HashMap<K, V>>, cb: F) -> T
+    where K: BytesContainer + Eq + Hash<Hasher>,
+          V: BytesContainer,
+          F: FnOnce(*mut c_void) -> T,
 {
     // On Windows we pass an "environment block" which is not a char**, but
     // rather a concatenation of null-terminated k=v\0 sequences, with a final
diff --git a/src/libstd/sys/windows/timer.rs b/src/libstd/sys/windows/timer.rs
index 343b78543bfd0..1ae3979cd9acc 100644
--- a/src/libstd/sys/windows/timer.rs
+++ b/src/libstd/sys/windows/timer.rs
@@ -91,7 +91,7 @@ fn helper(input: libc::HANDLE, messages: Receiver<Req>, _: ()) {
         } else {
             let remove = {
                 match &mut chans[idx as uint - 1] {
-                    &(ref mut c, oneshot) => { c.call(); oneshot }
+                    &mut (ref mut c, oneshot) => { c.call(); oneshot }
                 }
             };
             if remove {
diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index 6766127a5f1e4..0a9e0aedd3da8 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -100,7 +100,6 @@ impl Ident {
     }
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for Ident {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}#{}", self.name, self.ctxt)
@@ -203,7 +202,7 @@ impl Encodable for Ident {
 
 impl Decodable for Ident {
     fn decode<D: Decoder>(d: &mut D) -> Result<Ident, D::Error> {
-        Ok(str_to_ident(try!(d.read_str()).index(&FullRange)))
+        Ok(str_to_ident(&try!(d.read_str())[]))
     }
 }
 
@@ -1085,7 +1084,6 @@ pub enum IntTy {
     TyI64,
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for IntTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -1127,7 +1125,6 @@ impl UintTy {
     }
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for UintTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -1146,7 +1143,6 @@ pub enum FloatTy {
     TyF64,
 }
 
-//NOTE(stage0): remove after snapshot
 impl fmt::Show for FloatTy {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::String::fmt(self, f)
@@ -1734,11 +1730,8 @@ pub struct MacroDef {
 
 #[cfg(test)]
 mod test {
-    use serialize::json;
     use serialize;
-    use codemap::*;
     use super::*;
-    use std::fmt;
 
     // are ASTs encodable?
     #[test]
diff --git a/src/libsyntax/ast_map/mod.rs b/src/libsyntax/ast_map/mod.rs
index 7496a0f9f26db..3ef572791752b 100644
--- a/src/libsyntax/ast_map/mod.rs
+++ b/src/libsyntax/ast_map/mod.rs
@@ -32,7 +32,7 @@ use std::slice;
 
 pub mod blocks;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq, Show)]
 pub enum PathElem {
     PathMod(Name),
     PathName(Name)
@@ -46,13 +46,6 @@ impl PathElem {
     }
 }
 
-//NOTE(stage0): replace with deriving(Show) after snapshot
-impl fmt::Show for PathElem {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::String::fmt(self, f)
-    }
-}
-
 impl fmt::String for PathElem {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let slot = token::get_name(self.name());
@@ -90,7 +83,7 @@ impl<'a, T: Copy> Iterator for Values<'a, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
-        let &Values(ref mut items) = self;
+        let &mut Values(ref mut items) = self;
         items.next().map(|&x| x)
     }
 }
@@ -106,7 +99,7 @@ pub fn path_to_string<PI: Iterator<Item=PathElem>>(path: PI) -> String {
         if !s.is_empty() {
             s.push_str("::");
         }
-        s.push_str(e.index(&FullRange));
+        s.push_str(&e[]);
         s
     }).to_string()
 }
@@ -483,20 +476,20 @@ impl<'ast> Map<'ast> {
         F: FnOnce(Option<&[Attribute]>) -> T,
     {
         let attrs = match self.get(id) {
-            NodeItem(i) => Some(i.attrs.index(&FullRange)),
-            NodeForeignItem(fi) => Some(fi.attrs.index(&FullRange)),
+            NodeItem(i) => Some(&i.attrs[]),
+            NodeForeignItem(fi) => Some(&fi.attrs[]),
             NodeTraitItem(ref tm) => match **tm {
-                RequiredMethod(ref type_m) => Some(type_m.attrs.index(&FullRange)),
-                ProvidedMethod(ref m) => Some(m.attrs.index(&FullRange)),
-                TypeTraitItem(ref typ) => Some(typ.attrs.index(&FullRange)),
+                RequiredMethod(ref type_m) => Some(&type_m.attrs[]),
+                ProvidedMethod(ref m) => Some(&m.attrs[]),
+                TypeTraitItem(ref typ) => Some(&typ.attrs[]),
             },
             NodeImplItem(ref ii) => {
                 match **ii {
-                    MethodImplItem(ref m) => Some(m.attrs.index(&FullRange)),
-                    TypeImplItem(ref t) => Some(t.attrs.index(&FullRange)),
+                    MethodImplItem(ref m) => Some(&m.attrs[]),
+                    TypeImplItem(ref t) => Some(&t.attrs[]),
                 }
             }
-            NodeVariant(ref v) => Some(v.node.attrs.index(&FullRange)),
+            NodeVariant(ref v) => Some(&v.node.attrs[]),
             // unit/tuple structs take the attributes straight from
             // the struct definition.
             // FIXME(eddyb) make this work again (requires access to the map).
@@ -520,7 +513,7 @@ impl<'ast> Map<'ast> {
         NodesMatchingSuffix {
             map: self,
             item_name: parts.last().unwrap(),
-            in_which: parts.index(&(0..(parts.len() - 1))),
+            in_which: &parts[0..(parts.len() - 1)],
             idx: 0,
         }
     }
@@ -597,7 +590,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> {
                 None => return false,
                 Some((node_id, name)) => (node_id, name),
             };
-            if part.index(&FullRange) != mod_name.as_str() {
+            if &part[] != mod_name.as_str() {
                 return false;
             }
             cursor = self.map.get_parent(mod_id);
@@ -635,7 +628,7 @@ impl<'a, 'ast> NodesMatchingSuffix<'a, 'ast> {
     // We are looking at some node `n` with a given name and parent
     // id; do their names match what I am seeking?
     fn matches_names(&self, parent_of_n: NodeId, name: Name) -> bool {
-        name.as_str() == self.item_name.index(&FullRange) &&
+        name.as_str() == &self.item_name[] &&
             self.suffix_matches(parent_of_n)
     }
 }
@@ -1047,7 +1040,7 @@ impl<'a> NodePrinter for pprust::State<'a> {
 
 fn node_id_to_string(map: &Map, id: NodeId, include_id: bool) -> String {
     let id_str = format!(" (id={})", id);
-    let id_str = if include_id { id_str.index(&FullRange) } else { "" };
+    let id_str = if include_id { &id_str[] } else { "" };
 
     match map.find(id) {
         Some(NodeItem(item)) => {
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 871f1237aee51..b4e917e28cb24 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -85,6 +85,13 @@ pub fn is_shift_binop(b: BinOp) -> bool {
     }
 }
 
+pub fn is_comparison_binop(b: BinOp) -> bool {
+    match b {
+        BiEq | BiLt | BiLe | BiNe | BiGt | BiGe => true,
+        _ => false
+    }
+}
+
 /// Returns `true` if the binary operator takes its arguments by value
 pub fn is_by_value_binop(b: BinOp) -> bool {
     match b {
@@ -238,11 +245,11 @@ pub fn impl_pretty_name(trait_ref: &Option<TraitRef>, ty: &Ty) -> Ident {
     match *trait_ref {
         Some(ref trait_ref) => {
             pretty.push('.');
-            pretty.push_str(pprust::path_to_string(&trait_ref.path).index(&FullRange));
+            pretty.push_str(&pprust::path_to_string(&trait_ref.path)[]);
         }
         None => {}
     }
-    token::gensym_ident(pretty.index(&FullRange))
+    token::gensym_ident(&pretty[])
 }
 
 pub fn trait_method_to_ty_method(method: &Method) -> TypeMethod {
@@ -317,8 +324,7 @@ pub fn operator_prec(op: ast::BinOp) -> uint {
       BiBitAnd                  =>  8u,
       BiBitXor                  =>  7u,
       BiBitOr                   =>  6u,
-      BiLt | BiLe | BiGe | BiGt =>  4u,
-      BiEq | BiNe               =>  3u,
+      BiLt | BiLe | BiGe | BiGt | BiEq | BiNe => 3u,
       BiAnd                     =>  2u,
       BiOr                      =>  1u
   }
@@ -704,7 +710,7 @@ pub fn pat_is_ident(pat: P<ast::Pat>) -> bool {
 pub fn path_name_eq(a : &ast::Path, b : &ast::Path) -> bool {
     (a.span == b.span)
     && (a.global == b.global)
-    && (segments_name_eq(a.segments.index(&FullRange), b.segments.index(&FullRange)))
+    && (segments_name_eq(&a.segments[], &b.segments[]))
 }
 
 // are two arrays of segments equal when compared unhygienically?
@@ -791,14 +797,14 @@ mod test {
 
     #[test] fn idents_name_eq_test() {
         assert!(segments_name_eq(
-            [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
-                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange),
-            [Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}]
-                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange)));
+            &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
+                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[],
+            &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(78),ctxt:182}]
+                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[]));
         assert!(!segments_name_eq(
-            [Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
-                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange),
-            [Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}]
-                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>().index(&FullRange)));
+            &[Ident{name:Name(3),ctxt:4}, Ident{name:Name(78),ctxt:82}]
+                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[],
+            &[Ident{name:Name(3),ctxt:104}, Ident{name:Name(77),ctxt:182}]
+                .iter().map(ident_to_segment).collect::<Vec<PathSegment>>()[]));
     }
 }
diff --git a/src/libsyntax/attr.rs b/src/libsyntax/attr.rs
index 416fc8c2278a0..2cea55dfc55ef 100644
--- a/src/libsyntax/attr.rs
+++ b/src/libsyntax/attr.rs
@@ -98,7 +98,7 @@ impl AttrMetaMethods for MetaItem {
 
     fn meta_item_list<'a>(&'a self) -> Option<&'a [P<MetaItem>]> {
         match self.node {
-            MetaList(_, ref l) => Some(l.index(&FullRange)),
+            MetaList(_, ref l) => Some(&l[]),
             _ => None
         }
     }
@@ -136,8 +136,8 @@ impl AttributeMethods for Attribute {
             let comment = self.value_str().unwrap();
             let meta = mk_name_value_item_str(
                 InternedString::new("doc"),
-                token::intern_and_get_ident(strip_doc_comment_decoration(
-                        comment.get()).index(&FullRange)));
+                token::intern_and_get_ident(&strip_doc_comment_decoration(
+                        comment.get())[]));
             if self.node.style == ast::AttrOuter {
                 f(&mk_attr_outer(self.node.id, meta))
             } else {
@@ -297,9 +297,9 @@ pub fn find_inline_attr(attrs: &[Attribute]) -> InlineAttr {
             }
             MetaList(ref n, ref items) if *n == "inline" => {
                 mark_used(attr);
-                if contains_name(items.index(&FullRange), "always") {
+                if contains_name(&items[], "always") {
                     InlineAlways
-                } else if contains_name(items.index(&FullRange), "never") {
+                } else if contains_name(&items[], "never") {
                     InlineNever
                 } else {
                     InlineHint
@@ -403,7 +403,7 @@ pub fn require_unique_names(diagnostic: &SpanHandler, metas: &[P<MetaItem>]) {
 
         if !set.insert(name.clone()) {
             diagnostic.span_fatal(meta.span,
-                                  format!("duplicate meta item `{}`", name).index(&FullRange));
+                                  &format!("duplicate meta item `{}`", name)[]);
         }
     }
 }
diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs
index 31fe23847d9a8..d1768867f0da2 100644
--- a/src/libsyntax/codemap.rs
+++ b/src/libsyntax/codemap.rs
@@ -304,9 +304,9 @@ impl FileMap {
         lines.get(line_number).map(|&line| {
             let begin: BytePos = line - self.start_pos;
             let begin = begin.to_uint();
-            let slice = self.src.index(&(begin..));
+            let slice = &self.src[begin..];
             match slice.find('\n') {
-                Some(e) => slice.index(&(0..e)),
+                Some(e) => &slice[0..e],
                 None => slice
             }.to_string()
         })
@@ -351,9 +351,9 @@ impl CodeMap {
         // FIXME #12884: no efficient/safe way to remove from the start of a string
         // and reuse the allocation.
         let mut src = if src.starts_with("\u{feff}") {
-            String::from_str(src.index(&(3..)))
+            String::from_str(&src[3..])
         } else {
-            String::from_str(src.index(&FullRange))
+            String::from_str(&src[])
         };
 
         // Append '\n' in case it's not already there.
@@ -440,8 +440,7 @@ impl CodeMap {
         if begin.fm.start_pos != end.fm.start_pos {
             None
         } else {
-            Some(begin.fm.src.index(&(begin.pos.to_uint()..
-                                      end.pos.to_uint())).to_string())
+            Some((&begin.fm.src[begin.pos.to_uint()..end.pos.to_uint()]).to_string())
         }
     }
 
@@ -590,7 +589,12 @@ impl CodeMap {
                 Some(ref info) => {
                     // save the parent expn_id for next loop iteration
                     expnid = info.call_site.expn_id;
-                    if info.callee.span.is_none() {
+                    if info.callee.name == "format_args" {
+                        // This is a hack because the format_args builtin calls unstable APIs.
+                        // I spent like 6 hours trying to solve this more generally but am stupid.
+                        is_internal = true;
+                        false
+                    } else if info.callee.span.is_none() {
                         // it's a compiler built-in, we *really* don't want to mess with it
                         // so we skip it, unless it was called by a regular macro, in which case
                         // we will handle the caller macro next turn
diff --git a/src/libsyntax/diagnostic.rs b/src/libsyntax/diagnostic.rs
index fde2fdb3c558c..7e57709f33d0a 100644
--- a/src/libsyntax/diagnostic.rs
+++ b/src/libsyntax/diagnostic.rs
@@ -123,7 +123,7 @@ impl SpanHandler {
         panic!(ExplicitBug);
     }
     pub fn span_unimpl(&self, sp: Span, msg: &str) -> ! {
-        self.span_bug(sp, format!("unimplemented {}", msg).index(&FullRange));
+        self.span_bug(sp, &format!("unimplemented {}", msg)[]);
     }
     pub fn handler<'a>(&'a self) -> &'a Handler {
         &self.handler
@@ -166,7 +166,7 @@ impl Handler {
                         self.err_count.get());
           }
         }
-        self.fatal(s.index(&FullRange));
+        self.fatal(&s[]);
     }
     pub fn warn(&self, msg: &str) {
         self.emit.borrow_mut().emit(None, msg, None, Warning);
@@ -182,7 +182,7 @@ impl Handler {
         panic!(ExplicitBug);
     }
     pub fn unimpl(&self, msg: &str) -> ! {
-        self.bug(format!("unimplemented {}", msg).index(&FullRange));
+        self.bug(&format!("unimplemented {}", msg)[]);
     }
     pub fn emit(&self,
                 cmsp: Option<(&codemap::CodeMap, Span)>,
@@ -277,7 +277,7 @@ fn print_maybe_styled(w: &mut EmitterWriter,
             // to be miscolored. We assume this is rare enough that we don't
             // have to worry about it.
             if msg.ends_with("\n") {
-                try!(t.write_str(msg.index(&(0..(msg.len()-1)))));
+                try!(t.write_str(&msg[0..(msg.len()-1)]));
                 try!(t.reset());
                 try!(t.write_str("\n"));
             } else {
@@ -299,16 +299,16 @@ fn print_diagnostic(dst: &mut EmitterWriter, topic: &str, lvl: Level,
     }
 
     try!(print_maybe_styled(dst,
-                            format!("{}: ", lvl.to_string()).index(&FullRange),
+                            &format!("{}: ", lvl.to_string())[],
                             term::attr::ForegroundColor(lvl.color())));
     try!(print_maybe_styled(dst,
-                            format!("{}", msg).index(&FullRange),
+                            &format!("{}", msg)[],
                             term::attr::Bold));
 
     match code {
         Some(code) => {
             let style = term::attr::ForegroundColor(term::color::BRIGHT_MAGENTA);
-            try!(print_maybe_styled(dst, format!(" [{}]", code.clone()).index(&FullRange), style));
+            try!(print_maybe_styled(dst, &format!(" [{}]", code.clone())[], style));
         }
         None => ()
     }
@@ -398,12 +398,12 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan,
         // the span)
         let span_end = Span { lo: sp.hi, hi: sp.hi, expn_id: sp.expn_id};
         let ses = cm.span_to_string(span_end);
-        try!(print_diagnostic(dst, ses.index(&FullRange), lvl, msg, code));
+        try!(print_diagnostic(dst, &ses[], lvl, msg, code));
         if rsp.is_full_span() {
             try!(custom_highlight_lines(dst, cm, sp, lvl, lines));
         }
     } else {
-        try!(print_diagnostic(dst, ss.index(&FullRange), lvl, msg, code));
+        try!(print_diagnostic(dst, &ss[], lvl, msg, code));
         if rsp.is_full_span() {
             try!(highlight_lines(dst, cm, sp, lvl, lines));
         }
@@ -413,9 +413,9 @@ fn emit(dst: &mut EmitterWriter, cm: &codemap::CodeMap, rsp: RenderSpan,
         Some(code) =>
             match dst.registry.as_ref().and_then(|registry| registry.find_description(code)) {
                 Some(_) => {
-                    try!(print_diagnostic(dst, ss.index(&FullRange), Help,
-                                          format!("pass `--explain {}` to see a detailed \
-                                                   explanation", code).index(&FullRange), None));
+                    try!(print_diagnostic(dst, &ss[], Help,
+                                          &format!("pass `--explain {}` to see a detailed \
+                                                   explanation", code)[], None));
                 }
                 None => ()
             },
@@ -432,9 +432,9 @@ fn highlight_lines(err: &mut EmitterWriter,
     let fm = &*lines.file;
 
     let mut elided = false;
-    let mut display_lines = lines.lines.index(&FullRange);
+    let mut display_lines = &lines.lines[];
     if display_lines.len() > MAX_LINES {
-        display_lines = display_lines.index(&(0u..MAX_LINES));
+        display_lines = &display_lines[0u..MAX_LINES];
         elided = true;
     }
     // Print the offending lines
@@ -494,7 +494,7 @@ fn highlight_lines(err: &mut EmitterWriter,
             }
         }
         try!(print_maybe_styled(err,
-                                format!("{}\n", s).index(&FullRange),
+                                &format!("{}\n", s)[],
                                 term::attr::ForegroundColor(lvl.color())));
     }
     Ok(())
@@ -514,7 +514,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter,
                           -> io::IoResult<()> {
     let fm = &*lines.file;
 
-    let lines = lines.lines.index(&FullRange);
+    let lines = &lines.lines[];
     if lines.len() > MAX_LINES {
         if let Some(line) = fm.get_line(lines[0]) {
             try!(write!(&mut w.dst, "{}:{} {}\n", fm.name,
@@ -545,7 +545,7 @@ fn custom_highlight_lines(w: &mut EmitterWriter,
     s.push('^');
     s.push('\n');
     print_maybe_styled(w,
-                       s.index(&FullRange),
+                       &s[],
                        term::attr::ForegroundColor(lvl.color()))
 }
 
@@ -560,12 +560,12 @@ fn print_macro_backtrace(w: &mut EmitterWriter,
                 codemap::MacroAttribute => ("#[", "]"),
                 codemap::MacroBang => ("", "!")
             };
-            try!(print_diagnostic(w, ss.index(&FullRange), Note,
-                                  format!("in expansion of {}{}{}", pre,
+            try!(print_diagnostic(w, &ss[], Note,
+                                  &format!("in expansion of {}{}{}", pre,
                                           ei.callee.name,
-                                          post).index(&FullRange), None));
+                                          post)[], None));
             let ss = cm.span_to_string(ei.call_site);
-            try!(print_diagnostic(w, ss.index(&FullRange), Note, "expansion site", None));
+            try!(print_diagnostic(w, &ss[], Note, "expansion site", None));
             Ok(Some(ei.call_site))
         }
         None => Ok(None)
@@ -578,6 +578,6 @@ pub fn expect<T, M>(diag: &SpanHandler, opt: Option<T>, msg: M) -> T where
 {
     match opt {
         Some(t) => t,
-        None => diag.handler().bug(msg().index(&FullRange)),
+        None => diag.handler().bug(&msg()[]),
     }
 }
diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs
index 0f4ebd74b66c7..1469c50061cc7 100644
--- a/src/libsyntax/diagnostics/plugin.rs
+++ b/src/libsyntax/diagnostics/plugin.rs
@@ -56,9 +56,9 @@ pub fn expand_diagnostic_used<'cx>(ecx: &'cx mut ExtCtxt,
     with_used_diagnostics(|diagnostics| {
         match diagnostics.insert(code.name, span) {
             Some(previous_span) => {
-                ecx.span_warn(span, format!(
+                ecx.span_warn(span, &format!(
                     "diagnostic code {} already used", token::get_ident(code).get()
-                ).index(&FullRange));
+                )[]);
                 ecx.span_note(previous_span, "previous invocation");
             },
             None => ()
@@ -85,14 +85,14 @@ pub fn expand_register_diagnostic<'cx>(ecx: &'cx mut ExtCtxt,
     };
     with_registered_diagnostics(|diagnostics| {
         if diagnostics.insert(code.name, description).is_some() {
-            ecx.span_err(span, format!(
+            ecx.span_err(span, &format!(
                 "diagnostic code {} already registered", token::get_ident(*code).get()
-            ).index(&FullRange));
+            )[]);
         }
     });
-    let sym = Ident::new(token::gensym((
+    let sym = Ident::new(token::gensym(&(
         "__register_diagnostic_".to_string() + token::get_ident(*code).get()
-    ).index(&FullRange)));
+    )[]));
     MacItems::new(vec![quote_item!(ecx, mod $sym {}).unwrap()].into_iter())
 }
 
diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index 04dec0e802841..fd3bac5b2fc7b 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -99,8 +99,8 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                     let output = match constraint.get().slice_shift_char() {
                         Some(('=', _)) => None,
                         Some(('+', operand)) => {
-                            Some(token::intern_and_get_ident(format!(
-                                        "={}", operand).index(&FullRange)))
+                            Some(token::intern_and_get_ident(&format!(
+                                        "={}", operand)[]))
                         }
                         _ => {
                             cx.span_err(span, "output operand constraint lacks '=' or '+'");
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 52e402689ba77..9b9d8a9ceb395 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -341,9 +341,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
 
     let mut syntax_expanders = SyntaxEnv::new();
     syntax_expanders.insert(intern("macro_rules"), MacroRulesTT);
-    syntax_expanders.insert(intern("fmt"),
-                            builtin_normal_expander(
-                                ext::fmt::expand_syntax_ext));
     syntax_expanders.insert(intern("format_args"),
                             builtin_normal_expander(
                                 ext::format::expand_format_args));
@@ -353,9 +350,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
     syntax_expanders.insert(intern("option_env"),
                             builtin_normal_expander(
                                     ext::env::expand_option_env));
-    syntax_expanders.insert(intern("bytes"),
-                            builtin_normal_expander(
-                                    ext::bytes::expand_syntax_ext));
     syntax_expanders.insert(intern("concat_idents"),
                             builtin_normal_expander(
                                     ext::concat_idents::expand_syntax_ext));
@@ -367,8 +361,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
                                     ext::log_syntax::expand_syntax_ext));
     syntax_expanders.insert(intern("derive"),
                             Decorator(box ext::deriving::expand_meta_derive));
-    syntax_expanders.insert(intern("deriving"),
-                            Decorator(box ext::deriving::expand_meta_deriving));
 
     if ecfg.enable_quotes {
         // Quasi-quoting expanders
@@ -416,9 +408,6 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
     syntax_expanders.insert(intern("include_str"),
                             builtin_normal_expander(
                                     ext::source_util::expand_include_str));
-    syntax_expanders.insert(intern("include_bin"),
-                            builtin_normal_expander(
-                                    ext::source_util::expand_include_bin));
     syntax_expanders.insert(intern("include_bytes"),
                             builtin_normal_expander(
                                     ext::source_util::expand_include_bytes));
@@ -539,7 +528,7 @@ impl<'a> ExtCtxt<'a> {
     pub fn mod_pop(&mut self) { self.mod_path.pop().unwrap(); }
     pub fn mod_path(&self) -> Vec<ast::Ident> {
         let mut v = Vec::new();
-        v.push(token::str_to_ident(self.ecfg.crate_name.index(&FullRange)));
+        v.push(token::str_to_ident(&self.ecfg.crate_name[]));
         v.extend(self.mod_path.iter().map(|a| *a));
         return v;
     }
@@ -547,8 +536,8 @@ impl<'a> ExtCtxt<'a> {
         self.recursion_count += 1;
         if self.recursion_count > self.ecfg.recursion_limit {
             self.span_fatal(ei.call_site,
-                            format!("recursion limit reached while expanding the macro `{}`",
-                                    ei.callee.name).index(&FullRange));
+                            &format!("recursion limit reached while expanding the macro `{}`",
+                                    ei.callee.name)[]);
         }
 
         let mut call_site = ei.call_site;
@@ -670,7 +659,7 @@ pub fn check_zero_tts(cx: &ExtCtxt,
                       tts: &[ast::TokenTree],
                       name: &str) {
     if tts.len() != 0 {
-        cx.span_err(sp, format!("{} takes no arguments", name).index(&FullRange));
+        cx.span_err(sp, &format!("{} takes no arguments", name)[]);
     }
 }
 
@@ -683,12 +672,12 @@ pub fn get_single_str_from_tts(cx: &mut ExtCtxt,
                                -> Option<String> {
     let mut p = cx.new_parser_from_tts(tts);
     if p.token == token::Eof {
-        cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange));
+        cx.span_err(sp, &format!("{} takes 1 argument", name)[]);
         return None
     }
     let ret = cx.expander().fold_expr(p.parse_expr());
     if p.token != token::Eof {
-        cx.span_err(sp, format!("{} takes 1 argument", name).index(&FullRange));
+        cx.span_err(sp, &format!("{} takes 1 argument", name)[]);
     }
     expr_to_string(cx, ret, "argument must be a string literal").map(|(s, _)| {
         s.get().to_string()
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index bd4f295401cad..27523ea453585 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -708,8 +708,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     fn expr_fail(&self, span: Span, msg: InternedString) -> P<ast::Expr> {
         let loc = self.codemap().lookup_char_pos(span.lo);
         let expr_file = self.expr_str(span,
-                                      token::intern_and_get_ident(loc.file
-                                                                  .name.index(&FullRange)));
+                                      token::intern_and_get_ident(&loc.file.name[]));
         let expr_line = self.expr_uint(span, loc.line);
         let expr_file_line_tuple = self.expr_tuple(span, vec!(expr_file, expr_line));
         let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple);
diff --git a/src/libsyntax/ext/bytes.rs b/src/libsyntax/ext/bytes.rs
deleted file mode 100644
index 9f225d55b444f..0000000000000
--- a/src/libsyntax/ext/bytes.rs
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2013 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.
-
-/* The compiler code necessary to support the bytes! extension. */
-
-use ast;
-use codemap::Span;
-use ext::base::*;
-use ext::base;
-use ext::build::AstBuilder;
-use std::ascii::AsciiExt;
-
-pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt,
-                              sp: Span,
-                              tts: &[ast::TokenTree])
-                              -> Box<base::MacResult+'cx> {
-    cx.span_warn(sp, "`bytes!` is deprecated, use `b\"foo\"` literals instead");
-    cx.parse_sess.span_diagnostic.span_help(sp,
-        "see http://doc.rust-lang.org/reference.html#byte-and-byte-string-literals \
-         for documentation");
-    cx.parse_sess.span_diagnostic.span_help(sp,
-        "see https://github.com/rust-lang/rust/blob/master/src/etc/2014-06-rewrite-bytes-macros.py \
-         for an automated migration");
-
-    // Gather all argument expressions
-    let exprs = match get_exprs_from_tts(cx, sp, tts) {
-        None => return DummyResult::expr(sp),
-        Some(e) => e,
-    };
-    let mut bytes = Vec::new();
-    let mut err = false;
-
-    for expr in exprs.iter() {
-        match expr.node {
-            // expression is a literal
-            ast::ExprLit(ref lit) => match lit.node {
-                // string literal, push each byte to vector expression
-                ast::LitStr(ref s, _) => {
-                    for byte in s.get().bytes() {
-                        bytes.push(cx.expr_u8(expr.span, byte));
-                    }
-                }
-
-                // u8 literal, push to vector expression
-                ast::LitInt(v, ast::UnsignedIntLit(ast::TyU8)) => {
-                    if v > 0xFF {
-                        cx.span_err(expr.span, "too large u8 literal in bytes!");
-                        err = true;
-                    } else {
-                        bytes.push(cx.expr_u8(expr.span, v as u8));
-                    }
-                }
-
-                // integer literal, push to vector expression
-                ast::LitInt(_, ast::UnsuffixedIntLit(ast::Minus)) => {
-                    cx.span_err(expr.span, "negative integer literal in bytes!");
-                    err = true;
-                }
-                ast::LitInt(v, ast::UnsuffixedIntLit(ast::Plus)) => {
-                    if v > 0xFF {
-                        cx.span_err(expr.span, "too large integer literal in bytes!");
-                        err = true;
-                    } else {
-                        bytes.push(cx.expr_u8(expr.span, v as u8));
-                    }
-                }
-
-                // char literal, push to vector expression
-                ast::LitChar(v) => {
-                    if v.is_ascii() {
-                        bytes.push(cx.expr_u8(expr.span, v as u8));
-                    } else {
-                        cx.span_err(expr.span, "non-ascii char literal in bytes!");
-                        err = true;
-                    }
-                }
-
-                _ => {
-                    cx.span_err(expr.span, "unsupported literal in bytes!");
-                    err = true;
-                }
-            },
-
-            _ => {
-                cx.span_err(expr.span, "non-literal in bytes!");
-                err = true;
-            }
-        }
-    }
-
-    // For some reason using quote_expr!() here aborts if we threw an error.
-    // I'm assuming that the end of the recursive parse tricks the compiler
-    // into thinking this is a good time to stop. But we'd rather keep going.
-    if err {
-        // Since the compiler will stop after the macro expansion phase anyway, we
-        // don't need type info, so we can just return a DummyResult
-        return DummyResult::expr(sp);
-    }
-
-    let len = bytes.len();
-    let e = cx.expr_vec(sp, bytes);
-    let ty = cx.ty(sp, ast::TyFixedLengthVec(cx.ty_ident(sp, cx.ident_of("u8")),
-                                             cx.expr_uint(sp, len)));
-    let item = cx.item_static(sp, cx.ident_of("BYTES"), ty, ast::MutImmutable, e);
-    let ret = cx.expr_ident(sp, cx.ident_of("BYTES"));
-    let ret = cx.expr_addr_of(sp, ret);
-    let e = cx.expr_block(cx.block(sp, vec![cx.stmt_item(sp, item)],
-                                   Some(ret)));
-    MacExpr::new(e)
-}
diff --git a/src/libsyntax/ext/concat.rs b/src/libsyntax/ext/concat.rs
index 1f1781dceb30b..39895a3946a56 100644
--- a/src/libsyntax/ext/concat.rs
+++ b/src/libsyntax/ext/concat.rs
@@ -40,14 +40,14 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
                     ast::LitInt(i, ast::UnsignedIntLit(_)) |
                     ast::LitInt(i, ast::SignedIntLit(_, ast::Plus)) |
                     ast::LitInt(i, ast::UnsuffixedIntLit(ast::Plus)) => {
-                        accumulator.push_str(format!("{}", i).index(&FullRange));
+                        accumulator.push_str(&format!("{}", i)[]);
                     }
                     ast::LitInt(i, ast::SignedIntLit(_, ast::Minus)) |
                     ast::LitInt(i, ast::UnsuffixedIntLit(ast::Minus)) => {
-                        accumulator.push_str(format!("-{}", i).index(&FullRange));
+                        accumulator.push_str(&format!("-{}", i)[]);
                     }
                     ast::LitBool(b) => {
-                        accumulator.push_str(format!("{}", b).index(&FullRange));
+                        accumulator.push_str(&format!("{}", b)[]);
                     }
                     ast::LitByte(..) |
                     ast::LitBinary(..) => {
@@ -62,5 +62,5 @@ pub fn expand_syntax_ext(cx: &mut base::ExtCtxt,
     }
     base::MacExpr::new(cx.expr_str(
             sp,
-            token::intern_and_get_ident(accumulator.index(&FullRange))))
+            token::intern_and_get_ident(&accumulator[])))
 }
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 02f702248cb66..1af3ba1d326bc 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -40,7 +40,7 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]
             }
         }
     }
-    let res = str_to_ident(res_str.index(&FullRange));
+    let res = str_to_ident(&res_str[]);
 
     let e = P(ast::Expr {
         id: ast::DUMMY_NODE_ID,
diff --git a/src/libsyntax/ext/deriving/clone.rs b/src/libsyntax/ext/deriving/clone.rs
index d9d6cebd05c90..784a92b9a0e55 100644
--- a/src/libsyntax/ext/deriving/clone.rs
+++ b/src/libsyntax/ext/deriving/clone.rs
@@ -79,12 +79,12 @@ fn cs_clone(
         },
         EnumNonMatchingCollapsed (..) => {
             cx.span_bug(trait_span,
-                        format!("non-matching enum variants in \
-                                 `deriving({})`", name).index(&FullRange))
+                        &format!("non-matching enum variants in \
+                                 `deriving({})`", name)[])
         }
         StaticEnum(..) | StaticStruct(..) => {
             cx.span_bug(trait_span,
-                        format!("static method in `deriving({})`", name).index(&FullRange))
+                        &format!("static method in `deriving({})`", name)[])
         }
     }
 
@@ -100,8 +100,8 @@ fn cs_clone(
                 Some(i) => i,
                 None => {
                     cx.span_bug(trait_span,
-                                format!("unnamed field in normal struct in \
-                                         `deriving({})`", name).index(&FullRange))
+                                &format!("unnamed field in normal struct in \
+                                         `deriving({})`", name)[])
                 }
             };
             cx.field_imm(field.span, ident, subcall(field))
diff --git a/src/libsyntax/ext/deriving/decodable.rs b/src/libsyntax/ext/deriving/decodable.rs
index a9289f0175a69..7c65d2b4ff483 100644
--- a/src/libsyntax/ext/deriving/decodable.rs
+++ b/src/libsyntax/ext/deriving/decodable.rs
@@ -197,8 +197,7 @@ fn decode_static_fields<F>(cx: &mut ExtCtxt,
             } else {
                 let fields = fields.iter().enumerate().map(|(i, &span)| {
                     getarg(cx, span,
-                           token::intern_and_get_ident(format!("_field{}",
-                                                               i).index(&FullRange)),
+                           token::intern_and_get_ident(&format!("_field{}", i)[]),
                            i)
                 }).collect();
 
diff --git a/src/libsyntax/ext/deriving/encodable.rs b/src/libsyntax/ext/deriving/encodable.rs
index 7114217d51d0a..616390467f06f 100644
--- a/src/libsyntax/ext/deriving/encodable.rs
+++ b/src/libsyntax/ext/deriving/encodable.rs
@@ -183,7 +183,7 @@ fn encodable_substructure(cx: &mut ExtCtxt, trait_span: Span,
                 let name = match name {
                     Some(id) => token::get_ident(id),
                     None => {
-                        token::intern_and_get_ident(format!("_field{}", i).index(&FullRange))
+                        token::intern_and_get_ident(&format!("_field{}", i)[])
                     }
                 };
                 let enc = cx.expr_method_call(span, self_.clone(),
diff --git a/src/libsyntax/ext/deriving/generic/mod.rs b/src/libsyntax/ext/deriving/generic/mod.rs
index 50b3559f369fb..47b29a4db3e27 100644
--- a/src/libsyntax/ext/deriving/generic/mod.rs
+++ b/src/libsyntax/ext/deriving/generic/mod.rs
@@ -510,15 +510,15 @@ impl<'a> TraitDef<'a> {
                     self,
                     struct_def,
                     type_ident,
-                    self_args.index(&FullRange),
-                    nonself_args.index(&FullRange))
+                    &self_args[],
+                    &nonself_args[])
             } else {
                 method_def.expand_struct_method_body(cx,
                                                      self,
                                                      struct_def,
                                                      type_ident,
-                                                     self_args.index(&FullRange),
-                                                     nonself_args.index(&FullRange))
+                                                     &self_args[],
+                                                     &nonself_args[])
             };
 
             method_def.create_method(cx,
@@ -550,15 +550,15 @@ impl<'a> TraitDef<'a> {
                     self,
                     enum_def,
                     type_ident,
-                    self_args.index(&FullRange),
-                    nonself_args.index(&FullRange))
+                    &self_args[],
+                    &nonself_args[])
             } else {
                 method_def.expand_enum_method_body(cx,
                                                    self,
                                                    enum_def,
                                                    type_ident,
                                                    self_args,
-                                                   nonself_args.index(&FullRange))
+                                                   &nonself_args[])
             };
 
             method_def.create_method(cx,
@@ -645,7 +645,7 @@ impl<'a> MethodDef<'a> {
 
         for (i, ty) in self.args.iter().enumerate() {
             let ast_ty = ty.to_ty(cx, trait_.span, type_ident, generics);
-            let ident = cx.ident_of(format!("__arg_{}", i).index(&FullRange));
+            let ident = cx.ident_of(&format!("__arg_{}", i)[]);
             arg_tys.push((ident, ast_ty));
 
             let arg_expr = cx.expr_ident(trait_.span, ident);
@@ -751,8 +751,8 @@ impl<'a> MethodDef<'a> {
                 trait_.create_struct_pattern(cx,
                                              struct_path,
                                              struct_def,
-                                             format!("__self_{}",
-                                                     i).index(&FullRange),
+                                             &format!("__self_{}",
+                                                     i)[],
                                              ast::MutImmutable);
             patterns.push(pat);
             raw_fields.push(ident_expr);
@@ -908,22 +908,22 @@ impl<'a> MethodDef<'a> {
             .collect::<Vec<String>>();
 
         let self_arg_idents = self_arg_names.iter()
-            .map(|name|cx.ident_of(name.index(&FullRange)))
+            .map(|name|cx.ident_of(&name[]))
             .collect::<Vec<ast::Ident>>();
 
         // The `vi_idents` will be bound, solely in the catch-all, to
         // a series of let statements mapping each self_arg to a uint
         // corresponding to its variant index.
         let vi_idents: Vec<ast::Ident> = self_arg_names.iter()
-            .map(|name| { let vi_suffix = format!("{}_vi", name.index(&FullRange));
-                          cx.ident_of(vi_suffix.index(&FullRange)) })
+            .map(|name| { let vi_suffix = format!("{}_vi", &name[]);
+                          cx.ident_of(&vi_suffix[]) })
             .collect::<Vec<ast::Ident>>();
 
         // Builds, via callback to call_substructure_method, the
         // delegated expression that handles the catch-all case,
         // using `__variants_tuple` to drive logic if necessary.
         let catch_all_substructure = EnumNonMatchingCollapsed(
-            self_arg_idents, variants.index(&FullRange), vi_idents.index(&FullRange));
+            self_arg_idents, &variants[], &vi_idents[]);
 
         // These arms are of the form:
         // (Variant1, Variant1, ...) => Body1
@@ -945,12 +945,12 @@ impl<'a> MethodDef<'a> {
                 let mut subpats = Vec::with_capacity(self_arg_names.len());
                 let mut self_pats_idents = Vec::with_capacity(self_arg_names.len() - 1);
                 let first_self_pat_idents = {
-                    let (p, idents) = mk_self_pat(cx, self_arg_names[0].index(&FullRange));
+                    let (p, idents) = mk_self_pat(cx, &self_arg_names[0][]);
                     subpats.push(p);
                     idents
                 };
                 for self_arg_name in self_arg_names.tail().iter() {
-                    let (p, idents) = mk_self_pat(cx, self_arg_name.index(&FullRange));
+                    let (p, idents) = mk_self_pat(cx, &self_arg_name[]);
                     subpats.push(p);
                     self_pats_idents.push(idents);
                 }
@@ -1006,7 +1006,7 @@ impl<'a> MethodDef<'a> {
                                                 &**variant,
                                                 field_tuples);
                 let arm_expr = self.call_substructure_method(
-                    cx, trait_, type_ident, self_args.index(&FullRange), nonself_args,
+                    cx, trait_, type_ident, &self_args[], nonself_args,
                     &substructure);
 
                 cx.arm(sp, vec![single_pat], arm_expr)
@@ -1059,7 +1059,7 @@ impl<'a> MethodDef<'a> {
             }
 
             let arm_expr = self.call_substructure_method(
-                cx, trait_, type_ident, self_args.index(&FullRange), nonself_args,
+                cx, trait_, type_ident, &self_args[], nonself_args,
                 &catch_all_substructure);
 
             // Builds the expression:
@@ -1263,7 +1263,7 @@ impl<'a> TraitDef<'a> {
                     cx.span_bug(sp, "a struct with named and unnamed fields in `derive`");
                 }
             };
-            let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange));
+            let ident = cx.ident_of(&format!("{}_{}", prefix, i)[]);
             paths.push(codemap::Spanned{span: sp, node: ident});
             let val = cx.expr(
                 sp, ast::ExprParen(cx.expr_deref(sp, cx.expr_path(cx.path_ident(sp,ident)))));
@@ -1309,7 +1309,7 @@ impl<'a> TraitDef<'a> {
                 let mut ident_expr = Vec::new();
                 for (i, va) in variant_args.iter().enumerate() {
                     let sp = self.set_expn_info(cx, va.ty.span);
-                    let ident = cx.ident_of(format!("{}_{}", prefix, i).index(&FullRange));
+                    let ident = cx.ident_of(&format!("{}_{}", prefix, i)[]);
                     let path1 = codemap::Spanned{span: sp, node: ident};
                     paths.push(path1);
                     let expr_path = cx.expr_path(cx.path_ident(sp, ident));
@@ -1352,7 +1352,7 @@ pub fn cs_fold<F>(use_foldl: bool,
                       field.span,
                       old,
                       field.self_.clone(),
-                      field.other.index(&FullRange))
+                      &field.other[])
                 })
             } else {
                 all_fields.iter().rev().fold(base, |old, field| {
@@ -1360,12 +1360,12 @@ pub fn cs_fold<F>(use_foldl: bool,
                       field.span,
                       old,
                       field.self_.clone(),
-                      field.other.index(&FullRange))
+                      &field.other[])
                 })
             }
         },
         EnumNonMatchingCollapsed(ref all_args, _, tuple) =>
-            enum_nonmatch_f(cx, trait_span, (all_args.index(&FullRange), tuple),
+            enum_nonmatch_f(cx, trait_span, (&all_args[], tuple),
                             substructure.nonself_args),
         StaticEnum(..) | StaticStruct(..) => {
             cx.span_bug(trait_span, "static function in `derive`")
@@ -1405,7 +1405,7 @@ pub fn cs_same_method<F>(f: F,
             f(cx, trait_span, called)
         },
         EnumNonMatchingCollapsed(ref all_self_args, _, tuple) =>
-            enum_nonmatch_f(cx, trait_span, (all_self_args.index(&FullRange), tuple),
+            enum_nonmatch_f(cx, trait_span, (&all_self_args[], tuple),
                             substructure.nonself_args),
         StaticEnum(..) | StaticStruct(..) => {
             cx.span_bug(trait_span, "static function in `derive`")
diff --git a/src/libsyntax/ext/deriving/hash.rs b/src/libsyntax/ext/deriving/hash.rs
index 844bd80d1610a..db99c14244324 100644
--- a/src/libsyntax/ext/deriving/hash.rs
+++ b/src/libsyntax/ext/deriving/hash.rs
@@ -30,7 +30,8 @@ pub fn expand_deriving_hash<F>(cx: &mut ExtCtxt,
     let generics = LifetimeBounds {
         lifetimes: Vec::new(),
         bounds: vec!(("__S",
-                      vec!(Path::new(vec!("std", "hash", "Writer"))))),
+                      vec!(Path::new(vec!("std", "hash", "Writer")),
+                           Path::new(vec!("std", "hash", "Hasher"))))),
     };
     let args = Path::new_local("__S");
     let inline = cx.meta_word(span, InternedString::new("inline"));
diff --git a/src/libsyntax/ext/deriving/mod.rs b/src/libsyntax/ext/deriving/mod.rs
index 43a0e0606f8bb..603c447800716 100644
--- a/src/libsyntax/ext/deriving/mod.rs
+++ b/src/libsyntax/ext/deriving/mod.rs
@@ -40,16 +40,6 @@ pub mod totalord;
 
 pub mod generic;
 
-pub fn expand_meta_deriving(cx: &mut ExtCtxt,
-                            _span: Span,
-                            mitem: &MetaItem,
-                            item: &Item,
-                            push: Box<FnMut(P<Item>)>) {
-    cx.span_warn(mitem.span, "`deriving` is deprecated; use `derive`");
-
-    expand_meta_derive(cx, _span, mitem, item, push)
-}
-
 pub fn expand_meta_derive(cx: &mut ExtCtxt,
                           _span: Span,
                           mitem: &MetaItem,
@@ -121,9 +111,9 @@ pub fn expand_meta_derive(cx: &mut ExtCtxt,
 
                             ref tname => {
                                 cx.span_err(titem.span,
-                                            format!("unknown `derive` \
+                                            &format!("unknown `derive` \
                                                      trait: `{}`",
-                                                    *tname).index(&FullRange));
+                                                    *tname)[]);
                             }
                         };
                     }
diff --git a/src/libsyntax/ext/deriving/show.rs b/src/libsyntax/ext/deriving/show.rs
index fa9a7899a1228..48034ce50ab51 100644
--- a/src/libsyntax/ext/deriving/show.rs
+++ b/src/libsyntax/ext/deriving/show.rs
@@ -127,7 +127,7 @@ fn show_substructure(cx: &mut ExtCtxt, span: Span,
     let formatter = substr.nonself_args[0].clone();
 
     let meth = cx.ident_of("write_fmt");
-    let s = token::intern_and_get_ident(format_string.index(&FullRange));
+    let s = token::intern_and_get_ident(&format_string[]);
     let format_string = cx.expr_str(span, s);
 
     // phew, not our responsibility any more!
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index eb3544e3c5c7f..9b54e259761db 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -30,7 +30,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT
         Some(v) => v
     };
 
-    let e = match os::getenv(var.index(&FullRange)) {
+    let e = match os::getenv(&var[]) {
       None => {
           cx.expr_path(cx.path_all(sp,
                                    true,
@@ -56,7 +56,7 @@ pub fn expand_option_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenT
                                    cx.ident_of("Some")),
                               vec!(cx.expr_str(sp,
                                                token::intern_and_get_ident(
-                                          s.index(&FullRange)))))
+                                          &s[]))))
       }
     };
     MacExpr::new(e)
@@ -81,9 +81,9 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     };
     let msg = match exprs.next() {
         None => {
-            token::intern_and_get_ident(format!("environment variable `{}` \
+            token::intern_and_get_ident(&format!("environment variable `{}` \
                                                  not defined",
-                                                var).index(&FullRange))
+                                                var)[])
         }
         Some(second) => {
             match expr_to_string(cx, second, "expected string literal") {
@@ -106,7 +106,7 @@ pub fn expand_env<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
             cx.span_err(sp, msg.get());
             cx.expr_uint(sp, 0)
         }
-        Some(s) => cx.expr_str(sp, token::intern_and_get_ident(s.index(&FullRange)))
+        Some(s) => cx.expr_str(sp, token::intern_and_get_ident(&s[]))
     };
     MacExpr::new(e)
 }
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 3e1bccf394aa0..9ef996ac3179b 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -286,8 +286,8 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
                 None => {
                     fld.cx.span_err(
                         pth.span,
-                        format!("macro undefined: '{}!'",
-                                extnamestr.get()).index(&FullRange));
+                        &format!("macro undefined: '{}!'",
+                                extnamestr.get())[]);
 
                     // let compilation continue
                     None
@@ -303,7 +303,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
                                 },
                             });
                         let fm = fresh_mark();
-                        let marked_before = mark_tts(tts.index(&FullRange), fm);
+                        let marked_before = mark_tts(&tts[], fm);
 
                         // The span that we pass to the expanders we want to
                         // be the root of the call stack. That's the most
@@ -314,7 +314,7 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
                         let opt_parsed = {
                             let expanded = expandfun.expand(fld.cx,
                                                             mac_span,
-                                                            marked_before.index(&FullRange));
+                                                            &marked_before[]);
                             parse_thunk(expanded)
                         };
                         let parsed = match opt_parsed {
@@ -322,9 +322,9 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
                             None => {
                                 fld.cx.span_err(
                                     pth.span,
-                                    format!("non-expression macro in expression position: {}",
-                                            extnamestr.get().index(&FullRange)
-                                            ).index(&FullRange));
+                                    &format!("non-expression macro in expression position: {}",
+                                            &extnamestr.get()[]
+                                            )[]);
                                 return None;
                             }
                         };
@@ -333,8 +333,8 @@ fn expand_mac_invoc<T, F, G>(mac: ast::Mac, span: codemap::Span,
                     _ => {
                         fld.cx.span_err(
                             pth.span,
-                            format!("'{}' is not a tt-style macro",
-                                    extnamestr.get()).index(&FullRange));
+                            &format!("'{}' is not a tt-style macro",
+                                    extnamestr.get())[]);
                         None
                     }
                 }
@@ -439,7 +439,7 @@ pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
             if valid_ident {
                 fld.cx.mod_push(it.ident);
             }
-            let macro_use = contains_macro_use(fld, new_attrs.index(&FullRange));
+            let macro_use = contains_macro_use(fld, &new_attrs[]);
             let result = with_exts_frame!(fld.cx.syntax_env,
                                           macro_use,
                                           noop_fold_item(it, fld));
@@ -565,8 +565,8 @@ pub fn expand_item_mac(it: P<ast::Item>,
         let expanded = match fld.cx.syntax_env.find(&extname.name) {
             None => {
                 fld.cx.span_err(path_span,
-                                format!("macro undefined: '{}!'",
-                                        extnamestr).index(&FullRange));
+                                &format!("macro undefined: '{}!'",
+                                        extnamestr)[]);
                 // let compilation continue
                 return SmallVector::zero();
             }
@@ -576,10 +576,10 @@ pub fn expand_item_mac(it: P<ast::Item>,
                     if it.ident.name != parse::token::special_idents::invalid.name {
                         fld.cx
                             .span_err(path_span,
-                                      format!("macro {}! expects no ident argument, \
+                                      &format!("macro {}! expects no ident argument, \
                                         given '{}'",
                                       extnamestr,
-                                      token::get_ident(it.ident)).index(&FullRange));
+                                      token::get_ident(it.ident))[]);
                         return SmallVector::zero();
                     }
                     fld.cx.bt_push(ExpnInfo {
@@ -591,14 +591,14 @@ pub fn expand_item_mac(it: P<ast::Item>,
                         }
                     });
                     // mark before expansion:
-                    let marked_before = mark_tts(tts.index(&FullRange), fm);
-                    expander.expand(fld.cx, it.span, marked_before.index(&FullRange))
+                    let marked_before = mark_tts(&tts[], fm);
+                    expander.expand(fld.cx, it.span, &marked_before[])
                 }
                 IdentTT(ref expander, span) => {
                     if it.ident.name == parse::token::special_idents::invalid.name {
                         fld.cx.span_err(path_span,
-                                        format!("macro {}! expects an ident argument",
-                                                extnamestr.get()).index(&FullRange));
+                                        &format!("macro {}! expects an ident argument",
+                                                extnamestr.get())[]);
                         return SmallVector::zero();
                     }
                     fld.cx.bt_push(ExpnInfo {
@@ -610,14 +610,14 @@ pub fn expand_item_mac(it: P<ast::Item>,
                         }
                     });
                     // mark before expansion:
-                    let marked_tts = mark_tts(tts.index(&FullRange), fm);
+                    let marked_tts = mark_tts(&tts[], fm);
                     expander.expand(fld.cx, it.span, it.ident, marked_tts)
                 }
                 MacroRulesTT => {
                     if it.ident.name == parse::token::special_idents::invalid.name {
                         fld.cx.span_err(path_span,
-                                        format!("macro_rules! expects an ident argument")
-                                            .index(&FullRange));
+                                        &format!("macro_rules! expects an ident argument")
+                                        []);
                         return SmallVector::zero();
                     }
                     fld.cx.bt_push(ExpnInfo {
@@ -648,8 +648,8 @@ pub fn expand_item_mac(it: P<ast::Item>,
                 }
                 _ => {
                     fld.cx.span_err(it.span,
-                                    format!("{}! is not legal in item position",
-                                            extnamestr.get()).index(&FullRange));
+                                    &format!("{}! is not legal in item position",
+                                            extnamestr.get())[]);
                     return SmallVector::zero();
                 }
             }
@@ -667,8 +667,8 @@ pub fn expand_item_mac(it: P<ast::Item>,
         }
         None => {
             fld.cx.span_err(path_span,
-                            format!("non-item macro in item position: {}",
-                                    extnamestr.get()).index(&FullRange));
+                            &format!("non-item macro in item position: {}",
+                                    extnamestr.get())[]);
             return SmallVector::zero();
         }
     };
@@ -913,8 +913,8 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
         let marked_after = match fld.cx.syntax_env.find(&extname.name) {
             None => {
                 fld.cx.span_err(pth.span,
-                                format!("macro undefined: '{}!'",
-                                        extnamestr).index(&FullRange));
+                                &format!("macro undefined: '{}!'",
+                                        extnamestr)[]);
                 // let compilation continue
                 return DummyResult::raw_pat(span);
             }
@@ -931,19 +931,19 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
                     });
 
                     let fm = fresh_mark();
-                    let marked_before = mark_tts(tts.index(&FullRange), fm);
+                    let marked_before = mark_tts(&tts[], fm);
                     let mac_span = fld.cx.original_span();
                     let expanded = match expander.expand(fld.cx,
                                         mac_span,
-                                        marked_before.index(&FullRange)).make_pat() {
+                                        &marked_before[]).make_pat() {
                         Some(e) => e,
                         None => {
                             fld.cx.span_err(
                                 pth.span,
-                                format!(
+                                &format!(
                                     "non-pattern macro in pattern position: {}",
                                     extnamestr.get()
-                                ).index(&FullRange)
+                                    )[]
                             );
                             return DummyResult::raw_pat(span);
                         }
@@ -954,8 +954,8 @@ fn expand_pat(p: P<ast::Pat>, fld: &mut MacroExpander) -> P<ast::Pat> {
                 }
                 _ => {
                     fld.cx.span_err(span,
-                                    format!("{}! is not legal in pattern position",
-                                            extnamestr.get()).index(&FullRange));
+                                    &format!("{}! is not legal in pattern position",
+                                            extnamestr.get())[]);
                     return DummyResult::raw_pat(span);
                 }
             }
@@ -1232,7 +1232,7 @@ impl Folder for Marker {
             node: match node {
                 MacInvocTT(path, tts, ctxt) => {
                     MacInvocTT(self.fold_path(path),
-                               self.fold_tts(tts.index(&FullRange)),
+                               self.fold_tts(&tts[]),
                                mtwt::apply_mark(self.mark, ctxt))
                 }
             },
@@ -1295,7 +1295,7 @@ impl<'a, 'v> Visitor<'v> for MacroExterminator<'a> {
 
 #[cfg(test)]
 mod test {
-    use super::{pattern_bindings, expand_crate, contains_macro_use};
+    use super::{pattern_bindings, expand_crate};
     use super::{PatIdentFinder, IdentRenamer, PatIdentRenamer, ExpansionConfig};
     use ast;
     use ast::{Attribute_, AttrOuter, MetaWord, Name};
@@ -1404,22 +1404,6 @@ mod test {
         expand_crate(&sess, test_ecfg(), vec!(), vec!(), crate_ast);
     }
 
-    // make a MetaWord outer attribute with the given name
-    fn make_dummy_attr(s: &str) -> ast::Attribute {
-        Spanned {
-            span:codemap::DUMMY_SP,
-            node: Attribute_ {
-                id: attr::mk_attr_id(),
-                style: AttrOuter,
-                value: P(Spanned {
-                    node: MetaWord(token::intern_and_get_ident(s)),
-                    span: codemap::DUMMY_SP,
-                }),
-                is_sugared_doc: false,
-            }
-        }
-    }
-
     fn expand_crate_str(crate_str: String) -> ast::Crate {
         let ps = parse::new_parse_sess();
         let crate_ast = string_to_parser(&ps, crate_str).parse_crate_mod();
@@ -1655,7 +1639,7 @@ mod test {
                     let varref_idents : Vec<ast::Ident>
                         = varref.segments.iter().map(|s| s.identifier)
                         .collect();
-                    println!("varref #{}: {}, resolves to {}",idx, varref_idents, varref_name);
+                    println!("varref #{}: {:?}, resolves to {}",idx, varref_idents, varref_name);
                     let string = token::get_ident(final_varref_ident);
                     println!("varref's first segment's string: \"{}\"", string.get());
                     println!("binding #{}: {}, resolves to {}",
@@ -1713,7 +1697,7 @@ foo_module!();
                 let string = ident.get();
                 "xx" == string
             }).collect();
-        let cxbinds: &[&ast::Ident] = cxbinds.index(&FullRange);
+        let cxbinds: &[&ast::Ident] = &cxbinds[];
         let cxbind = match cxbinds {
             [b] => b,
             _ => panic!("expected just one binding for ext_cx")
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
deleted file mode 100644
index 5352cfaf749b0..0000000000000
--- a/src/libsyntax/ext/fmt.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2012-2013 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.
-
-/// Deprecated fmt! syntax extension
-
-use ast;
-use codemap::Span;
-use ext::base;
-use ext::build::AstBuilder;
-
-
-pub fn expand_syntax_ext(ecx: &mut base::ExtCtxt,
-                         sp: Span,
-                         _tts: &[ast::TokenTree])
-                         -> Box<base::MacResult+'static> {
-    ecx.span_err(sp, "`fmt!` is deprecated, use `format!` instead");
-    ecx.parse_sess.span_diagnostic.span_note(sp,
-        "see http://doc.rust-lang.org/std/fmt/ \
-         for documentation");
-
-    base::MacExpr::new(ecx.expr_uint(sp, 2))
-}
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 44a596d2657ef..637b6d4649d20 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -112,8 +112,8 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                 }
                 _ => {
                     ecx.span_err(p.span,
-                                 format!("expected ident for named argument, found `{}`",
-                                         p.this_token_to_string()).index(&FullRange));
+                                 &format!("expected ident for named argument, found `{}`",
+                                         p.this_token_to_string())[]);
                     return None;
                 }
             };
@@ -125,8 +125,8 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                 None => {}
                 Some(prev) => {
                     ecx.span_err(e.span,
-                                 format!("duplicate argument named `{}`",
-                                         name).index(&FullRange));
+                                 &format!("duplicate argument named `{}`",
+                                         name)[]);
                     ecx.parse_sess.span_diagnostic.span_note(prev.span, "previously here");
                     continue
                 }
@@ -217,7 +217,7 @@ impl<'a, 'b> Context<'a, 'b> {
                     let msg = format!("invalid reference to argument `{}` ({})",
                                       arg, self.describe_num_args());
 
-                    self.ecx.span_err(self.fmtsp, msg.index(&FullRange));
+                    self.ecx.span_err(self.fmtsp, &msg[]);
                     return;
                 }
                 {
@@ -237,7 +237,7 @@ impl<'a, 'b> Context<'a, 'b> {
                     Some(e) => e.span,
                     None => {
                         let msg = format!("there is no argument named `{}`", name);
-                        self.ecx.span_err(self.fmtsp, msg.index(&FullRange));
+                        self.ecx.span_err(self.fmtsp, &msg[]);
                         return;
                     }
                 };
@@ -277,22 +277,22 @@ impl<'a, 'b> Context<'a, 'b> {
         match (cur, ty) {
             (&Known(ref cur), &Known(ref ty)) => {
                 self.ecx.span_err(sp,
-                                  format!("argument redeclared with type `{}` when \
+                                  &format!("argument redeclared with type `{}` when \
                                            it was previously `{}`",
                                           *ty,
-                                          *cur).index(&FullRange));
+                                          *cur)[]);
             }
             (&Known(ref cur), _) => {
                 self.ecx.span_err(sp,
-                                  format!("argument used to format with `{}` was \
+                                  &format!("argument used to format with `{}` was \
                                            attempted to not be used for formatting",
-                                           *cur).index(&FullRange));
+                                           *cur)[]);
             }
             (_, &Known(ref ty)) => {
                 self.ecx.span_err(sp,
-                                  format!("argument previously used as a format \
+                                  &format!("argument previously used as a format \
                                            argument attempted to be used as `{}`",
-                                           *ty).index(&FullRange));
+                                           *ty)[]);
             }
             (_, _) => {
                 self.ecx.span_err(sp, "argument declared with multiple formats");
@@ -357,7 +357,7 @@ impl<'a, 'b> Context<'a, 'b> {
     /// Translate the accumulated string literals to a literal expression
     fn trans_literal_string(&mut self) -> P<ast::Expr> {
         let sp = self.fmtsp;
-        let s = token::intern_and_get_ident(self.literal.index(&FullRange));
+        let s = token::intern_and_get_ident(&self.literal[]);
         self.literal.clear();
         self.ecx.expr_str(sp, s)
     }
@@ -509,7 +509,7 @@ impl<'a, 'b> Context<'a, 'b> {
                 None => continue // error already generated
             };
 
-            let name = self.ecx.ident_of(format!("__arg{}", i).index(&FullRange));
+            let name = self.ecx.ident_of(&format!("__arg{}", i)[]);
             pats.push(self.ecx.pat_ident(e.span, name));
             locals.push(Context::format_arg(self.ecx, e.span, arg_ty,
                                             self.ecx.expr_ident(e.span, name)));
@@ -525,8 +525,8 @@ impl<'a, 'b> Context<'a, 'b> {
                 None => continue
             };
 
-            let lname = self.ecx.ident_of(format!("__arg{}",
-                                                  *name).index(&FullRange));
+            let lname = self.ecx.ident_of(&format!("__arg{}",
+                                                  *name)[]);
             pats.push(self.ecx.pat_ident(e.span, lname));
             names[self.name_positions[*name]] =
                 Some(Context::format_arg(self.ecx, e.span, arg_ty,
@@ -606,7 +606,7 @@ impl<'a, 'b> Context<'a, 'b> {
                   -> P<ast::Expr> {
         let trait_ = match *ty {
             Known(ref tyname) => {
-                match tyname.index(&FullRange) {
+                match &tyname[] {
                     ""  => "String",
                     "?" => "Show",
                     "e" => "LowerExp",
@@ -618,8 +618,8 @@ impl<'a, 'b> Context<'a, 'b> {
                     "X" => "UpperHex",
                     _ => {
                         ecx.span_err(sp,
-                                     format!("unknown format trait `{}`",
-                                             *tyname).index(&FullRange));
+                                     &format!("unknown format trait `{}`",
+                                             *tyname)[]);
                         "Dummy"
                     }
                 }
@@ -709,8 +709,8 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
         }
     }
     if !parser.errors.is_empty() {
-        cx.ecx.span_err(cx.fmtsp, format!("invalid format string: {}",
-                                          parser.errors.remove(0)).index(&FullRange));
+        cx.ecx.span_err(cx.fmtsp, &format!("invalid format string: {}",
+                                          parser.errors.remove(0))[]);
         return DummyResult::raw_expr(sp);
     }
     if !cx.literal.is_empty() {
diff --git a/src/libsyntax/ext/mtwt.rs b/src/libsyntax/ext/mtwt.rs
index bebd803ac4f86..ae8ff118fcc0f 100644
--- a/src/libsyntax/ext/mtwt.rs
+++ b/src/libsyntax/ext/mtwt.rs
@@ -223,7 +223,7 @@ pub fn marksof(ctxt: SyntaxContext, stopname: Name) -> Vec<Mrk> {
 }
 
 // the internal function for computing marks
-// it's not clear to me whether it's better to use a .index(&FullRange) mutable
+// it's not clear to me whether it's better to use a [] mutable
 // vector or a cons-list for this.
 fn marksof_internal(ctxt: SyntaxContext,
                     stopname: Name,
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 77aea0c370af0..2dbf29c145c8a 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -473,7 +473,7 @@ pub fn expand_quote_stmt(cx: &mut ExtCtxt,
 }
 
 fn ids_ext(strs: Vec<String> ) -> Vec<ast::Ident> {
-    strs.iter().map(|str| str_to_ident((*str).index(&FullRange))).collect()
+    strs.iter().map(|str| str_to_ident(&(*str)[])).collect()
 }
 
 fn id_ext(str: &str) -> ast::Ident {
@@ -675,7 +675,7 @@ fn mk_tt(cx: &ExtCtxt, tt: &ast::TokenTree) -> Vec<P<ast::Stmt>> {
             for i in range(0, tt.len()) {
                 seq.push(tt.get_tt(i));
             }
-            mk_tts(cx, seq.index(&FullRange))
+            mk_tts(cx, &seq[])
         }
         ast::TtToken(sp, ref tok) => {
             let e_sp = cx.expr_ident(sp, id_ext("_sp"));
@@ -764,7 +764,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     let stmt_let_tt = cx.stmt_let(sp, true, id_ext("tt"), cx.expr_vec_ng(sp));
 
     let mut vector = vec!(stmt_let_sp, stmt_let_tt);
-    vector.extend(mk_tts(cx, tts.index(&FullRange)).into_iter());
+    vector.extend(mk_tts(cx, &tts[]).into_iter());
     let block = cx.expr_block(
         cx.block_all(sp,
                      Vec::new(),
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 1ba91dd371c60..31a1a838b133d 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -57,7 +57,7 @@ pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
 
     let topmost = cx.original_span_in_file();
     let loc = cx.codemap().lookup_char_pos(topmost.lo);
-    let filename = token::intern_and_get_ident(loc.file.name.index(&FullRange));
+    let filename = token::intern_and_get_ident(&loc.file.name[]);
     base::MacExpr::new(cx.expr_str(topmost, filename))
 }
 
@@ -65,7 +65,7 @@ pub fn expand_stringify(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                         -> Box<base::MacResult+'static> {
     let s = pprust::tts_to_string(tts);
     base::MacExpr::new(cx.expr_str(sp,
-                                   token::intern_and_get_ident(s.index(&FullRange))))
+                                   token::intern_and_get_ident(&s[])))
 }
 
 pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
@@ -78,7 +78,7 @@ pub fn expand_mod(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                    .connect("::");
     base::MacExpr::new(cx.expr_str(
             sp,
-            token::intern_and_get_ident(string.index(&FullRange))))
+            token::intern_and_get_ident(&string[])))
 }
 
 /// include! : parse the given file as an expr
@@ -135,9 +135,9 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     let bytes = match File::open(&file).read_to_end() {
         Err(e) => {
             cx.span_err(sp,
-                        format!("couldn't read {:?}: {}",
+                        &format!("couldn't read {:?}: {}",
                                 file.display(),
-                                e).index(&FullRange));
+                                e)[]);
             return DummyResult::expr(sp);
         }
         Ok(bytes) => bytes,
@@ -147,26 +147,20 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
             // Add this input file to the code map to make it available as
             // dependency information
             let filename = format!("{:?}", file.display());
-            let interned = token::intern_and_get_ident(src.index(&FullRange));
+            let interned = token::intern_and_get_ident(&src[]);
             cx.codemap().new_filemap(filename, src);
 
             base::MacExpr::new(cx.expr_str(sp, interned))
         }
         Err(_) => {
             cx.span_err(sp,
-                        format!("{:?} wasn't a utf-8 file",
-                                file.display()).index(&FullRange));
+                        &format!("{:?} wasn't a utf-8 file",
+                                file.display())[]);
             return DummyResult::expr(sp);
         }
     }
 }
 
-pub fn expand_include_bin(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
-                          -> Box<base::MacResult+'static> {
-    cx.span_warn(sp, "include_bin! is deprecated; use include_bytes! instead");
-    expand_include_bytes(cx, sp, tts)
-}
-
 pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                             -> Box<base::MacResult+'static> {
     let file = match get_single_str_from_tts(cx, sp, tts, "include_bytes!") {
@@ -177,7 +171,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     match File::open(&file).read_to_end() {
         Err(e) => {
             cx.span_err(sp,
-                        format!("couldn't read {:?}: {}", file.display(), e).index(&FullRange));
+                        &format!("couldn't read {:?}: {}", file.display(), e)[]);
             return DummyResult::expr(sp);
         }
         Ok(bytes) => {
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index d33d03bbfa97e..9eda4bcef9942 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -153,7 +153,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint {
                 seq.num_captures
             }
             &TtDelimited(_, ref delim) => {
-                count_names(delim.tts.index(&FullRange))
+                count_names(&delim.tts[])
             }
             &TtToken(_, MatchNt(..)) => {
                 1
@@ -165,7 +165,7 @@ pub fn count_names(ms: &[TokenTree]) -> uint {
 
 pub fn initial_matcher_pos(ms: Rc<Vec<TokenTree>>, sep: Option<Token>, lo: BytePos)
                            -> Box<MatcherPos> {
-    let match_idx_hi = count_names(ms.index(&FullRange));
+    let match_idx_hi = count_names(&ms[]);
     let matches: Vec<_> = range(0, match_idx_hi).map(|_| Vec::new()).collect();
     box MatcherPos {
         stack: vec![],
@@ -228,8 +228,8 @@ pub fn nameize(p_s: &ParseSess, ms: &[TokenTree], res: &[Rc<NamedMatch>])
                         let string = token::get_ident(bind_name);
                         p_s.span_diagnostic
                            .span_fatal(sp,
-                                       format!("duplicated bind name: {}",
-                                               string.get()).index(&FullRange))
+                                       &format!("duplicated bind name: {}",
+                                               string.get())[])
                     }
                 }
             }
@@ -254,13 +254,13 @@ pub fn parse_or_else(sess: &ParseSess,
                      rdr: TtReader,
                      ms: Vec<TokenTree> )
                      -> HashMap<Ident, Rc<NamedMatch>> {
-    match parse(sess, cfg, rdr, ms.index(&FullRange)) {
+    match parse(sess, cfg, rdr, &ms[]) {
         Success(m) => m,
         Failure(sp, str) => {
-            sess.span_diagnostic.span_fatal(sp, str.index(&FullRange))
+            sess.span_diagnostic.span_fatal(sp, &str[])
         }
         Error(sp, str) => {
-            sess.span_diagnostic.span_fatal(sp, str.index(&FullRange))
+            sess.span_diagnostic.span_fatal(sp, &str[])
         }
     }
 }
@@ -447,7 +447,7 @@ pub fn parse(sess: &ParseSess,
                 for dv in (&mut eof_eis[0]).matches.iter_mut() {
                     v.push(dv.pop().unwrap());
                 }
-                return Success(nameize(sess, ms, v.index(&FullRange)));
+                return Success(nameize(sess, ms, &v[]));
             } else if eof_eis.len() > 1u {
                 return Error(sp, "ambiguity: multiple successful parses".to_string());
             } else {
@@ -532,8 +532,8 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
         token::Ident(sn,b) => { p.bump(); token::NtIdent(box sn,b) }
         _ => {
             let token_str = pprust::token_to_string(&p.token);
-            p.fatal((format!("expected ident, found {}",
-                             token_str.index(&FullRange))).index(&FullRange))
+            p.fatal(&format!("expected ident, found {}",
+                             &token_str[])[])
         }
       },
       "path" => {
@@ -541,7 +541,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
       }
       "meta" => token::NtMeta(p.parse_meta_item()),
       _ => {
-          p.fatal(format!("unsupported builtin nonterminal parser: {}", name).index(&FullRange))
+          p.fatal(&format!("unsupported builtin nonterminal parser: {}", name)[])
       }
     }
 }
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 64c53e298efe6..fc341e3bd8559 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -52,7 +52,7 @@ impl<'a> ParserAnyMacro<'a> {
                                following",
                               token_str);
             let span = parser.span;
-            parser.span_err(span, msg.index(&FullRange));
+            parser.span_err(span, &msg[]);
         }
     }
 }
@@ -126,8 +126,8 @@ impl TTMacroExpander for MacroRulesMacroExpander {
                           self.name,
                           self.imported_from,
                           arg,
-                          self.lhses.index(&FullRange),
-                          self.rhses.index(&FullRange))
+                          &self.lhses[],
+                          &self.rhses[])
     }
 }
 
@@ -154,7 +154,7 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt,
         match **lhs {
           MatchedNonterminal(NtTT(ref lhs_tt)) => {
             let lhs_tt = match **lhs_tt {
-                TtDelimited(_, ref delim) => delim.tts.index(&FullRange),
+                TtDelimited(_, ref delim) => &delim.tts[],
                 _ => cx.span_fatal(sp, "malformed macro lhs")
             };
             // `None` is because we're not interpolating
@@ -195,13 +195,13 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt,
                 best_fail_spot = sp;
                 best_fail_msg = (*msg).clone();
               },
-              Error(sp, ref msg) => cx.span_fatal(sp, msg.index(&FullRange))
+              Error(sp, ref msg) => cx.span_fatal(sp, &msg[])
             }
           }
           _ => cx.bug("non-matcher found in parsed lhses")
         }
     }
-    cx.span_fatal(best_fail_spot, best_fail_msg.index(&FullRange));
+    cx.span_fatal(best_fail_spot, &best_fail_msg[]);
 }
 
 // Note that macro-by-example's input is also matched against a token tree:
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index bc07c7f6cae4d..94b8356130aeb 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -255,7 +255,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                     }
                     LisContradiction(ref msg) => {
                         // FIXME #2887 blame macro invoker instead
-                        r.sp_diag.span_fatal(sp.clone(), msg.index(&FullRange));
+                        r.sp_diag.span_fatal(sp.clone(), &msg[]);
                     }
                     LisConstraint(len, _) => {
                         if len == 0 {
@@ -308,8 +308,8 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                             MatchedSeq(..) => {
                                 r.sp_diag.span_fatal(
                                     r.cur_span, /* blame the macro writer */
-                                    format!("variable '{:?}' is still repeating at this depth",
-                                            token::get_ident(ident)).index(&FullRange));
+                                    &format!("variable '{:?}' is still repeating at this depth",
+                                            token::get_ident(ident))[]);
                             }
                         }
                     }
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index f10113254de04..2cfcd38d48fca 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -70,6 +70,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("associated_types", Accepted),
     ("visible_private_types", Active),
     ("slicing_syntax", Active),
+    ("box_syntax", Active),
 
     ("if_let", Accepted),
     ("while_let", Accepted),
@@ -150,9 +151,9 @@ impl<'a> Context<'a> {
     fn gate_feature(&self, feature: &str, span: Span, explain: &str) {
         if !self.has_feature(feature) {
             self.span_handler.span_err(span, explain);
-            self.span_handler.span_help(span, format!("add #![feature({})] to the \
+            self.span_handler.span_help(span, &format!("add #![feature({})] to the \
                                                        crate attributes to enable",
-                                                      feature).index(&FullRange));
+                                                      feature)[]);
         }
     }
 
@@ -243,7 +244,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
         }
         match i.node {
             ast::ItemForeignMod(ref foreign_module) => {
-                if attr::contains_name(i.attrs.index(&FullRange), "link_args") {
+                if attr::contains_name(&i.attrs[], "link_args") {
                     self.gate_feature("link_args", i.span,
                                       "the `link_args` attribute is not portable \
                                        across platforms, it is recommended to \
@@ -257,14 +258,14 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
             }
 
             ast::ItemFn(..) => {
-                if attr::contains_name(i.attrs.index(&FullRange), "plugin_registrar") {
+                if attr::contains_name(&i.attrs[], "plugin_registrar") {
                     self.gate_feature("plugin_registrar", i.span,
                                       "compiler plugins are experimental and possibly buggy");
                 }
             }
 
             ast::ItemStruct(..) => {
-                if attr::contains_name(i.attrs.index(&FullRange), "simd") {
+                if attr::contains_name(&i.attrs[], "simd") {
                     self.gate_feature("simd", i.span,
                                       "SIMD types are experimental and possibly buggy");
                 }
@@ -290,7 +291,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
                                        removed in the future");
                 }
 
-                if attr::contains_name(i.attrs.index(&FullRange),
+                if attr::contains_name(&i.attrs[],
                                        "old_orphan_check") {
                     self.gate_feature(
                         "old_orphan_check",
@@ -298,7 +299,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
                         "the new orphan check rules will eventually be strictly enforced");
                 }
 
-                if attr::contains_name(i.attrs.index(&FullRange),
+                if attr::contains_name(&i.attrs[],
                                        "old_impl_check") {
                     self.gate_feature("old_impl_check",
                                       i.span,
@@ -313,7 +314,7 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
     }
 
     fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
-        if attr::contains_name(i.attrs.index(&FullRange), "linkage") {
+        if attr::contains_name(&i.attrs[], "linkage") {
             self.gate_feature("linkage", i.span,
                               "the `linkage` attribute is experimental \
                                and not portable across platforms")
@@ -338,10 +339,11 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
 
     fn visit_expr(&mut self, e: &ast::Expr) {
         match e.node {
-            ast::ExprRange(..) => {
-                self.gate_feature("slicing_syntax",
+            ast::ExprBox(..) | ast::ExprUnary(ast::UnOp::UnUniq, _) => {
+                self.gate_feature("box_syntax",
                                   e.span,
-                                  "range syntax is experimental");
+                                  "box expression syntax is experimental in alpha release; \
+                                   you can call `Box::new` instead.");
             }
             _ => {}
         }
@@ -365,6 +367,11 @@ impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
                                    but at the end of a slice (e.g. \
                                    `[0, ..xs, 0]` are experimental")
             }
+            ast::PatBox(..) => {
+                self.gate_feature("box_syntax",
+                                  pattern.span,
+                                  "box pattern syntax is experimental in alpha release");
+            }
             _ => {}
         }
         visit::walk_pat(self, pattern)
diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs
index 9e14f9dd1eaae..1efd6a87f863f 100644
--- a/src/libsyntax/lib.rs
+++ b/src/libsyntax/lib.rs
@@ -16,6 +16,7 @@
 
 #![crate_name = "syntax"]
 #![experimental]
+#![staged_api]
 #![crate_type = "dylib"]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -24,6 +25,7 @@
 
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 #![feature(quote, unsafe_destructor)]
 
 extern crate arena;
@@ -81,7 +83,6 @@ pub mod ext {
     pub mod asm;
     pub mod base;
     pub mod build;
-    pub mod bytes;
     pub mod cfg;
     pub mod cfg_attr;
     pub mod concat;
@@ -89,7 +90,6 @@ pub mod ext {
     pub mod deriving;
     pub mod env;
     pub mod expand;
-    pub mod fmt;
     pub mod format;
     pub mod log_syntax;
     pub mod mtwt;
diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index 4aad7f911dbb7..54ec9c7b146d7 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -92,7 +92,7 @@ impl<'a> ParserAttr for Parser<'a> {
             }
             _ => {
                 let token_str = self.this_token_to_string();
-                self.fatal(format!("expected `#`, found `{}`", token_str).index(&FullRange));
+                self.fatal(&format!("expected `#`, found `{}`", token_str)[]);
             }
         };
 
diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs
index e7fc5aac9c772..16ade904be883 100644
--- a/src/libsyntax/parse/lexer/comments.rs
+++ b/src/libsyntax/parse/lexer/comments.rs
@@ -82,7 +82,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String {
         while j > i && lines[j - 1].trim().is_empty() {
             j -= 1;
         }
-        return lines.index(&(i..j)).iter().map(|x| (*x).clone()).collect();
+        return lines[i..j].iter().map(|x| (*x).clone()).collect();
     }
 
     /// remove a "[ \t]*\*" block from each line, if possible
@@ -116,7 +116,7 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String {
 
         if can_trim {
             lines.iter().map(|line| {
-                line.index(&((i + 1)..line.len())).to_string()
+                (&line[(i + 1)..line.len()]).to_string()
             }).collect()
         } else {
             lines
@@ -127,12 +127,12 @@ pub fn strip_doc_comment_decoration(comment: &str) -> String {
     static ONLINERS: &'static [&'static str] = &["///!", "///", "//!", "//"];
     for prefix in ONLINERS.iter() {
         if comment.starts_with(*prefix) {
-            return comment.index(&(prefix.len()..)).to_string();
+            return (&comment[prefix.len()..]).to_string();
         }
     }
 
     if comment.starts_with("/*") {
-        let lines = comment.index(&(3u..(comment.len() - 2u)))
+        let lines = comment[3u..(comment.len() - 2u)]
             .lines_any()
             .map(|s| s.to_string())
             .collect::<Vec<String> >();
@@ -187,7 +187,7 @@ fn read_line_comments(rdr: &mut StringReader, code_to_the_left: bool,
         let line = rdr.read_one_line_comment();
         debug!("{}", line);
         // Doc comments are not put in comments.
-        if is_doc_comment(line.index(&FullRange)) {
+        if is_doc_comment(&line[]) {
             break;
         }
         lines.push(line);
@@ -224,10 +224,10 @@ fn all_whitespace(s: &str, col: CharPos) -> Option<uint> {
 fn trim_whitespace_prefix_and_push_line(lines: &mut Vec<String> ,
                                         s: String, col: CharPos) {
     let len = s.len();
-    let s1 = match all_whitespace(s.index(&FullRange), col) {
+    let s1 = match all_whitespace(&s[], col) {
         Some(col) => {
             if col < len {
-                s.index(&(col..len)).to_string()
+                (&s[col..len]).to_string()
             } else {
                 "".to_string()
             }
@@ -261,7 +261,7 @@ fn read_block_comment(rdr: &mut StringReader,
             rdr.bump();
             rdr.bump();
         }
-        if is_block_doc_comment(curr_line.index(&FullRange)) {
+        if is_block_doc_comment(&curr_line[]) {
             return
         }
         assert!(!curr_line.contains_char('\n'));
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index 153b18b876002..4cdafb36eecc4 100644
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -196,7 +196,7 @@ impl<'a> StringReader<'a> {
         let mut m = m.to_string();
         m.push_str(": ");
         for c in c.escape_default() { m.push(c) }
-        self.fatal_span_(from_pos, to_pos, m.index(&FullRange));
+        self.fatal_span_(from_pos, to_pos, &m[]);
     }
 
     /// Report a lexical error spanning [`from_pos`, `to_pos`), appending an
@@ -205,7 +205,7 @@ impl<'a> StringReader<'a> {
         let mut m = m.to_string();
         m.push_str(": ");
         for c in c.escape_default() { m.push(c) }
-        self.err_span_(from_pos, to_pos, m.index(&FullRange));
+        self.err_span_(from_pos, to_pos, &m[]);
     }
 
     /// Report a lexical error spanning [`from_pos`, `to_pos`), appending the
@@ -214,8 +214,8 @@ impl<'a> StringReader<'a> {
         m.push_str(": ");
         let from = self.byte_offset(from_pos).to_uint();
         let to = self.byte_offset(to_pos).to_uint();
-        m.push_str(self.filemap.src.index(&(from..to)));
-        self.fatal_span_(from_pos, to_pos, m.index(&FullRange));
+        m.push_str(&self.filemap.src[from..to]);
+        self.fatal_span_(from_pos, to_pos, &m[]);
     }
 
     /// Advance peek_tok and peek_span to refer to the next token, and
@@ -301,7 +301,7 @@ impl<'a> StringReader<'a> {
             while i < s.len() {
                 let str::CharRange { ch, next } = s.char_range_at(i);
                 if ch == '\r' {
-                    if j < i { buf.push_str(s.index(&(j..i))); }
+                    if j < i { buf.push_str(&s[j..i]); }
                     j = next;
                     if next >= s.len() || s.char_at(next) != '\n' {
                         let pos = start + BytePos(i as u32);
@@ -311,7 +311,7 @@ impl<'a> StringReader<'a> {
                 }
                 i = next;
             }
-            if j < s.len() { buf.push_str(s.index(&(j..))); }
+            if j < s.len() { buf.push_str(&s[j..]); }
             buf
         }
     }
@@ -556,7 +556,7 @@ impl<'a> StringReader<'a> {
                     self.translate_crlf(start_bpos, string,
                                         "bare CR not allowed in block doc-comment")
                 } else { string.into_cow() };
-                token::DocComment(token::intern(string.index(&FullRange)))
+                token::DocComment(token::intern(&string[]))
             } else {
                 token::Comment
             };
@@ -1110,7 +1110,7 @@ impl<'a> StringReader<'a> {
                 // expansion purposes. See #12512 for the gory details of why
                 // this is necessary.
                 let ident = self.with_str_from(start, |lifetime_name| {
-                    str_to_ident(format!("'{}", lifetime_name).index(&FullRange))
+                    str_to_ident(&format!("'{}", lifetime_name)[])
                 });
 
                 // Conjure up a "keyword checking ident" to make sure that
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index d26b3af67bd47..c42a6beea2d44 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -253,19 +253,19 @@ pub fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
     let bytes = match File::open(path).read_to_end() {
         Ok(bytes) => bytes,
         Err(e) => {
-            err(format!("couldn't read {:?}: {:?}",
+            err(&format!("couldn't read {:?}: {:?}",
                         path.display(),
-                        e).index(&FullRange));
+                        e)[]);
             unreachable!()
         }
     };
-    match str::from_utf8(bytes.index(&FullRange)).ok() {
+    match str::from_utf8(&bytes[]).ok() {
         Some(s) => {
             return string_to_filemap(sess, s.to_string(),
                                      path.as_str().unwrap().to_string())
         }
         None => {
-            err(format!("{:?} is not UTF-8 encoded", path.display()).index(&FullRange))
+            err(&format!("{:?} is not UTF-8 encoded", path.display())[])
         }
     }
     unreachable!()
@@ -399,10 +399,10 @@ pub fn char_lit(lit: &str) -> (char, int) {
     }
 
     let msg = format!("lexer should have rejected a bad character escape {}", lit);
-    let msg2 = msg.index(&FullRange);
+    let msg2 = &msg[];
 
     fn esc(len: uint, lit: &str) -> Option<(char, int)> {
-        num::from_str_radix(lit.index(&(2..len)), 16)
+        num::from_str_radix(&lit[2..len], 16)
         .and_then(char::from_u32)
         .map(|x| (x, len as int))
     }
@@ -410,7 +410,7 @@ pub fn char_lit(lit: &str) -> (char, int) {
     let unicode_escape = |&: | -> Option<(char, int)>
         if lit.as_bytes()[2] == b'{' {
             let idx = lit.find('}').expect(msg2);
-            let subslice = lit.index(&(3..idx));
+            let subslice = &lit[3..idx];
             num::from_str_radix(subslice, 16)
                 .and_then(char::from_u32)
                 .map(|x| (x, subslice.chars().count() as int + 4))
@@ -472,7 +472,7 @@ pub fn str_lit(lit: &str) -> String {
                             eat(&mut chars);
                         } else {
                             // otherwise, a normal escape
-                            let (c, n) = char_lit(lit.index(&(i..)));
+                            let (c, n) = char_lit(&lit[i..]);
                             for _ in range(0, n - 1) { // we don't need to move past the first \
                                 chars.next();
                             }
@@ -535,7 +535,7 @@ pub fn raw_str_lit(lit: &str) -> String {
 fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
     s.len() > 1 &&
         first_chars.contains(&s.char_at(0)) &&
-        s.index(&(1..)).chars().all(|c| '0' <= c && c <= '9')
+        s[1..].chars().all(|c| '0' <= c && c <= '9')
 }
 
 fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
@@ -548,7 +548,7 @@ fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
             if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
                 // if it looks like a width, lets try to be helpful.
                 sd.span_err(sp, &*format!("illegal width `{}` for float literal, \
-                                          valid widths are 32 and 64", suf.index(&(1..))));
+                                          valid widths are 32 and 64", &suf[1..]));
             } else {
                 sd.span_err(sp, &*format!("illegal suffix `{}` for float literal, \
                                           valid suffixes are `f32` and `f64`", suf));
@@ -584,7 +584,7 @@ pub fn byte_lit(lit: &str) -> (u8, uint) {
             b'\'' => b'\'',
             b'0' => b'\0',
             _ => {
-                match ::std::num::from_str_radix::<u64>(lit.index(&(2..4)), 16) {
+                match ::std::num::from_str_radix::<u64>(&lit[2..4], 16) {
                     Some(c) =>
                         if c > 0xFF {
                             panic!(err(2))
@@ -634,7 +634,7 @@ pub fn binary_lit(lit: &str) -> Rc<Vec<u8>> {
                     }
                     _ => {
                         // otherwise, a normal escape
-                        let (c, n) = byte_lit(lit.index(&(i..)));
+                        let (c, n) = byte_lit(&lit[i..]);
                         // we don't need to move past the first \
                         for _ in range(0, n - 1) {
                             chars.next();
@@ -663,7 +663,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) ->
     // s can only be ascii, byte indexing is fine
 
     let s2 = s.chars().filter(|&c| c != '_').collect::<String>();
-    let mut s = s2.index(&FullRange);
+    let mut s = &s2[];
 
     debug!("integer_lit: {}, {:?}", s, suffix);
 
@@ -696,7 +696,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) ->
     }
 
     if base != 10 {
-        s = s.index(&(2..));
+        s = &s[2..];
     }
 
     if let Some(suf) = suffix {
@@ -720,7 +720,7 @@ pub fn integer_lit(s: &str, suffix: Option<&str>, sd: &SpanHandler, sp: Span) ->
                 if looks_like_width_suffix(&['i', 'u'], suf) {
                     sd.span_err(sp, &*format!("illegal width `{}` for integer literal; \
                                               valid widths are 8, 16, 32 and 64",
-                                              suf.index(&(1..))));
+                                              &suf[1..]));
                 } else {
                     sd.span_err(sp, &*format!("illegal suffix `{}` for numeric literal", suf));
                 }
@@ -818,7 +818,7 @@ mod test {
     #[test]
     fn string_to_tts_macro () {
         let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string());
-        let tts: &[ast::TokenTree] = tts.index(&FullRange);
+        let tts: &[ast::TokenTree] = &tts[];
         match tts {
             [ast::TtToken(_, token::Ident(name_macro_rules, token::Plain)),
              ast::TtToken(_, token::Not),
@@ -826,19 +826,19 @@ mod test {
              ast::TtDelimited(_, ref macro_delimed)]
             if name_macro_rules.as_str() == "macro_rules"
             && name_zip.as_str() == "zip" => {
-                match macro_delimed.tts.index(&FullRange) {
+                match &macro_delimed.tts[] {
                     [ast::TtDelimited(_, ref first_delimed),
                      ast::TtToken(_, token::FatArrow),
                      ast::TtDelimited(_, ref second_delimed)]
                     if macro_delimed.delim == token::Paren => {
-                        match first_delimed.tts.index(&FullRange) {
+                        match &first_delimed.tts[] {
                             [ast::TtToken(_, token::Dollar),
                              ast::TtToken(_, token::Ident(name, token::Plain))]
                             if first_delimed.delim == token::Paren
                             && name.as_str() == "a" => {},
                             _ => panic!("value 3: {:?}", **first_delimed),
                         }
-                        match second_delimed.tts.index(&FullRange) {
+                        match &second_delimed.tts[] {
                             [ast::TtToken(_, token::Dollar),
                              ast::TtToken(_, token::Ident(name, token::Plain))]
                             if second_delimed.delim == token::Paren
@@ -1116,24 +1116,24 @@ mod test {
         let use_s = "use foo::bar::baz;";
         let vitem = string_to_view_item(use_s.to_string());
         let vitem_s = view_item_to_string(&vitem);
-        assert_eq!(vitem_s.index(&FullRange), use_s);
+        assert_eq!(&vitem_s[], use_s);
 
         let use_s = "use foo::bar as baz;";
         let vitem = string_to_view_item(use_s.to_string());
         let vitem_s = view_item_to_string(&vitem);
-        assert_eq!(vitem_s.index(&FullRange), use_s);
+        assert_eq!(&vitem_s[], use_s);
     }
 
     #[test] fn parse_extern_crate() {
         let ex_s = "extern crate foo;";
         let vitem = string_to_view_item(ex_s.to_string());
         let vitem_s = view_item_to_string(&vitem);
-        assert_eq!(vitem_s.index(&FullRange), ex_s);
+        assert_eq!(&vitem_s[], ex_s);
 
         let ex_s = "extern crate \"foo\" as bar;";
         let vitem = string_to_view_item(ex_s.to_string());
         let vitem_s = view_item_to_string(&vitem);
-        assert_eq!(vitem_s.index(&FullRange), ex_s);
+        assert_eq!(&vitem_s[], ex_s);
     }
 
     fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
@@ -1212,7 +1212,7 @@ mod test {
         let docs = item.attrs.iter().filter(|a| a.name().get() == "doc")
                     .map(|a| a.value_str().unwrap().get().to_string()).collect::<Vec<_>>();
         let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
-        assert_eq!(docs.index(&FullRange), b);
+        assert_eq!(&docs[], b);
 
         let source = "/** doc comment\r\n *  with CRLF */\r\nfn foo() {}".to_string();
         let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap();
diff --git a/src/libsyntax/parse/obsolete.rs b/src/libsyntax/parse/obsolete.rs
index 23728c74ae8b5..e9e207e7dbc3b 100644
--- a/src/libsyntax/parse/obsolete.rs
+++ b/src/libsyntax/parse/obsolete.rs
@@ -127,13 +127,13 @@ impl<'a> ParserObsoleteMethods for parser::Parser<'a> {
               kind_str: &str,
               desc: &str) {
         self.span_err(sp,
-                      format!("obsolete syntax: {}", kind_str).index(&FullRange));
+                      &format!("obsolete syntax: {}", kind_str)[]);
 
         if !self.obsolete_set.contains(&kind) {
             self.sess
                 .span_diagnostic
                 .handler()
-                .note(format!("{}", desc).index(&FullRange));
+                .note(&format!("{}", desc)[]);
             self.obsolete_set.insert(kind);
         }
     }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 9c16dbb2c5c0a..531e611594a59 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -16,7 +16,7 @@ use ast::{AssociatedType, BareFnTy};
 use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
 use ast::{ProvidedMethod, Public, Unsafety};
 use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
-use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, Block};
+use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, BiGt, Block};
 use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause};
 use ast::{Crate, CrateConfig, Decl, DeclItem};
 use ast::{DeclLocal, DefaultBlock, UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
@@ -388,13 +388,13 @@ impl<'a> Parser<'a> {
     pub fn unexpected_last(&mut self, t: &token::Token) -> ! {
         let token_str = Parser::token_to_string(t);
         let last_span = self.last_span;
-        self.span_fatal(last_span, format!("unexpected token: `{}`",
-                                                token_str).index(&FullRange));
+        self.span_fatal(last_span, &format!("unexpected token: `{}`",
+                                                token_str)[]);
     }
 
     pub fn unexpected(&mut self) -> ! {
         let this_token = self.this_token_to_string();
-        self.fatal(format!("unexpected token: `{}`", this_token).index(&FullRange));
+        self.fatal(&format!("unexpected token: `{}`", this_token)[]);
     }
 
     /// Expect and consume the token t. Signal an error if
@@ -406,9 +406,9 @@ impl<'a> Parser<'a> {
             } else {
                 let token_str = Parser::token_to_string(t);
                 let this_token_str = self.this_token_to_string();
-                self.fatal(format!("expected `{}`, found `{}`",
+                self.fatal(&format!("expected `{}`, found `{}`",
                                    token_str,
-                                   this_token_str).index(&FullRange))
+                                   this_token_str)[])
             }
         } else {
             self.expect_one_of(slice::ref_slice(t), &[]);
@@ -449,10 +449,10 @@ impl<'a> Parser<'a> {
             expected.push_all(&*self.expected_tokens);
             expected.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
             expected.dedup();
-            let expect = tokens_to_string(expected.index(&FullRange));
+            let expect = tokens_to_string(&expected[]);
             let actual = self.this_token_to_string();
             self.fatal(
-                (if expected.len() != 1 {
+                &(if expected.len() != 1 {
                     (format!("expected one of {}, found `{}`",
                              expect,
                              actual))
@@ -460,7 +460,7 @@ impl<'a> Parser<'a> {
                     (format!("expected {}, found `{}`",
                              expect,
                              actual))
-                }).index(&FullRange)
+                }[])
             )
         }
     }
@@ -493,7 +493,7 @@ impl<'a> Parser<'a> {
             // might be unit-struct construction; check for recoverableinput error.
             let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
             expected.push_all(inedible);
-            self.check_for_erroneous_unit_struct_expecting(expected.index(&FullRange));
+            self.check_for_erroneous_unit_struct_expecting(&expected[]);
         }
         self.expect_one_of(edible, inedible)
     }
@@ -510,9 +510,9 @@ impl<'a> Parser<'a> {
                .as_ref()
                .map_or(false, |t| t.is_ident() || t.is_path()) {
             let mut expected = edible.iter().map(|x| x.clone()).collect::<Vec<_>>();
-            expected.push_all(inedible.index(&FullRange));
+            expected.push_all(&inedible[]);
             self.check_for_erroneous_unit_struct_expecting(
-                expected.index(&FullRange));
+                &expected[]);
         }
         self.expect_one_of(edible, inedible)
     }
@@ -534,8 +534,8 @@ impl<'a> Parser<'a> {
             }
             _ => {
                 let token_str = self.this_token_to_string();
-                self.fatal((format!("expected ident, found `{}`",
-                                    token_str)).index(&FullRange))
+                self.fatal(&format!("expected ident, found `{}`",
+                                    token_str)[])
             }
         }
     }
@@ -592,8 +592,8 @@ impl<'a> Parser<'a> {
         if !self.eat_keyword(kw) {
             let id_interned_str = token::get_name(kw.to_name());
             let token_str = self.this_token_to_string();
-            self.fatal(format!("expected `{}`, found `{}`",
-                               id_interned_str, token_str).index(&FullRange))
+            self.fatal(&format!("expected `{}`, found `{}`",
+                               id_interned_str, token_str)[])
         }
     }
 
@@ -603,8 +603,8 @@ impl<'a> Parser<'a> {
             let token_str = self.this_token_to_string();
             let span = self.span;
             self.span_err(span,
-                          format!("expected identifier, found keyword `{}`",
-                                  token_str).index(&FullRange));
+                          &format!("expected identifier, found keyword `{}`",
+                                  token_str)[]);
         }
     }
 
@@ -612,8 +612,8 @@ impl<'a> Parser<'a> {
     pub fn check_reserved_keywords(&mut self) {
         if self.token.is_reserved_keyword() {
             let token_str = self.this_token_to_string();
-            self.fatal(format!("`{}` is a reserved keyword",
-                               token_str).index(&FullRange))
+            self.fatal(&format!("`{}` is a reserved keyword",
+                               token_str)[])
         }
     }
 
@@ -631,9 +631,9 @@ impl<'a> Parser<'a> {
                 let token_str = self.this_token_to_string();
                 let found_token =
                     Parser::token_to_string(&token::BinOp(token::And));
-                self.fatal(format!("expected `{}`, found `{}`",
+                self.fatal(&format!("expected `{}`, found `{}`",
                                    found_token,
-                                   token_str).index(&FullRange))
+                                   token_str)[])
             }
         }
     }
@@ -652,9 +652,9 @@ impl<'a> Parser<'a> {
                 let found_token = self.this_token_to_string();
                 let token_str =
                     Parser::token_to_string(&token::BinOp(token::Or));
-                self.fatal(format!("expected `{}`, found `{}`",
+                self.fatal(&format!("expected `{}`, found `{}`",
                                    token_str,
-                                   found_token).index(&FullRange))
+                                   found_token)[])
             }
         }
     }
@@ -695,9 +695,9 @@ impl<'a> Parser<'a> {
         if !self.eat_lt() {
             let found_token = self.this_token_to_string();
             let token_str = Parser::token_to_string(&token::Lt);
-            self.fatal(format!("expected `{}`, found `{}`",
+            self.fatal(&format!("expected `{}`, found `{}`",
                                token_str,
-                               found_token).index(&FullRange))
+                               found_token)[])
         }
     }
 
@@ -747,9 +747,9 @@ impl<'a> Parser<'a> {
             _ => {
                 let gt_str = Parser::token_to_string(&token::Gt);
                 let this_token_str = self.this_token_to_string();
-                self.fatal(format!("expected `{}`, found `{}`",
+                self.fatal(&format!("expected `{}`, found `{}`",
                                    gt_str,
-                                   this_token_str).index(&FullRange))
+                                   this_token_str)[])
             }
         }
     }
@@ -1371,7 +1371,7 @@ impl<'a> Parser<'a> {
                     let (inner_attrs, body) =
                         p.parse_inner_attrs_and_block();
                     let mut attrs = attrs;
-                    attrs.push_all(inner_attrs.index(&FullRange));
+                    attrs.push_all(&inner_attrs[]);
                     ProvidedMethod(P(ast::Method {
                         attrs: attrs,
                         id: ast::DUMMY_NODE_ID,
@@ -1389,8 +1389,8 @@ impl<'a> Parser<'a> {
 
                   _ => {
                       let token_str = p.this_token_to_string();
-                      p.fatal((format!("expected `;` or `{{`, found `{}`",
-                                       token_str)).index(&FullRange))
+                      p.fatal(&format!("expected `;` or `{{`, found `{}`",
+                                       token_str)[])
                   }
                 }
             }
@@ -1586,7 +1586,7 @@ impl<'a> Parser<'a> {
         } else {
             let this_token_str = self.this_token_to_string();
             let msg = format!("expected type, found `{}`", this_token_str);
-            self.fatal(msg.index(&FullRange));
+            self.fatal(&msg[]);
         };
 
         let sp = mk_sp(lo, self.last_span.hi);
@@ -1734,8 +1734,7 @@ impl<'a> Parser<'a> {
                     token::StrRaw(s, n) => {
                         (true,
                          LitStr(
-                            token::intern_and_get_ident(
-                                parse::raw_str_lit(s.as_str()).index(&FullRange)),
+                            token::intern_and_get_ident(&parse::raw_str_lit(s.as_str())[]),
                             ast::RawStr(n)))
                     }
                     token::Binary(i) =>
@@ -1979,7 +1978,7 @@ impl<'a> Parser<'a> {
                 };
             }
             _ => {
-                self.fatal(format!("expected a lifetime name").index(&FullRange));
+                self.fatal(&format!("expected a lifetime name")[]);
             }
         }
     }
@@ -2017,7 +2016,7 @@ impl<'a> Parser<'a> {
                     let msg = format!("expected `,` or `>` after lifetime \
                                       name, found `{}`",
                                       this_token_str);
-                    self.fatal(msg.index(&FullRange));
+                    self.fatal(&msg[]);
                 }
             }
         }
@@ -2501,16 +2500,16 @@ impl<'a> Parser<'a> {
                     let last_span = self.last_span;
                     let fstr = n.as_str();
                     self.span_err(last_span,
-                                  format!("unexpected token: `{}`", n.as_str()).index(&FullRange));
+                                  &format!("unexpected token: `{}`", n.as_str())[]);
                     if fstr.chars().all(|x| "0123456789.".contains_char(x)) {
                         let float = match fstr.parse::<f64>() {
                             Some(f) => f,
                             None => continue,
                         };
                         self.span_help(last_span,
-                            format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
+                            &format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
                                     float.trunc() as uint,
-                                    float.fract().to_string().index(&(1..))).index(&FullRange));
+                                    &float.fract().to_string()[1..])[]);
                     }
                     self.abort_if_errors();
 
@@ -2536,7 +2535,7 @@ impl<'a> Parser<'a> {
               }
 
               // expr[...]
-              // An index expression.
+              // Could be either an index expression or a slicing expression.
               token::OpenDelim(token::Bracket) => {
                 let bracket_pos = self.span.lo;
                 self.bump();
@@ -2576,22 +2575,6 @@ impl<'a> Parser<'a> {
                                    "use `&expr[]` to construct a slice of the whole of expr");
                 }
               }
-
-              // A range expression, either `expr..expr` or `expr..`.
-              token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
-                self.bump();
-
-                let opt_end = if self.token.can_begin_expr() {
-                    let end = self.parse_expr_res(RESTRICTION_NO_DOTS);
-                    Some(end)
-                } else {
-                    None
-                };
-
-                let hi = self.span.hi;
-                let range = self.mk_range(Some(e), opt_end);
-                return self.mk_expr(lo, hi, range);
-              }
               _ => return e
             }
         }
@@ -2655,8 +2638,8 @@ impl<'a> Parser<'a> {
         if self.quote_depth == 0u {
             match self.token {
                 token::SubstNt(name, _) =>
-                    self.fatal(format!("unknown macro variable `{}`",
-                                       token::get_ident(name)).index(&FullRange)),
+                    self.fatal(&format!("unknown macro variable `{}`",
+                                       token::get_ident(name))[]),
                 _ => {}
             }
         }
@@ -2717,8 +2700,8 @@ impl<'a> Parser<'a> {
                         Some(&sp) => p.span_note(sp, "unclosed delimiter"),
                     };
                     let token_str = p.this_token_to_string();
-                    p.fatal(format!("incorrect close delimiter: `{}`",
-                                    token_str).index(&FullRange))
+                    p.fatal(&format!("incorrect close delimiter: `{}`",
+                                    token_str)[])
                 },
                 /* we ought to allow different depths of unquotation */
                 token::Dollar | token::SubstNt(..) if p.quote_depth > 0u => {
@@ -2834,7 +2817,7 @@ impl<'a> Parser<'a> {
           token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
             // A range, closed above: `..expr`.
             self.bump();
-            let e = self.parse_prefix_expr();
+            let e = self.parse_expr();
             hi = e.span.hi;
             ex = self.mk_range(None, Some(e));
           }
@@ -2858,8 +2841,8 @@ impl<'a> Parser<'a> {
                         let span = self.span;
                         let this_token_to_string = self.this_token_to_string();
                         self.span_err(span,
-                                      format!("expected expression, found `{}`",
-                                              this_token_to_string).index(&FullRange));
+                                      &format!("expected expression, found `{}`",
+                                              this_token_to_string)[]);
                         let box_span = mk_sp(lo, self.last_span.hi);
                         self.span_help(box_span,
                                        "perhaps you meant `box() (foo)` instead?");
@@ -2901,11 +2884,15 @@ impl<'a> Parser<'a> {
             self.restrictions.contains(RESTRICTION_NO_BAR_OP) {
             return lhs;
         }
+
         self.expected_tokens.push(TokenType::Operator);
 
         let cur_opt = self.token.to_binop();
         match cur_opt {
             Some(cur_op) => {
+                if ast_util::is_comparison_binop(cur_op) {
+                    self.check_no_chained_comparison(&*lhs, cur_op)
+                }
                 let cur_prec = operator_prec(cur_op);
                 if cur_prec > min_prec {
                     self.bump();
@@ -2934,6 +2921,25 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Produce an error if comparison operators are chained (RFC #558).
+    /// We only need to check lhs, not rhs, because all comparison ops
+    /// have same precedence and are left-associative
+    fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: ast::BinOp) {
+        debug_assert!(ast_util::is_comparison_binop(outer_op));
+        match lhs.node {
+            ExprBinary(op, _, _) if ast_util::is_comparison_binop(op) => {
+                let op_span = self.span;
+                self.span_err(op_span,
+                    "Chained comparison operators require parentheses");
+                if op == BiLt && outer_op == BiGt {
+                    self.span_help(op_span,
+                        "Use ::< instead of < if you meant to specify type arguments.");
+                }
+            }
+            _ => {}
+        }
+    }
+
     /// Parse an assignment expression....
     /// actually, this seems to be the main entry point for
     /// parsing an arbitrary expression.
@@ -2970,6 +2976,23 @@ impl<'a> Parser<'a> {
               let assign_op = self.mk_assign_op(aop, lhs, rhs);
               self.mk_expr(span.lo, rhs_span.hi, assign_op)
           }
+          // A range expression, either `expr..expr` or `expr..`.
+          token::DotDot if !self.restrictions.contains(RESTRICTION_NO_DOTS) => {
+            self.bump();
+
+            let opt_end = if self.token.can_begin_expr() {
+                let end = self.parse_expr_res(RESTRICTION_NO_DOTS);
+                Some(end)
+            } else {
+                None
+            };
+
+            let lo = lhs.span.lo;
+            let hi = self.span.hi;
+            let range = self.mk_range(Some(lhs), opt_end);
+            return self.mk_expr(lo, hi, range);
+          }
+
           _ => {
               lhs
           }
@@ -3241,8 +3264,8 @@ impl<'a> Parser<'a> {
                 self.bump();
                 if self.token != token::CloseDelim(token::Brace) {
                     let token_str = self.this_token_to_string();
-                    self.fatal(format!("expected `{}`, found `{}`", "}",
-                                       token_str).index(&FullRange))
+                    self.fatal(&format!("expected `{}`, found `{}`", "}",
+                                       token_str)[])
                 }
                 etc = true;
                 break;
@@ -3262,8 +3285,8 @@ impl<'a> Parser<'a> {
                 match bind_type {
                     BindByRef(..) | BindByValue(MutMutable) => {
                         let token_str = self.this_token_to_string();
-                        self.fatal(format!("unexpected `{}`",
-                                           token_str).index(&FullRange))
+                        self.fatal(&format!("unexpected `{}`",
+                                           token_str)[])
                     }
                     _ => {}
                 }
@@ -3546,7 +3569,7 @@ impl<'a> Parser<'a> {
             let span = self.span;
             let tok_str = self.this_token_to_string();
             self.span_fatal(span,
-                            format!("expected identifier, found `{}`", tok_str).index(&FullRange));
+                            &format!("expected identifier, found `{}`", tok_str)[]);
         }
         let ident = self.parse_ident();
         let last_span = self.last_span;
@@ -3643,7 +3666,7 @@ impl<'a> Parser<'a> {
 
         let lo = self.span.lo;
         if self.token.is_keyword(keywords::Let) {
-            check_expected_item(self, item_attrs.index(&FullRange));
+            check_expected_item(self, &item_attrs[]);
             self.expect_keyword(keywords::Let);
             let decl = self.parse_let();
             P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
@@ -3652,7 +3675,7 @@ impl<'a> Parser<'a> {
             && self.look_ahead(1, |t| *t == token::Not) {
             // it's a macro invocation:
 
-            check_expected_item(self, item_attrs.index(&FullRange));
+            check_expected_item(self, &item_attrs[]);
 
             // Potential trouble: if we allow macros with paths instead of
             // idents, we'd need to look ahead past the whole path here...
@@ -3678,9 +3701,9 @@ impl<'a> Parser<'a> {
                         ""
                     };
                     let tok_str = self.this_token_to_string();
-                    self.fatal(format!("expected {}`(` or `{{`, found `{}`",
+                    self.fatal(&format!("expected {}`(` or `{{`, found `{}`",
                                        ident_str,
-                                       tok_str).index(&FullRange))
+                                       tok_str)[])
                 },
             };
 
@@ -3728,7 +3751,7 @@ impl<'a> Parser<'a> {
             }
         } else {
             let found_attrs = !item_attrs.is_empty();
-            let item_err = Parser::expected_item_err(item_attrs.index(&FullRange));
+            let item_err = Parser::expected_item_err(&item_attrs[]);
             match self.parse_item_or_view_item(item_attrs, false) {
                 IoviItem(i) => {
                     let hi = i.span.hi;
@@ -3772,7 +3795,7 @@ impl<'a> Parser<'a> {
             let sp = self.span;
             let tok = self.this_token_to_string();
             self.span_fatal_help(sp,
-                                 format!("expected `{{`, found `{}`", tok).index(&FullRange),
+                                 &format!("expected `{{`, found `{}`", tok)[],
                                  "place this code inside a block");
         }
 
@@ -3826,13 +3849,13 @@ impl<'a> Parser<'a> {
         while self.token != token::CloseDelim(token::Brace) {
             // parsing items even when they're not allowed lets us give
             // better error messages and recover more gracefully.
-            attributes_box.push_all(self.parse_outer_attributes().index(&FullRange));
+            attributes_box.push_all(&self.parse_outer_attributes()[]);
             match self.token {
                 token::Semi => {
                     if !attributes_box.is_empty() {
                         let last_span = self.last_span;
                         self.span_err(last_span,
-                                      Parser::expected_item_err(attributes_box.index(&FullRange)));
+                                      Parser::expected_item_err(&attributes_box[]));
                         attributes_box = Vec::new();
                     }
                     self.bump(); // empty
@@ -3924,7 +3947,7 @@ impl<'a> Parser<'a> {
         if !attributes_box.is_empty() {
             let last_span = self.last_span;
             self.span_err(last_span,
-                          Parser::expected_item_err(attributes_box.index(&FullRange)));
+                          Parser::expected_item_err(&attributes_box[]));
         }
 
         let hi = self.span.hi;
@@ -4367,8 +4390,8 @@ impl<'a> Parser<'a> {
             },
             _ => {
                 let token_str = self.this_token_to_string();
-                self.fatal(format!("expected `self`, found `{}`",
-                                   token_str).index(&FullRange))
+                self.fatal(&format!("expected `self`, found `{}`",
+                                   token_str)[])
             }
         }
     }
@@ -4521,8 +4544,8 @@ impl<'a> Parser<'a> {
                 }
                 _ => {
                     let token_str = self.this_token_to_string();
-                    self.fatal(format!("expected `,` or `)`, found `{}`",
-                                       token_str).index(&FullRange))
+                    self.fatal(&format!("expected `,` or `)`, found `{}`",
+                                       token_str)[])
                 }
             }
             }
@@ -4698,7 +4721,7 @@ impl<'a> Parser<'a> {
                 let (inner_attrs, body) = self.parse_inner_attrs_and_block();
                 let body_span = body.span;
                 let mut new_attrs = attrs;
-                new_attrs.push_all(inner_attrs.index(&FullRange));
+                new_attrs.push_all(&inner_attrs[]);
                 (ast::MethDecl(ident,
                                generics,
                                abi,
@@ -4915,17 +4938,17 @@ impl<'a> Parser<'a> {
             }
 
             if fields.len() == 0 {
-                self.fatal(format!("unit-like struct definition should be \
+                self.fatal(&format!("unit-like struct definition should be \
                     written as `struct {};`",
-                    token::get_ident(class_name.clone())).index(&FullRange));
+                    token::get_ident(class_name.clone()))[]);
             }
 
             self.bump();
         } else {
             let token_str = self.this_token_to_string();
-            self.fatal(format!("expected `where`, or `{}` after struct \
+            self.fatal(&format!("expected `where`, or `{}` after struct \
                                 name, found `{}`", "{",
-                                token_str).index(&FullRange));
+                                token_str)[]);
         }
 
         fields
@@ -4954,9 +4977,9 @@ impl<'a> Parser<'a> {
                 });
 
             if fields.len() == 0 {
-                self.fatal(format!("unit-like struct definition should be \
+                self.fatal(&format!("unit-like struct definition should be \
                     written as `struct {};`",
-                    token::get_ident(class_name.clone())).index(&FullRange));
+                    token::get_ident(class_name.clone()))[]);
             }
 
             self.parse_where_clause(generics);
@@ -4970,8 +4993,8 @@ impl<'a> Parser<'a> {
         // This case is where we see: `struct Foo<T>;`
         } else {
             let token_str = self.this_token_to_string();
-            self.fatal(format!("expected `where`, `{}`, `(`, or `;` after struct \
-                name, found `{}`", "{", token_str).index(&FullRange));
+            self.fatal(&format!("expected `where`, `{}`, `(`, or `;` after struct \
+                name, found `{}`", "{", token_str)[]);
         }
     }
 
@@ -4990,8 +5013,8 @@ impl<'a> Parser<'a> {
                 let span = self.span;
                 let token_str = self.this_token_to_string();
                 self.span_fatal_help(span,
-                                     format!("expected `,`, or `}}`, found `{}`",
-                                             token_str).index(&FullRange),
+                                     &format!("expected `,`, or `}}`, found `{}`",
+                                             token_str)[],
                                      "struct fields should be separated by commas")
             }
         }
@@ -5078,7 +5101,7 @@ impl<'a> Parser<'a> {
             let mut attrs = self.parse_outer_attributes();
             if first {
                 let mut tmp = attrs_remaining.clone();
-                tmp.push_all(attrs.index(&FullRange));
+                tmp.push_all(&attrs[]);
                 attrs = tmp;
                 first = false;
             }
@@ -5094,8 +5117,8 @@ impl<'a> Parser<'a> {
               }
               _ => {
                   let token_str = self.this_token_to_string();
-                  self.fatal(format!("expected item, found `{}`",
-                                     token_str).index(&FullRange))
+                  self.fatal(&format!("expected item, found `{}`",
+                                     token_str)[])
               }
             }
         }
@@ -5104,7 +5127,7 @@ impl<'a> Parser<'a> {
             // We parsed attributes for the first item but didn't find it
             let last_span = self.last_span;
             self.span_err(last_span,
-                          Parser::expected_item_err(attrs_remaining.index(&FullRange)));
+                          Parser::expected_item_err(&attrs_remaining[]));
         }
 
         ast::Mod {
@@ -5174,7 +5197,7 @@ impl<'a> Parser<'a> {
                     -> (ast::Item_, Vec<ast::Attribute> ) {
         let mut prefix = Path::new(self.sess.span_diagnostic.cm.span_to_filename(self.span));
         prefix.pop();
-        let mod_path = Path::new(".").join_many(self.mod_path_stack.index(&FullRange));
+        let mod_path = Path::new(".").join_many(&self.mod_path_stack[]);
         let dir_path = prefix.join(&mod_path);
         let mod_string = token::get_ident(id);
         let (file_path, owns_directory) = match ::attr::first_attr_value_str_by_name(
@@ -5184,8 +5207,8 @@ impl<'a> Parser<'a> {
                 let mod_name = mod_string.get().to_string();
                 let default_path_str = format!("{}.rs", mod_name);
                 let secondary_path_str = format!("{}/mod.rs", mod_name);
-                let default_path = dir_path.join(default_path_str.index(&FullRange));
-                let secondary_path = dir_path.join(secondary_path_str.index(&FullRange));
+                let default_path = dir_path.join(&default_path_str[]);
+                let secondary_path = dir_path.join(&secondary_path_str[]);
                 let default_exists = default_path.exists();
                 let secondary_exists = secondary_path.exists();
 
@@ -5197,16 +5220,16 @@ impl<'a> Parser<'a> {
                         None => self.root_module_name.as_ref().unwrap().clone(),
                     };
                     self.span_note(id_sp,
-                                   format!("maybe move this module `{0}` \
+                                   &format!("maybe move this module `{0}` \
                                             to its own directory via \
                                             `{0}/mod.rs`",
-                                           this_module).index(&FullRange));
+                                           this_module)[]);
                     if default_exists || secondary_exists {
                         self.span_note(id_sp,
-                                       format!("... or maybe `use` the module \
+                                       &format!("... or maybe `use` the module \
                                                 `{}` instead of possibly \
                                                 redeclaring it",
-                                               mod_name).index(&FullRange));
+                                               mod_name)[]);
                     }
                     self.abort_if_errors();
                 }
@@ -5216,22 +5239,22 @@ impl<'a> Parser<'a> {
                     (false, true) => (secondary_path, true),
                     (false, false) => {
                         self.span_fatal_help(id_sp,
-                                             format!("file not found for module `{}`",
-                                                     mod_name).index(&FullRange),
-                                             format!("name the file either {} or {} inside \
+                                             &format!("file not found for module `{}`",
+                                                     mod_name)[],
+                                             &format!("name the file either {} or {} inside \
                                                      the directory {:?}",
                                                      default_path_str,
                                                      secondary_path_str,
-                                                     dir_path.display()).index(&FullRange));
+                                                     dir_path.display())[]);
                     }
                     (true, true) => {
                         self.span_fatal_help(
                             id_sp,
-                            format!("file for module `{}` found at both {} \
+                            &format!("file for module `{}` found at both {} \
                                      and {}",
                                     mod_name,
                                     default_path_str,
-                                    secondary_path_str).index(&FullRange),
+                                    secondary_path_str)[],
                             "delete or rename one of them to remove the ambiguity");
                     }
                 }
@@ -5253,11 +5276,11 @@ impl<'a> Parser<'a> {
                 let mut err = String::from_str("circular modules: ");
                 let len = included_mod_stack.len();
                 for p in included_mod_stack.slice(i, len).iter() {
-                    err.push_str(p.display().as_cow().index(&FullRange));
+                    err.push_str(&p.display().as_cow()[]);
                     err.push_str(" -> ");
                 }
-                err.push_str(path.display().as_cow().index(&FullRange));
-                self.span_fatal(id_sp, err.index(&FullRange));
+                err.push_str(&path.display().as_cow()[]);
+                self.span_fatal(id_sp, &err[]);
             }
             None => ()
         }
@@ -5338,7 +5361,7 @@ impl<'a> Parser<'a> {
         if !attrs_remaining.is_empty() {
             let last_span = self.last_span;
             self.span_err(last_span,
-                          Parser::expected_item_err(attrs_remaining.index(&FullRange)));
+                          Parser::expected_item_err(&attrs_remaining[]));
         }
         assert!(self.token == token::CloseDelim(token::Brace));
         ast::ForeignMod {
@@ -5377,9 +5400,9 @@ impl<'a> Parser<'a> {
 
                     self.span_err(span, "expected `;`, found `as`");
                     self.span_help(span,
-                                   format!("perhaps you meant to enclose the crate name `{}` in \
+                                   &format!("perhaps you meant to enclose the crate name `{}` in \
                                            a string?",
-                                          the_ident.as_str()).index(&FullRange));
+                                          the_ident.as_str())[]);
                     None
                 } else {
                     None
@@ -5403,9 +5426,9 @@ impl<'a> Parser<'a> {
                 let span = self.span;
                 let token_str = self.this_token_to_string();
                 self.span_fatal(span,
-                                format!("expected extern crate name but \
+                                &format!("expected extern crate name but \
                                          found `{}`",
-                                        token_str).index(&FullRange));
+                                        token_str)[]);
             }
         };
 
@@ -5501,9 +5524,9 @@ impl<'a> Parser<'a> {
                 let struct_def = self.parse_struct_def();
                 if struct_def.fields.len() == 0 {
                     self.span_err(start_span,
-                        format!("unit-like struct variant should be written \
+                        &format!("unit-like struct variant should be written \
                                  without braces, as `{},`",
-                                token::get_ident(ident)).index(&FullRange));
+                                token::get_ident(ident))[]);
                 }
                 kind = StructVariantKind(struct_def);
             } else if self.check(&token::OpenDelim(token::Paren)) {
@@ -5585,10 +5608,10 @@ impl<'a> Parser<'a> {
                         let last_span = self.last_span;
                         self.span_err(
                             last_span,
-                            format!("illegal ABI: expected one of [{}], \
+                            &format!("illegal ABI: expected one of [{}], \
                                      found `{}`",
                                     abi::all_names().connect(", "),
-                                    the_string).index(&FullRange));
+                                    the_string)[]);
                         None
                     }
                 }
@@ -5647,10 +5670,10 @@ impl<'a> Parser<'a> {
                 if next_is_mod {
                     let last_span = self.last_span;
                     self.span_err(mk_sp(lo, last_span.hi),
-                                 format!("`extern mod` is obsolete, use \
+                                 &format!("`extern mod` is obsolete, use \
                                           `extern crate` instead \
                                           to refer to external \
-                                          crates.").index(&FullRange))
+                                          crates.")[])
                 }
                 return self.parse_item_extern_crate(lo, visibility, attrs);
             }
@@ -5677,8 +5700,8 @@ impl<'a> Parser<'a> {
             let span = self.span;
             let token_str = self.this_token_to_string();
             self.span_fatal(span,
-                            format!("expected `{}` or `fn`, found `{}`", "{",
-                                    token_str).index(&FullRange));
+                            &format!("expected `{}` or `fn`, found `{}`", "{",
+                                    token_str)[]);
         }
 
         if self.eat_keyword(keywords::Virtual) {
@@ -5791,7 +5814,7 @@ impl<'a> Parser<'a> {
         if self.eat_keyword(keywords::Mod) {
             // MODULE ITEM
             let (ident, item_, extra_attrs) =
-                self.parse_item_mod(attrs.index(&FullRange));
+                self.parse_item_mod(&attrs[]);
             let last_span = self.last_span;
             let item = self.mk_item(lo,
                                     last_span.hi,
@@ -6131,7 +6154,7 @@ impl<'a> Parser<'a> {
                                   macros_allowed: bool)
                                   -> ParsedItemsAndViewItems {
         let mut attrs = first_item_attrs;
-        attrs.push_all(self.parse_outer_attributes().index(&FullRange));
+        attrs.push_all(&self.parse_outer_attributes()[]);
         // First, parse view items.
         let mut view_items : Vec<ast::ViewItem> = Vec::new();
         let mut items = Vec::new();
@@ -6213,7 +6236,7 @@ impl<'a> Parser<'a> {
                            macros_allowed: bool)
         -> ParsedItemsAndViewItems {
         let mut attrs = first_item_attrs;
-        attrs.push_all(self.parse_outer_attributes().index(&FullRange));
+        attrs.push_all(&self.parse_outer_attributes()[]);
         let mut foreign_items = Vec::new();
         loop {
             match self.parse_foreign_item(attrs, macros_allowed) {
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 4378673891036..4b3573f84c571 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -480,7 +480,7 @@ macro_rules! declare_special_idents_and_keywords {(
         $(init_vec.push($si_str);)*
         $(init_vec.push($sk_str);)*
         $(init_vec.push($rk_str);)*
-        interner::StrInterner::prefill(init_vec.index(&FullRange))
+        interner::StrInterner::prefill(&init_vec[])
     }
 }}
 
@@ -629,7 +629,7 @@ impl InternedString {
 
     #[inline]
     pub fn get<'a>(&'a self) -> &'a str {
-        self.string.index(&FullRange)
+        &self.string[]
     }
 }
 
@@ -659,41 +659,41 @@ impl fmt::Show for InternedString {
 
 impl fmt::String for InternedString {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.string.index(&FullRange))
+        write!(f, "{}", &self.string[])
     }
 }
 
 impl<'a> PartialEq<&'a str> for InternedString {
     #[inline(always)]
     fn eq(&self, other: & &'a str) -> bool {
-        PartialEq::eq(self.string.index(&FullRange), *other)
+        PartialEq::eq(&self.string[], *other)
     }
     #[inline(always)]
     fn ne(&self, other: & &'a str) -> bool {
-        PartialEq::ne(self.string.index(&FullRange), *other)
+        PartialEq::ne(&self.string[], *other)
     }
 }
 
 impl<'a> PartialEq<InternedString > for &'a str {
     #[inline(always)]
     fn eq(&self, other: &InternedString) -> bool {
-        PartialEq::eq(*self, other.string.index(&FullRange))
+        PartialEq::eq(*self, &other.string[])
     }
     #[inline(always)]
     fn ne(&self, other: &InternedString) -> bool {
-        PartialEq::ne(*self, other.string.index(&FullRange))
+        PartialEq::ne(*self, &other.string[])
     }
 }
 
 impl Decodable for InternedString {
     fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
-        Ok(get_name(get_ident_interner().intern(try!(d.read_str()).index(&FullRange))))
+        Ok(get_name(get_ident_interner().intern(&try!(d.read_str())[])))
     }
 }
 
 impl Encodable for InternedString {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self.string.index(&FullRange))
+        s.emit_str(&self.string[])
     }
 }
 
diff --git a/src/libsyntax/print/pp.rs b/src/libsyntax/print/pp.rs
index 52306075c21ec..b69b812c9586e 100644
--- a/src/libsyntax/print/pp.rs
+++ b/src/libsyntax/print/pp.rs
@@ -138,9 +138,9 @@ pub fn buf_str(toks: Vec<Token>,
         if i != left {
             s.push_str(", ");
         }
-        s.push_str(format!("{}={}",
+        s.push_str(&format!("{}={}",
                            szs[i],
-                           tok_str(toks[i].clone())).index(&FullRange));
+                           tok_str(toks[i].clone()))[]);
         i += 1u;
         i %= n;
     }
@@ -602,7 +602,7 @@ impl Printer {
             assert_eq!(l, len);
             // assert!(l <= space);
             self.space -= len;
-            self.print_str(s.index(&FullRange))
+            self.print_str(&s[])
           }
           Eof => {
             // Eof should never get here.
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 87dcc9e70f461..9b6f8e6002d8a 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -114,7 +114,7 @@ pub fn print_crate<'a>(cm: &'a CodeMap,
                                       out,
                                       ann,
                                       is_expanded);
-    try!(s.print_mod(&krate.module, krate.attrs.index(&FullRange)));
+    try!(s.print_mod(&krate.module, &krate.attrs[]));
     try!(s.print_remaining_comments());
     eof(&mut s.s)
 }
@@ -580,7 +580,7 @@ impl<'a> State<'a> {
     pub fn synth_comment(&mut self, text: String) -> IoResult<()> {
         try!(word(&mut self.s, "/*"));
         try!(space(&mut self.s));
-        try!(word(&mut self.s, text.index(&FullRange)));
+        try!(word(&mut self.s, &text[]));
         try!(space(&mut self.s));
         word(&mut self.s, "*/")
     }
@@ -685,7 +685,7 @@ impl<'a> State<'a> {
             }
             ast::TyTup(ref elts) => {
                 try!(self.popen());
-                try!(self.commasep(Inconsistent, elts.index(&FullRange),
+                try!(self.commasep(Inconsistent, &elts[],
                                    |s, ty| s.print_type(&**ty)));
                 if elts.len() == 1 {
                     try!(word(&mut self.s, ","));
@@ -721,10 +721,10 @@ impl<'a> State<'a> {
             }
             ast::TyObjectSum(ref ty, ref bounds) => {
                 try!(self.print_type(&**ty));
-                try!(self.print_bounds("+", bounds.index(&FullRange)));
+                try!(self.print_bounds("+", &bounds[]));
             }
             ast::TyPolyTraitRef(ref bounds) => {
-                try!(self.print_bounds("", bounds.index(&FullRange)));
+                try!(self.print_bounds("", &bounds[]));
             }
             ast::TyQPath(ref qpath) => {
                 try!(word(&mut self.s, "<"));
@@ -759,7 +759,7 @@ impl<'a> State<'a> {
                               item: &ast::ForeignItem) -> IoResult<()> {
         try!(self.hardbreak_if_not_bol());
         try!(self.maybe_print_comment(item.span.lo));
-        try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&item.attrs[]));
         match item.node {
             ast::ForeignItemFn(ref decl, ref generics) => {
                 try!(self.print_fn(&**decl, None, abi::Rust, item.ident, generics,
@@ -769,8 +769,8 @@ impl<'a> State<'a> {
                 self.end() // end the outer fn box
             }
             ast::ForeignItemStatic(ref t, m) => {
-                try!(self.head(visibility_qualified(item.vis,
-                                                    "static").index(&FullRange)));
+                try!(self.head(&visibility_qualified(item.vis,
+                                                    "static")[]));
                 if m {
                     try!(self.word_space("mut"));
                 }
@@ -787,7 +787,7 @@ impl<'a> State<'a> {
     fn print_associated_type(&mut self, typedef: &ast::AssociatedType)
                              -> IoResult<()>
     {
-        try!(self.print_outer_attributes(typedef.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&typedef.attrs[]));
         try!(self.word_space("type"));
         try!(self.print_ty_param(&typedef.ty_param));
         word(&mut self.s, ";")
@@ -806,12 +806,12 @@ impl<'a> State<'a> {
     pub fn print_item(&mut self, item: &ast::Item) -> IoResult<()> {
         try!(self.hardbreak_if_not_bol());
         try!(self.maybe_print_comment(item.span.lo));
-        try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&item.attrs[]));
         try!(self.ann.pre(self, NodeItem(item)));
         match item.node {
             ast::ItemStatic(ref ty, m, ref expr) => {
-                try!(self.head(visibility_qualified(item.vis,
-                                                    "static").index(&FullRange)));
+                try!(self.head(&visibility_qualified(item.vis,
+                                                    "static")[]));
                 if m == ast::MutMutable {
                     try!(self.word_space("mut"));
                 }
@@ -827,8 +827,8 @@ impl<'a> State<'a> {
                 try!(self.end()); // end the outer cbox
             }
             ast::ItemConst(ref ty, ref expr) => {
-                try!(self.head(visibility_qualified(item.vis,
-                                                    "const").index(&FullRange)));
+                try!(self.head(&visibility_qualified(item.vis,
+                                                    "const")[]));
                 try!(self.print_ident(item.ident));
                 try!(self.word_space(":"));
                 try!(self.print_type(&**ty));
@@ -851,29 +851,28 @@ impl<'a> State<'a> {
                     item.vis
                 ));
                 try!(word(&mut self.s, " "));
-                try!(self.print_block_with_attrs(&**body, item.attrs.index(&FullRange)));
+                try!(self.print_block_with_attrs(&**body, &item.attrs[]));
             }
             ast::ItemMod(ref _mod) => {
-                try!(self.head(visibility_qualified(item.vis,
-                                                    "mod").index(&FullRange)));
+                try!(self.head(&visibility_qualified(item.vis,
+                                                    "mod")[]));
                 try!(self.print_ident(item.ident));
                 try!(self.nbsp());
                 try!(self.bopen());
-                try!(self.print_mod(_mod, item.attrs.index(&FullRange)));
+                try!(self.print_mod(_mod, &item.attrs[]));
                 try!(self.bclose(item.span));
             }
             ast::ItemForeignMod(ref nmod) => {
                 try!(self.head("extern"));
-                try!(self.word_nbsp(nmod.abi.to_string().index(&FullRange)));
+                try!(self.word_nbsp(&nmod.abi.to_string()[]));
                 try!(self.bopen());
-                try!(self.print_foreign_mod(nmod, item.attrs.index(&FullRange)));
+                try!(self.print_foreign_mod(nmod, &item.attrs[]));
                 try!(self.bclose(item.span));
             }
             ast::ItemTy(ref ty, ref params) => {
                 try!(self.ibox(indent_unit));
                 try!(self.ibox(0u));
-                try!(self.word_nbsp(visibility_qualified(item.vis,
-                                                         "type").index(&FullRange)));
+                try!(self.word_nbsp(&visibility_qualified(item.vis, "type")[]));
                 try!(self.print_ident(item.ident));
                 try!(self.print_generics(params));
                 try!(self.end()); // end the inner ibox
@@ -895,7 +894,7 @@ impl<'a> State<'a> {
                 ));
             }
             ast::ItemStruct(ref struct_def, ref generics) => {
-                try!(self.head(visibility_qualified(item.vis,"struct").index(&FullRange)));
+                try!(self.head(&visibility_qualified(item.vis,"struct")[]));
                 try!(self.print_struct(&**struct_def, generics, item.ident, item.span));
             }
 
@@ -936,7 +935,7 @@ impl<'a> State<'a> {
 
                 try!(space(&mut self.s));
                 try!(self.bopen());
-                try!(self.print_inner_attributes(item.attrs.index(&FullRange)));
+                try!(self.print_inner_attributes(&item.attrs[]));
                 for impl_item in impl_items.iter() {
                     match *impl_item {
                         ast::MethodImplItem(ref meth) => {
@@ -967,7 +966,7 @@ impl<'a> State<'a> {
                         real_bounds.push(b);
                     }
                 }
-                try!(self.print_bounds(":", real_bounds.index(&FullRange)));
+                try!(self.print_bounds(":", &real_bounds[]));
                 try!(self.print_where_clause(generics));
                 try!(word(&mut self.s, " "));
                 try!(self.bopen());
@@ -985,7 +984,7 @@ impl<'a> State<'a> {
                 try!(self.print_ident(item.ident));
                 try!(self.cbox(indent_unit));
                 try!(self.popen());
-                try!(self.print_tts(tts.index(&FullRange)));
+                try!(self.print_tts(&tts[]));
                 try!(self.pclose());
                 try!(word(&mut self.s, ";"));
                 try!(self.end());
@@ -1019,12 +1018,12 @@ impl<'a> State<'a> {
                           generics: &ast::Generics, ident: ast::Ident,
                           span: codemap::Span,
                           visibility: ast::Visibility) -> IoResult<()> {
-        try!(self.head(visibility_qualified(visibility, "enum").index(&FullRange)));
+        try!(self.head(&visibility_qualified(visibility, "enum")[]));
         try!(self.print_ident(ident));
         try!(self.print_generics(generics));
         try!(self.print_where_clause(generics));
         try!(space(&mut self.s));
-        self.print_variants(enum_definition.variants.index(&FullRange), span)
+        self.print_variants(&enum_definition.variants[], span)
     }
 
     pub fn print_variants(&mut self,
@@ -1034,7 +1033,7 @@ impl<'a> State<'a> {
         for v in variants.iter() {
             try!(self.space_if_not_bol());
             try!(self.maybe_print_comment(v.span.lo));
-            try!(self.print_outer_attributes(v.node.attrs.index(&FullRange)));
+            try!(self.print_outer_attributes(&v.node.attrs[]));
             try!(self.ibox(indent_unit));
             try!(self.print_variant(&**v));
             try!(word(&mut self.s, ","));
@@ -1062,7 +1061,7 @@ impl<'a> State<'a> {
             if !struct_def.fields.is_empty() {
                 try!(self.popen());
                 try!(self.commasep(
-                    Inconsistent, struct_def.fields.index(&FullRange),
+                    Inconsistent, &struct_def.fields[],
                     |s, field| {
                         match field.node.kind {
                             ast::NamedField(..) => panic!("unexpected named field"),
@@ -1092,7 +1091,7 @@ impl<'a> State<'a> {
                     ast::NamedField(ident, visibility) => {
                         try!(self.hardbreak_if_not_bol());
                         try!(self.maybe_print_comment(field.span.lo));
-                        try!(self.print_outer_attributes(field.node.attrs.index(&FullRange)));
+                        try!(self.print_outer_attributes(&field.node.attrs[]));
                         try!(self.print_visibility(visibility));
                         try!(self.print_ident(ident));
                         try!(self.word_nbsp(":"));
@@ -1116,7 +1115,7 @@ impl<'a> State<'a> {
     pub fn print_tt(&mut self, tt: &ast::TokenTree) -> IoResult<()> {
         match *tt {
             ast::TtToken(_, ref tk) => {
-                try!(word(&mut self.s, token_to_string(tk).index(&FullRange)));
+                try!(word(&mut self.s, &token_to_string(tk)[]));
                 match *tk {
                     parse::token::DocComment(..) => {
                         hardbreak(&mut self.s)
@@ -1125,11 +1124,11 @@ impl<'a> State<'a> {
                 }
             }
             ast::TtDelimited(_, ref delimed) => {
-                try!(word(&mut self.s, token_to_string(&delimed.open_token()).index(&FullRange)));
+                try!(word(&mut self.s, &token_to_string(&delimed.open_token())[]));
                 try!(space(&mut self.s));
-                try!(self.print_tts(delimed.tts.index(&FullRange)));
+                try!(self.print_tts(&delimed.tts[]));
                 try!(space(&mut self.s));
-                word(&mut self.s, token_to_string(&delimed.close_token()).index(&FullRange))
+                word(&mut self.s, &token_to_string(&delimed.close_token())[])
             },
             ast::TtSequence(_, ref seq) => {
                 try!(word(&mut self.s, "$("));
@@ -1139,7 +1138,7 @@ impl<'a> State<'a> {
                 try!(word(&mut self.s, ")"));
                 match seq.separator {
                     Some(ref tk) => {
-                        try!(word(&mut self.s, token_to_string(tk).index(&FullRange)));
+                        try!(word(&mut self.s, &token_to_string(tk)[]));
                     }
                     None => {},
                 }
@@ -1170,7 +1169,7 @@ impl<'a> State<'a> {
                 if !args.is_empty() {
                     try!(self.popen());
                     try!(self.commasep(Consistent,
-                                       args.index(&FullRange),
+                                       &args[],
                                        |s, arg| s.print_type(&*arg.ty)));
                     try!(self.pclose());
                 }
@@ -1194,7 +1193,7 @@ impl<'a> State<'a> {
     pub fn print_ty_method(&mut self, m: &ast::TypeMethod) -> IoResult<()> {
         try!(self.hardbreak_if_not_bol());
         try!(self.maybe_print_comment(m.span.lo));
-        try!(self.print_outer_attributes(m.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&m.attrs[]));
         try!(self.print_ty_fn(None,
                               None,
                               m.unsafety,
@@ -1226,7 +1225,7 @@ impl<'a> State<'a> {
     pub fn print_method(&mut self, meth: &ast::Method) -> IoResult<()> {
         try!(self.hardbreak_if_not_bol());
         try!(self.maybe_print_comment(meth.span.lo));
-        try!(self.print_outer_attributes(meth.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&meth.attrs[]));
         match meth.node {
             ast::MethDecl(ident,
                           ref generics,
@@ -1244,7 +1243,7 @@ impl<'a> State<'a> {
                                    Some(&explicit_self.node),
                                    vis));
                 try!(word(&mut self.s, " "));
-                self.print_block_with_attrs(&**body, meth.attrs.index(&FullRange))
+                self.print_block_with_attrs(&**body, &meth.attrs[])
             },
             ast::MethMac(codemap::Spanned { node: ast::MacInvocTT(ref pth, ref tts, _),
                                             ..}) => {
@@ -1253,7 +1252,7 @@ impl<'a> State<'a> {
                 try!(word(&mut self.s, "! "));
                 try!(self.cbox(indent_unit));
                 try!(self.popen());
-                try!(self.print_tts(tts.index(&FullRange)));
+                try!(self.print_tts(&tts[]));
                 try!(self.pclose());
                 try!(word(&mut self.s, ";"));
                 self.end()
@@ -1520,7 +1519,7 @@ impl<'a> State<'a> {
             ast::ExprVec(ref exprs) => {
                 try!(self.ibox(indent_unit));
                 try!(word(&mut self.s, "["));
-                try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange)));
+                try!(self.commasep_exprs(Inconsistent, &exprs[]));
                 try!(word(&mut self.s, "]"));
                 try!(self.end());
             }
@@ -1541,7 +1540,7 @@ impl<'a> State<'a> {
                     try!(word(&mut self.s, "{"));
                     try!(self.commasep_cmnt(
                         Consistent,
-                        fields.index(&FullRange),
+                        &fields[],
                         |s, field| {
                             try!(s.ibox(indent_unit));
                             try!(s.print_ident(field.ident.node));
@@ -1568,7 +1567,7 @@ impl<'a> State<'a> {
             }
             ast::ExprTup(ref exprs) => {
                 try!(self.popen());
-                try!(self.commasep_exprs(Inconsistent, exprs.index(&FullRange)));
+                try!(self.commasep_exprs(Inconsistent, &exprs[]));
                 if exprs.len() == 1 {
                     try!(word(&mut self.s, ","));
                 }
@@ -1576,7 +1575,7 @@ impl<'a> State<'a> {
             }
             ast::ExprCall(ref func, ref args) => {
                 try!(self.print_expr_maybe_paren(&**func));
-                try!(self.print_call_post(args.index(&FullRange)));
+                try!(self.print_call_post(&args[]));
             }
             ast::ExprMethodCall(ident, ref tys, ref args) => {
                 let base_args = args.slice_from(1);
@@ -1585,7 +1584,7 @@ impl<'a> State<'a> {
                 try!(self.print_ident(ident.node));
                 if tys.len() > 0u {
                     try!(word(&mut self.s, "::<"));
-                    try!(self.commasep(Inconsistent, tys.index(&FullRange),
+                    try!(self.commasep(Inconsistent, &tys[],
                                        |s, ty| s.print_type(&**ty)));
                     try!(word(&mut self.s, ">"));
                 }
@@ -1782,11 +1781,11 @@ impl<'a> State<'a> {
                 try!(self.print_string(a.asm.get(), a.asm_str_style));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent, a.outputs.index(&FullRange),
+                try!(self.commasep(Inconsistent, &a.outputs[],
                                    |s, &(ref co, ref o, is_rw)| {
                     match co.get().slice_shift_char() {
                         Some(('=', operand)) if is_rw => {
-                            try!(s.print_string(format!("+{}", operand).index(&FullRange),
+                            try!(s.print_string(&format!("+{}", operand)[],
                                                 ast::CookedStr))
                         }
                         _ => try!(s.print_string(co.get(), ast::CookedStr))
@@ -1799,7 +1798,7 @@ impl<'a> State<'a> {
                 try!(space(&mut self.s));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent, a.inputs.index(&FullRange),
+                try!(self.commasep(Inconsistent, &a.inputs[],
                                    |s, &(ref co, ref o)| {
                     try!(s.print_string(co.get(), ast::CookedStr));
                     try!(s.popen());
@@ -1810,7 +1809,7 @@ impl<'a> State<'a> {
                 try!(space(&mut self.s));
                 try!(self.word_space(":"));
 
-                try!(self.commasep(Inconsistent, a.clobbers.index(&FullRange),
+                try!(self.commasep(Inconsistent, &a.clobbers[],
                                    |s, co| {
                     try!(s.print_string(co.get(), ast::CookedStr));
                     Ok(())
@@ -1884,7 +1883,7 @@ impl<'a> State<'a> {
     pub fn print_ident(&mut self, ident: ast::Ident) -> IoResult<()> {
         if self.encode_idents_with_hygiene {
             let encoded = ident.encode_with_hygiene();
-            try!(word(&mut self.s, encoded.index(&FullRange)))
+            try!(word(&mut self.s, &encoded[]))
         } else {
             try!(word(&mut self.s, token::get_ident(ident).get()))
         }
@@ -1892,7 +1891,7 @@ impl<'a> State<'a> {
     }
 
     pub fn print_uint(&mut self, i: uint) -> IoResult<()> {
-        word(&mut self.s, i.to_string().index(&FullRange))
+        word(&mut self.s, &i.to_string()[])
     }
 
     pub fn print_name(&mut self, name: ast::Name) -> IoResult<()> {
@@ -1966,7 +1965,7 @@ impl<'a> State<'a> {
                     }
                     try!(self.commasep(
                         Inconsistent,
-                        data.types.index(&FullRange),
+                        &data.types[],
                         |s, ty| s.print_type(&**ty)));
                         comma = true;
                 }
@@ -1989,7 +1988,7 @@ impl<'a> State<'a> {
                 try!(word(&mut self.s, "("));
                 try!(self.commasep(
                     Inconsistent,
-                    data.inputs.index(&FullRange),
+                    &data.inputs[],
                     |s, ty| s.print_type(&**ty)));
                 try!(word(&mut self.s, ")"));
 
@@ -2042,7 +2041,7 @@ impl<'a> State<'a> {
                     Some(ref args) => {
                         if !args.is_empty() {
                             try!(self.popen());
-                            try!(self.commasep(Inconsistent, args.index(&FullRange),
+                            try!(self.commasep(Inconsistent, &args[],
                                               |s, p| s.print_pat(&**p)));
                             try!(self.pclose());
                         }
@@ -2054,7 +2053,7 @@ impl<'a> State<'a> {
                 try!(self.nbsp());
                 try!(self.word_space("{"));
                 try!(self.commasep_cmnt(
-                    Consistent, fields.index(&FullRange),
+                    Consistent, &fields[],
                     |s, f| {
                         try!(s.cbox(indent_unit));
                         if !f.node.is_shorthand {
@@ -2075,7 +2074,7 @@ impl<'a> State<'a> {
             ast::PatTup(ref elts) => {
                 try!(self.popen());
                 try!(self.commasep(Inconsistent,
-                                   elts.index(&FullRange),
+                                   &elts[],
                                    |s, p| s.print_pat(&**p)));
                 if elts.len() == 1 {
                     try!(word(&mut self.s, ","));
@@ -2103,7 +2102,7 @@ impl<'a> State<'a> {
             ast::PatVec(ref before, ref slice, ref after) => {
                 try!(word(&mut self.s, "["));
                 try!(self.commasep(Inconsistent,
-                                   before.index(&FullRange),
+                                   &before[],
                                    |s, p| s.print_pat(&**p)));
                 for p in slice.iter() {
                     if !before.is_empty() { try!(self.word_space(",")); }
@@ -2117,7 +2116,7 @@ impl<'a> State<'a> {
                     if !after.is_empty() { try!(self.word_space(",")); }
                 }
                 try!(self.commasep(Inconsistent,
-                                   after.index(&FullRange),
+                                   &after[],
                                    |s, p| s.print_pat(&**p)));
                 try!(word(&mut self.s, "]"));
             }
@@ -2134,7 +2133,7 @@ impl<'a> State<'a> {
         }
         try!(self.cbox(indent_unit));
         try!(self.ibox(0u));
-        try!(self.print_outer_attributes(arm.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&arm.attrs[]));
         let mut first = true;
         for p in arm.pats.iter() {
             if first {
@@ -2234,7 +2233,7 @@ impl<'a> State<'a> {
 
         // HACK(eddyb) ignore the separately printed self argument.
         let args = if first {
-            decl.inputs.index(&FullRange)
+            &decl.inputs[]
         } else {
             decl.inputs.slice_from(1)
         };
@@ -2400,7 +2399,7 @@ impl<'a> State<'a> {
             ints.push(i);
         }
 
-        try!(self.commasep(Inconsistent, ints.index(&FullRange), |s, &idx| {
+        try!(self.commasep(Inconsistent, &ints[], |s, &idx| {
             if idx < generics.lifetimes.len() {
                 let lifetime = &generics.lifetimes[idx];
                 s.print_lifetime_def(lifetime)
@@ -2417,7 +2416,7 @@ impl<'a> State<'a> {
 
     pub fn print_ty_param(&mut self, param: &ast::TyParam) -> IoResult<()> {
         try!(self.print_ident(param.ident));
-        try!(self.print_bounds(":", param.bounds.index(&FullRange)));
+        try!(self.print_bounds(":", &param.bounds[]));
         match param.default {
             Some(ref default) => {
                 try!(space(&mut self.s));
@@ -2493,7 +2492,7 @@ impl<'a> State<'a> {
                 try!(word(&mut self.s, name.get()));
                 try!(self.popen());
                 try!(self.commasep(Consistent,
-                                   items.index(&FullRange),
+                                   &items[],
                                    |s, i| s.print_meta_item(&**i)));
                 try!(self.pclose());
             }
@@ -2529,7 +2528,7 @@ impl<'a> State<'a> {
                     try!(self.print_path(path, false));
                     try!(word(&mut self.s, "::{"));
                 }
-                try!(self.commasep(Inconsistent, idents.index(&FullRange), |s, w| {
+                try!(self.commasep(Inconsistent, &idents[], |s, w| {
                     match w.node {
                         ast::PathListIdent { name, .. } => {
                             s.print_ident(name)
@@ -2547,7 +2546,7 @@ impl<'a> State<'a> {
     pub fn print_view_item(&mut self, item: &ast::ViewItem) -> IoResult<()> {
         try!(self.hardbreak_if_not_bol());
         try!(self.maybe_print_comment(item.span.lo));
-        try!(self.print_outer_attributes(item.attrs.index(&FullRange)));
+        try!(self.print_outer_attributes(&item.attrs[]));
         try!(self.print_visibility(item.vis));
         match item.node {
             ast::ViewItemExternCrate(id, ref optional_path, _) => {
@@ -2689,7 +2688,7 @@ impl<'a> State<'a> {
             try!(self.pclose());
         }
 
-        try!(self.print_bounds(":", bounds.index(&FullRange)));
+        try!(self.print_bounds(":", &bounds[]));
 
         try!(self.print_fn_output(decl));
 
@@ -2748,7 +2747,7 @@ impl<'a> State<'a> {
         try!(self.maybe_print_comment(lit.span.lo));
         match self.next_lit(lit.span.lo) {
             Some(ref ltrl) => {
-                return word(&mut self.s, (*ltrl).lit.index(&FullRange));
+                return word(&mut self.s, &(*ltrl).lit[]);
             }
             _ => ()
         }
@@ -2758,7 +2757,7 @@ impl<'a> State<'a> {
                 let mut res = String::from_str("b'");
                 ascii::escape_default(byte, |c| res.push(c as char));
                 res.push('\'');
-                word(&mut self.s, res.index(&FullRange))
+                word(&mut self.s, &res[])
             }
             ast::LitChar(ch) => {
                 let mut res = String::from_str("'");
@@ -2766,36 +2765,36 @@ impl<'a> State<'a> {
                     res.push(c);
                 }
                 res.push('\'');
-                word(&mut self.s, res.index(&FullRange))
+                word(&mut self.s, &res[])
             }
             ast::LitInt(i, t) => {
                 match t {
                     ast::SignedIntLit(st, ast::Plus) => {
                         word(&mut self.s,
-                             ast_util::int_ty_to_string(st, Some(i as i64)).index(&FullRange))
+                             &ast_util::int_ty_to_string(st, Some(i as i64))[])
                     }
                     ast::SignedIntLit(st, ast::Minus) => {
                         let istr = ast_util::int_ty_to_string(st, Some(-(i as i64)));
                         word(&mut self.s,
-                             format!("-{}", istr).index(&FullRange))
+                             &format!("-{}", istr)[])
                     }
                     ast::UnsignedIntLit(ut) => {
                         word(&mut self.s, ast_util::uint_ty_to_string(ut, Some(i)).as_slice())
                     }
                     ast::UnsuffixedIntLit(ast::Plus) => {
-                        word(&mut self.s, format!("{}", i).index(&FullRange))
+                        word(&mut self.s, &format!("{}", i)[])
                     }
                     ast::UnsuffixedIntLit(ast::Minus) => {
-                        word(&mut self.s, format!("-{}", i).index(&FullRange))
+                        word(&mut self.s, &format!("-{}", i)[])
                     }
                 }
             }
             ast::LitFloat(ref f, t) => {
                 word(&mut self.s,
-                     format!(
+                     &format!(
                          "{}{}",
                          f.get(),
-                         ast_util::float_ty_to_string(t).index(&FullRange)).index(&FullRange))
+                         &ast_util::float_ty_to_string(t)[])[])
             }
             ast::LitFloatUnsuffixed(ref f) => word(&mut self.s, f.get()),
             ast::LitBool(val) => {
@@ -2807,7 +2806,7 @@ impl<'a> State<'a> {
                     ascii::escape_default(ch as u8,
                                           |ch| escaped.push(ch as char));
                 }
-                word(&mut self.s, format!("b\"{}\"", escaped).index(&FullRange))
+                word(&mut self.s, &format!("b\"{}\"", escaped)[])
             }
         }
     }
@@ -2848,7 +2847,7 @@ impl<'a> State<'a> {
             comments::Mixed => {
                 assert_eq!(cmnt.lines.len(), 1u);
                 try!(zerobreak(&mut self.s));
-                try!(word(&mut self.s, cmnt.lines[0].index(&FullRange)));
+                try!(word(&mut self.s, &cmnt.lines[0][]));
                 zerobreak(&mut self.s)
             }
             comments::Isolated => {
@@ -2857,7 +2856,7 @@ impl<'a> State<'a> {
                     // Don't print empty lines because they will end up as trailing
                     // whitespace
                     if !line.is_empty() {
-                        try!(word(&mut self.s, line.index(&FullRange)));
+                        try!(word(&mut self.s, &line[]));
                     }
                     try!(hardbreak(&mut self.s));
                 }
@@ -2866,13 +2865,13 @@ impl<'a> State<'a> {
             comments::Trailing => {
                 try!(word(&mut self.s, " "));
                 if cmnt.lines.len() == 1u {
-                    try!(word(&mut self.s, cmnt.lines[0].index(&FullRange)));
+                    try!(word(&mut self.s, &cmnt.lines[0][]));
                     hardbreak(&mut self.s)
                 } else {
                     try!(self.ibox(0u));
                     for line in cmnt.lines.iter() {
                         if !line.is_empty() {
-                            try!(word(&mut self.s, line.index(&FullRange)));
+                            try!(word(&mut self.s, &line[]));
                         }
                         try!(hardbreak(&mut self.s));
                     }
@@ -2905,7 +2904,7 @@ impl<'a> State<'a> {
                          string=st))
             }
         };
-        word(&mut self.s, st.index(&FullRange))
+        word(&mut self.s, &st[])
     }
 
     pub fn next_comment(&mut self) -> Option<comments::Comment> {
@@ -2936,7 +2935,7 @@ impl<'a> State<'a> {
             Some(abi::Rust) => Ok(()),
             Some(abi) => {
                 try!(self.word_nbsp("extern"));
-                self.word_nbsp(abi.to_string().index(&FullRange))
+                self.word_nbsp(&abi.to_string()[])
             }
             None => Ok(())
         }
@@ -2947,7 +2946,7 @@ impl<'a> State<'a> {
         match opt_abi {
             Some(abi) => {
                 try!(self.word_nbsp("extern"));
-                self.word_nbsp(abi.to_string().index(&FullRange))
+                self.word_nbsp(&abi.to_string()[])
             }
             None => Ok(())
         }
@@ -2963,7 +2962,7 @@ impl<'a> State<'a> {
 
         if abi != abi::Rust {
             try!(self.word_nbsp("extern"));
-            try!(self.word_nbsp(abi.to_string().index(&FullRange)));
+            try!(self.word_nbsp(&abi.to_string()[]));
         }
 
         word(&mut self.s, "fn")
diff --git a/src/libsyntax/ptr.rs b/src/libsyntax/ptr.rs
index 8abb46011e65c..13a14d069d705 100644
--- a/src/libsyntax/ptr.rs
+++ b/src/libsyntax/ptr.rs
@@ -37,9 +37,11 @@
 //!   Moreover, a switch to, e.g. `P<'a, T>` would be easy and mostly automated.
 
 use std::fmt::{self, Show};
-use std::hash::Hash;
+use std::hash::{Hash, Hasher};
+#[cfg(stage0)] use std::hash::Writer;
 use std::ops::Deref;
 use std::ptr;
+
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
 /// An owned smart pointer.
@@ -105,7 +107,14 @@ impl<T: Show> Show for P<T> {
     }
 }
 
-impl<S, T: Hash<S>> Hash<S> for P<T> {
+#[cfg(stage0)]
+impl<S: Writer, T: Hash<S>> Hash<S> for P<T> {
+    fn hash(&self, state: &mut S) {
+        (**self).hash(state);
+    }
+}
+#[cfg(not(stage0))]
+impl<S: Hasher, T: Hash<S>> Hash<S> for P<T> {
     fn hash(&self, state: &mut S) {
         (**self).hash(state);
     }
diff --git a/src/libsyntax/std_inject.rs b/src/libsyntax/std_inject.rs
index daa51203287b3..28b9eaa54aabc 100644
--- a/src/libsyntax/std_inject.rs
+++ b/src/libsyntax/std_inject.rs
@@ -40,7 +40,7 @@ pub fn maybe_inject_prelude(krate: ast::Crate) -> ast::Crate {
 }
 
 fn use_std(krate: &ast::Crate) -> bool {
-    !attr::contains_name(krate.attrs.index(&FullRange), "no_std")
+    !attr::contains_name(&krate.attrs[], "no_std")
 }
 
 fn no_prelude(attrs: &[ast::Attribute]) -> bool {
@@ -48,7 +48,7 @@ fn no_prelude(attrs: &[ast::Attribute]) -> bool {
 }
 
 struct StandardLibraryInjector<'a> {
-    alt_std_name: Option<String>,
+    alt_std_name: Option<String>
 }
 
 impl<'a> fold::Folder for StandardLibraryInjector<'a> {
@@ -56,7 +56,7 @@ impl<'a> fold::Folder for StandardLibraryInjector<'a> {
 
         // The name to use in `extern crate "name" as std;`
         let actual_crate_name = match self.alt_std_name {
-            Some(ref s) => token::intern_and_get_ident(s.index(&FullRange)),
+            Some(ref s) => token::intern_and_get_ident(&s[]),
             None => token::intern_and_get_ident("std"),
         };
 
@@ -84,14 +84,13 @@ impl<'a> fold::Folder for StandardLibraryInjector<'a> {
 
 fn inject_crates_ref(krate: ast::Crate, alt_std_name: Option<String>) -> ast::Crate {
     let mut fold = StandardLibraryInjector {
-        alt_std_name: alt_std_name,
+        alt_std_name: alt_std_name
     };
     fold.fold_crate(krate)
 }
 
 struct PreludeInjector<'a>;
 
-
 impl<'a> fold::Folder for PreludeInjector<'a> {
     fn fold_crate(&mut self, mut krate: ast::Crate) -> ast::Crate {
         // Add #![no_std] here, so we don't re-inject when compiling pretty-printed source.
@@ -104,27 +103,17 @@ impl<'a> fold::Folder for PreludeInjector<'a> {
         attr::mark_used(&no_std_attr);
         krate.attrs.push(no_std_attr);
 
-        if !no_prelude(krate.attrs.index(&FullRange)) {
-            // only add `use std::prelude::*;` if there wasn't a
-            // `#![no_implicit_prelude]` at the crate level.
-            // fold_mod() will insert glob path.
-            let globs_attr = attr::mk_attr_inner(attr::mk_attr_id(),
-                                                 attr::mk_list_item(
-                InternedString::new("feature"),
-                vec!(
-                    attr::mk_word_item(InternedString::new("globs")),
-                )));
-            // std_inject runs after feature checking so manually mark this attr
-            attr::mark_used(&globs_attr);
-            krate.attrs.push(globs_attr);
-
+        // only add `use std::prelude::*;` if there wasn't a
+        // `#![no_implicit_prelude]` at the crate level.
+        // fold_mod() will insert glob path.
+        if !no_prelude(&krate.attrs[]) {
             krate.module = self.fold_mod(krate.module);
         }
         krate
     }
 
     fn fold_item(&mut self, item: P<ast::Item>) -> SmallVector<P<ast::Item>> {
-        if !no_prelude(item.attrs.index(&FullRange)) {
+        if !no_prelude(&item.attrs[]) {
             // only recur if there wasn't `#![no_implicit_prelude]`
             // on this item, i.e. this means that the prelude is not
             // implicitly imported though the whole subtree
diff --git a/src/libsyntax/test.rs b/src/libsyntax/test.rs
index 711715355e950..bacfa0bbfce4f 100644
--- a/src/libsyntax/test.rs
+++ b/src/libsyntax/test.rs
@@ -73,14 +73,14 @@ pub fn modify_for_testing(sess: &ParseSess,
     // We generate the test harness when building in the 'test'
     // configuration, either with the '--test' or '--cfg test'
     // command line options.
-    let should_test = attr::contains_name(krate.config.index(&FullRange), "test");
+    let should_test = attr::contains_name(&krate.config[], "test");
 
     // Check for #[reexport_test_harness_main = "some_name"] which
     // creates a `use some_name = __test::main;`. This needs to be
     // unconditional, so that the attribute is still marked as used in
     // non-test builds.
     let reexport_test_harness_main =
-        attr::first_attr_value_str_by_name(krate.attrs.index(&FullRange),
+        attr::first_attr_value_str_by_name(&krate.attrs[],
                                            "reexport_test_harness_main");
 
     if should_test {
@@ -119,7 +119,7 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
             self.cx.path.push(ident);
         }
         debug!("current path: {}",
-               ast_util::path_name_i(self.cx.path.index(&FullRange)));
+               ast_util::path_name_i(&self.cx.path[]));
 
         if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
             match i.node {
@@ -277,8 +277,8 @@ fn strip_test_functions(krate: ast::Crate) -> ast::Crate {
     // When not compiling with --test we should not compile the
     // #[test] functions
     config::strip_items(krate, |attrs| {
-        !attr::contains_name(attrs.index(&FullRange), "test") &&
-        !attr::contains_name(attrs.index(&FullRange), "bench")
+        !attr::contains_name(&attrs[], "test") &&
+        !attr::contains_name(&attrs[], "bench")
     })
 }
 
@@ -291,7 +291,7 @@ enum HasTestSignature {
 
 
 fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
-    let has_test_attr = attr::contains_name(i.attrs.index(&FullRange), "test");
+    let has_test_attr = attr::contains_name(&i.attrs[], "test");
 
     fn has_test_signature(i: &ast::Item) -> HasTestSignature {
         match &i.node {
@@ -329,7 +329,7 @@ fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 }
 
 fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
-    let has_bench_attr = attr::contains_name(i.attrs.index(&FullRange), "bench");
+    let has_bench_attr = attr::contains_name(&i.attrs[], "bench");
 
     fn has_test_signature(i: &ast::Item) -> bool {
         match i.node {
@@ -384,7 +384,7 @@ We're going to be building a module that looks more or less like:
 mod __test {
   extern crate test (name = "test", vers = "...");
   fn main() {
-    test::test_main_static(::os::args().index(&FullRange), tests)
+    test::test_main_static(&::os::args()[], tests)
   }
 
   static tests : &'static [test::TestDescAndFn] = &[
@@ -510,8 +510,8 @@ fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
 }
 
 fn is_test_crate(krate: &ast::Crate) -> bool {
-    match attr::find_crate_name(krate.attrs.index(&FullRange)) {
-        Some(ref s) if "test" == s.get().index(&FullRange) => true,
+    match attr::find_crate_name(&krate.attrs[]) {
+        Some(ref s) if "test" == &s.get()[] => true,
         _ => false
     }
 }
@@ -551,11 +551,11 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> {
     // creates $name: $expr
     let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr);
 
-    debug!("encoding {}", ast_util::path_name_i(path.index(&FullRange)));
+    debug!("encoding {}", ast_util::path_name_i(&path[]));
 
     // path to the #[test] function: "foo::bar::baz"
-    let path_string = ast_util::path_name_i(path.index(&FullRange));
-    let name_expr = ecx.expr_str(span, token::intern_and_get_ident(path_string.index(&FullRange)));
+    let path_string = ast_util::path_name_i(&path[]);
+    let name_expr = ecx.expr_str(span, token::intern_and_get_ident(&path_string[]));
 
     // self::test::StaticTestName($name_expr)
     let name_expr = ecx.expr_call(span,
diff --git a/src/libsyntax/util/interner.rs b/src/libsyntax/util/interner.rs
index 93de342d487dc..5dca39f1aea06 100644
--- a/src/libsyntax/util/interner.rs
+++ b/src/libsyntax/util/interner.rs
@@ -20,6 +20,7 @@ use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::Hash;
+use std::collections::hash_map::Hasher;
 use std::ops::Deref;
 use std::rc::Rc;
 
@@ -28,8 +29,8 @@ pub struct Interner<T> {
     vect: RefCell<Vec<T> >,
 }
 
-// when traits can extend traits, we should extend index<Name,T> to get .index(&FullRange)
-impl<T: Eq + Hash + Clone + 'static> Interner<T> {
+// when traits can extend traits, we should extend index<Name,T> to get []
+impl<T: Eq + Hash<Hasher> + Clone + 'static> Interner<T> {
     pub fn new() -> Interner<T> {
         Interner {
             map: RefCell::new(HashMap::new()),
@@ -78,7 +79,7 @@ impl<T: Eq + Hash + Clone + 'static> Interner<T> {
     }
 
     pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
-    where Q: BorrowFrom<T> + Eq + Hash {
+    where Q: BorrowFrom<T> + Eq + Hash<Hasher> {
         let map = self.map.borrow();
         match (*map).get(val) {
             Some(v) => Some(*v),
@@ -109,27 +110,27 @@ impl Eq for RcStr {}
 
 impl Ord for RcStr {
     fn cmp(&self, other: &RcStr) -> Ordering {
-        self.index(&FullRange).cmp(other.index(&FullRange))
+        self[].cmp(&other[])
     }
 }
 
 impl fmt::Show for RcStr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use std::fmt::Show;
-        self.index(&FullRange).fmt(f)
+        self[].fmt(f)
     }
 }
 
 impl BorrowFrom<RcStr> for str {
     fn borrow_from(owned: &RcStr) -> &str {
-        owned.string.index(&FullRange)
+        &owned.string[]
     }
 }
 
 impl Deref for RcStr {
     type Target = str;
 
-    fn deref(&self) -> &str { self.string.index(&FullRange) }
+    fn deref(&self) -> &str { &self.string[] }
 }
 
 /// A StrInterner differs from Interner<String> in that it accepts
@@ -139,7 +140,7 @@ pub struct StrInterner {
     vect: RefCell<Vec<RcStr> >,
 }
 
-/// When traits can extend traits, we should extend index<Name,T> to get .index(&FullRange)
+/// When traits can extend traits, we should extend index<Name,T> to get []
 impl StrInterner {
     pub fn new() -> StrInterner {
         StrInterner {
@@ -203,7 +204,7 @@ impl StrInterner {
     }
 
     pub fn find<Q: ?Sized>(&self, val: &Q) -> Option<Name>
-    where Q: BorrowFrom<RcStr> + Eq + Hash {
+    where Q: BorrowFrom<RcStr> + Eq + Hash<Hasher> {
         match (*self.map.borrow()).get(val) {
             Some(v) => Some(*v),
             None => None,
diff --git a/src/libterm/lib.rs b/src/libterm/lib.rs
index c953f591d8058..b4f224cb4a7ce 100644
--- a/src/libterm/lib.rs
+++ b/src/libterm/lib.rs
@@ -40,6 +40,7 @@
 
 #![crate_name = "term"]
 #![experimental = "use the crates.io `term` library instead"]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -49,6 +50,7 @@
 
 #![allow(unknown_features)]
 #![feature(slicing_syntax)]
+#![feature(box_syntax)]
 #![deny(missing_docs)]
 
 #[macro_use] extern crate log;
diff --git a/src/libterm/terminfo/mod.rs b/src/libterm/terminfo/mod.rs
index f2dcdc6160aa9..4933938f33836 100644
--- a/src/libterm/terminfo/mod.rs
+++ b/src/libterm/terminfo/mod.rs
@@ -180,7 +180,7 @@ impl<T: Writer+Send> TerminfoTerminal<T> {
             }
         };
 
-        let entry = open(term.index(&FullRange));
+        let entry = open(&term[]);
         if entry.is_err() {
             if os::getenv("MSYSCON").map_or(false, |s| {
                     "mintty.exe" == s
diff --git a/src/libterm/terminfo/parser/compiled.rs b/src/libterm/terminfo/parser/compiled.rs
index 7a06849abd161..4735b6e8f2ad9 100644
--- a/src/libterm/terminfo/parser/compiled.rs
+++ b/src/libterm/terminfo/parser/compiled.rs
@@ -284,13 +284,13 @@ pub fn parse(file: &mut io::Reader, longnames: bool)
 
 
             // Find the offset of the NUL we want to go to
-            let nulpos = string_table.index(&((offset as uint) .. (string_table_bytes as uint)))
+            let nulpos = string_table[(offset as uint) .. (string_table_bytes as uint)]
                 .iter().position(|&b| b == 0);
             match nulpos {
                 Some(len) => {
                     string_map.insert(name.to_string(),
-                                      string_table.index(&((offset as uint) ..
-                                          (offset as uint + len))).to_vec())
+                                      string_table[(offset as uint) ..
+                                                   (offset as uint + len)].to_vec())
                 },
                 None => {
                     return Err("invalid file: missing NUL in \
diff --git a/src/libterm/terminfo/searcher.rs b/src/libterm/terminfo/searcher.rs
index 2651be1ebb8f5..1fca3c62f78ca 100644
--- a/src/libterm/terminfo/searcher.rs
+++ b/src/libterm/terminfo/searcher.rs
@@ -61,13 +61,13 @@ pub fn get_dbpath_for_term(term: &str) -> Option<Box<Path>> {
     for p in dirs_to_search.iter() {
         if p.exists() {
             let f = first_char.to_string();
-            let newp = p.join_many(&[f.index(&FullRange), term]);
+            let newp = p.join_many(&[&f[], term]);
             if newp.exists() {
                 return Some(box newp);
             }
             // on some installations the dir is named after the hex of the char (e.g. OS X)
             let f = format!("{:x}", first_char as uint);
-            let newp = p.join_many(&[f.index(&FullRange), term]);
+            let newp = p.join_many(&[&f[], term]);
             if newp.exists() {
                 return Some(box newp);
             }
diff --git a/src/libtest/lib.rs b/src/libtest/lib.rs
index 68d06cc4dab64..d04308814f85b 100644
--- a/src/libtest/lib.rs
+++ b/src/libtest/lib.rs
@@ -25,12 +25,15 @@
 
 #![crate_name = "test"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![crate_type = "dylib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://doc.rust-lang.org/nightly/")]
+#![allow(unknown_features)]
 #![feature(asm, slicing_syntax)]
+#![feature(box_syntax)]
 
 extern crate getopts;
 extern crate regex;
@@ -948,7 +951,7 @@ fn should_sort_failures_before_printing_them() {
 
     st.write_failures().unwrap();
     let s = match st.out {
-        Raw(ref m) => String::from_utf8_lossy(m.index(&FullRange)),
+        Raw(ref m) => String::from_utf8_lossy(&m[]),
         Pretty(_) => unreachable!()
     };
 
diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs
index 1abb52459e493..6061c4fd1d3d3 100644
--- a/src/libtest/stats.rs
+++ b/src/libtest/stats.rs
@@ -12,7 +12,7 @@
 
 use std::cmp::Ordering::{self, Less, Greater, Equal};
 use std::collections::hash_map::Entry::{Occupied, Vacant};
-use std::collections::hash_map;
+use std::collections::hash_map::{self, Hasher};
 use std::fmt;
 use std::hash::Hash;
 use std::io;
@@ -440,7 +440,7 @@ pub fn write_boxplot<W: Writer, T: Float + fmt::String + fmt::Show + FromPrimiti
 /// Returns a HashMap with the number of occurrences of every element in the
 /// sequence that the iterator exposes.
 pub fn freq_count<T, U>(mut iter: T) -> hash_map::HashMap<U, uint>
-  where T: Iterator<Item=U>, U: Eq + Clone + Hash
+  where T: Iterator<Item=U>, U: Eq + Clone + Hash<Hasher>
 {
     let mut map: hash_map::HashMap<U,uint> = hash_map::HashMap::new();
     for elem in iter {
diff --git a/src/libunicode/lib.rs b/src/libunicode/lib.rs
index db98b429e4067..33b5bc4b5a432 100644
--- a/src/libunicode/lib.rs
+++ b/src/libunicode/lib.rs
@@ -22,6 +22,7 @@
 
 #![crate_name = "unicode"]
 #![experimental]
+#![staged_api]
 #![crate_type = "rlib"]
 #![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
diff --git a/src/snapshots.txt b/src/snapshots.txt
index d6134898cbdc8..aa31974c67abd 100644
--- a/src/snapshots.txt
+++ b/src/snapshots.txt
@@ -1,3 +1,12 @@
+S 2015-01-07 9e4e524
+  freebsd-x86_64 2563d33151bce1bbe08a85d712564bddc7503fc6
+  linux-i386 d8b73fc9aa3ad72ce1408a41e35d78dba10eb4d4
+  linux-x86_64 697880d3640e981bbbf23284363e8e9a158b588d
+  macos-i386 a73b1fc03e8cac747aab0aa186292bb4332a7a98
+  macos-x86_64 e4ae2670ea4ba5c2e5b4245409c9cab45c9eeb5b
+  winnt-i386 ddffa59d9605aa05e83e8f664db802da512611e9
+  winnt-x86_64 a56261ebbc580c6c14b1c1d0be25010f5201dc3f
+
 S 2015-01-06 340ac04
   freebsd-x86_64 5413b8931d7076e90c873e0cc7a43e0793c2b17a
   linux-i386 cacb8e3ad15937916e455d8f63e740c30a807b10
diff --git a/src/test/auxiliary/cci_nested_lib.rs b/src/test/auxiliary/cci_nested_lib.rs
index 44d001d45fda2..8494917c615eb 100644
--- a/src/test/auxiliary/cci_nested_lib.rs
+++ b/src/test/auxiliary/cci_nested_lib.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 use std::cell::RefCell;
 
diff --git a/src/test/auxiliary/issue-2380.rs b/src/test/auxiliary/issue-2380.rs
index af6bb050ef5a0..8eb6cd6e26318 100644
--- a/src/test/auxiliary/issue-2380.rs
+++ b/src/test/auxiliary/issue-2380.rs
@@ -11,6 +11,8 @@
 #![crate_name="a"]
 #![crate_type = "lib"]
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub trait i<T> { }
 
diff --git a/src/test/auxiliary/lint_group_plugin_test.rs b/src/test/auxiliary/lint_group_plugin_test.rs
index 097a5827fc4be..ae9804423bbd6 100644
--- a/src/test/auxiliary/lint_group_plugin_test.rs
+++ b/src/test/auxiliary/lint_group_plugin_test.rs
@@ -11,6 +11,7 @@
 // force-host
 
 #![feature(plugin_registrar)]
+#![feature(box_syntax)]
 
 extern crate syntax;
 
diff --git a/src/test/auxiliary/lint_plugin_test.rs b/src/test/auxiliary/lint_plugin_test.rs
index 01ef08c475234..06051b874939b 100644
--- a/src/test/auxiliary/lint_plugin_test.rs
+++ b/src/test/auxiliary/lint_plugin_test.rs
@@ -11,6 +11,7 @@
 // force-host
 
 #![feature(plugin_registrar)]
+#![feature(box_syntax)]
 
 extern crate syntax;
 
diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs
index 99f02cf2d58ba..9eeb7ee88571e 100644
--- a/src/test/auxiliary/macro_crate_test.rs
+++ b/src/test/auxiliary/macro_crate_test.rs
@@ -11,6 +11,7 @@
 // force-host
 
 #![feature(plugin_registrar, quote)]
+#![feature(box_syntax)]
 
 extern crate syntax;
 extern crate rustc;
diff --git a/src/test/auxiliary/method_self_arg1.rs b/src/test/auxiliary/method_self_arg1.rs
index 37022131c3d94..5865a8f467bad 100644
--- a/src/test/auxiliary/method_self_arg1.rs
+++ b/src/test/auxiliary/method_self_arg1.rs
@@ -10,6 +10,9 @@
 
 #![crate_type = "lib"]
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static mut COUNT: u64 = 1;
 
 pub fn get_count() -> u64 { unsafe { COUNT } }
diff --git a/src/test/auxiliary/method_self_arg2.rs b/src/test/auxiliary/method_self_arg2.rs
index eb4d62b01ad1a..a28a877a374bd 100644
--- a/src/test/auxiliary/method_self_arg2.rs
+++ b/src/test/auxiliary/method_self_arg2.rs
@@ -10,6 +10,9 @@
 
 #![crate_type = "lib"]
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static mut COUNT: u64 = 1;
 
 pub fn get_count() -> u64 { unsafe { COUNT } }
diff --git a/src/test/auxiliary/plugin_args.rs b/src/test/auxiliary/plugin_args.rs
index b90c3f1d727bf..e01a95d461b21 100644
--- a/src/test/auxiliary/plugin_args.rs
+++ b/src/test/auxiliary/plugin_args.rs
@@ -11,6 +11,7 @@
 // force-host
 
 #![feature(plugin_registrar)]
+#![feature(box_syntax)]
 
 extern crate syntax;
 extern crate rustc;
diff --git a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs
index 021eae90cf800..c460c60b02b06 100644
--- a/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs
+++ b/src/test/auxiliary/plugin_crate_outlive_expansion_phase.rs
@@ -11,6 +11,7 @@
 // force-host
 
 #![feature(plugin_registrar)]
+#![feature(box_syntax)]
 
 extern crate rustc;
 
diff --git a/src/test/bench/core-set.rs b/src/test/bench/core-set.rs
index 1dcac9fe0742d..edeb07c960e7e 100644
--- a/src/test/bench/core-set.rs
+++ b/src/test/bench/core-set.rs
@@ -18,6 +18,7 @@ extern crate rand;
 use std::collections::BTreeSet;
 use std::collections::BitvSet;
 use std::collections::HashSet;
+use std::collections::hash_map::Hasher;
 use std::hash::Hash;
 use std::os;
 use std::time::Duration;
@@ -43,7 +44,7 @@ trait MutableSet<T> {
     fn contains(&self, k: &T) -> bool;
 }
 
-impl<T: Hash + Eq> MutableSet<T> for HashSet<T> {
+impl<T: Hash<Hasher> + Eq> MutableSet<T> for HashSet<T> {
     fn insert(&mut self, k: T) { self.insert(k); }
     fn remove(&mut self, k: &T) -> bool { self.remove(k) }
     fn contains(&self, k: &T) -> bool { self.contains(k) }
diff --git a/src/test/bench/msgsend-pipes-shared.rs b/src/test/bench/msgsend-pipes-shared.rs
index 387601de8284c..a091e0853f96f 100644
--- a/src/test/bench/msgsend-pipes-shared.rs
+++ b/src/test/bench/msgsend-pipes-shared.rs
@@ -103,6 +103,6 @@ fn main() {
         args.into_iter().map(|x| x.to_string()).collect()
     };
 
-    println!("{}", args);
+    println!("{:?}", args);
     run(args.as_slice());
 }
diff --git a/src/test/bench/msgsend-pipes.rs b/src/test/bench/msgsend-pipes.rs
index d6d01e5452b95..a9e6cef38aaa6 100644
--- a/src/test/bench/msgsend-pipes.rs
+++ b/src/test/bench/msgsend-pipes.rs
@@ -112,6 +112,6 @@ fn main() {
         args.clone().into_iter().map(|x| x.to_string()).collect()
     };
 
-    println!("{}", args);
+    println!("{:?}", args);
     run(args.as_slice());
 }
diff --git a/src/test/bench/shootout-fannkuch-redux.rs b/src/test/bench/shootout-fannkuch-redux.rs
index 261741c073f3a..bd4b8e5e97f49 100644
--- a/src/test/bench/shootout-fannkuch-redux.rs
+++ b/src/test/bench/shootout-fannkuch-redux.rs
@@ -38,8 +38,6 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(slicing_syntax)]
-
 use std::{cmp, iter, mem};
 use std::thread::Thread;
 
diff --git a/src/test/bench/shootout-fasta-redux.rs b/src/test/bench/shootout-fasta-redux.rs
index 9a6152dc13c9d..5a47f9fbc573a 100644
--- a/src/test/bench/shootout-fasta-redux.rs
+++ b/src/test/bench/shootout-fasta-redux.rs
@@ -38,8 +38,6 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(slicing_syntax)]
-
 use std::cmp::min;
 use std::io::{stdout, IoResult};
 use std::iter::repeat;
diff --git a/src/test/bench/shootout-fasta.rs b/src/test/bench/shootout-fasta.rs
index 29994f45d3af2..e9da34615c192 100644
--- a/src/test/bench/shootout-fasta.rs
+++ b/src/test/bench/shootout-fasta.rs
@@ -38,8 +38,6 @@
 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 // OF THE POSSIBILITY OF SUCH DAMAGE.
 
-#![feature(slicing_syntax)]
-
 use std::cmp::min;
 use std::io::{BufferedWriter, File};
 use std::io;
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 3845c6c593c5f..03268b401933a 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -13,7 +13,7 @@
 
 // multi tasking k-nucleotide
 
-#![feature(slicing_syntax)]
+#![feature(box_syntax)]
 
 use std::ascii::{AsciiExt, OwnedAsciiExt};
 use std::cmp::Ordering::{self, Less, Greater, Equal};
@@ -64,7 +64,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String {
 
    let mut buffer = String::new();
    for &(ref k, v) in pairs_sorted.iter() {
-       buffer.push_str(format!("{} {:0.3}\n",
+       buffer.push_str(format!("{:?} {:0.3}\n",
                                k.to_ascii_uppercase(),
                                v).as_slice());
    }
@@ -193,8 +193,8 @@ fn main() {
            // start processing if this is the one
            ('>', false) => {
                match line.as_slice().slice_from(1).find_str("THREE") {
-                   option::Option::Some(_) => { proc_mode = true; }
-                   option::Option::None    => { }
+                   Some(_) => { proc_mode = true; }
+                   None    => { }
                }
            }
 
@@ -223,6 +223,6 @@ fn main() {
 
    // now fetch and print result messages
    for (ii, _sz) in sizes.iter().enumerate() {
-       println!("{}", from_child[ii].recv().unwrap());
+       println!("{:?}", from_child[ii].recv().unwrap());
    }
 }
diff --git a/src/test/bench/shootout-k-nucleotide.rs b/src/test/bench/shootout-k-nucleotide.rs
index d0ff47628d432..9057372d2cfa0 100644
--- a/src/test/bench/shootout-k-nucleotide.rs
+++ b/src/test/bench/shootout-k-nucleotide.rs
@@ -40,7 +40,7 @@
 
 // ignore-android see #10393 #13206
 
-#![feature(slicing_syntax)]
+#![feature(box_syntax)]
 
 use std::ascii::OwnedAsciiExt;
 use std::iter::repeat;
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index 34a036eff3750..0480c9d884ad0 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -118,7 +118,7 @@ fn transform(piece: Vec<(int, int)> , all: bool) -> Vec<Vec<(int, int)>> {
     // translating to (0, 0) as minimum coordinates.
     for cur_piece in res.iter_mut() {
         let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap();
-        for &(ref mut y, ref mut x) in cur_piece.iter_mut() {
+        for &mut (ref mut y, ref mut x) in cur_piece.iter_mut() {
             *y -= dy; *x -= dx;
         }
     }
diff --git a/src/test/bench/shootout-regex-dna.rs b/src/test/bench/shootout-regex-dna.rs
index ef538eb699189..074c059231299 100644
--- a/src/test/bench/shootout-regex-dna.rs
+++ b/src/test/bench/shootout-regex-dna.rs
@@ -41,7 +41,7 @@
 // ignore-stage1
 // ignore-cross-compile #12102
 
-#![feature(plugin, slicing_syntax)]
+#![feature(box_syntax)]
 
 extern crate regex;
 
diff --git a/src/test/bench/shootout-reverse-complement.rs b/src/test/bench/shootout-reverse-complement.rs
index 3003a88e972b4..841f70e13c4f9 100644
--- a/src/test/bench/shootout-reverse-complement.rs
+++ b/src/test/bench/shootout-reverse-complement.rs
@@ -40,7 +40,7 @@
 
 // ignore-android see #10393 #13206
 
-#![feature(slicing_syntax, unboxed_closures)]
+#![feature(unboxed_closures)]
 
 extern crate libc;
 
diff --git a/src/test/bench/sudoku.rs b/src/test/bench/sudoku.rs
index 85e8288b5cde5..786bbdfc8030a 100644
--- a/src/test/bench/sudoku.rs
+++ b/src/test/bench/sudoku.rs
@@ -10,6 +10,7 @@
 
 // ignore-pretty very bad with line comments
 
+#![feature(box_syntax)]
 #![allow(non_snake_case)]
 
 use std::io::BufferedReader;
diff --git a/src/test/bench/task-perf-alloc-unwind.rs b/src/test/bench/task-perf-alloc-unwind.rs
index 55e8dcbb6e8fb..dc536102d5dfd 100644
--- a/src/test/bench/task-perf-alloc-unwind.rs
+++ b/src/test/bench/task-perf-alloc-unwind.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(unsafe_destructor)]
+#![feature(unsafe_destructor, box_syntax)]
 
 use std::os;
 use std::thread::Thread;
diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs
index bbe5af1b51675..fb58028658e1b 100644
--- a/src/test/compile-fail/autoderef-full-lval.rs
+++ b/src/test/compile-fail/autoderef-full-lval.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct clam {
     x: Box<isize>,
     y: Box<isize>,
diff --git a/src/test/compile-fail/borrow-tuple-fields.rs b/src/test/compile-fail/borrow-tuple-fields.rs
index 1d09143c24d1d..59ed0e5fa0630 100644
--- a/src/test/compile-fail/borrow-tuple-fields.rs
+++ b/src/test/compile-fail/borrow-tuple-fields.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Foo(Box<int>, int);
 
 struct Bar(int, int);
diff --git a/src/test/compile-fail/borrowck-array-double-move.rs b/src/test/compile-fail/borrowck-array-double-move.rs
index c872d0dc4b9c4..ef2c629acfebd 100644
--- a/src/test/compile-fail/borrowck-array-double-move.rs
+++ b/src/test/compile-fail/borrowck-array-double-move.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f() {
     let mut a = [box 0i, box 1i];
     drop(a[0]);
diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
index ab2fc6c67b401..5a7788ed855ac 100644
--- a/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
+++ b/src/test/compile-fail/borrowck-bad-nested-calls-free.rs
@@ -11,6 +11,7 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
+#![feature(box_syntax)]
 
 fn rewrite(v: &mut Box<uint>) -> uint {
     *v = box 22;
diff --git a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
index 708eed0d113bd..263b7f9576b9f 100644
--- a/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
+++ b/src/test/compile-fail/borrowck-bad-nested-calls-move.rs
@@ -11,6 +11,7 @@
 // Test that we detect nested calls that could free pointers evaluated
 // for earlier arguments.
 
+#![feature(box_syntax)]
 
 fn rewrite(v: &mut Box<uint>) -> uint {
     *v = box 22;
diff --git a/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs b/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs
index 7e3c4658fc894..84f4e4f8817ca 100644
--- a/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs
+++ b/src/test/compile-fail/borrowck-borrow-immut-deref-of-box-as-mut.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct A;
 
 impl A {
diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
index 10c63965a7bbb..d983c5d508789 100644
--- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
+++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue-2.rs
@@ -18,7 +18,7 @@ struct defer<'a> {
 impl<'a> Drop for defer<'a> {
     fn drop(&mut self) {
         unsafe {
-            println!("{}", self.x);
+            println!("{:?}", self.x);
         }
     }
 }
diff --git a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
index f2ff5f86f6393..04ad583a2db42 100644
--- a/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
+++ b/src/test/compile-fail/borrowck-borrowed-uniq-rvalue.rs
@@ -10,6 +10,8 @@
 
 //buggy.rs
 
+#![feature(box_syntax)]
+
 extern crate collections;
 use std::collections::HashMap;
 
diff --git a/src/test/compile-fail/borrowck-box-insensitivity.rs b/src/test/compile-fail/borrowck-box-insensitivity.rs
index d05c03547ac4c..bd22b61fe3b60 100644
--- a/src/test/compile-fail/borrowck-box-insensitivity.rs
+++ b/src/test/compile-fail/borrowck-box-insensitivity.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct A {
     x: Box<int>,
     y: int,
diff --git a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
index 6dbdff9441d55..9aec8de46b6d9 100644
--- a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
+++ b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
@@ -11,6 +11,7 @@
 // Ensure that invoking a closure counts as a unique immutable borrow
 
 #![feature(unboxed_closures)]
+#![feature(box_syntax)]
 
 type Fn<'a> = Box<FnMut() + 'a>;
 
diff --git a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
index 47a47d0443255..126003b5d824d 100644
--- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
@@ -11,6 +11,7 @@
 // Tests that two closures cannot simultaneously have mutable
 // and immutable access to the variable. Issue #6801.
 
+#![feature(box_syntax)]
 
 fn get(x: &int) -> int {
     *x
diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs
index 0f284b5384913..e1f557cfab2d7 100644
--- a/src/test/compile-fail/borrowck-closures-two-mut.rs
+++ b/src/test/compile-fail/borrowck-closures-two-mut.rs
@@ -12,6 +12,7 @@
 // access to the variable, whether that mutable access be used
 // for direct assignment or for taking mutable ref. Issue #6801.
 
+#![feature(box_syntax)]
 
 fn a() {
     let mut x = 3i;
diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs
index 23c90fcf574d5..9aa9a50483c66 100644
--- a/src/test/compile-fail/borrowck-closures-use-after-free.rs
+++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs
@@ -12,6 +12,7 @@
 // cannot also be supplied a borrowed version of that
 // variable's contents. Issue #11192.
 
+#![feature(box_syntax)]
 
 struct Foo {
   x: int
diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs
index 49c93e3aa9e0c..52761fa348868 100644
--- a/src/test/compile-fail/borrowck-field-sensitivity.rs
+++ b/src/test/compile-fail/borrowck-field-sensitivity.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct A { a: int, b: Box<int> }
 
 fn deref_after_move() {
diff --git a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
index f0d42bb9ac115..bdcbc839c0056 100644
--- a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
+++ b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
@@ -10,6 +10,8 @@
 
 // Issue #16205.
 
+#![feature(box_syntax)]
+
 struct Foo {
     a: [Box<int>; 3],
 }
diff --git a/src/test/compile-fail/borrowck-issue-14498.rs b/src/test/compile-fail/borrowck-issue-14498.rs
index 45dda5fee5a32..8e46db5eba8bc 100644
--- a/src/test/compile-fail/borrowck-issue-14498.rs
+++ b/src/test/compile-fail/borrowck-issue-14498.rs
@@ -11,6 +11,8 @@
 // This tests that we can't modify Box<&mut T> contents while they
 // are borrowed.
 
+#![feature(box_syntax)]
+
 struct A { a: int }
 struct B<'a> { a: Box<&'a mut int> }
 
diff --git a/src/test/compile-fail/borrowck-issue-2657-1.rs b/src/test/compile-fail/borrowck-issue-2657-1.rs
index 9d28b2a436f4a..fa80bf38cfed9 100644
--- a/src/test/compile-fail/borrowck-issue-2657-1.rs
+++ b/src/test/compile-fail/borrowck-issue-2657-1.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let x = Some(box 1i);
     match x {
diff --git a/src/test/compile-fail/borrowck-issue-2657-2.rs b/src/test/compile-fail/borrowck-issue-2657-2.rs
index 973cf3bf8c889..f531b585ddef8 100644
--- a/src/test/compile-fail/borrowck-issue-2657-2.rs
+++ b/src/test/compile-fail/borrowck-issue-2657-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let x = Some(box 1i);
     match x {
diff --git a/src/test/compile-fail/borrowck-lend-flow-if.rs b/src/test/compile-fail/borrowck-lend-flow-if.rs
index f798d170f963b..8a618dfec1183 100644
--- a/src/test/compile-fail/borrowck-lend-flow-if.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-if.rs
@@ -14,6 +14,7 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+#![feature(box_syntax)]
 
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs
index ff038b545d5fe..954b801024421 100644
--- a/src/test/compile-fail/borrowck-lend-flow-loop.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs
@@ -14,6 +14,7 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+#![feature(box_syntax)]
 
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs
index 85fc7fb87b340..d5419b0585111 100644
--- a/src/test/compile-fail/borrowck-lend-flow.rs
+++ b/src/test/compile-fail/borrowck-lend-flow.rs
@@ -14,6 +14,7 @@
 // either genuine or would require more advanced changes.  The latter
 // cases are noted.
 
+#![feature(box_syntax)]
 
 fn borrow(_v: &int) {}
 fn borrow_mut(_v: &mut int) {}
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
index 5c282495cc239..8b39b6ff661b3 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) {
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move.rs b/src/test/compile-fail/borrowck-loan-blocks-move.rs
index 3c284ede0c89c..f588dbab4fa14 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn take(_v: Box<int>) {
 }
diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
index b6a71fcd446ab..e59baa1e37c8c 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) {
     f(v);
 }
diff --git a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
index 924d70e9f46c6..d955e8984bf39 100644
--- a/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
+++ b/src/test/compile-fail/borrowck-loan-in-overloaded-op.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::ops::Add;
 
 #[derive(Clone)]
diff --git a/src/test/compile-fail/borrowck-move-by-capture.rs b/src/test/compile-fail/borrowck-move-by-capture.rs
index 35f0751aa7895..2021276218817 100644
--- a/src/test/compile-fail/borrowck-move-by-capture.rs
+++ b/src/test/compile-fail/borrowck-move-by-capture.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 pub fn main() {
     let bar = box 3;
     let _g = |&mut:| {
diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs
index c61ec39ec50d1..4984987c5ca92 100644
--- a/src/test/compile-fail/borrowck-move-error-with-note.rs
+++ b/src/test/compile-fail/borrowck-move-error-with-note.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 enum Foo {
     Foo1(Box<u32>, Box<u32>),
diff --git a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
index 63409f5afb04c..936092df42e62 100644
--- a/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
+++ b/src/test/compile-fail/borrowck-move-from-subpath-of-borrowed-path.rs
@@ -11,6 +11,8 @@
 // verify that an error is raised when trying to move out of a
 // borrowed path.
 
+#![feature(box_syntax)]
+
 fn main() {
     let a = box box 2i;
     let b = &a;
diff --git a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
index ca484738cb6c8..35aef1352d1de 100644
--- a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
+++ b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn call_f<F:FnOnce() -> int>(f: F) -> int {
     f()
 }
diff --git a/src/test/compile-fail/borrowck-move-subcomponent.rs b/src/test/compile-fail/borrowck-move-subcomponent.rs
index a29a171e935dd..bdf6fe1f21d2c 100644
--- a/src/test/compile-fail/borrowck-move-subcomponent.rs
+++ b/src/test/compile-fail/borrowck-move-subcomponent.rs
@@ -11,6 +11,7 @@
 // Tests that the borrow checker checks all components of a path when moving
 // out.
 
+#![feature(box_syntax)]
 
 struct S {
   x : Box<int>
diff --git a/src/test/compile-fail/borrowck-multiple-captures.rs b/src/test/compile-fail/borrowck-multiple-captures.rs
index 2a26ff7d4a162..e90d25c781b42 100644
--- a/src/test/compile-fail/borrowck-multiple-captures.rs
+++ b/src/test/compile-fail/borrowck-multiple-captures.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 fn borrow<T>(_: &T) { }
diff --git a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
index db3fa6247db26..6985d203fb163 100644
--- a/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
+++ b/src/test/compile-fail/borrowck-no-cycle-in-exchange-heap.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct node_ {
     a: Box<cycle>
diff --git a/src/test/compile-fail/borrowck-overloaded-index-2.rs b/src/test/compile-fail/borrowck-overloaded-index-2.rs
index 53fb935755cf0..5e6d235574e69 100644
--- a/src/test/compile-fail/borrowck-overloaded-index-2.rs
+++ b/src/test/compile-fail/borrowck-overloaded-index-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::ops::Index;
 
 struct MyVec<T> {
diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs
index 9785b6a8f69a3..b0e8b2a523bd8 100644
--- a/src/test/compile-fail/borrowck-uniq-via-lend.rs
+++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn borrow(_v: &int) {}
 
diff --git a/src/test/compile-fail/borrowck-use-mut-borrow.rs b/src/test/compile-fail/borrowck-use-mut-borrow.rs
index 0d27473cb2d02..45813c45f0365 100644
--- a/src/test/compile-fail/borrowck-use-mut-borrow.rs
+++ b/src/test/compile-fail/borrowck-use-mut-borrow.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct A { a: int, b: int }
 
 impl Copy for A {}
diff --git a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
index 2eec788785605..c0abc3a25606a 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(advanced_slice_patterns)]
+#![feature(box_syntax)]
 
 fn a() {
     let mut vec = [box 1i, box 2, box 3];
diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs
index 1c7ae05961e66..c13faacfee443 100644
--- a/src/test/compile-fail/check-static-values-constraints.rs
+++ b/src/test/compile-fail/check-static-values-constraints.rs
@@ -10,6 +10,8 @@
 
 // Verifies all possible restrictions for statics values.
 
+#![feature(box_syntax)]
+
 use std::marker;
 
 struct WithDtor;
diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs
index ae0f377ba879d..25abd904d21cc 100644
--- a/src/test/compile-fail/class-cast-to-trait.rs
+++ b/src/test/compile-fail/class-cast-to-trait.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait noisy {
   fn speak(&self);
diff --git a/src/test/compile-fail/cross-borrow-trait.rs b/src/test/compile-fail/cross-borrow-trait.rs
index 1ccd5290fef87..ff96ea93184e6 100644
--- a/src/test/compile-fail/cross-borrow-trait.rs
+++ b/src/test/compile-fail/cross-borrow-trait.rs
@@ -11,6 +11,8 @@
 // Test that cross-borrowing (implicitly converting from `Box<T>` to `&T`) is
 // forbidden when `T` is a trait.
 
+#![feature(box_syntax)]
+
 struct Foo;
 trait Trait {}
 impl Trait for Foo {}
diff --git a/src/test/compile-fail/destructure-trait-ref.rs b/src/test/compile-fail/destructure-trait-ref.rs
index a2a5a3e257f29..0351040d329c4 100644
--- a/src/test/compile-fail/destructure-trait-ref.rs
+++ b/src/test/compile-fail/destructure-trait-ref.rs
@@ -11,6 +11,8 @@
 // The regression test for #15031 to make sure destructuring trait
 // reference work properly.
 
+#![feature(box_syntax)]
+
 trait T {}
 impl T for int {}
 
diff --git a/src/test/compile-fail/drop-on-non-struct.rs b/src/test/compile-fail/drop-on-non-struct.rs
index 238700254b8fd..8d2ca0b0a6b66 100644
--- a/src/test/compile-fail/drop-on-non-struct.rs
+++ b/src/test/compile-fail/drop-on-non-struct.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-impl Drop for int {
+impl<'a> Drop for &'a mut int {
     //~^ ERROR the Drop trait may only be implemented on structures
     //~^^ ERROR E0117
     fn drop(&mut self) {
diff --git a/src/test/compile-fail/drop-with-active-borrows-2.rs b/src/test/compile-fail/drop-with-active-borrows-2.rs
index 1cbd6292e9907..d9d3d79b5af16 100644
--- a/src/test/compile-fail/drop-with-active-borrows-2.rs
+++ b/src/test/compile-fail/drop-with-active-borrows-2.rs
@@ -15,5 +15,5 @@ fn read_lines_borrowed<'a>() -> Vec<&'a str> {
 }
 
 fn main() {
-    println!("{}", read_lines_borrowed());
+    println!("{:?}", read_lines_borrowed());
 }
diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs
index ebd0ee97efec4..6c40ca558de11 100644
--- a/src/test/compile-fail/dst-bad-assign-2.rs
+++ b/src/test/compile-fail/dst-bad-assign-2.rs
@@ -10,6 +10,8 @@
 
 // Forbid assignment into a dynamically sized type.
 
+#![feature(box_syntax)]
+
 struct Fat<T: ?Sized> {
     f1: int,
     f2: &'static str,
diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs
index f52c990ca52eb..78f70b9add051 100644
--- a/src/test/compile-fail/dst-bad-assign.rs
+++ b/src/test/compile-fail/dst-bad-assign.rs
@@ -10,6 +10,8 @@
 
 // Forbid assignment into a dynamically sized type.
 
+#![feature(box_syntax)]
+
 struct Fat<T: ?Sized> {
     f1: int,
     f2: &'static str,
diff --git a/src/test/compile-fail/dst-rvalue.rs b/src/test/compile-fail/dst-rvalue.rs
index 4c1dafd8c1a49..74e952364cd45 100644
--- a/src/test/compile-fail/dst-rvalue.rs
+++ b/src/test/compile-fail/dst-rvalue.rs
@@ -10,6 +10,8 @@
 
 // Check that dynamically sized rvalues are forbidden
 
+#![feature(box_syntax)]
+
 pub fn main() {
     let _x: Box<str> = box *"hello world";
     //~^ ERROR E0161
diff --git a/src/test/compile-fail/exclusive-drop-and-copy.rs b/src/test/compile-fail/exclusive-drop-and-copy.rs
new file mode 100644
index 0000000000000..17453bc677f2b
--- /dev/null
+++ b/src/test/compile-fail/exclusive-drop-and-copy.rs
@@ -0,0 +1,30 @@
+// 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.
+
+#![feature(unsafe_destructor)]
+
+// issue #20126
+
+#[derive(Copy)] //~ ERROR the trait `Copy` may not be implemented
+struct Foo;
+
+impl Drop for Foo {
+    fn drop(&mut self) {}
+}
+
+#[derive(Copy)] //~ ERROR the trait `Copy` may not be implemented
+struct Bar<T>;
+
+#[unsafe_destructor]
+impl<T> Drop for Bar<T> {
+    fn drop(&mut self) {}
+}
+
+fn main() {}
diff --git a/src/test/compile-fail/extern-with-type-bounds.rs b/src/test/compile-fail/extern-with-type-bounds.rs
new file mode 100644
index 0000000000000..8c7d00a9a11d4
--- /dev/null
+++ b/src/test/compile-fail/extern-with-type-bounds.rs
@@ -0,0 +1,33 @@
+// 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.
+
+#![feature(intrinsics)]
+
+use std::intrinsics::TypeId;
+
+extern "rust-intrinsic" {
+    // Real example from libcore
+    fn type_id<T: ?Sized + 'static>() -> TypeId;
+
+    // Silent bounds made explicit to make sure they are actually
+    // resolved.
+    fn transmute<T: Sized, U: Sized>(val: T) -> U;
+
+    // Bounds aren't checked right now, so this should work
+    // even though it's incorrect.
+    fn size_of<T: Clone>() -> uint;
+
+    // Unresolved bounds should still error.
+    fn align_of<T: NoSuchTrait>() -> uint;
+    //~^ ERROR attempt to bound type parameter with a nonexistent trait `NoSuchTrait`
+}
+
+fn main() {}
+
diff --git a/src/test/compile-fail/feature-gate-box-expr.rs b/src/test/compile-fail/feature-gate-box-expr.rs
new file mode 100644
index 0000000000000..bc7a70471cd8a
--- /dev/null
+++ b/src/test/compile-fail/feature-gate-box-expr.rs
@@ -0,0 +1,23 @@
+// 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.
+
+fn main() {
+    use std::boxed::HEAP;
+
+    let x = box 'c'; //~ ERROR box expression syntax is experimental in alpha release
+    println!("x: {}", x);
+
+    let x = box () 'c'; //~ ERROR box expression syntax is experimental in alpha release
+    println!("x: {}", x);
+
+    let x = box (HEAP) 'c'; //~ ERROR box expression syntax is experimental in alpha release
+    println!("x: {}", x);
+}
+
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs b/src/test/compile-fail/feature-gate-box-pat.rs
similarity index 69%
rename from src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs
rename to src/test/compile-fail/feature-gate-box-pat.rs
index 8e7c6147758ca..b36bc22b9dcce 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs
+++ b/src/test/compile-fail/feature-gate-box-pat.rs
@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(1024); //~ ERROR too large integer literal in bytes!
-    //~^ WARN `bytes!` is deprecated
+    let box x = Box::new('c'); //~ ERROR box pattern syntax is experimental in alpha release
+    println!("x: {}", x);
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs b/src/test/compile-fail/feature-gate-feature-gate.rs
similarity index 69%
rename from src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs
rename to src/test/compile-fail/feature-gate-feature-gate.rs
index c2d4973594371..b903b29658bbb 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs
+++ b/src/test/compile-fail/feature-gate-feature-gate.rs
@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main() {
-    let vec = bytes!(-1024); //~ ERROR non-literal in bytes
-    //~^ WARN `bytes!` is deprecated
-}
+#![forbid(unstable_features)]
+#![feature(intrinsics)] //~ ERROR unstable feature
+
+fn main() { }
diff --git a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
index cd49c7c016eeb..1e15e67876ed4 100644
--- a/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
+++ b/src/test/compile-fail/feature-gated-feature-in-macro-arg.rs
@@ -8,6 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// FIXME #20661: format_args! emits calls to the unstable std::fmt::rt
+// module, so the compiler has some hacks to make that possible
+// (in span_is_internal). Unnfortunately those hacks defeat this
+// particular scenario of checking feature gates in arguments to
+// println!().
+
+// ignore-test
+
 // tests that input to a macro is checked for use of gated features. If this
 // test succeeds due to the acceptance of a feature, pick a new feature to
 // test. Not ideal, but oh well :(
diff --git a/src/test/compile-fail/fn-trait-formatting.rs b/src/test/compile-fail/fn-trait-formatting.rs
index 06e8412ddaa23..723192952f2ee 100644
--- a/src/test/compile-fail/fn-trait-formatting.rs
+++ b/src/test/compile-fail/fn-trait-formatting.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(unboxed_closures)]
+#![feature(box_syntax)]
 
 fn needs_fn<F>(x: F) where F: Fn(isize) -> isize {}
 
diff --git a/src/test/compile-fail/huge-enum.rs b/src/test/compile-fail/huge-enum.rs
index 7c7a75abf3fc7..aef1fa85e0d94 100644
--- a/src/test/compile-fail/huge-enum.rs
+++ b/src/test/compile-fail/huge-enum.rs
@@ -12,12 +12,12 @@
 
 // FIXME: work properly with higher limits
 
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 fn main() {
     let big: Option<[u32; (1<<29)-1]> = None;
 }
 
-#[cfg(target_word_size = "64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 fn main() {
     let big: Option<[u32; (1<<45)-1]> = None;
 }
diff --git a/src/test/compile-fail/infinite-autoderef.rs b/src/test/compile-fail/infinite-autoderef.rs
index f0b9e796ae62d..3635c4dbb0263 100644
--- a/src/test/compile-fail/infinite-autoderef.rs
+++ b/src/test/compile-fail/infinite-autoderef.rs
@@ -10,6 +10,8 @@
 
 // error-pattern: reached the recursion limit while auto-dereferencing
 
+#![feature(box_syntax)]
+
 use std::ops::Deref;
 
 struct Foo;
diff --git a/src/test/compile-fail/issue-10291.rs b/src/test/compile-fail/issue-10291.rs
index dec4fc3b8f5b2..453746ffd6af1 100644
--- a/src/test/compile-fail/issue-10291.rs
+++ b/src/test/compile-fail/issue-10291.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn test<'x>(x: &'x int) {
     drop::<Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| {
         x
diff --git a/src/test/compile-fail/issue-10398.rs b/src/test/compile-fail/issue-10398.rs
index c90f064bf904c..11c577f9dc38d 100644
--- a/src/test/compile-fail/issue-10398.rs
+++ b/src/test/compile-fail/issue-10398.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let x = box 1i;
     let f = move|:| {
diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs
index f496c1e1227db..3784d3d6437ae 100644
--- a/src/test/compile-fail/issue-11192.rs
+++ b/src/test/compile-fail/issue-11192.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Foo {
     x: int
 }
diff --git a/src/test/compile-fail/issue-11515.rs b/src/test/compile-fail/issue-11515.rs
index 46fcb2ec340f9..f0089b0ae5b34 100644
--- a/src/test/compile-fail/issue-11515.rs
+++ b/src/test/compile-fail/issue-11515.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Test<'s> {
     func: Box<FnMut()+'static>
 }
diff --git a/src/test/compile-fail/issue-11844.rs b/src/test/compile-fail/issue-11844.rs
index 55c12b051b94d..560cbe1b8a87f 100644
--- a/src/test/compile-fail/issue-11844.rs
+++ b/src/test/compile-fail/issue-11844.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let a = Some(box 1);
     match a {
diff --git a/src/test/compile-fail/issue-11925.rs b/src/test/compile-fail/issue-11925.rs
index c561f0a696a9f..71e4598d63560 100644
--- a/src/test/compile-fail/issue-11925.rs
+++ b/src/test/compile-fail/issue-11925.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let r = {
         let x = box 42i;
diff --git a/src/test/compile-fail/issue-12116.rs b/src/test/compile-fail/issue-12116.rs
index 47907ac2be9b8..8a5e8c27259da 100644
--- a/src/test/compile-fail/issue-12116.rs
+++ b/src/test/compile-fail/issue-12116.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 enum IntList {
     Cons(int, Box<IntList>),
     Nil
diff --git a/src/test/compile-fail/issue-12127.rs b/src/test/compile-fail/issue-12127.rs
index 5f2837d28755d..2d87bdaf5242e 100644
--- a/src/test/compile-fail/issue-12127.rs
+++ b/src/test/compile-fail/issue-12127.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn do_it(x: &int) { }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-12470.rs b/src/test/compile-fail/issue-12470.rs
index 0202d538cf650..3187465530292 100644
--- a/src/test/compile-fail/issue-12470.rs
+++ b/src/test/compile-fail/issue-12470.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 trait X {
     fn get_i(&self) -> int;
 }
diff --git a/src/test/compile-fail/issue-14084.rs b/src/test/compile-fail/issue-14084.rs
index d247bf0913c3b..92e0dd3ad0e52 100644
--- a/src/test/compile-fail/issue-14084.rs
+++ b/src/test/compile-fail/issue-14084.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     box ( () ) 0;
     //~^ ERROR: only the managed heap and exchange heap are currently supported
diff --git a/src/test/compile-fail/issue-14915.rs b/src/test/compile-fail/issue-14915.rs
index 142fecc31fec1..18e4ccc331196 100644
--- a/src/test/compile-fail/issue-14915.rs
+++ b/src/test/compile-fail/issue-14915.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let x: Box<isize> = box 0;
 
diff --git a/src/test/compile-fail/issue-15756.rs b/src/test/compile-fail/issue-15756.rs
index c2d30224dc87f..02ccf9c0e08e7 100644
--- a/src/test/compile-fail/issue-15756.rs
+++ b/src/test/compile-fail/issue-15756.rs
@@ -14,7 +14,7 @@ use std::slice::ChunksMut;
 fn dft_iter<'a, T>(arg1: Chunks<'a,T>, arg2: ChunksMut<'a,T>)
 {
     for
-    &something
+    &mut something
 //~^ ERROR the trait `core::marker::Sized` is not implemented for the type `[T]`
     in arg2
     {
diff --git a/src/test/compile-fail/issue-17263.rs b/src/test/compile-fail/issue-17263.rs
index b610a2b0c91d6..ba993259216e5 100644
--- a/src/test/compile-fail/issue-17263.rs
+++ b/src/test/compile-fail/issue-17263.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Foo { a: int, b: int }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-17441.rs b/src/test/compile-fail/issue-17441.rs
index 6ae4fbca8b04c..a28162159a510 100644
--- a/src/test/compile-fail/issue-17441.rs
+++ b/src/test/compile-fail/issue-17441.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let _foo = &[1u, 2] as [usize];
     //~^ ERROR cast to unsized type: `&[usize; 2]` as `[usize]`
diff --git a/src/test/compile-fail/issue-17651.rs b/src/test/compile-fail/issue-17651.rs
index 589f1cf44bf16..d3678f7d87fdb 100644
--- a/src/test/compile-fail/issue-17651.rs
+++ b/src/test/compile-fail/issue-17651.rs
@@ -11,6 +11,8 @@
 // Test that moves of unsized values within closures are caught
 // and rejected.
 
+#![feature(box_syntax)]
+
 fn main() {
     (|&:| box *[0us].as_slice())();
     //~^ ERROR cannot move out of dereference
diff --git a/src/test/compile-fail/issue-17913.rs b/src/test/compile-fail/issue-17913.rs
index 3224edb381ccc..e2dbad56f84f2 100644
--- a/src/test/compile-fail/issue-17913.rs
+++ b/src/test/compile-fail/issue-17913.rs
@@ -8,16 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+
 // error-pattern: too big for the current architecture
 
-#[cfg(target_word_size = "64")]
+#![feature(box_syntax)]
+
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 fn main() {
     let n = 0u;
     let a = box [&n; 0xF000000000000000u];
     println!("{}", a[0xFFFFFFu]);
 }
 
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 fn main() {
     let n = 0u;
     let a = box [&n; 0xFFFFFFFFu];
diff --git a/src/test/compile-fail/issue-18783.rs b/src/test/compile-fail/issue-18783.rs
index 3a0fbddf8185f..657ef85233d5f 100644
--- a/src/test/compile-fail/issue-18783.rs
+++ b/src/test/compile-fail/issue-18783.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::cell::RefCell;
 
 fn main() {
diff --git a/src/test/compile-fail/issue-3601.rs b/src/test/compile-fail/issue-3601.rs
index f10305d017dc3..15b3ec0bfe708 100644
--- a/src/test/compile-fail/issue-3601.rs
+++ b/src/test/compile-fail/issue-3601.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct HTMLImageData {
     image: Option<String>
diff --git a/src/test/compile-fail/issue-3763.rs b/src/test/compile-fail/issue-3763.rs
index 73d42aa0de1ad..06939d8f35801 100644
--- a/src/test/compile-fail/issue-3763.rs
+++ b/src/test/compile-fail/issue-3763.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 mod my_mod {
     pub struct MyStruct {
diff --git a/src/test/compile-fail/issue-4335.rs b/src/test/compile-fail/issue-4335.rs
index d4f9ea5b276f9..f35332a2f039e 100644
--- a/src/test/compile-fail/issue-4335.rs
+++ b/src/test/compile-fail/issue-4335.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #![feature(unboxed_closures)]
+#![feature(box_syntax)]
 
 fn id<T>(t: T) -> T { t }
 
diff --git a/src/test/compile-fail/issue-4972.rs b/src/test/compile-fail/issue-4972.rs
index 765aec35fc6a8..b2b9dfce09217 100644
--- a/src/test/compile-fail/issue-4972.rs
+++ b/src/test/compile-fail/issue-4972.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait MyTrait { }
 
diff --git a/src/test/compile-fail/issue-5100.rs b/src/test/compile-fail/issue-5100.rs
index df3748ac93468..ca7f87ff61ae3 100644
--- a/src/test/compile-fail/issue-5100.rs
+++ b/src/test/compile-fail/issue-5100.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 enum A { B, C }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-5439.rs b/src/test/compile-fail/issue-5439.rs
index 55e3459a58922..72074d64edc3d 100644
--- a/src/test/compile-fail/issue-5439.rs
+++ b/src/test/compile-fail/issue-5439.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct Foo {
     foo: int,
diff --git a/src/test/compile-fail/issue-5543.rs b/src/test/compile-fail/issue-5543.rs
index 2d64013dc277f..cf98f1572e560 100644
--- a/src/test/compile-fail/issue-5543.rs
+++ b/src/test/compile-fail/issue-5543.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 trait Foo {}
 impl Foo for u8 {}
 
diff --git a/src/test/compile-fail/issue-6801.rs b/src/test/compile-fail/issue-6801.rs
index 433ae3bf89e03..27230989f63bc 100644
--- a/src/test/compile-fail/issue-6801.rs
+++ b/src/test/compile-fail/issue-6801.rs
@@ -12,6 +12,7 @@
 // transferring ownership of the owned box before invoking the stack
 // closure results in a crash.
 
+#![feature(box_syntax)]
 
 fn twice(x: Box<uint>) -> uint {
      *x * 2
diff --git a/src/test/compile-fail/issue-7013.rs b/src/test/compile-fail/issue-7013.rs
index d2f9ee4760303..d246e4e54d017 100644
--- a/src/test/compile-fail/issue-7013.rs
+++ b/src/test/compile-fail/issue-7013.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::cell::RefCell;
 use std::rc::Rc;
 
diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs
index c8c7ef4ed89d7..b4df38a6aac03 100644
--- a/src/test/compile-fail/issue-7364.rs
+++ b/src/test/compile-fail/issue-7364.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 use std::cell::RefCell;
 
diff --git a/src/test/compile-fail/kindck-impl-type-params-2.rs b/src/test/compile-fail/kindck-impl-type-params-2.rs
index 9e7c983195a66..e188fa9b813fe 100644
--- a/src/test/compile-fail/kindck-impl-type-params-2.rs
+++ b/src/test/compile-fail/kindck-impl-type-params-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 trait Foo {
 }
 
diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs
index 6ecf2593d00ab..34e77353463d1 100644
--- a/src/test/compile-fail/kindck-impl-type-params.rs
+++ b/src/test/compile-fail/kindck-impl-type-params.rs
@@ -11,6 +11,8 @@
 // Issue #14061: tests the interaction between generic implementation
 // parameter bounds and trait objects.
 
+#![feature(box_syntax)]
+
 struct S<T>;
 
 trait Gettable<T> {}
diff --git a/src/test/compile-fail/kindck-inherited-copy-bound.rs b/src/test/compile-fail/kindck-inherited-copy-bound.rs
index 7f610176b6569..192e358283fa7 100644
--- a/src/test/compile-fail/kindck-inherited-copy-bound.rs
+++ b/src/test/compile-fail/kindck-inherited-copy-bound.rs
@@ -10,6 +10,8 @@
 
 // Test that Copy bounds inherited by trait are checked.
 
+#![feature(box_syntax)]
+
 use std::any::Any;
 
 trait Foo : Copy {
diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs
index 5ee16f0aa26e5..1702cefec6d3a 100644
--- a/src/test/compile-fail/lint-owned-heap-memory.rs
+++ b/src/test/compile-fail/lint-owned-heap-memory.rs
@@ -10,7 +10,7 @@
 
 #![allow(dead_code)]
 #![forbid(box_pointers)]
-
+#![feature(box_syntax)]
 
 struct Foo {
     x: Box<int> //~ ERROR type uses owned
diff --git a/src/test/compile-fail/liveness-move-call-arg.rs b/src/test/compile-fail/liveness-move-call-arg.rs
index b9ad1c0fb65d9..08a523fb8ffb2 100644
--- a/src/test/compile-fail/liveness-move-call-arg.rs
+++ b/src/test/compile-fail/liveness-move-call-arg.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn take(_x: Box<int>) {}
 
diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs
index 127a68bd339e6..b2142258fb01d 100644
--- a/src/test/compile-fail/liveness-move-in-loop.rs
+++ b/src/test/compile-fail/liveness-move-in-loop.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let y: Box<int> = box 42;
     let mut x: Box<int>;
diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs
index 2cebe3f573bd9..549cf523d0329 100644
--- a/src/test/compile-fail/liveness-move-in-while.rs
+++ b/src/test/compile-fail/liveness-move-in-while.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let y: Box<int> = box 42;
     let mut x: Box<int>;
diff --git a/src/test/compile-fail/liveness-use-after-move.rs b/src/test/compile-fail/liveness-use-after-move.rs
index a988254141a75..e1cd12989cacd 100644
--- a/src/test/compile-fail/liveness-use-after-move.rs
+++ b/src/test/compile-fail/liveness-use-after-move.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn main() {
     let x = box 5i;
     let y = x;
diff --git a/src/test/compile-fail/macros-nonfatal-errors.rs b/src/test/compile-fail/macros-nonfatal-errors.rs
index f97cad559a15d..ce1b372a4c11e 100644
--- a/src/test/compile-fail/macros-nonfatal-errors.rs
+++ b/src/test/compile-fail/macros-nonfatal-errors.rs
@@ -22,9 +22,6 @@ enum CantDeriveThose {}
 fn main() {
     doesnt_exist!(); //~ ERROR
 
-    bytes!(invalid); //~ ERROR non-literal in bytes!
-    //~^ WARN `bytes!` is deprecated
-
     asm!(invalid); //~ ERROR
 
     concat_idents!("not", "idents"); //~ ERROR
diff --git a/src/test/compile-fail/map-types.rs b/src/test/compile-fail/map-types.rs
index 7aafeced3a6f4..ba2205f5868d4 100644
--- a/src/test/compile-fail/map-types.rs
+++ b/src/test/compile-fail/map-types.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 extern crate collections;
 
 use std::collections::HashMap;
diff --git a/src/test/compile-fail/move-out-of-tuple-field.rs b/src/test/compile-fail/move-out-of-tuple-field.rs
index 7fcb54e04672d..78b6736c1c86d 100644
--- a/src/test/compile-fail/move-out-of-tuple-field.rs
+++ b/src/test/compile-fail/move-out-of-tuple-field.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Foo(Box<int>);
 
 fn main() {
diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs
index 14af49dfc49c5..379397f22bd61 100644
--- a/src/test/compile-fail/moves-based-on-type-block-bad.rs
+++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs
@@ -10,6 +10,8 @@
 
 // ignore-tidy-linelength
 
+#![feature(box_syntax)]
+
 struct S {
     x: Box<E>
 }
diff --git a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
index ab762332ee43d..0f5e012ef1950 100644
--- a/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
+++ b/src/test/compile-fail/moves-based-on-type-move-out-of-closure-env-issue-1965.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 use std::uint;
 
 fn test(_x: Box<uint>) {}
diff --git a/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs b/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs
index 9053f97e8a7dd..f410541f0b7e9 100644
--- a/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs
+++ b/src/test/compile-fail/moves-based-on-type-no-recursive-stack-closure.rs
@@ -12,6 +12,7 @@
 // bound must be noncopyable. For details see
 // http://smallcultfollowing.com/babysteps/blog/2013/04/30/the-case-of-the-recurring-closure/
 
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct R<'a> {
diff --git a/src/test/compile-fail/moves-based-on-type-tuple.rs b/src/test/compile-fail/moves-based-on-type-tuple.rs
index 85c435ef0db02..397b22c486e77 100644
--- a/src/test/compile-fail/moves-based-on-type-tuple.rs
+++ b/src/test/compile-fail/moves-based-on-type-tuple.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn dup(x: Box<int>) -> Box<(Box<int>,Box<int>)> { box() (x, x) } //~ ERROR use of moved value
 fn main() {
diff --git a/src/test/compile-fail/moves-sru-moved-field.rs b/src/test/compile-fail/moves-sru-moved-field.rs
index 2cf7618d92dbc..6c351f887132d 100644
--- a/src/test/compile-fail/moves-sru-moved-field.rs
+++ b/src/test/compile-fail/moves-sru-moved-field.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 type Noncopyable = Box<int>;
 
diff --git a/src/test/compile-fail/mut-cross-borrowing.rs b/src/test/compile-fail/mut-cross-borrowing.rs
index 657c2832c4931..90bc0019531b3 100644
--- a/src/test/compile-fail/mut-cross-borrowing.rs
+++ b/src/test/compile-fail/mut-cross-borrowing.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn f(_: &mut int) {}
 
 fn main() {
diff --git a/src/test/compile-fail/mut-pattern-mismatched.rs b/src/test/compile-fail/mut-pattern-mismatched.rs
index 443be7d7b69a5..9f1d3d1fb3912 100644
--- a/src/test/compile-fail/mut-pattern-mismatched.rs
+++ b/src/test/compile-fail/mut-pattern-mismatched.rs
@@ -13,10 +13,8 @@ fn main() {
 
     // (separate lines to ensure the spans are accurate)
 
-    // SNAP 340ac04 uncomment this after the next snapshot
-    // NOTE(stage0) just in case tidy doesn't check snap's in tests
-    // let &_ // ~ ERROR expected `&mut isize`, found `&_`
-    //    = foo;
+     let &_ //~ ERROR expected `&mut isize`, found `&_`
+        = foo;
     let &mut _ = foo;
 
     let bar = &1is;
diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs
index 9a09448ff01fe..3d4d0fee0bfe2 100644
--- a/src/test/compile-fail/no-capture-arc.rs
+++ b/src/test/compile-fail/no-capture-arc.rs
@@ -23,5 +23,5 @@ fn main() {
 
     assert_eq!((*arc_v)[2], 3);
 
-    println!("{}", *arc_v);
+    println!("{:?}", *arc_v);
 }
diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs
index de23074368576..02028fe62e5eb 100644
--- a/src/test/compile-fail/no-reuse-move-arc.rs
+++ b/src/test/compile-fail/no-reuse-move-arc.rs
@@ -21,5 +21,5 @@ fn main() {
 
     assert_eq!((*arc_v)[2], 3); //~ ERROR use of moved value: `arc_v`
 
-    println!("{}", *arc_v); //~ ERROR use of moved value: `arc_v`
+    println!("{:?}", *arc_v); //~ ERROR use of moved value: `arc_v`
 }
diff --git a/src/test/compile-fail/occurs-check-2.rs b/src/test/compile-fail/occurs-check-2.rs
index 2765182225f96..bfabcff511686 100644
--- a/src/test/compile-fail/occurs-check-2.rs
+++ b/src/test/compile-fail/occurs-check-2.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn main() {
     let f;
diff --git a/src/test/compile-fail/occurs-check.rs b/src/test/compile-fail/occurs-check.rs
index 44318b36f4b8a..417bd9b57ee0a 100644
--- a/src/test/compile-fail/occurs-check.rs
+++ b/src/test/compile-fail/occurs-check.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn main() {
     let f;
diff --git a/src/test/compile-fail/packed-struct-generic-transmute.rs b/src/test/compile-fail/packed-struct-generic-transmute.rs
index 38177d076455d..6b6ab3f297019 100644
--- a/src/test/compile-fail/packed-struct-generic-transmute.rs
+++ b/src/test/compile-fail/packed-struct-generic-transmute.rs
@@ -15,8 +15,6 @@
 
 // error-pattern: transmute called on types with different size
 
-#![feature(slicing_syntax)]
-
 use std::mem;
 
 #[repr(packed)]
@@ -34,6 +32,6 @@ fn main() {
     let foo = Foo { bar: [1u8, 2, 3, 4, 5], baz: 10i32 };
     unsafe {
         let oof: Oof<[u8; 5], i32> = mem::transmute(foo);
-        println!("{} {}", &oof.rab[], oof.zab);
+        println!("{:?} {:?}", &oof.rab[], oof.zab);
     }
 }
diff --git a/src/test/compile-fail/pattern-bindings-after-at.rs b/src/test/compile-fail/pattern-bindings-after-at.rs
index 9cd2d0d28b165..54ac3cba636f2 100644
--- a/src/test/compile-fail/pattern-bindings-after-at.rs
+++ b/src/test/compile-fail/pattern-bindings-after-at.rs
@@ -15,7 +15,7 @@ enum Option<T> {
 
 fn main() {
     match &mut Some(1i) {
-        ref mut z @ &Some(ref a) => {
+        ref mut z @ &mut Some(ref a) => {
         //~^ ERROR pattern bindings are not allowed after an `@`
             **z = None;
             println!("{}", *a);
diff --git a/src/test/compile-fail/range-1.rs b/src/test/compile-fail/range-1.rs
index 0ade29750442b..1668b868e641e 100644
--- a/src/test/compile-fail/range-1.rs
+++ b/src/test/compile-fail/range-1.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // Test range syntax - type errors.
-#![feature(slicing_syntax)]
 
 pub fn main() {
     // Mixed types.
diff --git a/src/test/compile-fail/range-2.rs b/src/test/compile-fail/range-2.rs
index 74c304884a07c..40690bd844bce 100644
--- a/src/test/compile-fail/range-2.rs
+++ b/src/test/compile-fail/range-2.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 // Test range syntax - borrow errors.
-#![feature(slicing_syntax)]
 
 pub fn main() {
     let r = {
diff --git a/src/test/compile-fail/recursion.rs b/src/test/compile-fail/recursion.rs
index 67177eff9f95e..da05514f76300 100644
--- a/src/test/compile-fail/recursion.rs
+++ b/src/test/compile-fail/recursion.rs
@@ -8,6 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+//~^^^^^^^^^^ ERROR overflow
+//
+// We also get a second error message at the top of file (dummy
+// span). This is not helpful, but also kind of annoying to prevent,
+// so for now just live with it, since we also get a second message
+// that is more helpful.
+
 enum Nil {NilValue}
 struct Cons<T> {head:int, tail:T}
 trait Dot {fn dot(&self, other:Self) -> int;}
diff --git a/src/test/compile-fail/region-object-lifetime-in-coercion.rs b/src/test/compile-fail/region-object-lifetime-in-coercion.rs
index b2b2d3337c419..e4521873a61fd 100644
--- a/src/test/compile-fail/region-object-lifetime-in-coercion.rs
+++ b/src/test/compile-fail/region-object-lifetime-in-coercion.rs
@@ -11,6 +11,8 @@
 // Test that attempts to implicitly coerce a value into an
 // object respect the lifetime bound on the object type.
 
+#![feature(box_syntax)]
+
 trait Foo {}
 impl<'a> Foo for &'a [u8] {}
 
diff --git a/src/test/compile-fail/regions-close-associated-type-into-object.rs b/src/test/compile-fail/regions-close-associated-type-into-object.rs
index 816314529b5e8..8a03f36972dd1 100644
--- a/src/test/compile-fail/regions-close-associated-type-into-object.rs
+++ b/src/test/compile-fail/regions-close-associated-type-into-object.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 trait X {}
 
 trait Iter {
diff --git a/src/test/compile-fail/regions-close-object-into-object.rs b/src/test/compile-fail/regions-close-object-into-object.rs
index 48945868bd355..675f86b58f4e8 100644
--- a/src/test/compile-fail/regions-close-object-into-object.rs
+++ b/src/test/compile-fail/regions-close-object-into-object.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait A<T> {}
 struct B<'a, T>(&'a (A<T>+'a));
diff --git a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
index 037514f45c743..e17786e6a5112 100644
--- a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
+++ b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 trait Foo { }
 
 impl<'a> Foo for &'a int { }
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-1.rs b/src/test/compile-fail/regions-close-over-type-parameter-1.rs
index 5465f199f406f..985ae6116f006 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-1.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-1.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 // Test for what happens when a type parameter `A` is closed over into
 // an object. This should yield errors unless `A` (and the object)
 // both have suitable bounds.
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-2.rs b/src/test/compile-fail/regions-close-over-type-parameter-2.rs
index 0ee349aaebfcf..85ff336b4cbda 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-2.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 // Test for what happens when a type parameter `A` is closed over into
 // an object. This should yield errors unless `A` (and the object)
 // both have suitable bounds.
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
index cec785c6e9666..2aa77b2e53d71 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 // Various tests where we over type parameters with multiple lifetime
 // bounds.
 
diff --git a/src/test/compile-fail/regions-close-param-into-object.rs b/src/test/compile-fail/regions-close-param-into-object.rs
index 3e91d090c3140..74b36958c92f1 100644
--- a/src/test/compile-fail/regions-close-param-into-object.rs
+++ b/src/test/compile-fail/regions-close-param-into-object.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait X {}
 
diff --git a/src/test/compile-fail/regions-nested-fns.rs b/src/test/compile-fail/regions-nested-fns.rs
index 5d8ef718ef0d3..e8054779774b6 100644
--- a/src/test/compile-fail/regions-nested-fns.rs
+++ b/src/test/compile-fail/regions-nested-fns.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn ignore<T>(t: T) {}
 
 fn nested<'x>(x: &'x int) {
diff --git a/src/test/compile-fail/regions-proc-bound-capture.rs b/src/test/compile-fail/regions-proc-bound-capture.rs
index 0841c1852f883..b849ddf7b8201 100644
--- a/src/test/compile-fail/regions-proc-bound-capture.rs
+++ b/src/test/compile-fail/regions-proc-bound-capture.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 fn borrowed_proc<'a>(x: &'a int) -> Box<FnMut()->(int) + 'a> {
     // This is legal, because the region bound on `proc`
     // states that it captures `x`.
diff --git a/src/test/compile-fail/regions-ref-in-fn-arg.rs b/src/test/compile-fail/regions-ref-in-fn-arg.rs
index f9eecb60c6af1..e47fddbdc36fd 100644
--- a/src/test/compile-fail/regions-ref-in-fn-arg.rs
+++ b/src/test/compile-fail/regions-ref-in-fn-arg.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn arg_item(box ref x: Box<int>) -> &'static int {
     x //~^ ERROR borrowed value does not live long enough
diff --git a/src/test/compile-fail/regions-steal-closure.rs b/src/test/compile-fail/regions-steal-closure.rs
index 991040bc62fea..12f5f2954995f 100644
--- a/src/test/compile-fail/regions-steal-closure.rs
+++ b/src/test/compile-fail/regions-steal-closure.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct closure_box<'a> {
diff --git a/src/test/compile-fail/regions-trait-1.rs b/src/test/compile-fail/regions-trait-1.rs
index 7771a71c79bc0..32d89607e4b3e 100644
--- a/src/test/compile-fail/regions-trait-1.rs
+++ b/src/test/compile-fail/regions-trait-1.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct ctxt { v: uint }
 
diff --git a/src/test/compile-fail/regions-trait-variance.rs b/src/test/compile-fail/regions-trait-variance.rs
index 4e31a41c4e074..22e43c0bf8965 100644
--- a/src/test/compile-fail/regions-trait-variance.rs
+++ b/src/test/compile-fail/regions-trait-variance.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 // Issue #12470.
 
 trait X {
diff --git a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs b/src/test/compile-fail/require-parens-for-chained-comparison.rs
similarity index 50%
rename from src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs
rename to src/test/compile-fail/require-parens-for-chained-comparison.rs
index d03696cbbbcc4..7513815ad730c 100644
--- a/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs
+++ b/src/test/compile-fail/require-parens-for-chained-comparison.rs
@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -8,7 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+fn f<T>() {}
+
 fn main() {
-    let vec = bytes!('λ'); //~ ERROR non-ascii char literal in bytes!
-    //~^ WARN `bytes!` is deprecated
+    false == false == false;
+    //~^ ERROR: Chained comparison operators require parentheses
+
+    false == 0 < 2;
+    //~^ ERROR: Chained comparison operators require parentheses
+
+    f<X>();
+    //~^ ERROR: Chained comparison operators require parentheses
+    //~^^ HELP: Use ::< instead of < if you meant to specify type arguments.
 }
diff --git a/src/test/compile-fail/shadowed-type-parameter.rs b/src/test/compile-fail/shadowed-type-parameter.rs
new file mode 100644
index 0000000000000..1a3d7821159c3
--- /dev/null
+++ b/src/test/compile-fail/shadowed-type-parameter.rs
@@ -0,0 +1,38 @@
+// Copyright 2013 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.
+
+// Test that shadowed lifetimes generate an error.
+
+#![feature(box_syntax)]
+
+struct Foo<T>;
+
+impl<T> Foo<T> {
+    fn shadow_in_method<T>(&self) {}
+    //~^ ERROR type parameter `T` shadows another type parameter
+
+    fn not_shadow_in_item<U>(&self) {
+        struct Bar<T, U>; // not a shadow, separate item
+        fn foo<T, U>() {} // same
+    }
+}
+
+trait Bar<T> {
+    fn shadow_in_required<T>(&self);
+    //~^ ERROR type parameter `T` shadows another type parameter
+
+    fn shadow_in_provided<T>(&self) {}
+    //~^ ERROR type parameter `T` shadows another type parameter
+
+    fn not_shadow_in_required<U>(&self);
+    fn not_shadow_in_provided<U>(&self) {}
+}
+
+fn main() {}
diff --git a/src/test/compile-fail/slice-2.rs b/src/test/compile-fail/slice-2.rs
index a03693b5fada0..07162293565ed 100644
--- a/src/test/compile-fail/slice-2.rs
+++ b/src/test/compile-fail/slice-2.rs
@@ -10,8 +10,6 @@
 
 // Test that slicing syntax gives errors if we have not implemented the trait.
 
-#![feature(slicing_syntax)]
-
 struct Foo;
 
 fn main() {
diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs
index aab187f97515a..43c4326628d33 100644
--- a/src/test/compile-fail/slice-borrow.rs
+++ b/src/test/compile-fail/slice-borrow.rs
@@ -10,8 +10,6 @@
 
 // Test slicing expressions doesn't defeat the borrow checker.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let y;
     {
diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs
index 1dedb0cf888e5..12f184d410c90 100644
--- a/src/test/compile-fail/slice-mut-2.rs
+++ b/src/test/compile-fail/slice-mut-2.rs
@@ -10,8 +10,6 @@
 
 // Test mutability and slicing syntax.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Can't mutably slice an immutable slice
diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs
index f0f525a553576..9bd9a752e4e89 100644
--- a/src/test/compile-fail/slice-mut.rs
+++ b/src/test/compile-fail/slice-mut.rs
@@ -10,8 +10,6 @@
 
 // Test mutability and slicing syntax.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     // Immutable slices are not mutable.
diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs
index 84c72de5548a2..fd05f05502e9c 100644
--- a/src/test/compile-fail/static-mut-not-constant.rs
+++ b/src/test/compile-fail/static-mut-not-constant.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 static mut a: Box<int> = box 3;
 //~^ ERROR statics are not allowed to have custom pointers
diff --git a/src/test/compile-fail/static-region-bound.rs b/src/test/compile-fail/static-region-bound.rs
index 1e5a5ecc08e08..42f9d24bc52bb 100644
--- a/src/test/compile-fail/static-region-bound.rs
+++ b/src/test/compile-fail/static-region-bound.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 fn f<T:'static>(_: T) {}
 
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs b/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs
deleted file mode 100644
index ac33ffb60e294..0000000000000
--- a/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2013 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 main() {
-    let vec = bytes!(-1024u8); //~ ERROR non-literal in bytes
-    //~^ WARN `bytes!` is deprecated
-}
diff --git a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs b/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
deleted file mode 100644
index f6b3659354c5b..0000000000000
--- a/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2013 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 main() {
-    let vec = bytes!(45f64); //~ ERROR unsupported literal in bytes!
-    //~^ WARN `bytes!` is deprecated
-}
diff --git a/src/test/compile-fail/trait-coercion-generic-bad.rs b/src/test/compile-fail/trait-coercion-generic-bad.rs
index e6ea8e10b22cc..1ddfc5b7ccd48 100644
--- a/src/test/compile-fail/trait-coercion-generic-bad.rs
+++ b/src/test/compile-fail/trait-coercion-generic-bad.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct Struct {
     person: &'static str
diff --git a/src/test/compile-fail/trait-coercion-generic-regions.rs b/src/test/compile-fail/trait-coercion-generic-regions.rs
index 5f4d51918edc0..9c78d7ea2439a 100644
--- a/src/test/compile-fail/trait-coercion-generic-regions.rs
+++ b/src/test/compile-fail/trait-coercion-generic-regions.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct Struct {
     person: &'static str
diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs
index a24f7710d7b61..f66034e395c88 100644
--- a/src/test/compile-fail/trait-test-2.rs
+++ b/src/test/compile-fail/trait-test-2.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait bar { fn dup(&self) -> Self; fn blah<X>(&self); }
 impl bar for int { fn dup(&self) -> int { *self } fn blah<X>(&self) {} }
diff --git a/src/test/compile-fail/ufcs-explicit-self-bad.rs b/src/test/compile-fail/ufcs-explicit-self-bad.rs
index 8d3610affdfb9..5ba660495f705 100644
--- a/src/test/compile-fail/ufcs-explicit-self-bad.rs
+++ b/src/test/compile-fail/ufcs-explicit-self-bad.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Foo {
     f: int,
 }
diff --git a/src/test/compile-fail/unboxed-closure-illegal-move.rs b/src/test/compile-fail/unboxed-closure-illegal-move.rs
index 9e981f2c9bb02..4d6f04da02661 100644
--- a/src/test/compile-fail/unboxed-closure-illegal-move.rs
+++ b/src/test/compile-fail/unboxed-closure-illegal-move.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 // Tests that we can't move out of an unboxed closure environment
diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs
index e237e2c8b7561..2dde11ada2855 100644
--- a/src/test/compile-fail/unique-object-noncopyable.rs
+++ b/src/test/compile-fail/unique-object-noncopyable.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 trait Foo {
     fn f(&self);
diff --git a/src/test/compile-fail/unique-pinned-nocopy.rs b/src/test/compile-fail/unique-pinned-nocopy.rs
index d306d171ca855..04eaa3d7ae067 100644
--- a/src/test/compile-fail/unique-pinned-nocopy.rs
+++ b/src/test/compile-fail/unique-pinned-nocopy.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 #[derive(Show)]
 struct r {
   b: bool,
diff --git a/src/test/compile-fail/unique-unique-kind.rs b/src/test/compile-fail/unique-unique-kind.rs
index 49cebbf52552b..ae354729b9202 100644
--- a/src/test/compile-fail/unique-unique-kind.rs
+++ b/src/test/compile-fail/unique-unique-kind.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 use std::rc::Rc;
 
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index 4848c988300ab..b558989304f64 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -10,6 +10,8 @@
 
 #![feature(unsafe_destructor)]
 
+#![feature(box_syntax)]
+
 use std::cell::Cell;
 
 #[derive(Show)]
diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs
index 3ff6c733026b5..934ddb5f80bb1 100644
--- a/src/test/compile-fail/unreachable-arm.rs
+++ b/src/test/compile-fail/unreachable-arm.rs
@@ -10,6 +10,7 @@
 
 // error-pattern:unreachable pattern
 
+#![feature(box_syntax)]
 
 enum foo { a(Box<foo>, int), b(uint), }
 
diff --git a/src/test/compile-fail/unsized2.rs b/src/test/compile-fail/unsized2.rs
index c5f9e8d599193..604f7ba3255cd 100644
--- a/src/test/compile-fail/unsized2.rs
+++ b/src/test/compile-fail/unsized2.rs
@@ -13,5 +13,8 @@
 fn f<X>() {}
 
 pub fn main() {
-    f<type>(); //~ ERROR expected identifier, found keyword `type`
+    f<type>();
+    //~^ ERROR expected identifier, found keyword `type`
+    //~^^ ERROR: Chained comparison operators require parentheses
+    //~^^^ HELP: Use ::< instead of < if you meant to specify type arguments.
 }
diff --git a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
index 364bfc4298599..d8a82d8fbf046 100644
--- a/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
+++ b/src/test/compile-fail/use-after-move-implicity-coerced-object.rs
@@ -10,6 +10,8 @@
 
 // ignore-tidy-linelength
 
+#![feature(box_syntax)]
+
 use std::fmt;
 
 struct Number {
diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs
index 607d6163208c9..ce0f2808e33fe 100644
--- a/src/test/compile-fail/use-after-move-self.rs
+++ b/src/test/compile-fail/use-after-move-self.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
 
 struct S {
     x: Box<int>,
diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs
index 148473f898798..d8af859c081e9 100644
--- a/src/test/compile-fail/where-clauses-not-parameter.rs
+++ b/src/test/compile-fail/where-clauses-not-parameter.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn equal<T>(_: &T, _: &T) -> bool where int : Eq {
+fn equal<T>(_: &T, _: &T) -> bool where isize : Eq {
     true //~^ ERROR cannot bound type `isize`, where clause bounds may only be attached
 }
 
@@ -16,24 +16,26 @@ fn equal<T>(_: &T, _: &T) -> bool where int : Eq {
 fn test<T: Eq>() -> bool where Option<T> : Eq {}
 
 // This should be rejected as well.
-fn test2() -> bool where Option<int> : Eq {}
-//~^ ERROR cannot bound type `core::option::Option<isize>`, where clause bounds
+fn test2() -> bool where Option<isize> : Eq {}
+//~^ ERROR cannot bound type `core::option::Option<isize>`, where clause bounds may
 
 #[derive(PartialEq)]
 //~^ ERROR cannot bound type `isize`, where clause bounds
-enum Foo<T> where int : Eq { MkFoo }
+enum Foo<T> where isize : Eq { MkFoo }
 //~^ ERROR cannot bound type `isize`, where clause bounds
 
 fn test3<T: Eq>() -> bool where Option<Foo<T>> : Eq {}
 
-fn test4() -> bool where Option<Foo<int>> : Eq {}
+fn test4() -> bool where Option<Foo<isize>> : Eq {}
 //~^ ERROR cannot bound type `core::option::Option<Foo<isize>>`, where clause bounds
 
-trait Baz<T> where int : Eq {
-    fn baz() where String : Eq;
+trait Baz<T> where isize : Eq {
+    //~^ ERROR cannot bound type `isize`, where clause bounds may only
+    fn baz() where String : Eq; //~ ERROR cannot bound type `collections::string::String`
+    //~^ ERROR cannot bound type `isize`, where clause
 }
 
-impl Baz<int> for int where int : Eq {
+impl Baz<int> for int where isize : Eq {
     //~^ ERROR cannot bound type `isize`, where clause bounds
     fn baz() where String : Eq {}
 }
diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs
index e3cf438be439c..53d2befc49d06 100644
--- a/src/test/debuginfo/borrowed-struct.rs
+++ b/src/test/debuginfo/borrowed-struct.rs
@@ -64,6 +64,7 @@
 // lldb-check:[...]$6 = 26.5
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct SomeStruct {
diff --git a/src/test/debuginfo/borrowed-tuple.rs b/src/test/debuginfo/borrowed-tuple.rs
index ce0930f2fbf38..c7e5987fbcfa2 100644
--- a/src/test/debuginfo/borrowed-tuple.rs
+++ b/src/test/debuginfo/borrowed-tuple.rs
@@ -42,6 +42,7 @@
 
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
diff --git a/src/test/debuginfo/borrowed-unique-basic.rs b/src/test/debuginfo/borrowed-unique-basic.rs
index d152775a8ed6a..fc186a0b5b21f 100644
--- a/src/test/debuginfo/borrowed-unique-basic.rs
+++ b/src/test/debuginfo/borrowed-unique-basic.rs
@@ -112,6 +112,7 @@
 // lldb-check:[...]$12 = 3.5
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs
index 5a70eb1904128..0439e3dc34d49 100644
--- a/src/test/debuginfo/box.rs
+++ b/src/test/debuginfo/box.rs
@@ -32,6 +32,7 @@
 // lldb-check:[...]$1 = (2, 3.5)
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
diff --git a/src/test/debuginfo/boxed-struct.rs b/src/test/debuginfo/boxed-struct.rs
index f9d762bf99d28..6397efa0a96a3 100644
--- a/src/test/debuginfo/boxed-struct.rs
+++ b/src/test/debuginfo/boxed-struct.rs
@@ -35,6 +35,7 @@
 // lldb-check:[...]$1 = StructWithDestructor { x: 77, y: 777, z: 7777, w: 77777 }
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct StructWithSomePadding {
diff --git a/src/test/debuginfo/closure-in-generic-function.rs b/src/test/debuginfo/closure-in-generic-function.rs
index e3cb190c3f2c4..f8b125694002d 100644
--- a/src/test/debuginfo/closure-in-generic-function.rs
+++ b/src/test/debuginfo/closure-in-generic-function.rs
@@ -46,6 +46,7 @@
 // lldb-check:[...]$3 = 110
 // lldb-command:continue
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) {
diff --git a/src/test/debuginfo/destructured-fn-argument.rs b/src/test/debuginfo/destructured-fn-argument.rs
index b4688e4928a6b..73289c56befc4 100644
--- a/src/test/debuginfo/destructured-fn-argument.rs
+++ b/src/test/debuginfo/destructured-fn-argument.rs
@@ -311,6 +311,7 @@
 // lldb-command:continue
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 use self::Univariant::Unit;
diff --git a/src/test/debuginfo/destructured-for-loop-variable.rs b/src/test/debuginfo/destructured-for-loop-variable.rs
index 364720d0e4fb3..103bdc0355084 100644
--- a/src/test/debuginfo/destructured-for-loop-variable.rs
+++ b/src/test/debuginfo/destructured-for-loop-variable.rs
@@ -153,6 +153,7 @@
 // lldb-command:continue
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs
index d5a6b36f1fcf9..1fd598e18c16d 100644
--- a/src/test/debuginfo/destructured-local.rs
+++ b/src/test/debuginfo/destructured-local.rs
@@ -244,6 +244,7 @@
 
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 use self::Univariant::Unit;
diff --git a/src/test/debuginfo/generic-method-on-generic-struct.rs b/src/test/debuginfo/generic-method-on-generic-struct.rs
index 0e358499a3d02..66cd73622ffb4 100644
--- a/src/test/debuginfo/generic-method-on-generic-struct.rs
+++ b/src/test/debuginfo/generic-method-on-generic-struct.rs
@@ -112,6 +112,7 @@
 // lldb-check:[...]$14 = -10.5
 // lldb-command:continue
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct<T> {
diff --git a/src/test/debuginfo/method-on-enum.rs b/src/test/debuginfo/method-on-enum.rs
index b1ebb124d4e76..732e1d5c50029 100644
--- a/src/test/debuginfo/method-on-enum.rs
+++ b/src/test/debuginfo/method-on-enum.rs
@@ -113,6 +113,7 @@
 // lldb-check:[...]$14 = -10
 // lldb-command:continue
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 enum Enum {
diff --git a/src/test/debuginfo/method-on-generic-struct.rs b/src/test/debuginfo/method-on-generic-struct.rs
index 68a6ac8c1f31e..c1785951e2348 100644
--- a/src/test/debuginfo/method-on-generic-struct.rs
+++ b/src/test/debuginfo/method-on-generic-struct.rs
@@ -113,6 +113,7 @@
 // lldb-command:continue
 
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct<T> {
diff --git a/src/test/debuginfo/method-on-struct.rs b/src/test/debuginfo/method-on-struct.rs
index 84e74d4364cfa..d88a32b8475a3 100644
--- a/src/test/debuginfo/method-on-struct.rs
+++ b/src/test/debuginfo/method-on-struct.rs
@@ -113,6 +113,7 @@
 // lldb-command:continue
 
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/method-on-trait.rs b/src/test/debuginfo/method-on-trait.rs
index f53bb11eac442..5622d17225ba8 100644
--- a/src/test/debuginfo/method-on-trait.rs
+++ b/src/test/debuginfo/method-on-trait.rs
@@ -113,6 +113,7 @@
 // lldb-command:continue
 
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/method-on-tuple-struct.rs b/src/test/debuginfo/method-on-tuple-struct.rs
index 6994c38818c1b..02f7808221a85 100644
--- a/src/test/debuginfo/method-on-tuple-struct.rs
+++ b/src/test/debuginfo/method-on-tuple-struct.rs
@@ -113,6 +113,7 @@
 // lldb-command:continue
 
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct TupleStruct(int, f64);
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index 90c32ad8da11f..2cbe9f43789d9 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -69,6 +69,7 @@
 // gdb-command:continue
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 use self::Opt::{Empty, Val};
diff --git a/src/test/debuginfo/self-in-default-method.rs b/src/test/debuginfo/self-in-default-method.rs
index 87884d2f95629..a1074e490f7eb 100644
--- a/src/test/debuginfo/self-in-default-method.rs
+++ b/src/test/debuginfo/self-in-default-method.rs
@@ -112,6 +112,7 @@
 // lldb-check:[...]$14 = -10
 // lldb-command:continue
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/self-in-generic-default-method.rs b/src/test/debuginfo/self-in-generic-default-method.rs
index 62b5e6872ee49..f0da6e26870bd 100644
--- a/src/test/debuginfo/self-in-generic-default-method.rs
+++ b/src/test/debuginfo/self-in-generic-default-method.rs
@@ -112,6 +112,7 @@
 // lldb-check:[...]$14 = -10.5
 // lldb-command:continue
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/trait-pointers.rs b/src/test/debuginfo/trait-pointers.rs
index 9f8c0aa06e676..b95190f875a60 100644
--- a/src/test/debuginfo/trait-pointers.rs
+++ b/src/test/debuginfo/trait-pointers.rs
@@ -16,6 +16,7 @@
 // lldb-command:run
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 trait Trait {
diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs
index b508da73f4add..156e5f12ad5e8 100644
--- a/src/test/debuginfo/type-names.rs
+++ b/src/test/debuginfo/type-names.rs
@@ -173,6 +173,7 @@
 // gdb-command:whatis closure2
 // gdb-check:type = struct (closure, usize)
 
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 use self::Enum1::{Variant1_1, Variant1_2};
diff --git a/src/test/debuginfo/unique-enum.rs b/src/test/debuginfo/unique-enum.rs
index 3d028eb1077bc..08622b2dca8fb 100644
--- a/src/test/debuginfo/unique-enum.rs
+++ b/src/test/debuginfo/unique-enum.rs
@@ -42,6 +42,7 @@
 // lldb-check:[...]$2 = TheOnlyCase(123234)
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 // The first element is to ensure proper alignment, irrespective of the machines word size. Since
diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs
index 3a7fbb9a3a132..d7831c983c050 100644
--- a/src/test/debuginfo/var-captured-in-nested-closure.rs
+++ b/src/test/debuginfo/var-captured-in-nested-closure.rs
@@ -79,6 +79,7 @@
 // lldb-command:continue
 
 #![allow(unused_variables)]
+#![feature(box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs
index b34749260f30c..30a07ea46ddd3 100644
--- a/src/test/debuginfo/var-captured-in-sendable-closure.rs
+++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs
@@ -41,7 +41,7 @@
 // lldb-check:[...]$2 = 5
 
 #![allow(unused_variables)]
-#![feature(unboxed_closures)]
+#![feature(unboxed_closures, box_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs
index a743adae51e9c..9daf6abba1143 100644
--- a/src/test/debuginfo/var-captured-in-stack-closure.rs
+++ b/src/test/debuginfo/var-captured-in-stack-closure.rs
@@ -70,7 +70,7 @@
 // lldb-command:print *owned
 // lldb-check:[...]$9 = 6
 
-#![feature(unboxed_closures)]
+#![feature(unboxed_closures, box_syntax)]
 #![allow(unused_variables)]
 #![omit_gdb_pretty_printer_section]
 
diff --git a/src/test/debuginfo/vec-slices.rs b/src/test/debuginfo/vec-slices.rs
index 14f1dbb9d651c..949dffaac068f 100644
--- a/src/test/debuginfo/vec-slices.rs
+++ b/src/test/debuginfo/vec-slices.rs
@@ -77,7 +77,6 @@
 // lldb-check:[...]$5 = &[AStruct { x: 10, y: 11, z: 12 }, AStruct { x: 13, y: 14, z: 15 }]
 
 #![allow(unused_variables)]
-#![feature(slicing_syntax)]
 #![omit_gdb_pretty_printer_section]
 
 struct AStruct {
diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index f20087ef677f2..dac6e628d10d5 100644
--- a/src/test/pretty/issue-4264.pp
+++ b/src/test/pretty/issue-4264.pp
@@ -1,5 +1,4 @@
 #![no_std]
-#![feature(globs)]
 #[macro_use]
 extern crate "std" as std;
 #[prelude_import]
diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs
index f575fb3292480..382394b14070d 100644
--- a/src/test/pretty/path-type-bounds.rs
+++ b/src/test/pretty/path-type-bounds.rs
@@ -19,6 +19,6 @@ fn foo<'a>(x: Box<Tr+ Sync + 'a>) -> Box<Tr+ Sync + 'a> { x }
 fn main() {
     let x: Box<Tr+ Sync>;
 
-    box() 1i as Box<Tr+ Sync>;
+    Box::new(1i) as Box<Tr+ Sync>;
 }
 
diff --git a/src/test/run-fail/args-panic.rs b/src/test/run-fail/args-panic.rs
index 4878ec59fd4bc..eab7475bc8668 100644
--- a/src/test/run-fail/args-panic.rs
+++ b/src/test/run-fail/args-panic.rs
@@ -11,6 +11,9 @@
 
 // error-pattern:meep
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f(_a: int, _b: int, _c: Box<int>) { panic!("moop"); }
 
 fn main() { f(1, panic!("meep"), box 42); }
diff --git a/src/test/run-fail/panic-macro-any-wrapped.rs b/src/test/run-fail/panic-macro-any-wrapped.rs
index e25390a798628..89e47bf46ab02 100644
--- a/src/test/run-fail/panic-macro-any-wrapped.rs
+++ b/src/test/run-fail/panic-macro-any-wrapped.rs
@@ -10,6 +10,9 @@
 
 // error-pattern:panicked at 'Box<Any>'
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() {
     panic!(box 612_i64);
 }
diff --git a/src/test/run-fail/panic-macro-any.rs b/src/test/run-fail/panic-macro-any.rs
index b73c66c4f2165..231c57390b301 100644
--- a/src/test/run-fail/panic-macro-any.rs
+++ b/src/test/run-fail/panic-macro-any.rs
@@ -10,6 +10,9 @@
 
 // error-pattern:panicked at 'Box<Any>'
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() {
     panic!(box 413i as Box<::std::any::Any+Send>);
 }
diff --git a/src/test/run-fail/unique-panic.rs b/src/test/run-fail/unique-panic.rs
index 07c9a21c5c110..9f643c09795df 100644
--- a/src/test/run-fail/unique-panic.rs
+++ b/src/test/run-fail/unique-panic.rs
@@ -9,4 +9,8 @@
 // except according to those terms.
 
 // error-pattern: panic
+
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() { box panic!(); }
diff --git a/src/test/run-fail/unwind-unique.rs b/src/test/run-fail/unwind-unique.rs
index 6b5aefbab802b..f39ded8f98e80 100644
--- a/src/test/run-fail/unwind-unique.rs
+++ b/src/test/run-fail/unwind-unique.rs
@@ -10,6 +10,8 @@
 
 // error-pattern:fail
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn failfn() {
     panic!();
diff --git a/src/test/run-make/save-analysis/foo.rs b/src/test/run-make/save-analysis/foo.rs
index 61c5312f234c2..c72d685b311c6 100644
--- a/src/test/run-make/save-analysis/foo.rs
+++ b/src/test/run-make/save-analysis/foo.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 struct Foo {
     f: int
 }
diff --git a/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs b/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs
index 5d7dbbe5a292a..195055f12d1e4 100644
--- a/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs
+++ b/src/test/run-pass-valgrind/cleanup-auto-borrow-obj.rs
@@ -13,6 +13,7 @@
 // schedule cleanups when auto borrowing trait objects.
 // This program should be valgrind clean.
 
+#![feature(box_syntax)]
 
 static mut DROP_RAN: bool = false;
 
diff --git a/src/test/run-pass-valgrind/dst-dtor-1.rs b/src/test/run-pass-valgrind/dst-dtor-1.rs
index 8b8b7f169c5a0..47e2a18a9992a 100644
--- a/src/test/run-pass-valgrind/dst-dtor-1.rs
+++ b/src/test/run-pass-valgrind/dst-dtor-1.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 static mut DROP_RAN: bool = false;
 
 struct Foo;
diff --git a/src/test/run-pass-valgrind/dst-dtor-2.rs b/src/test/run-pass-valgrind/dst-dtor-2.rs
index 743293c23f6ad..2c7b89d680a3d 100644
--- a/src/test/run-pass-valgrind/dst-dtor-2.rs
+++ b/src/test/run-pass-valgrind/dst-dtor-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(box_syntax)]
+
 static mut DROP_RAN: int = 0;
 
 struct Foo;
diff --git a/src/test/run-pass/alignment-gep-tup-like-1.rs b/src/test/run-pass/alignment-gep-tup-like-1.rs
index ecc1a6a495c11..72a79e188b3dc 100644
--- a/src/test/run-pass/alignment-gep-tup-like-1.rs
+++ b/src/test/run-pass/alignment-gep-tup-like-1.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct pair<A,B> {
     a: A, b: B
 }
diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs
index 3da245efd79a8..089e1b8c5c2a3 100644
--- a/src/test/run-pass/assert-eq-macro-success.rs
+++ b/src/test/run-pass/assert-eq-macro-success.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 #[derive(PartialEq, Show)]
 struct Point { x : int }
diff --git a/src/test/run-pass/associated-type-doubleendediterator-object.rs b/src/test/run-pass/associated-type-doubleendediterator-object.rs
index 429027cbf304d..7365e052171ef 100644
--- a/src/test/run-pass/associated-type-doubleendediterator-object.rs
+++ b/src/test/run-pass/associated-type-doubleendediterator-object.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn pairwise_sub(mut t: Box<DoubleEndedIterator<Item=int>>) -> int {
     let mut result = 0;
     loop {
diff --git a/src/test/run-pass/associated-types-ref-from-struct.rs b/src/test/run-pass/associated-types-ref-from-struct.rs
new file mode 100644
index 0000000000000..3c7cc7c497534
--- /dev/null
+++ b/src/test/run-pass/associated-types-ref-from-struct.rs
@@ -0,0 +1,62 @@
+// 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.
+
+// Test associated type references in structure fields.
+
+trait Test {
+    type V;
+
+    fn test(&self, value: &Self::V) -> bool;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct TesterPair<T:Test> {
+    tester: T,
+    value: T::V,
+}
+
+impl<T:Test> TesterPair<T> {
+    fn new(tester: T, value: T::V) -> TesterPair<T> {
+        TesterPair { tester: tester, value: value }
+    }
+
+    fn test(&self) -> bool {
+        self.tester.test(&self.value)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct EqU32(u32);
+impl Test for EqU32 {
+    type V = u32;
+
+    fn test(&self, value: &u32) -> bool {
+        self.0 == *value
+    }
+}
+
+struct EqI32(i32);
+impl Test for EqI32 {
+    type V = i32;
+
+    fn test(&self, value: &i32) -> bool {
+        self.0 == *value
+    }
+}
+
+fn main() {
+    let tester = TesterPair::new(EqU32(22), 23);
+    tester.test();
+
+    let tester = TesterPair::new(EqI32(22), 23);
+    tester.test();
+}
diff --git a/src/test/run-pass/bytes-macro-static.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
similarity index 62%
rename from src/test/run-pass/bytes-macro-static.rs
rename to src/test/run-pass/associated-types-ref-in-struct-literal.rs
index 2ce8c40c77183..b51d44a0c244b 100644
--- a/src/test/run-pass/bytes-macro-static.rs
+++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
@@ -8,14 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static FOO: &'static [u8] = bytes!("hello, world");
+// Test associated type references in a struct literal. Issue #20535.
 
-pub fn main() {
-    let b: &'static [u8] = match true {
-        true => bytes!("test"),
-        false => unreachable!()
-    };
+pub trait Foo {
+    type Bar;
+}
+
+impl Foo for int {
+    type Bar = int;
+}
+
+struct Thing<F: Foo> {
+    a: F,
+    b: F::Bar,
+}
 
-    assert_eq!(b, "test".as_bytes());
-    assert_eq!(FOO, "hello, world".as_bytes());
+fn main() {
+    let thing = Thing{a: 1i, b: 2i};
+    assert_eq!(thing.a + 1, thing.b);
 }
diff --git a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs b/src/test/run-pass/associated-types-region-erasure-issue-20582.rs
similarity index 53%
rename from src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs
rename to src/test/run-pass/associated-types-region-erasure-issue-20582.rs
index 1a9aa3753eec7..03ab8f7e43136 100644
--- a/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs
+++ b/src/test/run-pass/associated-types-region-erasure-issue-20582.rs
@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -8,7 +8,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// Regression test for #20582. This test caused an ICE related to
+// inconsistent region erasure in trans.
+
+struct Foo<'a> {
+    buf: &'a[u8]
+}
+
+impl<'a> Iterator for Foo<'a> {
+    type Item = &'a[u8];
+
+    fn next(&mut self) -> Option<<Self as Iterator>::Item> {
+        Some(self.buf)
+    }
+}
+
 fn main() {
-    let vec = bytes!(1024u8); //~ ERROR too large u8 literal in bytes!
-    //~^ WARN `bytes!` is deprecated
 }
diff --git a/src/test/run-pass/autoderef-method-on-trait.rs b/src/test/run-pass/autoderef-method-on-trait.rs
index f13f598fda28c..876fc123f480c 100644
--- a/src/test/run-pass/autoderef-method-on-trait.rs
+++ b/src/test/run-pass/autoderef-method-on-trait.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> uint;
diff --git a/src/test/run-pass/autoderef-method-priority.rs b/src/test/run-pass/autoderef-method-priority.rs
index cc4dd13cf61c9..f5d5c81117e11 100644
--- a/src/test/run-pass/autoderef-method-priority.rs
+++ b/src/test/run-pass/autoderef-method-priority.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait double {
     fn double(self) -> uint;
diff --git a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
index 856ee686db30e..282cf62190ce3 100644
--- a/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
+++ b/src/test/run-pass/autoderef-method-twice-but-not-thrice.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait double {
     fn double(self: Box<Self>) -> uint;
diff --git a/src/test/run-pass/autoderef-method-twice.rs b/src/test/run-pass/autoderef-method-twice.rs
index 94da61483eaae..eb44e3b52b90f 100644
--- a/src/test/run-pass/autoderef-method-twice.rs
+++ b/src/test/run-pass/autoderef-method-twice.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait double {
     fn double(self: Box<Self>) -> uint;
 }
diff --git a/src/test/run-pass/autoderef-method.rs b/src/test/run-pass/autoderef-method.rs
index 2e9751ce6acfc..4bbb17c6dd698 100644
--- a/src/test/run-pass/autoderef-method.rs
+++ b/src/test/run-pass/autoderef-method.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait double {
     fn double(self: Box<Self>) -> uint;
 }
diff --git a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
index 7f44bcdb50c1a..e026ac9dcbaad 100644
--- a/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
+++ b/src/test/run-pass/autoref-intermediate-types-issue-3585.rs
@@ -9,6 +9,9 @@
 // except according to those terms.
 
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait Foo {
     fn foo(&self) -> String;
 }
diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs
index c5f69f249db6b..325f6dec76f80 100644
--- a/src/test/run-pass/bitv-perf-test.rs
+++ b/src/test/run-pass/bitv-perf-test.rs
@@ -9,6 +9,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 extern crate collections;
 use std::collections::Bitv;
 
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index 038f9e5c9ab43..9fcd87418bee3 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn borrow<F>(x: &int, f: F) where F: FnOnce(&int) {
     f(x)
diff --git a/src/test/run-pass/borrowck-field-sensitivity.rs b/src/test/run-pass/borrowck-field-sensitivity.rs
index 33be47e504be2..89d80190042c7 100644
--- a/src/test/run-pass/borrowck-field-sensitivity.rs
+++ b/src/test/run-pass/borrowck-field-sensitivity.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct A { a: int, b: Box<int> }
 struct B { a: Box<int>, b: Box<int> }
 
diff --git a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
index 28db3953a0021..49483e40096b3 100644
--- a/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
+++ b/src/test/run-pass/borrowck-macro-interaction-issue-6304.rs
@@ -11,6 +11,7 @@
 // Check that we do not ICE when compiling this
 // macro, which reuses the expression `$id`
 
+#![feature(box_syntax)]
 
 struct Foo {
   a: int
diff --git a/src/test/run-pass/borrowck-move-by-capture-ok.rs b/src/test/run-pass/borrowck-move-by-capture-ok.rs
index a6b142bb12654..773780ffb0953 100644
--- a/src/test/run-pass/borrowck-move-by-capture-ok.rs
+++ b/src/test/run-pass/borrowck-move-by-capture-ok.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 pub fn main() {
diff --git a/src/test/run-pass/borrowck-mut-uniq.rs b/src/test/run-pass/borrowck-mut-uniq.rs
index c586ff2c93ab3..4416c57e3456e 100644
--- a/src/test/run-pass/borrowck-mut-uniq.rs
+++ b/src/test/run-pass/borrowck-mut-uniq.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::mem::swap;
 
 #[derive(Show)]
diff --git a/src/test/run-pass/borrowck-use-mut-borrow.rs b/src/test/run-pass/borrowck-use-mut-borrow.rs
index cbfdd5961ffac..7be12ff3cc965 100644
--- a/src/test/run-pass/borrowck-use-mut-borrow.rs
+++ b/src/test/run-pass/borrowck-use-mut-borrow.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct A { a: int, b: Box<int> }
 
 fn field_copy_after_field_borrow() {
diff --git a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs b/src/test/run-pass/box-new.rs
similarity index 72%
rename from src/test/compile-fail/syntax-extension-bytes-non-literal.rs
rename to src/test/run-pass/box-new.rs
index 3a2e104818fd2..168218e1b1e27 100644
--- a/src/test/compile-fail/syntax-extension-bytes-non-literal.rs
+++ b/src/test/run-pass/box-new.rs
@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// 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.
 //
@@ -9,6 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let vec = bytes!(foo); //~ ERROR non-literal in bytes!
-    //~^ WARN `bytes!` is deprecated
+    let _a = Box::new(1);
 }
diff --git a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
index d326c20707d9f..631133cc7ff8b 100644
--- a/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
+++ b/src/test/run-pass/cancel-clean-via-immediate-rvalue-ref.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo(x: &mut Box<u8>) {
     *x = box 5;
diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs
index e3e0041050762..00673bee8b47f 100644
--- a/src/test/run-pass/capturing-logging.rs
+++ b/src/test/run-pass/capturing-logging.rs
@@ -11,6 +11,9 @@
 // ignore-android (FIXME #11419)
 // exec-env:RUST_LOG=info
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 #[macro_use]
 extern crate log;
 
diff --git a/src/test/run-pass/cci_borrow.rs b/src/test/run-pass/cci_borrow.rs
index 262c19174b18b..ef5ee5aa3b4ab 100644
--- a/src/test/run-pass/cci_borrow.rs
+++ b/src/test/run-pass/cci_borrow.rs
@@ -10,6 +10,8 @@
 
 // aux-build:cci_borrow_lib.rs
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 extern crate cci_borrow_lib;
 use cci_borrow_lib::foo;
diff --git a/src/test/run-pass/cfg_attr.rs b/src/test/run-pass/cfg_attr.rs
index 15d3f4a04d57a..7e508d91c877d 100644
--- a/src/test/run-pass/cfg_attr.rs
+++ b/src/test/run-pass/cfg_attr.rs
@@ -14,37 +14,37 @@ use std::fmt::Show;
 
 struct NotShowable;
 
-#[cfg_attr(set1, deriving(Show))]
+#[cfg_attr(set1, derive(Show))]
 struct Set1;
 
-#[cfg_attr(notset, deriving(Show))]
+#[cfg_attr(notset, derive(Show))]
 struct Notset(NotShowable);
 
-#[cfg_attr(not(notset), deriving(Show))]
+#[cfg_attr(not(notset), derive(Show))]
 struct NotNotset;
 
-#[cfg_attr(not(set1), deriving(Show))]
+#[cfg_attr(not(set1), derive(Show))]
 struct NotSet1(NotShowable);
 
-#[cfg_attr(all(set1, set2), deriving(Show))]
+#[cfg_attr(all(set1, set2), derive(Show))]
 struct AllSet1Set2;
 
-#[cfg_attr(all(set1, notset), deriving(Show))]
+#[cfg_attr(all(set1, notset), derive(Show))]
 struct AllSet1Notset(NotShowable);
 
-#[cfg_attr(any(set1, notset), deriving(Show))]
+#[cfg_attr(any(set1, notset), derive(Show))]
 struct AnySet1Notset;
 
-#[cfg_attr(any(notset, notset2), deriving(Show))]
+#[cfg_attr(any(notset, notset2), derive(Show))]
 struct AnyNotsetNotset2(NotShowable);
 
-#[cfg_attr(all(not(notset), any(set1, notset)), deriving(Show))]
+#[cfg_attr(all(not(notset), any(set1, notset)), derive(Show))]
 struct Complex;
 
-#[cfg_attr(any(notset, not(any(set1, notset))), deriving(Show))]
+#[cfg_attr(any(notset, not(any(set1, notset))), derive(Show))]
 struct ComplexNot(NotShowable);
 
-#[cfg_attr(any(target_endian = "little", target_endian = "big"), deriving(Show))]
+#[cfg_attr(any(target_endian = "little", target_endian = "big"), derive(Show))]
 struct KeyValue;
 
 fn is_show<T: Show>() {}
diff --git a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
index a041bbfe8ad92..e6cae99067e05 100644
--- a/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
+++ b/src/test/run-pass/class-cast-to-trait-cross-crate-2.rs
@@ -9,6 +9,10 @@
 // except according to those terms.
 
 // aux-build:cci_class_cast.rs
+
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 extern crate cci_class_cast;
 
 use std::string::ToString;
diff --git a/src/test/run-pass/class-separate-impl.rs b/src/test/run-pass/class-separate-impl.rs
index 9c7913dc0b0b1..c2fa98a66df95 100644
--- a/src/test/run-pass/class-separate-impl.rs
+++ b/src/test/run-pass/class-separate-impl.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::fmt;
 
 struct cat {
diff --git a/src/test/run-pass/cleanup-arm-conditional.rs b/src/test/run-pass/cleanup-arm-conditional.rs
index 65ad68ba702f4..0d155ae085c73 100644
--- a/src/test/run-pass/cleanup-arm-conditional.rs
+++ b/src/test/run-pass/cleanup-arm-conditional.rs
@@ -21,6 +21,9 @@
 // Test that cleanup scope for temporaries created in a match
 // arm is confined to the match arm itself.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::os;
 
 struct Test { x: int }
diff --git a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
index 89b0010208132..83f93cb81a1e6 100644
--- a/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
+++ b/src/test/run-pass/cleanup-rvalue-during-if-and-while.rs
@@ -12,6 +12,8 @@
 // This test verifies that temporaries created for `while`'s and `if`
 // conditions are dropped after the condition is evaluated.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Temporary;
 
diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs
index 59763e417a258..bbfe0e6a18dbc 100644
--- a/src/test/run-pass/cleanup-rvalue-scopes.rs
+++ b/src/test/run-pass/cleanup-rvalue-scopes.rs
@@ -12,6 +12,8 @@
 // statement or end of block, as appropriate given the temporary
 // lifetime rules.
 
+#![feature(box_syntax)]
+
 use std::ops::Drop;
 
 static mut FLAGS: u64 = 0;
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 526819940d003..04ab0d881a84d 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
@@ -24,6 +24,9 @@
 // It's unclear how likely such a bug is to recur, but it seems like a
 // scenario worth testing.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 enum Conzabble {
diff --git a/src/test/run-pass/clone-with-exterior.rs b/src/test/run-pass/clone-with-exterior.rs
index cb495859708b6..8eeae7a28ac85 100644
--- a/src/test/run-pass/clone-with-exterior.rs
+++ b/src/test/run-pass/clone-with-exterior.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 struct Pair {
diff --git a/src/test/run-pass/close-over-big-then-small-data.rs b/src/test/run-pass/close-over-big-then-small-data.rs
index 375767c8f5157..99fdc34602617 100644
--- a/src/test/run-pass/close-over-big-then-small-data.rs
+++ b/src/test/run-pass/close-over-big-then-small-data.rs
@@ -12,6 +12,9 @@
 // storing closure data (as we used to do), the u64 would
 // overwrite the u16.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Pair<A,B> {
     a: A, b: B
 }
diff --git a/src/test/run-pass/coerce-expect-unsized.rs b/src/test/run-pass/coerce-expect-unsized.rs
index 09f230792a9b7..3964d54f8609c 100644
--- a/src/test/run-pass/coerce-expect-unsized.rs
+++ b/src/test/run-pass/coerce-expect-unsized.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::fmt::Show;
 
 // Check that coercions apply at the pointer level and don't cause
diff --git a/src/test/run-pass/coerce-match-calls.rs b/src/test/run-pass/coerce-match-calls.rs
new file mode 100644
index 0000000000000..0ff28b471a30d
--- /dev/null
+++ b/src/test/run-pass/coerce-match-calls.rs
@@ -0,0 +1,23 @@
+// 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.
+
+// Check that coercions are propagated through match and if expressions.
+
+use std::boxed::Box;
+
+pub fn main() {
+    let _: Box<[int]> = if true { Box::new([1i, 2, 3]) } else { Box::new([1i]) };
+
+    let _: Box<[int]> = match true { true => Box::new([1i, 2, 3]), false => Box::new([1i]) };
+
+    // Check we don't get over-keen at propagating coercions in the case of casts.
+    let x = if true { 42 } else { 42u8 } as u16;
+    let x = match true { true => 42, false => 42u8 } as u16;
+}
diff --git a/src/test/run-pass/coerce-match.rs b/src/test/run-pass/coerce-match.rs
index d67664bb1be47..0992ee97d061f 100644
--- a/src/test/run-pass/coerce-match.rs
+++ b/src/test/run-pass/coerce-match.rs
@@ -10,6 +10,9 @@
 
 // Check that coercions are propagated through match and if expressions.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let _: Box<[int]> = if true { box [1i, 2, 3] } else { box [1i] };
 
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index e24bc1dbff9d5..3a6973fe61c77 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -11,6 +11,8 @@
 // Make sure const bounds work on things, and test that a few types
 // are const.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo<T: Sync>(x: T) -> T { x }
 
diff --git a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs
index 0088a36eda9a3..1a3e87b55b64b 100644
--- a/src/test/run-pass/crate-method-reexport-grrrrrrr.rs
+++ b/src/test/run-pass/crate-method-reexport-grrrrrrr.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // This is a regression test that the metadata for the
 // name_pool::methods impl in the other crate is reachable from this
diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs
index d9b0940f80b3f..ead0683b87090 100644
--- a/src/test/run-pass/deref-lval.rs
+++ b/src/test/run-pass/deref-lval.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 use std::cell::Cell;
 
diff --git a/src/test/run-pass/deref.rs b/src/test/run-pass/deref.rs
index 117b133a11319..b4ee0246d8780 100644
--- a/src/test/run-pass/deref.rs
+++ b/src/test/run-pass/deref.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let x: Box<int> = box 10;
diff --git a/src/test/run-pass/deriving-default-box.rs b/src/test/run-pass/deriving-default-box.rs
index aea6ebd25975c..b00ceb6ed22c7 100644
--- a/src/test/run-pass/deriving-default-box.rs
+++ b/src/test/run-pass/deriving-default-box.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::default::Default;
 
 #[derive(Default)]
diff --git a/src/test/run-pass/deriving-encodable-decodable-box.rs b/src/test/run-pass/deriving-encodable-decodable-box.rs
index b7be14321fde6..1a204fa3e206e 100644
--- a/src/test/run-pass/deriving-encodable-decodable-box.rs
+++ b/src/test/run-pass/deriving-encodable-decodable-box.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(old_orphan_check)]
 
 extern crate serialize;
diff --git a/src/test/run-pass/deriving-eq-ord-boxed-slice.rs b/src/test/run-pass/deriving-eq-ord-boxed-slice.rs
index 6701a32133938..3b89c943edb1c 100644
--- a/src/test/run-pass/deriving-eq-ord-boxed-slice.rs
+++ b/src/test/run-pass/deriving-eq-ord-boxed-slice.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 #[derive(PartialEq, PartialOrd, Eq, Ord)]
 struct Foo(Box<[u8]>);
 
diff --git a/src/test/run-pass/deriving-hash.rs b/src/test/run-pass/deriving-hash.rs
index ddad703d7dfdb..02ab7e5db5b89 100644
--- a/src/test/run-pass/deriving-hash.rs
+++ b/src/test/run-pass/deriving-hash.rs
@@ -8,9 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
-use std::hash;
-use std::hash::Hash;
+use std::hash::{Hash, SipHasher};
 
 #[derive(Hash)]
 struct Person {
@@ -19,6 +17,10 @@ struct Person {
     phone: uint,
 }
 
+fn hash<T: Hash<SipHasher>>(t: &T) -> u64 {
+    std::hash::hash::<T, SipHasher>(t)
+}
+
 fn main() {
     let person1 = Person {
         id: 5,
@@ -30,6 +32,6 @@ fn main() {
         name: "Bob".to_string(),
         phone: 555_666_7777
     };
-    assert!(hash::hash(&person1) == hash::hash(&person1));
-    assert!(hash::hash(&person1) != hash::hash(&person2));
+    assert!(hash(&person1) == hash(&person1));
+    assert!(hash(&person1) != hash(&person2));
 }
diff --git a/src/test/run-pass/deriving-meta-multiple.rs b/src/test/run-pass/deriving-meta-multiple.rs
index c435a1f344d3d..f45dce9da632e 100644
--- a/src/test/run-pass/deriving-meta-multiple.rs
+++ b/src/test/run-pass/deriving-meta-multiple.rs
@@ -9,7 +9,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::hash::hash;
+use std::hash::{Hash, SipHasher};
 
 // testing multiple separate deriving attributes
 #[derive(PartialEq)]
@@ -20,6 +20,8 @@ struct Foo {
     baz: int
 }
 
+fn hash<T: Hash<SipHasher>>(_t: &T) {}
+
 pub fn main() {
     let a = Foo {bar: 4, baz: -3};
 
diff --git a/src/test/run-pass/deriving-meta.rs b/src/test/run-pass/deriving-meta.rs
index 54dc2b97b77f3..d6a2fad08ed88 100644
--- a/src/test/run-pass/deriving-meta.rs
+++ b/src/test/run-pass/deriving-meta.rs
@@ -9,7 +9,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::hash::hash;
+use std::hash::{Hash, SipHasher};
 
 #[derive(PartialEq, Clone, Hash)]
 struct Foo {
@@ -17,6 +17,8 @@ struct Foo {
     baz: int
 }
 
+fn hash<T: Hash<SipHasher>>(_t: &T) {}
+
 pub fn main() {
     let a = Foo {bar: 4, baz: -3};
 
diff --git a/src/test/run-pass/drop-on-empty-block-exit.rs b/src/test/run-pass/drop-on-empty-block-exit.rs
index e3927bd536773..f875d0644a07d 100644
--- a/src/test/run-pass/drop-on-empty-block-exit.rs
+++ b/src/test/run-pass/drop-on-empty-block-exit.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum t { foo(Box<int>), }
 
diff --git a/src/test/run-pass/drop-struct-as-object.rs b/src/test/run-pass/drop-struct-as-object.rs
index 6d7715ed9a5a0..7a3b6df539f14 100644
--- a/src/test/run-pass/drop-struct-as-object.rs
+++ b/src/test/run-pass/drop-struct-as-object.rs
@@ -11,6 +11,9 @@
 // Test that destructor on a struct runs successfully after the struct
 // is boxed and converted to an object.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static mut value: uint = 0;
 
 struct Cat {
diff --git a/src/test/run-pass/drop-trait-enum.rs b/src/test/run-pass/drop-trait-enum.rs
index f1cc4fb172409..9bfb3572ab562 100644
--- a/src/test/run-pass/drop-trait-enum.rs
+++ b/src/test/run-pass/drop-trait-enum.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 use std::sync::mpsc::{channel, Sender};
 
@@ -36,13 +39,13 @@ enum Foo {
 impl Drop for Foo {
     fn drop(&mut self) {
         match self {
-            &Foo::SimpleVariant(ref mut sender) => {
+            &mut Foo::SimpleVariant(ref mut sender) => {
                 sender.send(Message::DestructorRan).unwrap();
             }
-            &Foo::NestedVariant(_, _, ref mut sender) => {
+            &mut Foo::NestedVariant(_, _, ref mut sender) => {
                 sender.send(Message::DestructorRan).unwrap();
             }
-            &Foo::FailingVariant { .. } => {
+            &mut Foo::FailingVariant { .. } => {
                 panic!("Failed");
             }
         }
@@ -66,7 +69,7 @@ pub fn main() {
     assert_eq!(receiver.recv().ok(), None);
 
     let (sender, receiver) = channel();
-    let _t = Thread::spawn(move|| {
+    let _t = Thread::scoped(move|| {
         let v = Foo::FailingVariant { on_drop: SendOnDrop { sender: sender } };
     });
     assert_eq!(receiver.recv().unwrap(), Message::Dropped);
@@ -74,7 +77,7 @@ pub fn main() {
 
     let (sender, receiver) = channel();
     let _t = {
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             let mut v = Foo::NestedVariant(box 42u, SendOnDrop {
                 sender: sender.clone()
             }, sender.clone());
diff --git a/src/test/run-pass/dst-deref-mut.rs b/src/test/run-pass/dst-deref-mut.rs
index 0a12df53de232..909f7f4897a6a 100644
--- a/src/test/run-pass/dst-deref-mut.rs
+++ b/src/test/run-pass/dst-deref-mut.rs
@@ -10,6 +10,9 @@
 
 // Test that a custom deref with a fat pointer return type does not ICE
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::ops::{Deref, DerefMut};
 
 pub struct Arr {
diff --git a/src/test/run-pass/dst-deref.rs b/src/test/run-pass/dst-deref.rs
index 8ef8f1a868d51..ad4456b5b592d 100644
--- a/src/test/run-pass/dst-deref.rs
+++ b/src/test/run-pass/dst-deref.rs
@@ -10,6 +10,9 @@
 
 // Test that a custom deref with a fat pointer return type does not ICE
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::ops::Deref;
 
 pub struct Arr {
diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs
index 9c0e5a6f5c899..b2092e745a116 100644
--- a/src/test/run-pass/dst-struct.rs
+++ b/src/test/run-pass/dst-struct.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Fat<T: ?Sized> {
     f1: int,
     f2: &'static str,
diff --git a/src/test/run-pass/dst-trait.rs b/src/test/run-pass/dst-trait.rs
index 0b50609fddfef..627d197879d26 100644
--- a/src/test/run-pass/dst-trait.rs
+++ b/src/test/run-pass/dst-trait.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Fat<T: ?Sized> {
     f1: int,
     f2: &'static str,
diff --git a/src/test/run-pass/empty-allocation-non-null.rs b/src/test/run-pass/empty-allocation-non-null.rs
index 56eb340ef59ac..269e0ee6ce425 100644
--- a/src/test/run-pass/empty-allocation-non-null.rs
+++ b/src/test/run-pass/empty-allocation-non-null.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     assert!(Some(box() ()).is_some());
 
diff --git a/src/test/run-pass/empty-allocation-rvalue-non-null.rs b/src/test/run-pass/empty-allocation-rvalue-non-null.rs
index 96c5f81558e39..e95d58c706b27 100644
--- a/src/test/run-pass/empty-allocation-rvalue-non-null.rs
+++ b/src/test/run-pass/empty-allocation-rvalue-non-null.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let x = *box() ();
 }
diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
index 7d856fd5656c7..817136572024b 100644
--- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
+++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 /*!
  * This is a regression test for a bug in LLVM, fixed in upstream r179587,
diff --git a/src/test/run-pass/evec-slice.rs b/src/test/run-pass/evec-slice.rs
index ab6576b9b427d..734ac3066534e 100644
--- a/src/test/run-pass/evec-slice.rs
+++ b/src/test/run-pass/evec-slice.rs
@@ -22,7 +22,7 @@ pub fn main() {
     let c : &[int] = &[2,2,2,2,3];
     let cc : &[int] = &[2,2,2,2,2,2];
 
-    println!("{}", a);
+    println!("{:?}", a);
 
     assert!(a < b);
     assert!(a <= b);
@@ -30,7 +30,7 @@ pub fn main() {
     assert!(b >= a);
     assert!(b > a);
 
-    println!("{}", b);
+    println!("{:?}", b);
 
     assert!(b < c);
     assert!(b <= c);
@@ -44,7 +44,7 @@ pub fn main() {
     assert!(c >= a);
     assert!(c > a);
 
-    println!("{}", c);
+    println!("{:?}", c);
 
     assert!(a < cc);
     assert!(a <= cc);
@@ -52,5 +52,5 @@ pub fn main() {
     assert!(cc >= a);
     assert!(cc > a);
 
-    println!("{}", cc);
+    println!("{:?}", cc);
 }
diff --git a/src/test/run-pass/explicit-self-generic.rs b/src/test/run-pass/explicit-self-generic.rs
index 87f1adba8ddcf..a2aaaa235e429 100644
--- a/src/test/run-pass/explicit-self-generic.rs
+++ b/src/test/run-pass/explicit-self-generic.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct LM { resize_at: uint, size: uint }
 
 impl Copy for LM {}
diff --git a/src/test/run-pass/explicit-self-objects-uniq.rs b/src/test/run-pass/explicit-self-objects-uniq.rs
index e566f218aa8f6..501ba01b4ce1c 100644
--- a/src/test/run-pass/explicit-self-objects-uniq.rs
+++ b/src/test/run-pass/explicit-self-objects-uniq.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait Foo {
     fn f(self: Box<Self>);
diff --git a/src/test/run-pass/explicit-self.rs b/src/test/run-pass/explicit-self.rs
index 8a67e40844a73..e5d8ec3f8ad0d 100644
--- a/src/test/run-pass/explicit-self.rs
+++ b/src/test/run-pass/explicit-self.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static tau: f64 = 2.0*3.14159265358979323;
 
 struct Point {x: f64, y: f64}
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index 5c1039fe43368..1654c87c6a484 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn test_generic<T, F>(expected: Box<T>, eq: F) where T: Clone, F: FnOnce(Box<T>, Box<T>) -> bool {
     let actual: Box<T> = { expected.clone() };
     assert!(eq(expected, actual));
diff --git a/src/test/run-pass/expr-block-generic-unique2.rs b/src/test/run-pass/expr-block-generic-unique2.rs
index 3d736cca6d524..e41ce37cc3a1d 100644
--- a/src/test/run-pass/expr-block-generic-unique2.rs
+++ b/src/test/run-pass/expr-block-generic-unique2.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn test_generic<T, F>(expected: T, eq: F) where T: Clone, F: FnOnce(T, T) -> bool {
     let actual: T = { expected.clone() };
     assert!(eq(expected, actual));
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index 0dff989002f5b..d934ce677d121 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -9,6 +9,7 @@
 // except according to those terms.
 
 
-
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() { let x = { box 100i }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs
index b1fdf51d9b133..5294d05401c89 100644
--- a/src/test/run-pass/expr-if-unique.rs
+++ b/src/test/run-pass/expr-if-unique.rs
@@ -9,7 +9,8 @@
 // except according to those terms.
 
 
-
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 
 // Tests for if as expressions returning boxed types
diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs
index 5fc9a502ca8a0..9de1379f480f1 100644
--- a/src/test/run-pass/expr-match-generic-unique1.rs
+++ b/src/test/run-pass/expr-match-generic-unique1.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn test_generic<T: Clone, F>(expected: Box<T>, eq: F) where F: FnOnce(Box<T>, Box<T>) -> bool {
     let actual: Box<T> = match true {
         true => { expected.clone() },
diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs
index e608f9c46c79c..489cd8437d21f 100644
--- a/src/test/run-pass/expr-match-generic-unique2.rs
+++ b/src/test/run-pass/expr-match-generic-unique2.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn test_generic<T: Clone, F>(expected: T, eq: F) where F: FnOnce(T, T) -> bool {
     let actual: T = match true {
         true => expected.clone(),
diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs
index 83f2ada02b0ff..7958f4927daf8 100644
--- a/src/test/run-pass/expr-match-unique.rs
+++ b/src/test/run-pass/expr-match-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
diff --git a/src/test/run-pass/ext-expand-inner-exprs.rs b/src/test/run-pass/ext-expand-inner-exprs.rs
index 1c96cbd93142c..d204f808e4471 100644
--- a/src/test/run-pass/ext-expand-inner-exprs.rs
+++ b/src/test/run-pass/ext-expand-inner-exprs.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static FOO : &'static [u8] = bytes!(concat!(concat!("hel", "lo"), "world"));
+static FOO : &'static str = concat!(concat!("hel", "lo"), "world");
 
 pub fn main() {
-    assert_eq!(FOO, "helloworld".as_bytes());
+    assert_eq!(FOO, "helloworld");
 }
diff --git a/src/test/run-pass/extern-stress.rs b/src/test/run-pass/extern-stress.rs
index bb9e94073828a..c3e04177cce7d 100644
--- a/src/test/run-pass/extern-stress.rs
+++ b/src/test/run-pass/extern-stress.rs
@@ -42,7 +42,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t {
 
 pub fn main() {
     range(0u, 100).map(|_| {
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             assert_eq!(count(5), 16);
         })
     }).collect::<Vec<_>>();
diff --git a/src/test/run-pass/extern-yield.rs b/src/test/run-pass/extern-yield.rs
index 46829e9ba6ef8..f5e91b9de67a9 100644
--- a/src/test/run-pass/extern-yield.rs
+++ b/src/test/run-pass/extern-yield.rs
@@ -39,7 +39,7 @@ fn count(n: libc::uintptr_t) -> libc::uintptr_t {
 
 pub fn main() {
     range(0, 10u).map(|i| {
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             let result = count(5);
             println!("result = {}", result);
             assert_eq!(result, 16);
diff --git a/src/test/run-pass/fsu-moves-and-copies.rs b/src/test/run-pass/fsu-moves-and-copies.rs
index a08cd33362f47..0f8d7c24360fb 100644
--- a/src/test/run-pass/fsu-moves-and-copies.rs
+++ b/src/test/run-pass/fsu-moves-and-copies.rs
@@ -11,6 +11,9 @@
 // Issue 4691: Ensure that functional-struct-updates operates
 // correctly and moves rather than copy when appropriate.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::marker::NoCopy as NP;
 
 struct ncint { np: NP, v: int }
diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs
index 6d06c12c4507e..b23d8db3cfdd5 100644
--- a/src/test/run-pass/func-arg-incomplete-pattern.rs
+++ b/src/test/run-pass/func-arg-incomplete-pattern.rs
@@ -11,6 +11,8 @@
 // Test that we do not leak when the arg pattern must drop part of the
 // argument (in this case, the `y` field).
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Foo {
     x: Box<uint>,
diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs
index 5eeace6505400..9e94bca96f7bd 100644
--- a/src/test/run-pass/func-arg-ref-pattern.rs
+++ b/src/test/run-pass/func-arg-ref-pattern.rs
@@ -14,6 +14,8 @@
 // boxes. Make sure that we don't free the box as we match the
 // pattern.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn getaddr(box ref x: Box<uint>) -> *const uint {
     let addr: *const uint = &*x;
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 8b5dfb6cf75a0..34b7f15e4c6b1 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn id<T:Send>(t: T) -> T { return t; }
 
 pub fn main() {
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index 0746c994c2a6b..a2f7bdfd81709 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Recbox<T> {x: Box<T>}
 
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index e1a8ad7c20ab0..be83cb04f2c37 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f<T>(x: Box<T>) -> Box<T> { return x; }
 
 pub fn main() { let x = f(box 3i); println!("{}", *x); }
diff --git a/src/test/run-pass/generic-object.rs b/src/test/run-pass/generic-object.rs
index d0a5af8e2cecf..986b35cbecf96 100644
--- a/src/test/run-pass/generic-object.rs
+++ b/src/test/run-pass/generic-object.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait Foo<T> {
     fn get(&self) -> T;
diff --git a/src/test/run-pass/generic-recursive-tag.rs b/src/test/run-pass/generic-recursive-tag.rs
index b738b5271220a..845375d9b840a 100644
--- a/src/test/run-pass/generic-recursive-tag.rs
+++ b/src/test/run-pass/generic-recursive-tag.rs
@@ -10,6 +10,8 @@
 
 // ignore-pretty FIXME(#14193)
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum list<T> { cons(Box<T>, Box<list<T>>), nil, }
 
diff --git a/src/test/run-pass/generic-tag.rs b/src/test/run-pass/generic-tag.rs
index 250c5bb66af47..b0d4944ba540b 100644
--- a/src/test/run-pass/generic-tag.rs
+++ b/src/test/run-pass/generic-tag.rs
@@ -10,6 +10,8 @@
 
 #![allow(dead_assignment)]
 #![allow(unused_variable)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum option<T> { some(Box<T>), none, }
 
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 4821b9354bfda..1d39c47417c10 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Triple<T> { x: T, y: T, z: T }
 
diff --git a/src/test/run-pass/hashmap-memory.rs b/src/test/run-pass/hashmap-memory.rs
index f83698edc9052..0e82ad437829f 100644
--- a/src/test/run-pass/hashmap-memory.rs
+++ b/src/test/run-pass/hashmap-memory.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 /**
diff --git a/src/test/run-pass/hrtb-precedence-of-plus.rs b/src/test/run-pass/hrtb-precedence-of-plus.rs
index 9a43b5b711eb5..1d1e744ef0802 100644
--- a/src/test/run-pass/hrtb-precedence-of-plus.rs
+++ b/src/test/run-pass/hrtb-precedence-of-plus.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 // Test that `Fn(int) -> int + 'static` parses as `(Fn(int) -> int) +
diff --git a/src/test/run-pass/huge-largest-array.rs b/src/test/run-pass/huge-largest-array.rs
index e24731546edfe..e1b0c1153657e 100644
--- a/src/test/run-pass/huge-largest-array.rs
+++ b/src/test/run-pass/huge-largest-array.rs
@@ -10,12 +10,12 @@
 
 use std::mem::size_of;
 
-#[cfg(target_word_size = "32")]
+#[cfg(any(all(stage0, target_word_size = "32"), all(not(stage0), target_pointer_width = "32")))]
 pub fn main() {
     assert_eq!(size_of::<[u8; (1 << 31) - 1]>(), (1 << 31) - 1);
 }
 
-#[cfg(target_word_size = "64")]
+#[cfg(any(all(stage0, target_word_size = "64"), all(not(stage0), target_pointer_width = "64")))]
 pub fn main() {
     assert_eq!(size_of::<[u8; (1 << 47) - 1]>(), (1 << 47) - 1);
 }
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index 8b0d7c18fb119..dbc23a63bbadf 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -13,6 +13,8 @@
 
 #![deny(warnings)]
 #![allow(unused_must_use)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 use std::fmt;
 
@@ -183,7 +185,7 @@ fn test_write() {
 // can do with them just yet (to test the output)
 fn test_print() {
     print!("hi");
-    print!("{}", vec!(0u8));
+    print!("{:?}", vec!(0u8));
     println!("hello");
     println!("this is a {}", "test");
     println!("{foo}", foo="bar");
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index ee82a99a8084b..eeae3f35cfcd0 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unsafe_destructor)]
 
 use std::cell::Cell;
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index 3b81943000bf8..0644fbbc99f41 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(intrinsics)]
 
 mod rusti {
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index f1bbf353f717d..fb04f67e380ab 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(intrinsics)]
 
 use std::mem::transmute;
diff --git a/src/test/run-pass/issue-10682.rs b/src/test/run-pass/issue-10682.rs
index fd0ad1ef47ecb..883e52b61d081 100644
--- a/src/test/run-pass/issue-10682.rs
+++ b/src/test/run-pass/issue-10682.rs
@@ -11,6 +11,9 @@
 // Regression test for issue #10682
 // Nested `proc` usage can't use outer owned data
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn work(_: Box<int>) {}
 fn foo<F:FnOnce()>(_: F) {}
 
diff --git a/src/test/run-pass/issue-10767.rs b/src/test/run-pass/issue-10767.rs
index d28950241874d..c717053cffc74 100644
--- a/src/test/run-pass/issue-10767.rs
+++ b/src/test/run-pass/issue-10767.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     fn f() {
diff --git a/src/test/run-pass/issue-10802.rs b/src/test/run-pass/issue-10802.rs
index ab080834ac94b..de2b4c51e52a9 100644
--- a/src/test/run-pass/issue-10802.rs
+++ b/src/test/run-pass/issue-10802.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct DroppableStruct;
 enum DroppableEnum {
     DroppableVariant1, DroppableVariant2
diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs
index 549a70f19e334..194208620a8ea 100644
--- a/src/test/run-pass/issue-11205.rs
+++ b/src/test/run-pass/issue-11205.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(dead_code)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait Foo {}
 impl Foo for int {}
diff --git a/src/test/run-pass/issue-11552.rs b/src/test/run-pass/issue-11552.rs
index 92862961acaba..f47f1e06011d9 100644
--- a/src/test/run-pass/issue-11552.rs
+++ b/src/test/run-pass/issue-11552.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 #[derive(Clone)]
 enum Noun
diff --git a/src/test/run-pass/issue-11677.rs b/src/test/run-pass/issue-11677.rs
index 14c1b1b06eabf..6fa4505869478 100644
--- a/src/test/run-pass/issue-11677.rs
+++ b/src/test/run-pass/issue-11677.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(dead_code)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // this code used to cause an ICE
 
diff --git a/src/test/run-pass/issue-12744.rs b/src/test/run-pass/issue-12744.rs
index a91dbd2b716b6..ec929a9c792de 100644
--- a/src/test/run-pass/issue-12744.rs
+++ b/src/test/run-pass/issue-12744.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() {
     fn test() -> Box<std::any::Any + 'static> { box 1i }
     println!("{:?}", test())
diff --git a/src/test/run-pass/issue-13323.rs b/src/test/run-pass/issue-13323.rs
index b7cd8a9011276..75d3c6f334d07 100644
--- a/src/test/run-pass/issue-13323.rs
+++ b/src/test/run-pass/issue-13323.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct StrWrap {
     s: String
 }
diff --git a/src/test/run-pass/issue-13808.rs b/src/test/run-pass/issue-13808.rs
index c0652b946dbe5..3c5ece87b737d 100644
--- a/src/test/run-pass/issue-13808.rs
+++ b/src/test/run-pass/issue-13808.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Foo<'a> {
     listener: Box<FnMut() + 'a>,
 }
diff --git a/src/test/run-pass/issue-14399.rs b/src/test/run-pass/issue-14399.rs
index bb0fe6a87ab07..7e533c2cf86c1 100644
--- a/src/test/run-pass/issue-14399.rs
+++ b/src/test/run-pass/issue-14399.rs
@@ -13,6 +13,9 @@
 // value was coerced to a trait object. (v.clone() returns Box<B1>
 // which is coerced to Box<A>).
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 #[derive(Clone)]
 struct B1;
 
diff --git a/src/test/run-pass/issue-14589.rs b/src/test/run-pass/issue-14589.rs
index afc2fc6cf647f..d9763baa82657 100644
--- a/src/test/run-pass/issue-14589.rs
+++ b/src/test/run-pass/issue-14589.rs
@@ -11,6 +11,9 @@
 // All 3 expressions should work in that the argument gets
 // coerced to a trait object
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() {
     send::<Box<Foo>>(box Output(0));
     Test::<Box<Foo>>::foo(box Output(0));
diff --git a/src/test/run-pass/issue-14919.rs b/src/test/run-pass/issue-14919.rs
index 21bda93ecec65..4d05b98147bd6 100644
--- a/src/test/run-pass/issue-14919.rs
+++ b/src/test/run-pass/issue-14919.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait Matcher {
     fn next_match(&mut self) -> Option<(uint, uint)>;
 }
diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs
index 03d18cf8c9815..6b273b5786a93 100644
--- a/src/test/run-pass/issue-15571.rs
+++ b/src/test/run-pass/issue-15571.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn match_on_local() {
     let mut foo = Some(box 5i);
     match foo {
diff --git a/src/test/run-pass/issue-15730.rs b/src/test/run-pass/issue-15730.rs
index 4e1aa454a881d..72daa0cba4104 100644
--- a/src/test/run-pass/issue-15730.rs
+++ b/src/test/run-pass/issue-15730.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let mut array = [1, 2, 3];
     let pie_slice = &array[1..2];
diff --git a/src/test/run-pass/issue-15763.rs b/src/test/run-pass/issue-15763.rs
index 48fdcb09080ae..283ea25b6fe17 100644
--- a/src/test/run-pass/issue-15763.rs
+++ b/src/test/run-pass/issue-15763.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 #[derive(PartialEq, Show)]
 struct Bar {
diff --git a/src/test/run-pass/issue-16668.rs b/src/test/run-pass/issue-16668.rs
index 1febf33742974..75b1e11ddc1e6 100644
--- a/src/test/run-pass/issue-16668.rs
+++ b/src/test/run-pass/issue-16668.rs
@@ -10,6 +10,8 @@
 
 // ignore-pretty
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct Parser<'a, I, O> {
diff --git a/src/test/run-pass/issue-16739.rs b/src/test/run-pass/issue-16739.rs
index 552ce565f6b17..cb6f068cf45b8 100644
--- a/src/test/run-pass/issue-16739.rs
+++ b/src/test/run-pass/issue-16739.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 // Test that unboxing shim for calling rust-call ABI methods through a
diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs
index 6ef4f868d2150..175e218881138 100644
--- a/src/test/run-pass/issue-16774.rs
+++ b/src/test/run-pass/issue-16774.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::ops::{Deref, DerefMut};
@@ -36,7 +38,7 @@ impl Deref for X {
 
 impl DerefMut for X {
     fn deref_mut(&mut self) -> &mut int {
-        let &X(box ref mut x) = self;
+        let &mut X(box ref mut x) = self;
         x
     }
 }
diff --git a/src/test/run-pass/issue-17322.rs b/src/test/run-pass/issue-17322.rs
index c5784154a2ece..b50bf442b5d60 100644
--- a/src/test/run-pass/issue-17322.rs
+++ b/src/test/run-pass/issue-17322.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::io;
 
 fn f(wr: &mut Writer) {
diff --git a/src/test/run-pass/issue-17503.rs b/src/test/run-pass/issue-17503.rs
index 8acda17500692..65bf088786efb 100644
--- a/src/test/run-pass/issue-17503.rs
+++ b/src/test/run-pass/issue-17503.rs
@@ -8,14 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let s: &[int] = &[0, 1, 2, 3, 4];
     let ss: &&[int] = &s;
     let sss: &&&[int] = &ss;
 
-    println!("{}", &s[0..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-17734.rs b/src/test/run-pass/issue-17734.rs
index f68ab01ea9b54..e58fbe0b4c283 100644
--- a/src/test/run-pass/issue-17734.rs
+++ b/src/test/run-pass/issue-17734.rs
@@ -10,6 +10,9 @@
 
 // Test that generating drop glue for Box<str> doesn't ICE
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f(s: Box<str>) -> Box<str> {
     s
 }
diff --git a/src/test/run-pass/issue-18425.rs b/src/test/run-pass/issue-18425.rs
index f61530c741851..6d223923ac1df 100644
--- a/src/test/run-pass/issue-18425.rs
+++ b/src/test/run-pass/issue-18425.rs
@@ -11,6 +11,9 @@
 // Check that trans doesn't ICE when translating an array repeat
 // expression with a count of 1 and a non-Copy element type.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn main() {
     let _ = [box 1u; 1];
 }
diff --git a/src/test/run-pass/issue-20644.rs b/src/test/run-pass/issue-20644.rs
index 4a57ed56594b1..f74b09a3d246f 100644
--- a/src/test/run-pass/issue-20644.rs
+++ b/src/test/run-pass/issue-20644.rs
@@ -11,7 +11,6 @@
 // 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)]
 
diff --git a/src/test/run-pass/issue-2288.rs b/src/test/run-pass/issue-2288.rs
index 1f371f0a1c204..7baead6929beb 100644
--- a/src/test/run-pass/issue-2288.rs
+++ b/src/test/run-pass/issue-2288.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait clam<A> {
   fn chowder(&self, y: A);
diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs
index e2a03c696f2f2..c146f8a7a9afb 100644
--- a/src/test/run-pass/issue-2633-2.rs
+++ b/src/test/run-pass/issue-2633-2.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 
 fn a_val(x: Box<int>, y: Box<int>) -> int {
     *x + *y
diff --git a/src/test/run-pass/issue-2708.rs b/src/test/run-pass/issue-2708.rs
index 3ac4b874f3ad8..1f072af0f5a64 100644
--- a/src/test/run-pass/issue-2708.rs
+++ b/src/test/run-pass/issue-2708.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Font {
     fontbuf: uint,
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 3ca3e0592e789..6f5f46edc01cb 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -11,6 +11,8 @@
 //
 // ignore-lexer-test FIXME #15883
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unsafe_destructor)]
 
 pub type Task = int;
diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs
index 9eec2d048d473..3e4cffe5dfa38 100644
--- a/src/test/run-pass/issue-2734.rs
+++ b/src/test/run-pass/issue-2734.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait hax { }
 impl<A> hax for A { }
diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs
index 74b64bb87cfc5..cb376d0e4398d 100644
--- a/src/test/run-pass/issue-2735.rs
+++ b/src/test/run-pass/issue-2735.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait hax { }
 impl<A> hax for A { }
diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs
index cdc41e892f964..295fd538de635 100644
--- a/src/test/run-pass/issue-2935.rs
+++ b/src/test/run-pass/issue-2935.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 //type t = { a: int };
 // type t = { a: bool };
diff --git a/src/test/run-pass/issue-3012-2.rs b/src/test/run-pass/issue-3012-2.rs
index aa2ce824822b1..de2d4374d787f 100644
--- a/src/test/run-pass/issue-3012-2.rs
+++ b/src/test/run-pass/issue-3012-2.rs
@@ -10,6 +10,8 @@
 
 // aux-build:issue-3012-1.rs
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 extern crate socketlib;
 extern crate libc;
diff --git a/src/test/run-pass/issue-3026.rs b/src/test/run-pass/issue-3026.rs
index b30c0a117a805..cd71bfce27428 100644
--- a/src/test/run-pass/issue-3026.rs
+++ b/src/test/run-pass/issue-3026.rs
@@ -9,6 +9,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 extern crate collections;
 
 use std::collections::HashMap;
diff --git a/src/test/run-pass/issue-3052.rs b/src/test/run-pass/issue-3052.rs
index 72cf2219bb6f0..c08bdf5440812 100644
--- a/src/test/run-pass/issue-3052.rs
+++ b/src/test/run-pass/issue-3052.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 type Connection = Box<FnMut(Vec<u8>) + 'static>;
 
diff --git a/src/test/run-pass/issue-3121.rs b/src/test/run-pass/issue-3121.rs
index 9e9d611f1a320..c789921f6220a 100644
--- a/src/test/run-pass/issue-3121.rs
+++ b/src/test/run-pass/issue-3121.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum side { mayo, catsup, vinegar }
 enum order { hamburger, fries(side), shake }
diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs
index 139d984b50733..a72b272abaac6 100644
--- a/src/test/run-pass/issue-3290.rs
+++ b/src/test/run-pass/issue-3290.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
    let mut x = box 3i;
    x = x;
diff --git a/src/test/run-pass/issue-3424.rs b/src/test/run-pass/issue-3424.rs
index 528870d033476..6647fbe2238ef 100644
--- a/src/test/run-pass/issue-3424.rs
+++ b/src/test/run-pass/issue-3424.rs
@@ -11,6 +11,8 @@
 
 // rustc --test ignores2.rs && ./ignores2
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::path::{Path};
diff --git a/src/test/run-pass/issue-3447.rs b/src/test/run-pass/issue-3447.rs
index 4ebf981e4ee55..12c2155dd57a7 100644
--- a/src/test/run-pass/issue-3447.rs
+++ b/src/test/run-pass/issue-3447.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 use std::cell::RefCell;
 
diff --git a/src/test/run-pass/issue-3609.rs b/src/test/run-pass/issue-3609.rs
index c3cfaf22dee05..56eb7486c928c 100644
--- a/src/test/run-pass/issue-3609.rs
+++ b/src/test/run-pass/issue-3609.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 use std::sync::mpsc::Sender;
 use std::thunk::Invoke;
diff --git a/src/test/run-pass/issue-3794.rs b/src/test/run-pass/issue-3794.rs
index 926b53cf92c0d..91c938981c10b 100644
--- a/src/test/run-pass/issue-3794.rs
+++ b/src/test/run-pass/issue-3794.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait T {
     fn print(&self);
 }
diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs
index 063b2d7030147..5434e44c17376 100644
--- a/src/test/run-pass/issue-3878.rs
+++ b/src/test/run-pass/issue-3878.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(path_statement)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let y = box 1i;
diff --git a/src/test/run-pass/issue-3888-2.rs b/src/test/run-pass/issue-3888-2.rs
index 5ed9729c14258..bf3d0b786af65 100644
--- a/src/test/run-pass/issue-3888-2.rs
+++ b/src/test/run-pass/issue-3888-2.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 fn vec_peek<'r, T>(v: &'r [T]) -> &'r [T] {
     &v[1..5]
 }
diff --git a/src/test/run-pass/issue-4464.rs b/src/test/run-pass/issue-4464.rs
index 2581069d29b05..33a5c7a167f99 100644
--- a/src/test/run-pass/issue-4464.rs
+++ b/src/test/run-pass/issue-4464.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 fn broken(v: &[u8], i: uint, j: uint) -> &[u8] { &v[i..j] }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-4735.rs b/src/test/run-pass/issue-4735.rs
index 7730d75a3a9c2..bf422bd0405a1 100644
--- a/src/test/run-pass/issue-4735.rs
+++ b/src/test/run-pass/issue-4735.rs
@@ -10,6 +10,9 @@
 
 // ignore-fast doesn't like extern crate
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 extern crate libc;
 
 use std::mem::transmute;
diff --git a/src/test/run-pass/issue-4759.rs b/src/test/run-pass/issue-4759.rs
index 4b5c3566965f9..2245e80971a90 100644
--- a/src/test/run-pass/issue-4759.rs
+++ b/src/test/run-pass/issue-4759.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct T { a: Box<int> }
 
diff --git a/src/test/run-pass/issue-5192.rs b/src/test/run-pass/issue-5192.rs
index 3b1a8c4a19077..bb79cd4d04667 100644
--- a/src/test/run-pass/issue-5192.rs
+++ b/src/test/run-pass/issue-5192.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub trait EventLoop {
 }
diff --git a/src/test/run-pass/issue-5666.rs b/src/test/run-pass/issue-5666.rs
index 222e1d54a5d99..e53f4c8692304 100644
--- a/src/test/run-pass/issue-5666.rs
+++ b/src/test/run-pass/issue-5666.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Dog {
     name : String
diff --git a/src/test/run-pass/issue-5688.rs b/src/test/run-pass/issue-5688.rs
index 7c8940aafbfbe..cfe9c8f994c47 100644
--- a/src/test/run-pass/issue-5688.rs
+++ b/src/test/run-pass/issue-5688.rs
@@ -25,6 +25,6 @@ static V: &'static [X] = &[X { vec: &[1, 2, 3] }];
 
 pub fn main() {
     for &v in V.iter() {
-        println!("{}", v.vec);
+        println!("{:?}", v.vec);
     }
 }
diff --git a/src/test/run-pass/issue-5718.rs b/src/test/run-pass/issue-5718.rs
index 589ccefd9ea28..36aa8a9cbca5d 100644
--- a/src/test/run-pass/issue-5718.rs
+++ b/src/test/run-pass/issue-5718.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Element;
 
 macro_rules! foo {
diff --git a/src/test/run-pass/issue-5884.rs b/src/test/run-pass/issue-5884.rs
index 4010c31eed50a..6502c66d85821 100644
--- a/src/test/run-pass/issue-5884.rs
+++ b/src/test/run-pass/issue-5884.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub struct Foo {
     a: int,
diff --git a/src/test/run-pass/issue-6117.rs b/src/test/run-pass/issue-6117.rs
index e979bc86171ce..85de03dfe3426 100644
--- a/src/test/run-pass/issue-6117.rs
+++ b/src/test/run-pass/issue-6117.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum Either<T, U> { Left(T), Right(U) }
 
diff --git a/src/test/run-pass/issue-6128.rs b/src/test/run-pass/issue-6128.rs
index 4b31f39330932..d96862b588f9d 100644
--- a/src/test/run-pass/issue-6128.rs
+++ b/src/test/run-pass/issue-6128.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 extern crate collections;
 
 use std::collections::HashMap;
diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs
index 2b474b8cfbbe2..b9f1a8bda7b5e 100644
--- a/src/test/run-pass/issue-6318.rs
+++ b/src/test/run-pass/issue-6318.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub enum Thing {
     A(Box<Foo+'static>)
diff --git a/src/test/run-pass/issue-6557.rs b/src/test/run-pass/issue-6557.rs
index 7061a17dcdd0c..3163f1393280a 100644
--- a/src/test/run-pass/issue-6557.rs
+++ b/src/test/run-pass/issue-6557.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo(box (_x, _y): Box<(int, int)>) {}
 
diff --git a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
index a08bdb09d3daa..b6dfbb1ca42ad 100644
--- a/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
+++ b/src/test/run-pass/issue-7673-cast-generically-implemented-trait.rs
@@ -14,6 +14,8 @@
 
 */
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {}
 
diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs
index e4f4db6ea63b7..2a2ca4f071274 100644
--- a/src/test/run-pass/issue-8498.rs
+++ b/src/test/run-pass/issue-8498.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     match &[(box 5i,box 7i)] {
         ps => {
diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index 0ca63d52bd849..42739628eed75 100644
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 fn assert_repr_eq<T: std::fmt::Show>(obj : T, expected : String) {
     assert_eq!(expected, format!("{:?}", obj));
 }
diff --git a/src/test/run-pass/issue-9129.rs b/src/test/run-pass/issue-9129.rs
index 5d5240272e542..2ef1c1d264a40 100644
--- a/src/test/run-pass/issue-9129.rs
+++ b/src/test/run-pass/issue-9129.rs
@@ -10,6 +10,8 @@
 
 // ignore-pretty
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub trait bomb { fn boom(&self, Ident); }
 pub struct S;
diff --git a/src/test/run-pass/issue-9382.rs b/src/test/run-pass/issue-9382.rs
index 369f93222e13e..07212237305ef 100644
--- a/src/test/run-pass/issue-9382.rs
+++ b/src/test/run-pass/issue-9382.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(unnecessary_allocation)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // Tests for a previous bug that occurred due to an interaction
 // between struct field initialization and the auto-coercion
diff --git a/src/test/run-pass/issue-9396.rs b/src/test/run-pass/issue-9396.rs
index 34bb50c5cf669..73355d15a2759 100644
--- a/src/test/run-pass/issue-9396.rs
+++ b/src/test/run-pass/issue-9396.rs
@@ -15,7 +15,7 @@ use std::time::Duration;
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _t = Thread::spawn(move||{
+    let _t = Thread::scoped(move||{
         let mut timer = Timer::new().unwrap();
         timer.sleep(Duration::milliseconds(10));
         tx.send(()).unwrap();
diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs
index fbd6c92a02065..999fb2c4b69f3 100644
--- a/src/test/run-pass/kindck-owned-trait-contains-1.rs
+++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait repeat<A> { fn get(&self) -> A; }
 
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 6615bb6368fd7..9be9f0982642a 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -10,6 +10,8 @@
 
 // Make sure #1399 stays fixed
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct A { a: Box<int> }
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index 206d4db3db4f8..4a7e844268f61 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -10,6 +10,9 @@
 
 // Make sure #1399 stays fixed
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct A { a: Box<int> }
 
 pub fn main() {
diff --git a/src/test/run-pass/leak-unique-as-tydesc.rs b/src/test/run-pass/leak-unique-as-tydesc.rs
index b109e94b74f2b..65808de3cf42b 100644
--- a/src/test/run-pass/leak-unique-as-tydesc.rs
+++ b/src/test/run-pass/leak-unique-as-tydesc.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn leaky<T>(_t: T) { }
 
diff --git a/src/test/run-pass/let-assignability.rs b/src/test/run-pass/let-assignability.rs
index 6bea1aebc4588..9ac016d534f09 100644
--- a/src/test/run-pass/let-assignability.rs
+++ b/src/test/run-pass/let-assignability.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f() {
     let a = box 1;
     let b: &int = &*a;
diff --git a/src/test/run-pass/list.rs b/src/test/run-pass/list.rs
index 9b20398038d41..e55c1b36f3e24 100644
--- a/src/test/run-pass/list.rs
+++ b/src/test/run-pass/list.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 enum list { cons(int, Box<list>), nil, }
 
diff --git a/src/test/run-pass/match-implicit-copy-unique.rs b/src/test/run-pass/match-implicit-copy-unique.rs
index 0e7c959d58c33..6883187c402f3 100644
--- a/src/test/run-pass/match-implicit-copy-unique.rs
+++ b/src/test/run-pass/match-implicit-copy-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Pair { a: Box<int>, b: Box<int> }
 
diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs
index 5c834a06a74db..ebe01a1d1f221 100644
--- a/src/test/run-pass/match-unique-bind.rs
+++ b/src/test/run-pass/match-unique-bind.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     match box 100i {
       box x => {
diff --git a/src/test/run-pass/match-value-binding-in-guard-3291.rs b/src/test/run-pass/match-value-binding-in-guard-3291.rs
index 0e7e9be6765b4..beb125492b2c1 100644
--- a/src/test/run-pass/match-value-binding-in-guard-3291.rs
+++ b/src/test/run-pass/match-value-binding-in-guard-3291.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo(x: Option<Box<int>>, b: bool) -> int {
     match x {
diff --git a/src/test/run-pass/method-projection.rs b/src/test/run-pass/method-projection.rs
new file mode 100644
index 0000000000000..6f72a163981c9
--- /dev/null
+++ b/src/test/run-pass/method-projection.rs
@@ -0,0 +1,78 @@
+// 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.
+
+// Test that we can use method notation to call methods based on a
+// projection bound from a trait. Issue #20469.
+
+///////////////////////////////////////////////////////////////////////////
+
+trait MakeString {
+    fn make_string(&self) -> String;
+}
+
+impl MakeString for int {
+    fn make_string(&self) -> String {
+        format!("{}", *self)
+    }
+}
+
+impl MakeString for uint {
+    fn make_string(&self) -> String {
+        format!("{}", *self)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+trait Foo {
+    type F: MakeString;
+
+    fn get(&self) -> &Self::F;
+}
+
+fn foo<F:Foo>(f: &F) -> String {
+    f.get().make_string()
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct SomeStruct {
+    field: int,
+}
+
+impl Foo for SomeStruct {
+    type F = int;
+
+    fn get(&self) -> &int {
+        &self.field
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct SomeOtherStruct {
+    field: uint,
+}
+
+impl Foo for SomeOtherStruct {
+    type F = uint;
+
+    fn get(&self) -> &uint {
+        &self.field
+    }
+}
+
+fn main() {
+    let x = SomeStruct { field: 22 };
+    assert_eq!(foo(&x), format!("22"));
+
+    let x = SomeOtherStruct { field: 44 };
+    assert_eq!(foo(&x), format!("44"));
+}
diff --git a/src/test/run-pass/method-self-arg-aux1.rs b/src/test/run-pass/method-self-arg-aux1.rs
index d4a0d514a7da6..e9a1e19d4bf84 100644
--- a/src/test/run-pass/method-self-arg-aux1.rs
+++ b/src/test/run-pass/method-self-arg-aux1.rs
@@ -10,6 +10,9 @@
 
 // Test method calls with self as an argument (cross-crate)
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 // aux-build:method_self_arg1.rs
 extern crate method_self_arg1;
 use method_self_arg1::Foo;
diff --git a/src/test/run-pass/method-self-arg-aux2.rs b/src/test/run-pass/method-self-arg-aux2.rs
index b94f1ae6ba64e..7fa810ce1549a 100644
--- a/src/test/run-pass/method-self-arg-aux2.rs
+++ b/src/test/run-pass/method-self-arg-aux2.rs
@@ -10,6 +10,9 @@
 
 // Test method calls with self as an argument (cross-crate)
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 // aux-build:method_self_arg2.rs
 extern crate method_self_arg2;
 use method_self_arg2::{Foo, Bar};
diff --git a/src/test/run-pass/method-self-arg-trait.rs b/src/test/run-pass/method-self-arg-trait.rs
index 29d100beb064f..39018a873942e 100644
--- a/src/test/run-pass/method-self-arg-trait.rs
+++ b/src/test/run-pass/method-self-arg-trait.rs
@@ -10,6 +10,9 @@
 
 // Test method calls with self as an argument
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static mut COUNT: u64 = 1;
 
 struct Foo;
diff --git a/src/test/run-pass/method-self-arg.rs b/src/test/run-pass/method-self-arg.rs
index 788a25efcf987..ae15bc60746b2 100644
--- a/src/test/run-pass/method-self-arg.rs
+++ b/src/test/run-pass/method-self-arg.rs
@@ -10,6 +10,9 @@
 
 // Test method calls with self as an argument
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 static mut COUNT: uint = 1;
 
 struct Foo;
diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
index cae783e7ea84a..b18c29dc3c136 100644
--- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs
+++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
@@ -16,6 +16,9 @@
 // version will run (note that the `push` occurs after the call to
 // `foo()`).
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait Foo {
     fn foo(&self) -> int;
 }
diff --git a/src/test/run-pass/move-1-unique.rs b/src/test/run-pass/move-1-unique.rs
index 2da6076d13863..018cd440cad34 100644
--- a/src/test/run-pass/move-1-unique.rs
+++ b/src/test/run-pass/move-1-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 #[derive(Clone)]
 struct Triple {
diff --git a/src/test/run-pass/move-2-unique.rs b/src/test/run-pass/move-2-unique.rs
index 65d8281407c4f..50187ef8baad2 100644
--- a/src/test/run-pass/move-2-unique.rs
+++ b/src/test/run-pass/move-2-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct X { x: int, y: int, z: int }
 
diff --git a/src/test/run-pass/move-2.rs b/src/test/run-pass/move-2.rs
index 04540c2f35b29..6561a9b2d5b56 100644
--- a/src/test/run-pass/move-2.rs
+++ b/src/test/run-pass/move-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct X { x: int, y: int, z: int }
 
diff --git a/src/test/run-pass/move-3-unique.rs b/src/test/run-pass/move-3-unique.rs
index 2820e0d712056..a10e3f9f5b0d0 100644
--- a/src/test/run-pass/move-3-unique.rs
+++ b/src/test/run-pass/move-3-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 #[derive(Clone)]
 struct Triple {
diff --git a/src/test/run-pass/move-4-unique.rs b/src/test/run-pass/move-4-unique.rs
index 286781a482277..9e5eeef75527c 100644
--- a/src/test/run-pass/move-4-unique.rs
+++ b/src/test/run-pass/move-4-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Triple {a: int, b: int, c: int}
 
diff --git a/src/test/run-pass/move-4.rs b/src/test/run-pass/move-4.rs
index 5e5d01ae6ee45..c902677c64531 100644
--- a/src/test/run-pass/move-4.rs
+++ b/src/test/run-pass/move-4.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Triple { a: int, b: int, c: int }
 
diff --git a/src/test/run-pass/move-arg-2-unique.rs b/src/test/run-pass/move-arg-2-unique.rs
index 29fd070fc19d2..e496e9e210533 100644
--- a/src/test/run-pass/move-arg-2-unique.rs
+++ b/src/test/run-pass/move-arg-2-unique.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn test(foo: Box<Vec<int>> ) { assert!(((*foo)[0] == 10)); }
 
diff --git a/src/test/run-pass/move-arg-2.rs b/src/test/run-pass/move-arg-2.rs
index 0f3d0baecbe51..fdb6799b90f79 100644
--- a/src/test/run-pass/move-arg-2.rs
+++ b/src/test/run-pass/move-arg-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn test(foo: Box<Vec<int>>) { assert!(((*foo)[0] == 10)); }
 
diff --git a/src/test/run-pass/mut-function-arguments.rs b/src/test/run-pass/mut-function-arguments.rs
index f80728519136e..388b814b2af10 100644
--- a/src/test/run-pass/mut-function-arguments.rs
+++ b/src/test/run-pass/mut-function-arguments.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn f(mut y: Box<int>) {
     *y = 5;
diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs
index 991d0ecdc87a6..4ea51b3b409aa 100644
--- a/src/test/run-pass/new-box-syntax.rs
+++ b/src/test/run-pass/new-box-syntax.rs
@@ -11,6 +11,9 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 // Tests that the new `box` syntax works with unique pointers.
 
 use std::boxed::{Box, HEAP};
diff --git a/src/test/run-pass/new-box.rs b/src/test/run-pass/new-box.rs
index 8531fd5f975ac..1f2207ad87378 100644
--- a/src/test/run-pass/new-box.rs
+++ b/src/test/run-pass/new-box.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn f(x: Box<int>) {
     let y: &int = &*x;
diff --git a/src/test/run-pass/newlambdas-ret-infer.rs b/src/test/run-pass/newlambdas-ret-infer.rs
index d74f1349506c1..130cdc85b013d 100644
--- a/src/test/run-pass/newlambdas-ret-infer.rs
+++ b/src/test/run-pass/newlambdas-ret-infer.rs
@@ -11,6 +11,9 @@
 // Test that the lambda kind is inferred correctly as a return
 // expression
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn unique() -> Box<FnMut()+'static> { return box || (); }
 
 pub fn main() {
diff --git a/src/test/run-pass/newlambdas-ret-infer2.rs b/src/test/run-pass/newlambdas-ret-infer2.rs
index 43a6ac296e9dc..0952bedd6e309 100644
--- a/src/test/run-pass/newlambdas-ret-infer2.rs
+++ b/src/test/run-pass/newlambdas-ret-infer2.rs
@@ -11,6 +11,9 @@
 // Test that the lambda kind is inferred correctly as a return
 // expression
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn unique() -> Box<FnMut()+'static> { box || () }
 
 pub fn main() {
diff --git a/src/test/run-pass/nullable-pointer-iotareduction.rs b/src/test/run-pass/nullable-pointer-iotareduction.rs
index 0293c4e36ac59..bb62b1599a4fe 100644
--- a/src/test/run-pass/nullable-pointer-iotareduction.rs
+++ b/src/test/run-pass/nullable-pointer-iotareduction.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::{option, mem};
 
 // Iota-reduction is a rule in the Calculus of (Co-)Inductive Constructions,
diff --git a/src/test/run-pass/object-one-type-two-traits.rs b/src/test/run-pass/object-one-type-two-traits.rs
index 4964b3f672844..ebdf3c08a2263 100644
--- a/src/test/run-pass/object-one-type-two-traits.rs
+++ b/src/test/run-pass/object-one-type-two-traits.rs
@@ -11,6 +11,9 @@
 // Testing creating two vtables with the same self type, but different
 // traits.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::any::Any;
 
 trait Wrap {
diff --git a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
index ab3d39e273371..cd97c34f8c6a6 100644
--- a/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
+++ b/src/test/run-pass/objects-owned-object-borrowed-method-headerless.rs
@@ -12,6 +12,9 @@
 // closed over do not contain managed values, and thus the boxes do
 // not have headers.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 
 trait FooTrait {
     fn foo(&self) -> uint;
diff --git a/src/test/run-pass/objects-owned-object-owned-method.rs b/src/test/run-pass/objects-owned-object-owned-method.rs
index 14ddc5d660f0c..d355999c50606 100644
--- a/src/test/run-pass/objects-owned-object-owned-method.rs
+++ b/src/test/run-pass/objects-owned-object-owned-method.rs
@@ -12,6 +12,8 @@
 // closed over contain managed values. This implies that the boxes
 // will have headers that must be skipped over.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait FooTrait {
     fn foo(self: Box<Self>) -> uint;
diff --git a/src/test/run-pass/output-slot-variants.rs b/src/test/run-pass/output-slot-variants.rs
index 8a10cc8c1ef4b..fb87cd5eb69cd 100644
--- a/src/test/run-pass/output-slot-variants.rs
+++ b/src/test/run-pass/output-slot-variants.rs
@@ -10,6 +10,8 @@
 
 #![allow(dead_assignment)]
 #![allow(unused_variable)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct A { a: int, b: int }
 struct Abox { a: Box<int>, b: Box<int> }
diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs
index 949a7b158d41c..5831d500b8393 100644
--- a/src/test/run-pass/overloaded-autoderef.rs
+++ b/src/test/run-pass/overloaded-autoderef.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::num::ToPrimitive;
diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs
index 1251394a549d6..a2cc7b7dfea57 100644
--- a/src/test/run-pass/overloaded-deref.rs
+++ b/src/test/run-pass/overloaded-deref.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::string::String;
diff --git a/src/test/run-pass/overloaded-index-autoderef.rs b/src/test/run-pass/overloaded-index-autoderef.rs
index bc67c0afc7b52..637d2c9469445 100644
--- a/src/test/run-pass/overloaded-index-autoderef.rs
+++ b/src/test/run-pass/overloaded-index-autoderef.rs
@@ -10,6 +10,9 @@
 
 // Test overloaded indexing combined with autoderef.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::ops::{Index, IndexMut};
 
 struct Foo {
diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs
index 498b81d307e29..e784318fc762f 100644
--- a/src/test/run-pass/owned-implies-static.rs
+++ b/src/test/run-pass/owned-implies-static.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f<T: 'static>(_x: T) {}
 
 pub fn main() {
diff --git a/src/test/run-pass/pure-sum.rs b/src/test/run-pass/pure-sum.rs
index 3b2897cf3a6f5..7fbdd2f219e14 100644
--- a/src/test/run-pass/pure-sum.rs
+++ b/src/test/run-pass/pure-sum.rs
@@ -10,6 +10,8 @@
 
 // Check that functions can modify local state.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn sums_to(v: Vec<int> , sum: int) -> bool {
     let mut i = 0u;
diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs
index 43b6d4b3109c8..90e8716899082 100644
--- a/src/test/run-pass/range.rs
+++ b/src/test/run-pass/range.rs
@@ -10,8 +10,6 @@
 
 // Test range syntax.
 
-#![feature(slicing_syntax)]
-
 fn foo() -> int { 42 }
 
 pub fn main() {
diff --git a/src/test/run-pass/ranges-precedence.rs b/src/test/run-pass/ranges-precedence.rs
new file mode 100644
index 0000000000000..f678eed8775cd
--- /dev/null
+++ b/src/test/run-pass/ranges-precedence.rs
@@ -0,0 +1,52 @@
+// 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.
+
+// Test that the precedence of ranges is correct
+
+#![feature(slicing_syntax)]
+
+struct Foo {
+    foo: uint,
+}
+
+impl Foo {
+    fn bar(&self) -> uint { 5 }
+}
+
+fn main() {
+    let x = 1+3..4+5;
+    assert!(x == (4..9));
+
+    let x = 1..4+5;
+    assert!(x == (1..9));
+
+    let x = 1+3..4;
+    assert!(x == (4..4));
+
+    let a = Foo { foo: 3 };
+    let x = a.foo..a.bar();
+    assert!(x == (3..5));
+
+    let x = 1+3..;
+    assert!(x == (4..));
+    let x = ..1+3;
+    assert!(x == (..4));
+
+    let a = &[0i32, 1, 2, 3, 4, 5, 6];
+    let x = &a[1+1..2+2];
+    assert!(x == &a[2..4]);
+    let x = &a[..1+2];
+    assert!(x == &a[..3]);
+    let x = &a[1+2..];
+    assert!(x == &a[3..]);
+
+    for _i in 2+4..10-3 {}
+}
+
diff --git a/src/test/run-pass/rcvr-borrowed-to-region.rs b/src/test/run-pass/rcvr-borrowed-to-region.rs
index 8ad2dbc1acb75..84a230fd5767c 100644
--- a/src/test/run-pass/rcvr-borrowed-to-region.rs
+++ b/src/test/run-pass/rcvr-borrowed-to-region.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait get {
     fn get(self) -> int;
diff --git a/src/test/run-pass/regions-borrow-at.rs b/src/test/run-pass/regions-borrow-at.rs
index 9a758c5d8ada4..ba86e3f7b57b3 100644
--- a/src/test/run-pass/regions-borrow-at.rs
+++ b/src/test/run-pass/regions-borrow-at.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo(x: &uint) -> uint {
     *x
diff --git a/src/test/run-pass/regions-borrow-uniq.rs b/src/test/run-pass/regions-borrow-uniq.rs
index 36f7d88f7d797..30a22512d2a7f 100644
--- a/src/test/run-pass/regions-borrow-uniq.rs
+++ b/src/test/run-pass/regions-borrow-uniq.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn foo(x: &uint) -> uint {
     *x
 }
diff --git a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
index 5dba80ad38a16..3922cb1219c03 100644
--- a/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
+++ b/src/test/run-pass/regions-close-over-type-parameter-successfully.rs
@@ -11,6 +11,9 @@
 // A test where we (successfully) close over a reference into
 // an object.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait SomeTrait { fn get(&self) -> int; }
 
 impl<'a> SomeTrait for &'a int {
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index a7724e68310a7..0152793d96c6c 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct closure_box<'a> {
diff --git a/src/test/run-pass/regions-dependent-addr-of.rs b/src/test/run-pass/regions-dependent-addr-of.rs
index 41396ef01bee8..e38a472fa4c8f 100644
--- a/src/test/run-pass/regions-dependent-addr-of.rs
+++ b/src/test/run-pass/regions-dependent-addr-of.rs
@@ -11,6 +11,8 @@
 // Test lifetimes are linked properly when we create dependent region pointers.
 // Issue #3148.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct A {
     value: B
diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs
index 907f610ff25db..3267ff2c7e0e7 100644
--- a/src/test/run-pass/regions-early-bound-trait-param.rs
+++ b/src/test/run-pass/regions-early-bound-trait-param.rs
@@ -11,6 +11,8 @@
 // Tests that you can use an early-bound lifetime parameter as
 // on of the generic parameters in a trait.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait Trait<'a> {
     fn long(&'a self) -> int;
diff --git a/src/test/run-pass/regions-escape-into-other-fn.rs b/src/test/run-pass/regions-escape-into-other-fn.rs
index 5b0b7cc5b4ef1..9637c43170f6b 100644
--- a/src/test/run-pass/regions-escape-into-other-fn.rs
+++ b/src/test/run-pass/regions-escape-into-other-fn.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn foo(x: &uint) -> &uint { x }
 fn bar(x: &uint) -> uint { *x }
diff --git a/src/test/run-pass/regions-fn-subtyping.rs b/src/test/run-pass/regions-fn-subtyping.rs
index e9f774150dcfd..faa9b37bdcc63 100644
--- a/src/test/run-pass/regions-fn-subtyping.rs
+++ b/src/test/run-pass/regions-fn-subtyping.rs
@@ -12,6 +12,8 @@
 
 #![allow(dead_assignment)]
 #![allow(unused_variable)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // Should pass region checking.
 fn ok(f: Box<FnMut(&uint)>) {
diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
index 1ecaf41702e06..f397b5124caf5 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn borrow<T>(x: &T) -> &T {x}
 
 pub fn main() {
diff --git a/src/test/run-pass/regions-infer-borrow-scope.rs b/src/test/run-pass/regions-infer-borrow-scope.rs
index d3dbca53f605f..708d031a68a63 100644
--- a/src/test/run-pass/regions-infer-borrow-scope.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Point {x: int, y: int}
 
diff --git a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
index c796566b79d57..c4852c9162cab 100644
--- a/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
+++ b/src/test/run-pass/regions-lifetime-nonfree-late-bound.rs
@@ -22,6 +22,9 @@
 // doing region-folding, when really all clients of the region-folding
 // case only want to see FREE lifetime variables, not bound ones.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     fn explicit() {
         fn test<F>(_x: Option<Box<F>>) where F: FnMut(Box<for<'a> FnMut(&'a int)>) {}
diff --git a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
index 6eb981046163e..e779e002b2990 100644
--- a/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
+++ b/src/test/run-pass/regions-relate-bound-regions-on-closures-to-inference-variables.rs
@@ -17,6 +17,9 @@
 // changes were caught. However, those uses in the compiler could
 // easily get changed or refactored away in the future.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Ctxt<'tcx> {
     x: &'tcx Vec<int>
 }
diff --git a/src/test/run-pass/regions-static-closure.rs b/src/test/run-pass/regions-static-closure.rs
index 0f36dc0457544..abd5789bb1f76 100644
--- a/src/test/run-pass/regions-static-closure.rs
+++ b/src/test/run-pass/regions-static-closure.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 struct closure_box<'a> {
diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index e854a7326329c..d1d37ea5bb099 100644
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -8,16 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(slicing_syntax)]
-
 pub fn main() {
     let x = [ [true]; 512 ];
     let y = [ 0i; 1 ];
 
     print!("[");
     for xi in x.iter() {
-        print!("{}, ", &xi[]);
+        print!("{:?}, ", &xi[]);
     }
     println!("]");
-    println!("{}", &y[]);
+    println!("{:?}", &y[]);
 }
diff --git a/src/test/run-pass/rust-log-filter.rs b/src/test/run-pass/rust-log-filter.rs
index 95f90ebbf8edf..28d47f7aa9be5 100644
--- a/src/test/run-pass/rust-log-filter.rs
+++ b/src/test/run-pass/rust-log-filter.rs
@@ -10,6 +10,9 @@
 
 // exec-env:RUST_LOG=rust-log-filter/f.o
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 #[macro_use]
 extern crate log;
 
diff --git a/src/test/run-pass/self-impl.rs b/src/test/run-pass/self-impl.rs
index 74416b96e9360..40a4dc52a70b3 100644
--- a/src/test/run-pass/self-impl.rs
+++ b/src/test/run-pass/self-impl.rs
@@ -10,6 +10,9 @@
 
 // Test that we can use `Self` types in impls in the expected way.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Foo;
 
 // Test uses on inherent impl.
diff --git a/src/test/run-pass/self-in-mut-slot-default-method.rs b/src/test/run-pass/self-in-mut-slot-default-method.rs
index bced8012b6832..e934498ea0506 100644
--- a/src/test/run-pass/self-in-mut-slot-default-method.rs
+++ b/src/test/run-pass/self-in-mut-slot-default-method.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct X {
     a: int
diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs
index 75fb98f8e24f9..3092898d98652 100644
--- a/src/test/run-pass/self-re-assign.rs
+++ b/src/test/run-pass/self-re-assign.rs
@@ -11,6 +11,9 @@
 // Ensure assigning an owned or managed variable to itself works. In particular,
 // that we do not glue_drop before we glue_take (#3290).
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::rc::Rc;
 
 pub fn main() {
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 a6e4716c3b8a3..89624c3ac16a3 100644
--- a/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
+++ b/src/test/run-pass/sendfn-spawn-with-fn-arg.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 pub fn main() { test05(); }
diff --git a/src/test/run-pass/show-boxed-slice.rs b/src/test/run-pass/show-boxed-slice.rs
index e0d005a485bc0..fc0b501e9c523 100644
--- a/src/test/run-pass/show-boxed-slice.rs
+++ b/src/test/run-pass/show-boxed-slice.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 #[derive(Show)]
 struct Foo(Box<[u8]>);
 
diff --git a/src/test/run-pass/simd-size-align.rs b/src/test/run-pass/simd-size-align.rs
new file mode 100644
index 0000000000000..582810f0def33
--- /dev/null
+++ b/src/test/run-pass/simd-size-align.rs
@@ -0,0 +1,70 @@
+// 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.
+
+#![feature(simd)]
+#![allow(non_camel_case_types)]
+
+use std::mem;
+
+/// `T` should satisfy `size_of T (mod min_align_of T) === 0` to be stored at `Vec<T>` properly
+/// Please consult the issue #20460
+fn check<T>() {
+    assert_eq!(mem::size_of::<T>() % mem::min_align_of::<T>(), 0)
+}
+
+fn main() {
+    check::<u8x2>();
+    check::<u8x3>();
+    check::<u8x4>();
+    check::<u8x5>();
+    check::<u8x6>();
+    check::<u8x7>();
+    check::<u8x8>();
+
+    check::<i16x2>();
+    check::<i16x3>();
+    check::<i16x4>();
+    check::<i16x5>();
+    check::<i16x6>();
+    check::<i16x7>();
+    check::<i16x8>();
+
+    check::<f32x2>();
+    check::<f32x3>();
+    check::<f32x4>();
+    check::<f32x5>();
+    check::<f32x6>();
+    check::<f32x7>();
+    check::<f32x8>();
+}
+
+#[simd] struct u8x2(u8, u8);
+#[simd] struct u8x3(u8, u8, u8);
+#[simd] struct u8x4(u8, u8, u8, u8);
+#[simd] struct u8x5(u8, u8, u8, u8, u8);
+#[simd] struct u8x6(u8, u8, u8, u8, u8, u8);
+#[simd] struct u8x7(u8, u8, u8, u8, u8, u8, u8);
+#[simd] struct u8x8(u8, u8, u8, u8, u8, u8, u8, u8);
+
+#[simd] struct i16x2(i16, i16);
+#[simd] struct i16x3(i16, i16, i16);
+#[simd] struct i16x4(i16, i16, i16, i16);
+#[simd] struct i16x5(i16, i16, i16, i16, i16);
+#[simd] struct i16x6(i16, i16, i16, i16, i16, i16);
+#[simd] struct i16x7(i16, i16, i16, i16, i16, i16, i16);
+#[simd] struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
+
+#[simd] struct f32x2(f32, f32);
+#[simd] struct f32x3(f32, f32, f32);
+#[simd] struct f32x4(f32, f32, f32, f32);
+#[simd] struct f32x5(f32, f32, f32, f32, f32);
+#[simd] struct f32x6(f32, f32, f32, f32, f32, f32);
+#[simd] struct f32x7(f32, f32, f32, f32, f32, f32, f32);
+#[simd] struct f32x8(f32, f32, f32, f32, f32, f32, f32, f32);
diff --git a/src/test/run-pass/slice-2.rs b/src/test/run-pass/slice-2.rs
index 05f318b53c2e5..8f031d2e97e3f 100644
--- a/src/test/run-pass/slice-2.rs
+++ b/src/test/run-pass/slice-2.rs
@@ -10,8 +10,6 @@
 
 // Test slicing expressions on slices and Vecs.
 
-#![feature(slicing_syntax)]
-
 fn main() {
     let x: &[int] = &[1, 2, 3, 4, 5];
     let cmp: &[int] = &[1, 2, 3, 4, 5];
diff --git a/src/test/run-pass/slice-panic-1.rs b/src/test/run-pass/slice-panic-1.rs
index 8b9a3f10a60bc..b2e3d83ca9b36 100644
--- a/src/test/run-pass/slice-panic-1.rs
+++ b/src/test/run-pass/slice-panic-1.rs
@@ -10,8 +10,6 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-#![feature(slicing_syntax)]
-
 use std::thread::Thread;
 
 struct Foo;
diff --git a/src/test/run-pass/slice-panic-2.rs b/src/test/run-pass/slice-panic-2.rs
index 94a0530bffb94..dea45e63ab000 100644
--- a/src/test/run-pass/slice-panic-2.rs
+++ b/src/test/run-pass/slice-panic-2.rs
@@ -10,8 +10,6 @@
 
 // Test that if a slicing expr[..] fails, the correct cleanups happen.
 
-#![feature(slicing_syntax)]
-
 use std::thread::Thread;
 
 struct Foo;
diff --git a/src/test/run-pass/slice.rs b/src/test/run-pass/slice.rs
index fca7daeb07d6f..9cb7cfd7fe98b 100644
--- a/src/test/run-pass/slice.rs
+++ b/src/test/run-pass/slice.rs
@@ -10,11 +10,10 @@
 
 // Test slicing sugar.
 
-#![feature(slicing_syntax)]
 #![feature(associated_types)]
 
 extern crate core;
-use core::ops::{Index, Range, RangeTo, RangeFrom, FullRange};
+use core::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, FullRange};
 
 static mut COUNT: uint = 0;
 
diff --git a/src/test/run-pass/syntax-extension-bytes.rs b/src/test/run-pass/syntax-extension-bytes.rs
deleted file mode 100644
index 1f92677fb6f89..0000000000000
--- a/src/test/run-pass/syntax-extension-bytes.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2013 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.
-
-static static_vec: &'static [u8] = bytes!("abc", 0xFF, '!');
-
-pub fn main() {
-    let vec: &'static [u8] = bytes!("abc");
-    let expected: &[u8] = &[97_u8, 98_u8, 99_u8];
-    assert_eq!(vec, expected);
-
-    let vec: &'static [u8] = bytes!("null", 0);
-    let expected: &[u8] = &[110_u8, 117_u8, 108_u8, 108_u8, 0_u8];
-    assert_eq!(vec, expected);
-
-    let vec: &'static [u8] = bytes!(' ', " ", 32, 32u8);
-    let expected: &[u8] = &[32_u8, 32_u8, 32_u8, 32_u8];
-    assert_eq!(vec, expected);
-
-    let expected: &[u8] = &[97_u8, 98_u8, 99_u8, 255_u8, 33_u8];
-    assert_eq!(static_vec, expected);
-}
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index b2bcf395783ae..ca2a8cf5506ee 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 use std::sync::mpsc::channel;
 
diff --git a/src/test/run-pass/task-stderr.rs b/src/test/run-pass/task-stderr.rs
index 7ff5960375cb2..5e6247bac93f9 100644
--- a/src/test/run-pass/task-stderr.rs
+++ b/src/test/run-pass/task-stderr.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::sync::mpsc::channel;
 use std::io::{ChanReader, ChanWriter};
 use std::thread;
diff --git a/src/test/run-pass/tcp-accept-stress.rs b/src/test/run-pass/tcp-accept-stress.rs
index cd3cb872fd3bc..cad7173203483 100644
--- a/src/test/run-pass/tcp-accept-stress.rs
+++ b/src/test/run-pass/tcp-accept-stress.rs
@@ -34,11 +34,11 @@ fn test() {
 
     let (srv_tx, srv_rx) = channel();
     let (cli_tx, cli_rx) = channel();
-    for _ in range(0, N) {
+    let _t = range(0, N).map(|_| {
         let a = a.clone();
         let cnt = cnt.clone();
         let srv_tx = srv_tx.clone();
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             let mut a = a;
             loop {
                 match a.accept() {
@@ -52,18 +52,18 @@ fn test() {
                 }
             }
             srv_tx.send(());
-        });
-    }
+        })
+    }).collect::<Vec<_>>();
 
-    for _ in range(0, N) {
+    let _t = range(0, N).map(|_| {
         let cli_tx = cli_tx.clone();
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             for _ in range(0, M) {
                 let _s = TcpStream::connect(addr).unwrap();
             }
             cli_tx.send(());
-        });
-    }
+        })
+    }).collect::<Vec<_>>();
     drop((cli_tx, srv_tx));
 
     // wait for senders
diff --git a/src/test/run-pass/threads.rs b/src/test/run-pass/threads.rs
index c47ca0db2a156..abc2938df00bb 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)});
+        Thread::scoped({let i = i; move|| child(i)});
         i = i - 1;
     }
     println!("main thread exiting");
diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs
index bc397bb63196e..0089646d0a14a 100644
--- a/src/test/run-pass/trait-bounds-in-arc.rs
+++ b/src/test/run-pass/trait-bounds-in-arc.rs
@@ -13,6 +13,8 @@
 
 // ignore-pretty
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::sync::Arc;
diff --git a/src/test/run-pass/trait-coercion-generic.rs b/src/test/run-pass/trait-coercion-generic.rs
index 7d924f977cbef..22db6c64770ec 100644
--- a/src/test/run-pass/trait-coercion-generic.rs
+++ b/src/test/run-pass/trait-coercion-generic.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 trait Trait<T> {
     fn f(&self, x: T);
diff --git a/src/test/run-pass/trait-coercion.rs b/src/test/run-pass/trait-coercion.rs
index 37d69ddfe0766..0d4a05bed7f56 100644
--- a/src/test/run-pass/trait-coercion.rs
+++ b/src/test/run-pass/trait-coercion.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::io;
 
 trait Trait {
diff --git a/src/test/run-pass/trait-contravariant-self.rs b/src/test/run-pass/trait-contravariant-self.rs
index e06e01b9e0512..19d76b8890118 100644
--- a/src/test/run-pass/trait-contravariant-self.rs
+++ b/src/test/run-pass/trait-contravariant-self.rs
@@ -22,6 +22,9 @@
 // 4. `Bar for Box<Foo> <: Bar for Box<Foo:Send>` because
 //    `Box<Foo:Send> <: Box<Foo>`.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait Foo { }
 struct SFoo;
 impl Foo for SFoo { }
diff --git a/src/test/run-pass/trait-object-generics.rs b/src/test/run-pass/trait-object-generics.rs
index 81aa5daaf91ce..76352c799a0f2 100644
--- a/src/test/run-pass/trait-object-generics.rs
+++ b/src/test/run-pass/trait-object-generics.rs
@@ -10,6 +10,8 @@
 
 // test for #8664
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub trait Trait2<A> {
     fn doit(&self);
diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs
index a94f73c2b6da7..7e2b7ae0663b9 100644
--- a/src/test/run-pass/traits-conditional-dispatch.rs
+++ b/src/test/run-pass/traits-conditional-dispatch.rs
@@ -12,6 +12,9 @@
 // blanket impl for T:Copy coexists with an impl for Box<T>, because
 // Box does not impl Copy.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 trait Get {
     fn get(&self) -> Self;
 }
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index 7265ddf661501..3fcb04d6848e8 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn p_foo<T>(_pinned: T) { }
 fn s_foo<T>(_shared: T) { }
diff --git a/src/test/run-pass/typeclasses-eq-example-static.rs b/src/test/run-pass/typeclasses-eq-example-static.rs
index 63a59b6f750ea..20a28c5a9ead9 100644
--- a/src/test/run-pass/typeclasses-eq-example-static.rs
+++ b/src/test/run-pass/typeclasses-eq-example-static.rs
@@ -9,6 +9,9 @@
 // except according to those terms.
 
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 // Example from lkuper's intern talk, August 2012 -- now with static
 // methods!
 use Color::{cyan, magenta, yellow, black};
diff --git a/src/test/run-pass/typeclasses-eq-example.rs b/src/test/run-pass/typeclasses-eq-example.rs
index 431a9383b3bd3..aa290edd8631a 100644
--- a/src/test/run-pass/typeclasses-eq-example.rs
+++ b/src/test/run-pass/typeclasses-eq-example.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 // Example from lkuper's intern talk, August 2012.
 use Color::{cyan, magenta, yellow, black};
diff --git a/src/test/run-pass/typeid-intrinsic.rs b/src/test/run-pass/typeid-intrinsic.rs
index bba043ea8f8ac..e346c4ff3495e 100644
--- a/src/test/run-pass/typeid-intrinsic.rs
+++ b/src/test/run-pass/typeid-intrinsic.rs
@@ -14,7 +14,7 @@
 extern crate "typeid-intrinsic" as other1;
 extern crate "typeid-intrinsic2" as other2;
 
-use std::hash;
+use std::hash::{self, SipHasher};
 use std::intrinsics;
 use std::intrinsics::TypeId;
 
@@ -70,5 +70,6 @@ pub fn main() {
     // check it has a hash
     let (a, b) = (TypeId::of::<uint>(), TypeId::of::<uint>());
 
-    assert_eq!(hash::hash(&a), hash::hash(&b));
+    assert_eq!(hash::hash::<TypeId, SipHasher>(&a),
+               hash::hash::<TypeId, SipHasher>(&b));
 }
diff --git a/src/test/run-pass/ufcs-explicit-self.rs b/src/test/run-pass/ufcs-explicit-self.rs
index b6b9fb67f9053..968f3511247c6 100644
--- a/src/test/run-pass/ufcs-explicit-self.rs
+++ b/src/test/run-pass/ufcs-explicit-self.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Foo {
     f: int,
 }
diff --git a/src/test/run-pass/unboxed-closures-boxed.rs b/src/test/run-pass/unboxed-closures-boxed.rs
index 60e59400e1a09..dc35d5bf2caca 100644
--- a/src/test/run-pass/unboxed-closures-boxed.rs
+++ b/src/test/run-pass/unboxed-closures-boxed.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::ops::FnMut;
diff --git a/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs b/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs
index 8909f4e261faa..da647e90c00f6 100644
--- a/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs
+++ b/src/test/run-pass/unboxed-closures-call-sugar-object-autoderef.rs
@@ -10,6 +10,8 @@
 
 // Test that the call operator autoderefs when calling to an object type.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::ops::FnMut;
diff --git a/src/test/run-pass/unboxed-closures-call-sugar-object.rs b/src/test/run-pass/unboxed-closures-call-sugar-object.rs
index 2dec53cc13afb..8ee3c96f580d1 100644
--- a/src/test/run-pass/unboxed-closures-call-sugar-object.rs
+++ b/src/test/run-pass/unboxed-closures-call-sugar-object.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 use std::ops::FnMut;
diff --git a/src/test/run-pass/unboxed-closures-monomorphization.rs b/src/test/run-pass/unboxed-closures-monomorphization.rs
index 52855f826731c..6701f879e4f2b 100644
--- a/src/test/run-pass/unboxed-closures-monomorphization.rs
+++ b/src/test/run-pass/unboxed-closures-monomorphization.rs
@@ -11,6 +11,8 @@
 // Test that unboxed closures in contexts with free type parameters
 // monomorphize correctly (issue #16791)
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 fn main(){
diff --git a/src/test/run-pass/unboxed-closures-prelude.rs b/src/test/run-pass/unboxed-closures-prelude.rs
index d1bd7e908c826..915715727e8e6 100644
--- a/src/test/run-pass/unboxed-closures-prelude.rs
+++ b/src/test/run-pass/unboxed-closures-prelude.rs
@@ -10,6 +10,8 @@
 
 // Tests that the reexports of `FnOnce` et al from the prelude work.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 #![feature(unboxed_closures)]
 
 fn main() {
diff --git a/src/test/run-pass/uniq-self-in-mut-slot.rs b/src/test/run-pass/uniq-self-in-mut-slot.rs
index 4d7830e1cdca1..b7980ed9021e2 100644
--- a/src/test/run-pass/uniq-self-in-mut-slot.rs
+++ b/src/test/run-pass/uniq-self-in-mut-slot.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct X {
     a: int
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index fb5f6e4a8aa19..9e3d9544d427e 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let mut i = box 1i;
     // Should be a copy
diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs
index 505e9b46e03c7..81c4b6ab7e514 100644
--- a/src/test/run-pass/unique-assign-drop.rs
+++ b/src/test/run-pass/unique-assign-drop.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(dead_assignment)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let i = box 1i;
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index 493ec8ddc207d..7c9bbd6417177 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 
 fn f<T>(t: T) -> T {
     let t1 = t;
diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs
index 64d65a7b2e524..199657fd995d6 100644
--- a/src/test/run-pass/unique-assign.rs
+++ b/src/test/run-pass/unique-assign.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let mut i;
     i = box 1i;
diff --git a/src/test/run-pass/unique-autoderef-field.rs b/src/test/run-pass/unique-autoderef-field.rs
index 67f96decaa9da..aab7f4108fba6 100644
--- a/src/test/run-pass/unique-autoderef-field.rs
+++ b/src/test/run-pass/unique-autoderef-field.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct J { j: int }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index f9bd5114e7da9..1c7b4c534ed81 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let i = box vec!(100i);
diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs
index 38be635d83726..dba4d8db8496f 100644
--- a/src/test/run-pass/unique-cmp.rs
+++ b/src/test/run-pass/unique-cmp.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 100i;
     assert!(i == box 100i);
diff --git a/src/test/run-pass/unique-containing-tag.rs b/src/test/run-pass/unique-containing-tag.rs
index ccb21b605c191..e4099c94c2f1a 100644
--- a/src/test/run-pass/unique-containing-tag.rs
+++ b/src/test/run-pass/unique-containing-tag.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     enum t { t1(int), t2(int), }
 
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index acd405e2659af..cec74d251b304 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     box 100i;
 }
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index ddc2bb6c30f17..d0ad03b773c3b 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let mut i = box 1i;
     // Should be a copy
diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs
index 1d98cfb6b4bfb..d7c19eb63588c 100644
--- a/src/test/run-pass/unique-decl-init.rs
+++ b/src/test/run-pass/unique-decl-init.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 1i;
     let j = i;
diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs
index e2e7b2ec771aa..0acdc8f3b8029 100644
--- a/src/test/run-pass/unique-decl-move.rs
+++ b/src/test/run-pass/unique-decl-move.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 100i;
     let j = i;
diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs
index 37ca58913ab39..752ea830aa5dd 100644
--- a/src/test/run-pass/unique-deref.rs
+++ b/src/test/run-pass/unique-deref.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 100i;
     assert_eq!(*i, 100);
diff --git a/src/test/run-pass/unique-destructure.rs b/src/test/run-pass/unique-destructure.rs
index 0b3041f2249e1..3213146cbf4a7 100644
--- a/src/test/run-pass/unique-destructure.rs
+++ b/src/test/run-pass/unique-destructure.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct Foo { a: int, b: int }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index a4b6ff5accff2..ec2c9f8c6661d 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let _x = box vec!(0i,0,0,0,0);
 }
diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs
index 68290d85d0e62..0e47d39e55f50 100644
--- a/src/test/run-pass/unique-fn-arg-move.rs
+++ b/src/test/run-pass/unique-fn-arg-move.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn f(i: Box<int>) {
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-fn-arg-mut.rs b/src/test/run-pass/unique-fn-arg-mut.rs
index ccf6a4fd7aeae..e1d148cc9a555 100644
--- a/src/test/run-pass/unique-fn-arg-mut.rs
+++ b/src/test/run-pass/unique-fn-arg-mut.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn f(i: &mut Box<int>) {
     *i = box 200;
diff --git a/src/test/run-pass/unique-fn-arg.rs b/src/test/run-pass/unique-fn-arg.rs
index 6769011cffef8..301994a74a85a 100644
--- a/src/test/run-pass/unique-fn-arg.rs
+++ b/src/test/run-pass/unique-fn-arg.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn f(i: Box<int>) {
     assert_eq!(*i, 100);
diff --git a/src/test/run-pass/unique-fn-ret.rs b/src/test/run-pass/unique-fn-ret.rs
index 8493652cf8a08..de2c265089bed 100644
--- a/src/test/run-pass/unique-fn-ret.rs
+++ b/src/test/run-pass/unique-fn-ret.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 fn f() -> Box<int> {
     box 100
diff --git a/src/test/run-pass/unique-in-tag.rs b/src/test/run-pass/unique-in-tag.rs
index ffff9b98f54e8..4f02018346bdb 100644
--- a/src/test/run-pass/unique-in-tag.rs
+++ b/src/test/run-pass/unique-in-tag.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn test1() {
     enum bar { u(Box<int>), w(int), }
 
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 577a8f1430b2f..4620815e74e9e 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let mut a = vec!(box 10i);
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 0f8527664b92e..389ca2c18b1bf 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let vect = vec!(box 100i);
     assert!(vect[0] == box 100);
diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs
index 6e58ec23a3b03..b36d08364a2f8 100644
--- a/src/test/run-pass/unique-init.rs
+++ b/src/test/run-pass/unique-init.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let _i = box 100i;
 }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index d3f4a8b109016..56f7a3f7990e5 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::cmp::PartialEq;
 
 fn sendable() {
diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs
index bae87230ba052..05579796dab90 100644
--- a/src/test/run-pass/unique-log.rs
+++ b/src/test/run-pass/unique-log.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 100i;
     println!("{}", i);
diff --git a/src/test/run-pass/unique-match-discrim.rs b/src/test/run-pass/unique-match-discrim.rs
index 68b46db3a947b..a1502c2eb8c0f 100644
--- a/src/test/run-pass/unique-match-discrim.rs
+++ b/src/test/run-pass/unique-match-discrim.rs
@@ -10,6 +10,9 @@
 
 // Issue #961
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn altsimple() {
     match box true {
       _ => { }
diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs
index 1b6ef92865c99..1388c6c5d2ba5 100644
--- a/src/test/run-pass/unique-move-drop.rs
+++ b/src/test/run-pass/unique-move-drop.rs
@@ -9,6 +9,8 @@
 // except according to those terms.
 
 #![allow(unused_variable)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() {
     let i = box 100i;
diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs
index 1902fabe6399c..af82d3e14eae5 100644
--- a/src/test/run-pass/unique-move-temp.rs
+++ b/src/test/run-pass/unique-move-temp.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let mut i;
     i = box 100i;
diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs
index 398db63ce080d..791c4799bf07b 100644
--- a/src/test/run-pass/unique-move.rs
+++ b/src/test/run-pass/unique-move.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let i = box 100i;
     let mut j;
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index eebb170559017..c4f860d930b8c 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let mut i = box 0i;
     *i = 1;
diff --git a/src/test/run-pass/unique-object-move.rs b/src/test/run-pass/unique-object-move.rs
index 6d0432faf5514..cec523a06712e 100644
--- a/src/test/run-pass/unique-object-move.rs
+++ b/src/test/run-pass/unique-object-move.rs
@@ -10,6 +10,8 @@
 
 // Issue #5192
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub trait EventLoop { }
 
diff --git a/src/test/run-pass/unique-pat-2.rs b/src/test/run-pass/unique-pat-2.rs
index bf99f06f58ab5..eab775fc1db4e 100644
--- a/src/test/run-pass/unique-pat-2.rs
+++ b/src/test/run-pass/unique-pat-2.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 struct Foo {a: int, b: uint}
 
diff --git a/src/test/run-pass/unique-pat-3.rs b/src/test/run-pass/unique-pat-3.rs
index 559d8f8cb3ca1..42a4b1a9c0cbf 100644
--- a/src/test/run-pass/unique-pat-3.rs
+++ b/src/test/run-pass/unique-pat-3.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 enum bar { u(Box<int>), w(int), }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-pat.rs b/src/test/run-pass/unique-pat.rs
index a0eee7e3cb6ee..ee975b9c81a03 100644
--- a/src/test/run-pass/unique-pat.rs
+++ b/src/test/run-pass/unique-pat.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 fn simple() {
     match box true {
       box true => { }
diff --git a/src/test/run-pass/unique-rec.rs b/src/test/run-pass/unique-rec.rs
index ff7f009990da7..756911d29fc8c 100644
--- a/src/test/run-pass/unique-rec.rs
+++ b/src/test/run-pass/unique-rec.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 struct X { x: int }
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-send-2.rs b/src/test/run-pass/unique-send-2.rs
index bb3019ede4b57..90f4b2e634440 100644
--- a/src/test/run-pass/unique-send-2.rs
+++ b/src/test/run-pass/unique-send-2.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::sync::mpsc::{channel, Sender};
 use std::thread::Thread;
 
@@ -19,13 +22,13 @@ pub fn main() {
     let (tx, rx) = channel();
     let n = 100u;
     let mut expected = 0u;
-    for i in range(0u, n) {
+    let _t = range(0u, n).map(|i| {
+        expected += i;
         let tx = tx.clone();
-        Thread::spawn(move|| {
+        Thread::scoped(move|| {
             child(&tx, i)
-        });
-        expected += i;
-    }
+        })
+    }).collect::<Vec<_>>();
 
     let mut actual = 0u;
     for _ in range(0u, n) {
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index afafb204c1c9f..1372858545557 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::sync::mpsc::channel;
 
 pub fn main() {
diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs
index d467d042e4e42..cd3b59a69bab8 100644
--- a/src/test/run-pass/unique-swap.rs
+++ b/src/test/run-pass/unique-swap.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::mem::swap;
 
 pub fn main() {
diff --git a/src/test/run-pass/unsized2.rs b/src/test/run-pass/unsized2.rs
index c7e8b2a05ec5b..285100dd7197c 100644
--- a/src/test/run-pass/unsized2.rs
+++ b/src/test/run-pass/unsized2.rs
@@ -10,6 +10,9 @@
 //
 // ignore-lexer-test FIXME #15879
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 // Test sized-ness checking in substitution.
 
 // Unbounded.
diff --git a/src/test/run-pass/unsized3.rs b/src/test/run-pass/unsized3.rs
index 271f5817c9e79..983152cd056d9 100644
--- a/src/test/run-pass/unsized3.rs
+++ b/src/test/run-pass/unsized3.rs
@@ -10,6 +10,9 @@
 
 // Test structs with always-unsized fields.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::mem;
 use std::raw;
 
diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs
index bd20a174d1e49..27945f469205f 100644
--- a/src/test/run-pass/unused-move-capture.rs
+++ b/src/test/run-pass/unused-move-capture.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     let _x = box 1i;
     let lam_move = |&:| {};
diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs
index 883ec44bf2eb4..22201c7d83fef 100644
--- a/src/test/run-pass/unused-move.rs
+++ b/src/test/run-pass/unused-move.rs
@@ -13,6 +13,8 @@
 // Abstract: zero-fill to block after drop
 
 #![allow(path_statement)]
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main()
 {
diff --git a/src/test/run-pass/unwind-resource.rs b/src/test/run-pass/unwind-resource.rs
index 3f59b2c6c7641..159bac101830a 100644
--- a/src/test/run-pass/unwind-resource.rs
+++ b/src/test/run-pass/unwind-resource.rs
@@ -37,7 +37,7 @@ fn f(tx: Sender<bool>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let _t = Thread::spawn(move|| f(tx.clone()));
+    let _t = Thread::scoped(move|| f(tx.clone()));
     println!("hiiiiiiiii");
     assert!(rx.recv().unwrap());
 }
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 554a08ea64460..371fd677bd981 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 use std::thread::Thread;
 
 fn f() {
diff --git a/src/test/run-pass/vec-dst.rs b/src/test/run-pass/vec-dst.rs
index 4a36231e72b0a..40073c2b74219 100644
--- a/src/test/run-pass/vec-dst.rs
+++ b/src/test/run-pass/vec-dst.rs
@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![allow(unknown_features)]
+#![feature(box_syntax)]
+
 pub fn main() {
     // Tests for indexing into box/& [T; n]
     let x: [int; 3] = [1, 2, 3];
diff --git a/src/test/run-pass/vec-fixed-length.rs b/src/test/run-pass/vec-fixed-length.rs
index 20e1becd008a5..101999bbe088a 100644
--- a/src/test/run-pass/vec-fixed-length.rs
+++ b/src/test/run-pass/vec-fixed-length.rs
@@ -21,7 +21,7 @@ pub fn main() {
 
     // FIXME #10183
     // FIXME #18069
-    //if cfg!(target_word_size = "64") {
+    //if cfg!(target_pointer_width = "64") {
     //    assert_eq!(size_of::<[u8; (1 << 32)]>(), (1u << 32));
     //}
 }
diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs
index 52e0ba89479f5..97c12d0954e4b 100644
--- a/src/test/run-pass/vec-to_str.rs
+++ b/src/test/run-pass/vec-to_str.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 pub fn main() {
-    assert_eq!((vec!(0i, 1)).to_string(), "[0, 1]".to_string());
+    assert_eq!(format!("{:?}", vec!(0i, 1)), "[0i, 1i]".to_string());
 
     let foo = vec!(3i, 4);
     let bar: &[int] = &[4, 5];
 
-    assert_eq!(foo.to_string(), "[3, 4]".to_string());
-    assert_eq!(bar.to_string(), "[4, 5]".to_string());
+    assert_eq!(format!("{:?}", foo), "[3i, 4i]");
+    assert_eq!(format!("{:?}", bar), "[4i, 5i]");
 }
diff --git a/src/test/run-pass/vector-no-ann-2.rs b/src/test/run-pass/vector-no-ann-2.rs
index ba66a448c2509..6391893b9a484 100644
--- a/src/test/run-pass/vector-no-ann-2.rs
+++ b/src/test/run-pass/vector-no-ann-2.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
+#![allow(unknown_features)]
+#![feature(box_syntax)]
 
 pub fn main() { let _quux: Box<Vec<uint>> = box Vec::new(); }