diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs index 6d30de96a3c37..073bebcb3f6ff 100644 --- a/src/libsyntax/ext/tt/macro_parser.rs +++ b/src/libsyntax/ext/tt/macro_parser.rs @@ -87,6 +87,7 @@ use parse::attr::ParserAttr; use parse::parser::{LifetimeAndTypesWithoutColons, Parser}; use parse::token::{Token, Nonterminal}; use parse::token; +use print::pprust; use ptr::P; use std::rc::Rc; @@ -402,7 +403,7 @@ pub fn parse(sess: &ParseSess, nts, next_eis.len()).to_string()); } else if bb_eis.len() == 0u && next_eis.len() == 0u { return Failure(sp, format!("no rules expected the token `{}`", - token::to_string(&tok)).to_string()); + pprust::token_to_string(&tok)).to_string()); } else if next_eis.len() > 0u { /* Now process the next token */ while next_eis.len() > 0u { @@ -449,7 +450,7 @@ pub fn parse_nt(p: &mut Parser, name: &str) -> Nonterminal { "ident" => match p.token { token::Ident(sn,b) => { p.bump(); token::NtIdent(box sn,b) } _ => { - let token_str = token::to_string(&p.token); + let token_str = pprust::token_to_string(&p.token); p.fatal((format!("expected ident, found {}", token_str.as_slice())).as_slice()) } diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index 66b21aed5525d..3814ecfbe5bc6 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -15,7 +15,7 @@ use parse::lexer::{is_whitespace, Reader}; use parse::lexer::{StringReader, TokenAndSpan}; use parse::lexer::is_block_doc_comment; use parse::lexer; -use parse::token; +use print::pprust; use std::io; use std::str; @@ -373,7 +373,7 @@ pub fn gather_comments_and_literals(span_diagnostic: &diagnostic::SpanHandler, literals.push(Literal {lit: s.to_string(), pos: sp.lo}); }) } else { - debug!("tok: {}", token::to_string(&tok)); + debug!("tok: {}", pprust::token_to_string(&tok)); } first_read = false; } diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 54b1cc2dbad15..654de709566ae 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -78,6 +78,7 @@ use parse::token::InternedString; use parse::token::{keywords, special_idents}; use parse::token; use parse::{new_sub_parser_from_file, ParseSess}; +use print::pprust; use ptr::P; use owned_slice::OwnedSlice; @@ -394,7 +395,7 @@ impl<'a> Parser<'a> { /// Convert a token to a string using self's reader pub fn token_to_string(token: &token::Token) -> String { - token::to_string(token) + pprust::token_to_string(token) } /// Convert the current token to a string using self's reader diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 1a69944bffa24..9ed8e4bc3a707 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -431,101 +431,6 @@ impl fmt::Show for Nonterminal { } } -pub fn binop_to_string(o: BinOpToken) -> &'static str { - match o { - Plus => "+", - Minus => "-", - Star => "*", - Slash => "/", - Percent => "%", - Caret => "^", - And => "&", - Or => "|", - Shl => "<<", - Shr => ">>", - } -} - -pub fn to_string(t: &Token) -> String { - match *t { - Eq => "=".into_string(), - Lt => "<".into_string(), - Le => "<=".into_string(), - EqEq => "==".into_string(), - Ne => "!=".into_string(), - Ge => ">=".into_string(), - Gt => ">".into_string(), - Not => "!".into_string(), - Tilde => "~".into_string(), - OrOr => "||".into_string(), - AndAnd => "&&".into_string(), - BinOp(op) => binop_to_string(op).into_string(), - BinOpEq(op) => format!("{}=", binop_to_string(op)), - - /* Structural symbols */ - At => "@".into_string(), - Dot => ".".into_string(), - DotDot => "..".into_string(), - DotDotDot => "...".into_string(), - Comma => ",".into_string(), - Semi => ";".into_string(), - Colon => ":".into_string(), - ModSep => "::".into_string(), - RArrow => "->".into_string(), - LArrow => "<-".into_string(), - FatArrow => "=>".into_string(), - LParen => "(".into_string(), - RParen => ")".into_string(), - LBracket => "[".into_string(), - RBracket => "]".into_string(), - LBrace => "{".into_string(), - RBrace => "}".into_string(), - Pound => "#".into_string(), - Dollar => "$".into_string(), - Question => "?".into_string(), - - /* Literals */ - LitByte(b) => format!("b'{}'", b.as_str()), - LitChar(c) => format!("'{}'", c.as_str()), - LitFloat(c) => c.as_str().into_string(), - LitInteger(c) => c.as_str().into_string(), - LitStr(s) => format!("\"{}\"", s.as_str()), - LitStrRaw(s, n) => format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n), - string=s.as_str()), - LitBinary(v) => format!("b\"{}\"", v.as_str()), - LitBinaryRaw(s, n) => format!("br{delim}\"{string}\"{delim}", - delim="#".repeat(n), - string=s.as_str()), - - /* Name components */ - Ident(s, _) => get_ident(s).get().into_string(), - Lifetime(s) => format!("{}", get_ident(s)), - Underscore => "_".into_string(), - - /* Other */ - DocComment(s) => s.as_str().into_string(), - Eof => "".into_string(), - Whitespace => " ".into_string(), - Comment => "/* */".into_string(), - Shebang(s) => format!("/* shebang: {}*/", s.as_str()), - - Interpolated(ref nt) => match *nt { - NtExpr(ref e) => ::print::pprust::expr_to_string(&**e), - NtMeta(ref e) => ::print::pprust::meta_item_to_string(&**e), - NtTy(ref e) => ::print::pprust::ty_to_string(&**e), - NtPath(ref e) => ::print::pprust::path_to_string(&**e), - NtItem(..) => "an interpolated item".into_string(), - NtBlock(..) => "an interpolated block".into_string(), - NtStmt(..) => "an interpolated statement".into_string(), - NtPat(..) => "an interpolated pattern".into_string(), - NtIdent(..) => "an interpolated identifier".into_string(), - NtTT(..) => "an interpolated tt".into_string(), - NtMatchers(..) => "an interpolated matcher sequence".into_string(), - } - } -} - // Get the first "argument" macro_rules! first { ( $first:expr, $( $remainder:expr, )* ) => ( $first ) diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 25ef8700ed005..a52987f5bd174 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -21,6 +21,7 @@ use attr::{AttrMetaMethods, AttributeMethods}; use codemap::{CodeMap, BytePos}; use codemap; use diagnostic; +use parse::token::{BinOpToken, Token}; use parse::token; use parse::lexer::comments; use parse; @@ -181,6 +182,101 @@ pub fn to_string(f: |&mut State| -> IoResult<()>) -> String { } } +pub fn binop_to_string(op: BinOpToken) -> &'static str { + match op { + token::Plus => "+", + token::Minus => "-", + token::Star => "*", + token::Slash => "/", + token::Percent => "%", + token::Caret => "^", + token::And => "&", + token::Or => "|", + token::Shl => "<<", + token::Shr => ">>", + } +} + +pub fn token_to_string(tok: &Token) -> String { + match *tok { + token::Eq => "=".into_string(), + token::Lt => "<".into_string(), + token::Le => "<=".into_string(), + token::EqEq => "==".into_string(), + token::Ne => "!=".into_string(), + token::Ge => ">=".into_string(), + token::Gt => ">".into_string(), + token::Not => "!".into_string(), + token::Tilde => "~".into_string(), + token::OrOr => "||".into_string(), + token::AndAnd => "&&".into_string(), + token::BinOp(op) => binop_to_string(op).into_string(), + token::BinOpEq(op) => format!("{}=", binop_to_string(op)), + + /* Structural symbols */ + token::At => "@".into_string(), + token::Dot => ".".into_string(), + token::DotDot => "..".into_string(), + token::DotDotDot => "...".into_string(), + token::Comma => ",".into_string(), + token::Semi => ";".into_string(), + token::Colon => ":".into_string(), + token::ModSep => "::".into_string(), + token::RArrow => "->".into_string(), + token::LArrow => "<-".into_string(), + token::FatArrow => "=>".into_string(), + token::LParen => "(".into_string(), + token::RParen => ")".into_string(), + token::LBracket => "[".into_string(), + token::RBracket => "]".into_string(), + token::LBrace => "{".into_string(), + token::RBrace => "}".into_string(), + token::Pound => "#".into_string(), + token::Dollar => "$".into_string(), + token::Question => "?".into_string(), + + /* Literals */ + token::LitByte(b) => format!("b'{}'", b.as_str()), + token::LitChar(c) => format!("'{}'", c.as_str()), + token::LitFloat(c) => c.as_str().into_string(), + token::LitInteger(c) => c.as_str().into_string(), + token::LitStr(s) => format!("\"{}\"", s.as_str()), + token::LitStrRaw(s, n) => format!("r{delim}\"{string}\"{delim}", + delim="#".repeat(n), + string=s.as_str()), + token::LitBinary(v) => format!("b\"{}\"", v.as_str()), + token::LitBinaryRaw(s, n) => format!("br{delim}\"{string}\"{delim}", + delim="#".repeat(n), + string=s.as_str()), + + /* Name components */ + token::Ident(s, _) => token::get_ident(s).get().into_string(), + token::Lifetime(s) => format!("{}", token::get_ident(s)), + token::Underscore => "_".into_string(), + + /* Other */ + token::DocComment(s) => s.as_str().into_string(), + token::Eof => "".into_string(), + token::Whitespace => " ".into_string(), + token::Comment => "/* */".into_string(), + token::Shebang(s) => format!("/* shebang: {}*/", s.as_str()), + + token::Interpolated(ref nt) => match *nt { + token::NtExpr(ref e) => expr_to_string(&**e), + token::NtMeta(ref e) => meta_item_to_string(&**e), + token::NtTy(ref e) => ty_to_string(&**e), + token::NtPath(ref e) => path_to_string(&**e), + token::NtItem(..) => "an interpolated item".into_string(), + token::NtBlock(..) => "an interpolated block".into_string(), + token::NtStmt(..) => "an interpolated statement".into_string(), + token::NtPat(..) => "an interpolated pattern".into_string(), + token::NtIdent(..) => "an interpolated identifier".into_string(), + token::NtTT(..) => "an interpolated tt".into_string(), + token::NtMatchers(..) => "an interpolated matcher sequence".into_string(), + } + } +} + // FIXME (Issue #16472): the thing_to_string_impls macro should go away // after we revise the syntax::ext::quote::ToToken impls to go directly // to token-trees instead of thing -> string -> token-trees. @@ -1026,14 +1122,14 @@ impl<'a> State<'a> { match *tt { ast::TtDelimited(_, ref delimed) => { let (ref open, ref tts, ref close) = **delimed; - try!(word(&mut self.s, parse::token::to_string(&open.token).as_slice())); + try!(word(&mut self.s, token_to_string(&open.token).as_slice())); try!(space(&mut self.s)); try!(self.print_tts(tts.as_slice())); try!(space(&mut self.s)); - word(&mut self.s, parse::token::to_string(&close.token).as_slice()) + word(&mut self.s, token_to_string(&close.token).as_slice()) }, ast::TtToken(_, ref tk) => { - try!(word(&mut self.s, parse::token::to_string(tk).as_slice())); + try!(word(&mut self.s, token_to_string(tk).as_slice())); match *tk { parse::token::DocComment(..) => { hardbreak(&mut self.s) @@ -1049,10 +1145,9 @@ impl<'a> State<'a> { try!(word(&mut self.s, ")")); match *separator { Some(ref tk) => { - try!(word(&mut self.s, - parse::token::to_string(tk).as_slice())); + try!(word(&mut self.s, token_to_string(tk).as_slice())); } - None => () + None => {}, } match kleene_op { ast::ZeroOrMore => word(&mut self.s, "*"),