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

23 files changed, 146 insertions, 336 deletions

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index 04dec0e8028..fd3bac5b2fc 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 52e402689ba..9b9d8a9ceb3 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 bd4f295401c..27523ea4535 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 9f225d55b44..00000000000
--- 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 1f1781dceb3..39895a3946a 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 02f702248cb..1af3ba1d326 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 d9d6cebd05c..784a92b9a0e 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 a9289f0175a..7c65d2b4ff4 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 7114217d51d..616390467f0 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 50b3559f369..47b29a4db3e 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 844bd80d161..db99c142443 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 43a0e0606f8..603c4478007 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 fa9a7899a12..48034ce50ab 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 eb3544e3c5c..9b54e259761 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 3e1bccf394a..9ef996ac317 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 5352cfaf749..00000000000
--- 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 44a596d2657..637b6d4649d 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 bebd803ac4f..ae8ff118fcc 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 77aea0c370a..2dbf29c145c 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 1ba91dd371c..31a1a838b13 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 d33d03bbfa9..9eda4bcef99 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 64c53e298ef..fc341e3bd85 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 bc07c7f6cae..94b8356130a 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))[]);
                             }
                         }
                     }