remove `Tt` prefix from TokenType variants

[breaking change]

2 files changed, 28 insertions, 29 deletions

diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index a468f0d1d98..5c0ffb770b7 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -669,7 +669,7 @@ mod tests {
     use std::rc::Rc;
     use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION};
     use owned_slice::OwnedSlice;
-    use ast;
+    use ast::{self, TokenTree};
     use abi;
     use attr::{first_attr_value_str_by_name, AttrMetaMethods};
     use parse;
@@ -739,10 +739,10 @@ mod tests {
         match (tts.len(), tts.get(0), tts.get(1), tts.get(2), tts.get(3)) {
             (
                 4,
-                Some(&ast::TtToken(_, token::Ident(name_macro_rules, token::Plain))),
-                Some(&ast::TtToken(_, token::Not)),
-                Some(&ast::TtToken(_, token::Ident(name_zip, token::Plain))),
-                Some(&ast::TtDelimited(_, ref macro_delimed)),
+                Some(&TokenTree::Token(_, token::Ident(name_macro_rules, token::Plain))),
+                Some(&TokenTree::Token(_, token::Not)),
+                Some(&TokenTree::Token(_, token::Ident(name_zip, token::Plain))),
+                Some(&TokenTree::Delimited(_, ref macro_delimed)),
             )
             if name_macro_rules.name.as_str() == "macro_rules"
             && name_zip.name.as_str() == "zip" => {
@@ -750,17 +750,17 @@ mod tests {
                 match (tts.len(), tts.get(0), tts.get(1), tts.get(2)) {
                     (
                         3,
-                        Some(&ast::TtDelimited(_, ref first_delimed)),
-                        Some(&ast::TtToken(_, token::FatArrow)),
-                        Some(&ast::TtDelimited(_, ref second_delimed)),
+                        Some(&TokenTree::Delimited(_, ref first_delimed)),
+                        Some(&TokenTree::Token(_, token::FatArrow)),
+                        Some(&TokenTree::Delimited(_, ref second_delimed)),
                     )
                     if macro_delimed.delim == token::Paren => {
                         let tts = &first_delimed.tts[..];
                         match (tts.len(), tts.get(0), tts.get(1)) {
                             (
                                 2,
-                                Some(&ast::TtToken(_, token::Dollar)),
-                                Some(&ast::TtToken(_, token::Ident(ident, token::Plain))),
+                                Some(&TokenTree::Token(_, token::Dollar)),
+                                Some(&TokenTree::Token(_, token::Ident(ident, token::Plain))),
                             )
                             if first_delimed.delim == token::Paren
                             && ident.name.as_str() == "a" => {},
@@ -770,8 +770,8 @@ mod tests {
                         match (tts.len(), tts.get(0), tts.get(1)) {
                             (
                                 2,
-                                Some(&ast::TtToken(_, token::Dollar)),
-                                Some(&ast::TtToken(_, token::Ident(ident, token::Plain))),
+                                Some(&TokenTree::Token(_, token::Dollar)),
+                                Some(&TokenTree::Token(_, token::Ident(ident, token::Plain))),
                             )
                             if second_delimed.delim == token::Paren
                             && ident.name.as_str() == "a" => {},
@@ -790,39 +790,39 @@ mod tests {
         let tts = string_to_tts("fn a (b : i32) { b; }".to_string());
 
         let expected = vec![
-            ast::TtToken(sp(0, 2),
+            TokenTree::Token(sp(0, 2),
                          token::Ident(str_to_ident("fn"),
                          token::IdentStyle::Plain)),
-            ast::TtToken(sp(3, 4),
+            TokenTree::Token(sp(3, 4),
                          token::Ident(str_to_ident("a"),
                          token::IdentStyle::Plain)),
-            ast::TtDelimited(
+            TokenTree::Delimited(
                 sp(5, 14),
                 Rc::new(ast::Delimited {
                     delim: token::DelimToken::Paren,
                     open_span: sp(5, 6),
                     tts: vec![
-                        ast::TtToken(sp(6, 7),
+                        TokenTree::Token(sp(6, 7),
                                      token::Ident(str_to_ident("b"),
                                      token::IdentStyle::Plain)),
-                        ast::TtToken(sp(8, 9),
+                        TokenTree::Token(sp(8, 9),
                                      token::Colon),
-                        ast::TtToken(sp(10, 13),
+                        TokenTree::Token(sp(10, 13),
                                      token::Ident(str_to_ident("i32"),
                                      token::IdentStyle::Plain)),
                     ],
                     close_span: sp(13, 14),
                 })),
-            ast::TtDelimited(
+            TokenTree::Delimited(
                 sp(15, 21),
                 Rc::new(ast::Delimited {
                     delim: token::DelimToken::Brace,
                     open_span: sp(15, 16),
                     tts: vec![
-                        ast::TtToken(sp(17, 18),
+                        TokenTree::Token(sp(17, 18),
                                      token::Ident(str_to_ident("b"),
                                      token::IdentStyle::Plain)),
-                        ast::TtToken(sp(18, 19),
+                        TokenTree::Token(sp(18, 19),
                                      token::Semi)
                     ],
                     close_span: sp(20, 21),
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 2401f6be78f..907197eb4df 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -48,7 +48,6 @@ use ast::{StmtExpr, StmtSemi, StmtMac, VariantData, StructField};
 use ast::{BiSub, StrStyle};
 use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
 use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
-use ast::{TtDelimited, TtSequence, TtToken};
 use ast::{Ty, Ty_, TypeBinding, TyMac};
 use ast::{TyFixedLengthVec, TyBareFn, TyTypeof, TyInfer};
 use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr};
@@ -2428,7 +2427,7 @@ impl<'a> Parser<'a> {
                     ));
                     let (sep, repeat) = try!(self.parse_sep_and_kleene_op());
                     let name_num = macro_parser::count_names(&seq);
-                    return Ok(TtSequence(mk_sp(sp.lo, seq_span.hi),
+                    return Ok(TokenTree::Sequence(mk_sp(sp.lo, seq_span.hi),
                                       Rc::new(SequenceRepetition {
                                           tts: seq,
                                           separator: sep,
@@ -2437,7 +2436,7 @@ impl<'a> Parser<'a> {
                                       })));
                 } else if self.token.is_keyword_allow_following_colon(keywords::Crate) {
                     try!(self.bump());
-                    return Ok(TtToken(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar)));
+                    return Ok(TokenTree::Token(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar)));
                 } else {
                     sp = mk_sp(sp.lo, self.span.hi);
                     let namep = match self.token { token::Ident(_, p) => p, _ => token::Plain };
@@ -2459,9 +2458,9 @@ impl<'a> Parser<'a> {
             sp = mk_sp(sp.lo, self.span.hi);
             let kindp = match self.token { token::Ident(_, p) => p, _ => token::Plain };
             let nt_kind = try!(self.parse_ident());
-            Ok(TtToken(sp, MatchNt(name, nt_kind, namep, kindp)))
+            Ok(TokenTree::Token(sp, MatchNt(name, nt_kind, namep, kindp)))
         } else {
-            Ok(TtToken(sp, SubstNt(name, namep)))
+            Ok(TokenTree::Token(sp, SubstNt(name, namep)))
         }
     }
 
@@ -2509,7 +2508,7 @@ impl<'a> Parser<'a> {
     /// parse a single token tree from the input.
     pub fn parse_token_tree(&mut self) -> PResult<TokenTree> {
         // FIXME #6994: currently, this is too eager. It
-        // parses token trees but also identifies TtSequence's
+        // parses token trees but also identifies TokenType::Sequence's
         // and token::SubstNt's; it's too early to know yet
         // whether something will be a nonterminal or a seq
         // yet.
@@ -2540,7 +2539,7 @@ impl<'a> Parser<'a> {
                     p.parse_unquoted()
                 }
                 _ => {
-                    Ok(TtToken(p.span, try!(p.bump_and_get())))
+                    Ok(TokenTree::Token(p.span, try!(p.bump_and_get())))
                 }
             }
         }
@@ -2579,7 +2578,7 @@ impl<'a> Parser<'a> {
                 // Expand to cover the entire delimited token tree
                 let span = Span { hi: close_span.hi, ..pre_span };
 
-                Ok(TtDelimited(span, Rc::new(Delimited {
+                Ok(TokenTree::Delimited(span, Rc::new(Delimited {
                     delim: delim,
                     open_span: open_span,
                     tts: tts,