use slicing sugar

3 files changed, 20 insertions, 20 deletions

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))[]);
                             }
                         }
                     }