rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

syntax: Turn token::Lit into a struct

Browse Source
This commit is contained in:
Vadim Petrochenkov
2019-05-19 01:04:26 +03:00
parent 558559e70f
commit ca2a50fad7
12 changed files with 275 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
src/libsyntax_ext/proc_macro_server.rs
View File

@@ -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