syntax: Turn `token::Lit` into a struct

2 files changed, 33 insertions, 64 deletions

diff --git a/src/libsyntax_ext/assert.rs b/src/libsyntax_ext/assert.rs
index cd69733571d..a11cd9c6f76 100644
--- a/src/libsyntax_ext/assert.rs
+++ b/src/libsyntax_ext/assert.rs
@@ -4,7 +4,7 @@ use syntax::ast::{self, *};
 use syntax::source_map::Spanned;
 use syntax::ext::base::*;
 use syntax::ext::build::AstBuilder;
-use syntax::parse::token;
+use syntax::parse::token::{self, Token};
 use syntax::parse::parser::Parser;
 use syntax::print::pprust;
 use syntax::ptr::P;
@@ -31,13 +31,10 @@ pub fn expand_assert<'cx>(
         tts: custom_message.unwrap_or_else(|| {
             TokenStream::from(TokenTree::Token(
                 DUMMY_SP,
-                token::Literal(
-                    token::Lit::Str_(Name::intern(&format!(
-                        "assertion failed: {}",
-                        pprust::expr_to_string(&cond_expr).escape_debug()
-                    ))),
-                    None,
-                ),
+                Token::lit(token::Str, Symbol::intern(&format!(
+                    "assertion failed: {}",
+                    pprust::expr_to_string(&cond_expr).escape_debug()
+                )), None),
             ))
         }).into(),
         delim: MacDelimiter::Parenthesis,
@@ -106,7 +103,7 @@ fn parse_assert<'a>(
     //
     // Parse this as an actual message, and suggest inserting a comma. Eventually, this should be
     // turned into an error.
-    let custom_message = if let token::Literal(token::Lit::Str_(_), _) = parser.token {
+    let custom_message = if let token::Literal(token::Lit { kind: token::Str, .. }) = parser.token {
         let mut err = cx.struct_span_warn(parser.span, "unexpected string literal");
         let comma_span = cx.source_map().next_point(parser.prev_span);
         err.span_suggestion_short(
diff --git a/src/libsyntax_ext/proc_macro_server.rs b/src/libsyntax_ext/proc_macro_server.rs
index 69e83f5a84c..a9bc5fe357d 100644
--- a/src/libsyntax_ext/proc_macro_server.rs
+++ b/src/libsyntax_ext/proc_macro_server.rs
@@ -150,7 +150,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)>
                 stack.push(tt!(Ident::new(ident.name, false)));
                 tt!(Punct::new('\'', true))
             }
-            Literal(lit, suffix) => tt!(Literal { lit, suffix }),
+            Literal(lit) => tt!(Literal { lit }),
             DocComment(c) => {
                 let style = comments::doc_comment_style(&c.as_str());
                 let stripped = comments::strip_doc_comment_decoration(&c.as_str());
@@ -161,7 +161,7 @@ impl FromInternal<(TreeAndJoint, &'_ ParseSess, &'_ mut Vec<Self>)>
                 let stream = vec![
                     Ident(ast::Ident::new(Symbol::intern("doc"), span), false),
                     Eq,
-                    Literal(Lit::Str_(Symbol::intern(&escaped)), None),
+                    Token::lit(token::Str, Symbol::intern(&escaped), None),
                 ]
                 .into_iter()
                 .map(|token| tokenstream::TokenTree::Token(span, token))
@@ -215,31 +215,29 @@ impl ToInternal<TokenStream> for TokenTree<Group, Punct, Ident, Literal> {
                 return tokenstream::TokenTree::Token(span, token).into();
             }
             TokenTree::Literal(self::Literal {
-                lit: Lit::Integer(ref a),
-                suffix,
+                lit: token::Lit { kind: token::Integer, symbol, suffix },
                 span,
-            }) if a.as_str().starts_with("-") => {
+            }) if symbol.as_str().starts_with("-") => {
                 let minus = BinOp(BinOpToken::Minus);
-                let integer = Symbol::intern(&a.as_str()[1..]);
-                let integer = Literal(Lit::Integer(integer), suffix);
+                let symbol = Symbol::intern(&symbol.as_str()[1..]);
+                let integer = Token::lit(token::Integer, symbol, suffix);
                 let a = tokenstream::TokenTree::Token(span, minus);
                 let b = tokenstream::TokenTree::Token(span, integer);
                 return vec![a, b].into_iter().collect();
             }
             TokenTree::Literal(self::Literal {
-                lit: Lit::Float(ref a),
-                suffix,
+                lit: token::Lit { kind: token::Float, symbol, suffix },
                 span,
-            }) if a.as_str().starts_with("-") => {
+            }) if symbol.as_str().starts_with("-") => {
                 let minus = BinOp(BinOpToken::Minus);
-                let float = Symbol::intern(&a.as_str()[1..]);
-                let float = Literal(Lit::Float(float), suffix);
+                let symbol = Symbol::intern(&symbol.as_str()[1..]);
+                let float = Token::lit(token::Float, symbol, suffix);
                 let a = tokenstream::TokenTree::Token(span, minus);
                 let b = tokenstream::TokenTree::Token(span, float);
                 return vec![a, b].into_iter().collect();
             }
-            TokenTree::Literal(self::Literal { lit, suffix, span }) => {
-                return tokenstream::TokenTree::Token(span, Literal(lit, suffix)).into()
+            TokenTree::Literal(self::Literal { lit, span }) => {
+                return tokenstream::TokenTree::Token(span, Literal(lit)).into()
             }
         };
 
@@ -355,7 +353,6 @@ impl Ident {
 #[derive(Clone, Debug)]
 pub struct Literal {
     lit: token::Lit,
-    suffix: Option<Symbol>,
     span: Span,
 }
 
@@ -381,6 +378,13 @@ impl<'a> Rustc<'a> {
             call_site: to_span(Transparency::Transparent),
         }
     }
+
+    pub fn lit(&mut self, kind: token::LitKind, symbol: Symbol, suffix: Option<Symbol>) -> Literal {
+        Literal {
+            lit: token::Lit::new(kind, symbol, suffix),
+            span: server::Span::call_site(self),
+        }
+    }
 }
 
 impl server::Types for Rustc<'_> {
@@ -536,59 +540,31 @@ impl server::Literal for Rustc<'_> {
         format!("{:?}", literal)
     }
     fn integer(&mut self, n: &str) -> Self::Literal {
-        Literal {
-            lit: token::Lit::Integer(Symbol::intern(n)),
-            suffix: None,
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Integer, Symbol::intern(n), None)
     }
     fn typed_integer(&mut self, n: &str, kind: &str) -> Self::Literal {
-        Literal {
-            lit: token::Lit::Integer(Symbol::intern(n)),
-            suffix: Some(Symbol::intern(kind)),
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Integer, Symbol::intern(n), Some(Symbol::intern(kind)))
     }
     fn float(&mut self, n: &str) -> Self::Literal {
-        Literal {
-            lit: token::Lit::Float(Symbol::intern(n)),
-            suffix: None,
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Float, Symbol::intern(n), None)
     }
     fn f32(&mut self, n: &str) -> Self::Literal {
-        Literal {
-            lit: token::Lit::Float(Symbol::intern(n)),
-            suffix: Some(Symbol::intern("f32")),
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Float, Symbol::intern(n), Some(Symbol::intern("f32")))
     }
     fn f64(&mut self, n: &str) -> Self::Literal {
-        Literal {
-            lit: token::Lit::Float(Symbol::intern(n)),
-            suffix: Some(Symbol::intern("f64")),
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Float, Symbol::intern(n), Some(Symbol::intern("f64")))
     }
     fn string(&mut self, string: &str) -> Self::Literal {
         let mut escaped = String::new();
         for ch in string.chars() {
             escaped.extend(ch.escape_debug());
         }
-        Literal {
-            lit: token::Lit::Str_(Symbol::intern(&escaped)),
-            suffix: None,
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Str, Symbol::intern(&escaped), None)
     }
     fn character(&mut self, ch: char) -> Self::Literal {
         let mut escaped = String::new();
         escaped.extend(ch.escape_unicode());
-        Literal {
-            lit: token::Lit::Char(Symbol::intern(&escaped)),
-            suffix: None,
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::Char, Symbol::intern(&escaped), None)
     }
     fn byte_string(&mut self, bytes: &[u8]) -> Self::Literal {
         let string = bytes
@@ -597,11 +573,7 @@ impl server::Literal for Rustc<'_> {
             .flat_map(ascii::escape_default)
             .map(Into::<char>::into)
             .collect::<String>();
-        Literal {
-            lit: token::Lit::ByteStr(Symbol::intern(&string)),
-            suffix: None,
-            span: server::Span::call_site(self),
-        }
+        self.lit(token::ByteStr, Symbol::intern(&string), None)
     }
     fn span(&mut self, literal: &Self::Literal) -> Self::Span {
         literal.span