-impl Lit {
- crate fn tokens(&self) -> TokenStream {
- TokenTree::Token(self.span, self.node.token()).into()
- }
-}
-
-impl LitKind {
- fn token(&self) -> Token {
- match self.lit_token() {
- (token::Bool(symbol), _) => Token::Ident(Ident::with_empty_ctxt(symbol), false),
- (lit, suffix) => Token::Literal(lit, suffix),
- }
- }
-
- pub(crate) fn lit_token(&self) -> (token::Lit, Option<Symbol>) {
- use std::ascii;
-
- match *self {
- LitKind::Str(string, ast::StrStyle::Cooked) => {
- let escaped = string.as_str().escape_default().to_string();
- (token::Lit::Str_(Symbol::intern(&escaped)), None)
- }
- LitKind::Str(string, ast::StrStyle::Raw(n)) => {
- (token::Lit::StrRaw(string, n), None)
- }
- LitKind::ByteStr(ref bytes) => {
- let string = bytes.iter().cloned().flat_map(ascii::escape_default)
- .map(Into::<char>::into).collect::<String>();
- (token::Lit::ByteStr(Symbol::intern(&string)), None)
- }
- LitKind::Byte(byte) => {
- let string: String = ascii::escape_default(byte).map(Into::<char>::into).collect();
- (token::Lit::Byte(Symbol::intern(&string)), None)
- }
- LitKind::Char(ch) => {
- let string: String = ch.escape_default().map(Into::<char>::into).collect();
- (token::Lit::Char(Symbol::intern(&string)), None)
- }
- LitKind::Int(n, ty) => {
- let suffix = match ty {
- ast::LitIntType::Unsigned(ty) => Some(Symbol::intern(ty.ty_to_string())),
- ast::LitIntType::Signed(ty) => Some(Symbol::intern(ty.ty_to_string())),
- ast::LitIntType::Unsuffixed => None,
- };
- (token::Lit::Integer(Symbol::intern(&n.to_string())), suffix)
- }
- LitKind::Float(symbol, ty) => {
- (token::Lit::Float(symbol), Some(Symbol::intern(ty.ty_to_string())))
- }
- LitKind::FloatUnsuffixed(symbol) => (token::Lit::Float(symbol), None),
- LitKind::Bool(value) => {
- let kw = if value { keywords::True } else { keywords::False };
- (token::Lit::Bool(kw.name()), None)
- }
- LitKind::Err(val) => (token::Lit::Err(val), None),
- }
- }
-
- fn from_token(token: Token) -> Option<(LitKind, token::Lit, Option<Symbol>)> {
- match token {
- Token::Ident(ident, false) if ident.name == keywords::True.name() =>
- Some((LitKind::Bool(true), token::Bool(ident.name), None)),
- Token::Ident(ident, false) if ident.name == keywords::False.name() =>
- Some((LitKind::Bool(false), token::Bool(ident.name), None)),
- Token::Interpolated(nt) => match *nt {
- token::NtExpr(ref v) | token::NtLiteral(ref v) => match v.node {
- ExprKind::Lit(ref lit) => Some((lit.node.clone(), lit.token, lit.suffix)),
- _ => None,
- },
- _ => None,
- },
- Token::Literal(lit, suf) => {
- let (suffix_illegal, result) = parse::lit_token(lit, suf, None);
- if result.is_none() || suffix_illegal && suf.is_some() {
- return None;
- }
- Some((result.unwrap(), lit, suf))
- }
- _ => None,
- }
- }
-}
-