Use PascalCase for token variants

9 files changed, 133 insertions, 133 deletions

diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs
index 702be0c0eee..2b52b7feacc 100644
--- a/src/libsyntax/ext/asm.rs
+++ b/src/libsyntax/ext/asm.rs
@@ -72,21 +72,21 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                 asm_str_style = Some(style);
             }
             Outputs => {
-                while p.token != token::EOF &&
-                      p.token != token::COLON &&
-                      p.token != token::MOD_SEP {
+                while p.token != token::Eof &&
+                      p.token != token::Colon &&
+                      p.token != token::ModSep {
 
                     if outputs.len() != 0 {
-                        p.eat(&token::COMMA);
+                        p.eat(&token::Comma);
                     }
 
                     let (constraint, _str_style) = p.parse_str();
 
                     let span = p.last_span;
 
-                    p.expect(&token::LPAREN);
+                    p.expect(&token::LParen);
                     let out = p.parse_expr();
-                    p.expect(&token::RPAREN);
+                    p.expect(&token::RParen);
 
                     // Expands a read+write operand into two operands.
                     //
@@ -113,12 +113,12 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                 }
             }
             Inputs => {
-                while p.token != token::EOF &&
-                      p.token != token::COLON &&
-                      p.token != token::MOD_SEP {
+                while p.token != token::Eof &&
+                      p.token != token::Colon &&
+                      p.token != token::ModSep {
 
                     if inputs.len() != 0 {
-                        p.eat(&token::COMMA);
+                        p.eat(&token::Comma);
                     }
 
                     let (constraint, _str_style) = p.parse_str();
@@ -129,21 +129,21 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                         cx.span_err(p.last_span, "input operand constraint contains '+'");
                     }
 
-                    p.expect(&token::LPAREN);
+                    p.expect(&token::LParen);
                     let input = p.parse_expr();
-                    p.expect(&token::RPAREN);
+                    p.expect(&token::RParen);
 
                     inputs.push((constraint, input));
                 }
             }
             Clobbers => {
                 let mut clobs = Vec::new();
-                while p.token != token::EOF &&
-                      p.token != token::COLON &&
-                      p.token != token::MOD_SEP {
+                while p.token != token::Eof &&
+                      p.token != token::Colon &&
+                      p.token != token::ModSep {
 
                     if clobs.len() != 0 {
-                        p.eat(&token::COMMA);
+                        p.eat(&token::Comma);
                     }
 
                     let (s, _str_style) = p.parse_str();
@@ -172,8 +172,8 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                     cx.span_warn(p.last_span, "unrecognized option");
                 }
 
-                if p.token == token::COMMA {
-                    p.eat(&token::COMMA);
+                if p.token == token::Comma {
+                    p.eat(&token::Comma);
                 }
             }
             StateNone => ()
@@ -183,17 +183,17 @@ pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
             // MOD_SEP is a double colon '::' without space in between.
             // When encountered, the state must be advanced twice.
             match (&p.token, state.next(), state.next().next()) {
-                (&token::COLON, StateNone, _)   |
-                (&token::MOD_SEP, _, StateNone) => {
+                (&token::Colon, StateNone, _)   |
+                (&token::ModSep, _, StateNone) => {
                     p.bump();
                     break 'statement;
                 }
-                (&token::COLON, st, _)   |
-                (&token::MOD_SEP, _, st) => {
+                (&token::Colon, st, _)   |
+                (&token::ModSep, _, st) => {
                     p.bump();
                     state = st;
                 }
-                (&token::EOF, _, _) => break 'statement,
+                (&token::Eof, _, _) => break 'statement,
                 _ => break
             }
         }
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index 64c8068607a..a8326e79ef3 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -684,8 +684,8 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
         cx.span_err(sp, format!("{} takes 1 argument.", name).as_slice());
     } else {
         match tts[0] {
-            ast::TtToken(_, token::LIT_STR(ident)) => return Some(parse::str_lit(ident.as_str())),
-            ast::TtToken(_, token::LIT_STR_RAW(ident, _)) => {
+            ast::TtToken(_, token::LitStr(ident)) => return Some(parse::str_lit(ident.as_str())),
+            ast::TtToken(_, token::LitStrRaw(ident, _)) => {
                 return Some(parse::raw_str_lit(ident.as_str()))
             }
             _ => {
@@ -704,12 +704,12 @@ pub fn get_exprs_from_tts(cx: &mut ExtCtxt,
                           tts: &[ast::TokenTree]) -> Option<Vec<P<ast::Expr>>> {
     let mut p = cx.new_parser_from_tts(tts);
     let mut es = Vec::new();
-    while p.token != token::EOF {
+    while p.token != token::Eof {
         es.push(cx.expander().fold_expr(p.parse_expr()));
-        if p.eat(&token::COMMA) {
+        if p.eat(&token::Comma) {
             continue;
         }
-        if p.token != token::EOF {
+        if p.token != token::Eof {
             cx.span_err(sp, "expected token: `,`");
             return None;
         }
diff --git a/src/libsyntax/ext/cfg.rs b/src/libsyntax/ext/cfg.rs
index f697acb417d..72da60ffe09 100644
--- a/src/libsyntax/ext/cfg.rs
+++ b/src/libsyntax/ext/cfg.rs
@@ -29,7 +29,7 @@ pub fn expand_cfg<'cx>(cx: &mut ExtCtxt,
     let mut p = cx.new_parser_from_tts(tts);
     let cfg = p.parse_meta_item();
 
-    if !p.eat(&token::EOF) {
+    if !p.eat(&token::Eof) {
         cx.span_err(sp, "expected 1 cfg-pattern");
         return DummyResult::expr(sp);
     }
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index e12f9ee133a..e5e93a7d8b3 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -23,21 +23,21 @@ pub fn expand_syntax_ext<'cx>(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]
     for (i, e) in tts.iter().enumerate() {
         if i & 1 == 1 {
             match *e {
-                ast::TtToken(_, token::COMMA) => (),
+                ast::TtToken(_, token::Comma) => {},
                 _ => {
                     cx.span_err(sp, "concat_idents! expecting comma.");
                     return DummyResult::expr(sp);
-                }
+                },
             }
         } else {
             match *e {
-                ast::TtToken(_, token::IDENT(ident,_)) => {
+                ast::TtToken(_, token::Ident(ident, _)) => {
                     res_str.push_str(token::get_ident(ident).get())
-                }
+                },
                 _ => {
                     cx.span_err(sp, "concat_idents! requires ident args.");
                     return DummyResult::expr(sp);
-                }
+                },
             }
         }
     }
diff --git a/src/libsyntax/ext/format.rs b/src/libsyntax/ext/format.rs
index 87cd61c9b22..fdf61d4abd9 100644
--- a/src/libsyntax/ext/format.rs
+++ b/src/libsyntax/ext/format.rs
@@ -91,7 +91,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool,
     // Parse the leading function expression (maybe a block, maybe a path)
     let invocation = if allow_method {
         let e = p.parse_expr();
-        if !p.eat(&token::COMMA) {
+        if !p.eat(&token::Comma) {
             ecx.span_err(sp, "expected token: `,`");
             return (Call(e), None);
         }
@@ -99,28 +99,28 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool,
     } else {
         Call(p.parse_expr())
     };
-    if !p.eat(&token::COMMA) {
+    if !p.eat(&token::Comma) {
         ecx.span_err(sp, "expected token: `,`");
         return (invocation, None);
     }
 
-    if p.token == token::EOF {
+    if p.token == token::Eof {
         ecx.span_err(sp, "requires at least a format string argument");
         return (invocation, None);
     }
     let fmtstr = p.parse_expr();
     let mut named = false;
-    while p.token != token::EOF {
-        if !p.eat(&token::COMMA) {
+    while p.token != token::Eof {
+        if !p.eat(&token::Comma) {
             ecx.span_err(sp, "expected token: `,`");
             return (invocation, None);
         }
-        if p.token == token::EOF { break } // accept trailing commas
+        if p.token == token::Eof { break } // accept trailing commas
         if named || (token::is_ident(&p.token) &&
-                     p.look_ahead(1, |t| *t == token::EQ)) {
+                     p.look_ahead(1, |t| *t == token::Eq)) {
             named = true;
             let ident = match p.token {
-                token::IDENT(i, _) => {
+                token::Ident(i, _) => {
                     p.bump();
                     i
                 }
@@ -139,7 +139,7 @@ fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool,
             };
             let interned_name = token::get_ident(ident);
             let name = interned_name.get();
-            p.expect(&token::EQ);
+            p.expect(&token::Eq);
             let e = p.parse_expr();
             match names.find_equiv(&name) {
                 None => {}
diff --git a/src/libsyntax/ext/quote.rs b/src/libsyntax/ext/quote.rs
index 6f1fd90adfa..39a538f917b 100644
--- a/src/libsyntax/ext/quote.rs
+++ b/src/libsyntax/ext/quote.rs
@@ -515,123 +515,122 @@ fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> P<ast::Expr> {
     cx.expr_path(cx.path_global(sp, idents))
 }
 
-fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> P<ast::Expr> {
+fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOpToken) -> P<ast::Expr> {
     let name = match bop {
-        PLUS => "PLUS",
-        MINUS => "MINUS",
-        STAR => "STAR",
-        SLASH => "SLASH",
-        PERCENT => "PERCENT",
-        CARET => "CARET",
-        AND => "AND",
-        OR => "OR",
-        SHL => "SHL",
-        SHR => "SHR"
+        token::Plus     => "Plus",
+        token::Minus    => "Minus",
+        token::Star     => "Star",
+        token::Slash    => "Slash",
+        token::Percent  => "Percent",
+        token::Caret    => "Caret",
+        token::And      => "And",
+        token::Or       => "Or",
+        token::Shl      => "Shl",
+        token::Shr      => "Shr"
     };
     mk_token_path(cx, sp, name)
 }
 
 fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> P<ast::Expr> {
-
     match *tok {
-        BINOP(binop) => {
-            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOP"), vec!(mk_binop(cx, sp, binop)));
+        token::BinOp(binop) => {
+            return cx.expr_call(sp, mk_token_path(cx, sp, "BinOp"), vec!(mk_binop(cx, sp, binop)));
         }
-        BINOPEQ(binop) => {
-            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOPEQ"),
+        token::BinOpEq(binop) => {
+            return cx.expr_call(sp, mk_token_path(cx, sp, "BinOpEq"),
                                 vec!(mk_binop(cx, sp, binop)));
         }
 
-        LIT_BYTE(i) => {
+        token::LitByte(i) => {
             let e_byte = mk_name(cx, sp, i.ident());
 
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_BYTE"), vec!(e_byte));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LitByte"), vec!(e_byte));
         }
 
-        LIT_CHAR(i) => {
+        token::LitChar(i) => {
             let e_char = mk_name(cx, sp, i.ident());
 
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_CHAR"), vec!(e_char));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LitChar"), vec!(e_char));
         }
 
-        LIT_INTEGER(i) => {
+        token::LitInteger(i) => {
             let e_int = mk_name(cx, sp, i.ident());
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_INTEGER"), vec!(e_int));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LitInteger"), vec!(e_int));
         }
 
-        LIT_FLOAT(fident) => {
+        token::LitFloat(fident) => {
             let e_fident = mk_name(cx, sp, fident.ident());
-            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_FLOAT"), vec!(e_fident));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LitFloat"), vec!(e_fident));
         }
 
-        LIT_STR(ident) => {
+        token::LitStr(ident) => {
             return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIT_STR"),
+                                mk_token_path(cx, sp, "LitStr"),
                                 vec!(mk_name(cx, sp, ident.ident())));
         }
 
-        LIT_STR_RAW(ident, n) => {
+        token::LitStrRaw(ident, n) => {
             return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIT_STR_RAW"),
+                                mk_token_path(cx, sp, "LitStrRaw"),
                                 vec!(mk_name(cx, sp, ident.ident()), cx.expr_uint(sp, n)));
         }
 
-        IDENT(ident, b) => {
+        token::Ident(ident, b) => {
             return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "IDENT"),
+                                mk_token_path(cx, sp, "Ident"),
                                 vec!(mk_ident(cx, sp, ident), cx.expr_bool(sp, b)));
         }
 
-        LIFETIME(ident) => {
+        token::Lifetime(ident) => {
             return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "LIFETIME"),
+                                mk_token_path(cx, sp, "Lifetime"),
                                 vec!(mk_ident(cx, sp, ident)));
         }
 
-        DOC_COMMENT(ident) => {
+        token::DocComment(ident) => {
             return cx.expr_call(sp,
-                                mk_token_path(cx, sp, "DOC_COMMENT"),
+                                mk_token_path(cx, sp, "DocComment"),
                                 vec!(mk_name(cx, sp, ident.ident())));
         }
 
-        INTERPOLATED(_) => fail!("quote! with interpolated token"),
+        token::Interpolated(_) => fail!("quote! with interpolated token"),
 
         _ => ()
     }
 
     let name = match *tok {
-        EQ => "EQ",
-        LT => "LT",
-        LE => "LE",
-        EQEQ => "EQEQ",
-        NE => "NE",
-        GE => "GE",
-        GT => "GT",
-        ANDAND => "ANDAND",
-        OROR => "OROR",
-        NOT => "NOT",
-        TILDE => "TILDE",
-        AT => "AT",
-        DOT => "DOT",
-        DOTDOT => "DOTDOT",
-        COMMA => "COMMA",
-        SEMI => "SEMI",
-        COLON => "COLON",
-        MOD_SEP => "MOD_SEP",
-        RARROW => "RARROW",
-        LARROW => "LARROW",
-        FAT_ARROW => "FAT_ARROW",
-        LPAREN => "LPAREN",
-        RPAREN => "RPAREN",
-        LBRACKET => "LBRACKET",
-        RBRACKET => "RBRACKET",
-        LBRACE => "LBRACE",
-        RBRACE => "RBRACE",
-        POUND => "POUND",
-        DOLLAR => "DOLLAR",
-        UNDERSCORE => "UNDERSCORE",
-        EOF => "EOF",
-        _ => fail!()
+        token::Eq           => "Eq",
+        token::Lt           => "Lt",
+        token::Le           => "Le",
+        token::EqEq         => "EqEq",
+        token::Ne           => "Ne",
+        token::Ge           => "Ge",
+        token::Gt           => "Gt",
+        token::AndAnd       => "AndAnd",
+        token::OrOr         => "OrOr",
+        token::Not          => "Not",
+        token::Tilde        => "Tilde",
+        token::At           => "At",
+        token::Dot          => "Dot",
+        token::DotDot       => "DotDot",
+        token::Comma        => "Comma",
+        token::Semi         => "Semi",
+        token::Colon        => "Colon",
+        token::ModSep       => "ModSep",
+        token::RArrow       => "RArrow",
+        token::LArrow       => "LArrow",
+        token::FatArrow     => "FatArrow",
+        token::LParen       => "LParen",
+        token::RParen       => "RParen",
+        token::LBracket     => "LBracket",
+        token::RBracket     => "RBracket",
+        token::LBrace       => "LBrace",
+        token::RBrace       => "RBrace",
+        token::Pound        => "Pound",
+        token::Dollar       => "Dollar",
+        token::Underscore   => "Underscore",
+        token::Eof          => "Eof",
+        _                   => fail!(),
     };
     mk_token_path(cx, sp, name)
 }
@@ -702,7 +701,7 @@ fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     p.quote_depth += 1u;
 
     let cx_expr = p.parse_expr();
-    if !p.eat(&token::COMMA) {
+    if !p.eat(&token::Comma) {
         p.fatal("expected token `,`");
     }
 
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index cea8cab5265..6d30de96a3c 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -85,7 +85,7 @@ use parse::lexer::*; //resolve bug?
 use parse::ParseSess;
 use parse::attr::ParserAttr;
 use parse::parser::{LifetimeAndTypesWithoutColons, Parser};
-use parse::token::{Token, EOF, Nonterminal};
+use parse::token::{Token, Nonterminal};
 use parse::token;
 use ptr::P;
 
@@ -226,8 +226,8 @@ pub fn parse_or_else(sess: &ParseSess,
 /// unhygienic comparison)
 pub fn token_name_eq(t1 : &Token, t2 : &Token) -> bool {
     match (t1,t2) {
-        (&token::IDENT(id1,_),&token::IDENT(id2,_))
-        | (&token::LIFETIME(id1),&token::LIFETIME(id2)) =>
+        (&token::Ident(id1,_),&token::Ident(id2,_))
+        | (&token::Lifetime(id1),&token::Lifetime(id2)) =>
             id1.name == id2.name,
         _ => *t1 == *t2
     }
@@ -354,9 +354,9 @@ pub fn parse(sess: &ParseSess,
                     // Built-in nonterminals never start with these tokens,
                     // so we can eliminate them from consideration.
                     match tok {
-                        token::RPAREN |
-                        token::RBRACE |
-                        token::RBRACKET => {},
+                        token::RParen |
+                        token::RBrace |
+                        token::RBracket => {},
                         _ => bb_eis.push(ei)
                     }
                   }
@@ -372,7 +372,7 @@ pub fn parse(sess: &ParseSess,
         }
 
         /* error messages here could be improved with links to orig. rules */
-        if token_name_eq(&tok, &EOF) {
+        if token_name_eq(&tok, &token::Eof) {
             if eof_eis.len() == 1u {
                 let mut v = Vec::new();
                 for dv in eof_eis.get_mut(0).matches.iter_mut() {
@@ -447,7 +447,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal {
       "ty" => token::NtTy(p.parse_ty(false /* no need to disambiguate*/)),
       // this could be handled like a token, since it is one
       "ident" => match p.token {
-        token::IDENT(sn,b) => { p.bump(); token::NtIdent(box sn,b) }
+        token::Ident(sn,b) => { p.bump(); token::NtIdent(box sn,b) }
         _ => {
             let token_str = token::to_string(&p.token);
             p.fatal((format!("expected ident, found {}",
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index 3b51fb380b8..20428e50c7f 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -20,7 +20,7 @@ use parse::lexer::new_tt_reader;
 use parse::parser::Parser;
 use parse::attr::ParserAttr;
 use parse::token::{special_idents, gensym_ident};
-use parse::token::{FAT_ARROW, SEMI, NtMatchers, NtTT, EOF};
+use parse::token::{NtMatchers, NtTT};
 use parse::token;
 use print;
 use ptr::P;
@@ -43,10 +43,10 @@ impl<'a> ParserAnyMacro<'a> {
     /// allowed to be there.
     fn ensure_complete_parse(&self, allow_semi: bool) {
         let mut parser = self.parser.borrow_mut();
-        if allow_semi && parser.token == SEMI {
+        if allow_semi && parser.token == token::Semi {
             parser.bump()
         }
-        if parser.token != EOF {
+        if parser.token != token::Eof {
             let token_str = parser.this_token_to_string();
             let msg = format!("macro expansion ignores token `{}` and any \
                                following",
@@ -89,7 +89,7 @@ impl<'a> MacResult for ParserAnyMacro<'a> {
         loop {
             let mut parser = self.parser.borrow_mut();
             match parser.token {
-                EOF => break,
+                token::Eof => break,
                 _ => {
                     let attrs = parser.parse_outer_attributes();
                     ret.push(parser.parse_method(attrs, ast::Inherited))
@@ -231,12 +231,13 @@ pub fn add_new_extension<'cx>(cx: &'cx mut ExtCtxt,
     let argument_gram = vec!(
         ms(MatchSeq(vec!(
             ms(MatchNonterminal(lhs_nm, special_idents::matchers, 0u)),
-            ms(MatchTok(FAT_ARROW)),
-            ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u))), Some(SEMI),
-                                ast::OneOrMore, 0u, 2u)),
+            ms(MatchTok(token::FatArrow)),
+            ms(MatchNonterminal(rhs_nm, special_idents::tt, 1u))),
+                                Some(token::Semi), ast::OneOrMore, 0u, 2u)),
         //to phase into semicolon-termination instead of
         //semicolon-separation
-        ms(MatchSeq(vec!(ms(MatchTok(SEMI))), None, ast::ZeroOrMore, 2u, 2u)));
+        ms(MatchSeq(vec!(ms(MatchTok(token::Semi))), None,
+                            ast::ZeroOrMore, 2u, 2u)));
 
 
     // Parse the macro_rules! invocation (`none` is for no interpolations):
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 1bb519f66cd..2c7b583d460 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -13,7 +13,7 @@ use ast::{TokenTree, TtDelimited, TtToken, TtSequence, TtNonterminal, Ident};
 use codemap::{Span, DUMMY_SP};
 use diagnostic::SpanHandler;
 use ext::tt::macro_parser::{NamedMatch, MatchedSeq, MatchedNonterminal};
-use parse::token::{EOF, INTERPOLATED, IDENT, Token, NtIdent};
+use parse::token::{Token, NtIdent};
 use parse::token;
 use parse::lexer::TokenAndSpan;
 
@@ -66,7 +66,7 @@ pub fn new_tt_reader<'a>(sp_diag: &'a SpanHandler,
         repeat_idx: Vec::new(),
         repeat_len: Vec::new(),
         /* dummy values, never read: */
-        cur_tok: EOF,
+        cur_tok: token::Eof,
         cur_span: DUMMY_SP,
     };
     tt_next_token(&mut r); /* get cur_tok and cur_span set up */
@@ -158,7 +158,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
     loop {
         let should_pop = match r.stack.last() {
             None => {
-                assert_eq!(ret_val.tok, EOF);
+                assert_eq!(ret_val.tok, token::Eof);
                 return ret_val;
             }
             Some(frame) => {
@@ -175,7 +175,7 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
             let prev = r.stack.pop().unwrap();
             match r.stack.last_mut() {
                 None => {
-                    r.cur_tok = EOF;
+                    r.cur_tok = token::Eof;
                     return ret_val;
                 }
                 Some(frame) => {
@@ -272,13 +272,13 @@ pub fn tt_next_token(r: &mut TtReader) -> TokenAndSpan {
                        (b) we actually can, since it's a token. */
                     MatchedNonterminal(NtIdent(box sn, b)) => {
                         r.cur_span = sp;
-                        r.cur_tok = IDENT(sn,b);
+                        r.cur_tok = token::Ident(sn,b);
                         return ret_val;
                     }
                     MatchedNonterminal(ref other_whole_nt) => {
                         // FIXME(pcwalton): Bad copy.
                         r.cur_span = sp;
-                        r.cur_tok = INTERPOLATED((*other_whole_nt).clone());
+                        r.cur_tok = token::Interpolated((*other_whole_nt).clone());
                         return ret_val;
                     }
                     MatchedSeq(..) => {