fn token_name_eq(t1: &Token, t2: &Token) -> bool {
if let (Some((id1, is_raw1)), Some((id2, is_raw2))) = (t1.ident(), t2.ident()) {
id1.name == id2.name && is_raw1 == is_raw2
- } else if let (&token::Lifetime(id1), &token::Lifetime(id2)) = (t1, t2) {
+ } else if let (Some(id1), Some(id2)) = (t1.lifetime(), t2.lifetime()) {
id1.name == id2.name
} else {
*t1 == *t2
"path" => token::NtPath(panictry!(p.parse_path_common(PathStyle::Type, false))),
"meta" => token::NtMeta(panictry!(p.parse_meta_item())),
"vis" => token::NtVis(panictry!(p.parse_visibility(true))),
- "lifetime" => token::NtLifetime(p.expect_lifetime()),
+ "lifetime" => token::NtLifetime(p.expect_lifetime().ident),
// this is not supposed to happen, since it has been checked
// when compiling the macro.
_ => p.span_bug(sp, "invalid fragment specifier"),
token::NtPat(pat) => token::NtPat(fld.fold_pat(pat)),
token::NtExpr(expr) => token::NtExpr(fld.fold_expr(expr)),
token::NtTy(ty) => token::NtTy(fld.fold_ty(ty)),
- token::NtIdent(id, is_raw) => token::NtIdent(fld.fold_ident(id), is_raw),
+ token::NtIdent(ident, is_raw) => token::NtIdent(fld.fold_ident(ident), is_raw),
+ token::NtLifetime(ident) => token::NtLifetime(fld.fold_ident(ident)),
token::NtMeta(meta) => token::NtMeta(fld.fold_meta_item(meta)),
token::NtPath(path) => token::NtPath(fld.fold_path(path)),
token::NtTT(tt) => token::NtTT(fld.fold_tt(tt)),
token::NtWhereClause(fld.fold_where_clause(where_clause)),
token::NtArg(arg) => token::NtArg(fld.fold_arg(arg)),
token::NtVis(vis) => token::NtVis(fld.fold_vis(vis)),
- token::NtLifetime(lifetime) => token::NtLifetime(fld.fold_lifetime(lifetime)),
token::NtForeignItem(ni) =>
token::NtForeignItem(fld.fold_foreign_item(ni)
// see reasoning above
/// Parse single lifetime 'a or panic.
pub fn expect_lifetime(&mut self) -> Lifetime {
- if let Some(lifetime) = self.token.lifetime2(self.span) {
+ if let Some(ident) = self.token.lifetime() {
+ let span = self.span;
self.bump();
- lifetime
+ Lifetime { ident: Ident::new(ident.name, span), id: ast::DUMMY_NODE_ID }
} else {
self.span_bug(self.span, "not a lifetime")
}
}
fn eat_label(&mut self) -> Option<Label> {
- if let Some(lifetime) = self.token.lifetime2(self.span) {
+ if let Some(ident) = self.token.lifetime() {
+ let span = self.span;
self.bump();
- Some(Label { ident: lifetime.ident })
+ Some(Label { ident: Ident::new(ident.name, span) })
} else {
None
}
}
pub fn process_potential_macro_variable(&mut self) {
- let (ident, is_raw) = match self.token {
+ let (token, span) = match self.token {
token::Dollar if self.span.ctxt() != syntax_pos::hygiene::SyntaxContext::empty() &&
self.look_ahead(1, |t| t.is_ident()) => {
self.bump();
}
token::Interpolated(ref nt) => {
self.meta_var_span = Some(self.span);
+ // Interpolated identifier and lifetime tokens are replaced with usual identifier
+ // and lifetime tokens, so the former are never encountered during normal parsing.
match nt.0 {
- token::NtIdent(ident, is_raw) => (ident, is_raw),
+ token::NtIdent(ident, is_raw) => (token::Ident(ident, is_raw), ident.span),
+ token::NtLifetime(ident) => (token::Lifetime(ident), ident.span),
_ => return,
}
}
_ => return,
};
- self.token = token::Ident(ident, is_raw);
- self.span = ident.span;
+ self.token = token;
+ self.span = span;
}
/// parse a single token tree from the input.
}
}
- pub fn ident(&self) -> Option<(ast::Ident, bool)> {
+ /// Returns an identifier if this token is an identifier.
+ pub fn ident(&self) -> Option<(ast::Ident, /* is_raw */ bool)> {
match *self {
Ident(ident, is_raw) => Some((ident, is_raw)),
Interpolated(ref nt) => match nt.0 {
_ => None,
}
}
-
+ /// Returns a lifetime identifier if this token is a lifetime.
+ pub fn lifetime(&self) -> Option<ast::Ident> {
+ match *self {
+ Lifetime(ident) => Some(ident),
+ Interpolated(ref nt) => match nt.0 {
+ NtLifetime(ident) => Some(ident),
+ _ => None,
+ },
+ _ => None,
+ }
+ }
/// Returns `true` if the token is an identifier.
pub fn is_ident(&self) -> bool {
self.ident().is_some()
}
+ /// Returns `true` if the token is a lifetime.
+ pub fn is_lifetime(&self) -> bool {
+ self.lifetime().is_some()
+ }
/// Returns `true` if the token is a documentation comment.
pub fn is_doc_comment(&self) -> bool {
false
}
- /// Returns a lifetime with the span and a dummy id if it is a lifetime,
- /// or the original lifetime if it is an interpolated lifetime, ignoring
- /// the span.
- pub fn lifetime2(&self, span: Span) -> Option<ast::Lifetime> {
- match *self {
- Lifetime(ident) => Some(ast::Lifetime { id: ast::DUMMY_NODE_ID,
- ident: ast::Ident::new(ident.name, span) }),
- Interpolated(ref nt) => match nt.0 {
- NtLifetime(lifetime) => Some(lifetime),
- _ => None,
- },
- _ => None,
- }
- }
-
- /// Returns `true` if the token is a lifetime.
- pub fn is_lifetime(&self) -> bool {
- self.lifetime2(syntax_pos::DUMMY_SP).is_some()
- }
-
/// Returns `true` if the token is either the `mut` or `const` keyword.
pub fn is_mutability(&self) -> bool {
self.is_keyword(keywords::Mut) ||
}
}
+ /// Returns `true` if the token is either a special identifier or a keyword.
+ pub fn is_reserved_ident(&self) -> bool {
+ match self.ident() {
+ Some((id, false)) => is_reserved_ident(id),
+ _ => false,
+ }
+ }
+
pub fn glue(self, joint: Token) -> Option<Token> {
Some(match self {
Eq => match joint {
}
}
- /// Returns `true` if the token is either a special identifier or a keyword.
- pub fn is_reserved_ident(&self) -> bool {
- match self.ident() {
- Some((id, false)) => is_reserved_ident(id),
- _ => false,
- }
- }
-
pub fn interpolated_to_tokenstream(&self, sess: &ParseSess, span: Span)
-> TokenStream
{
let token = Token::Ident(ident, is_raw);
tokens = Some(TokenTree::Token(ident.span, token).into());
}
- Nonterminal::NtLifetime(lifetime) => {
- let token = Token::Lifetime(lifetime.ident);
- tokens = Some(TokenTree::Token(lifetime.ident.span, token).into());
+ Nonterminal::NtLifetime(ident) => {
+ let token = Token::Lifetime(ident);
+ tokens = Some(TokenTree::Token(ident.span, token).into());
}
Nonterminal::NtTT(ref tt) => {
tokens = Some(tt.clone().into());
NtExpr(P<ast::Expr>),
NtTy(P<ast::Ty>),
NtIdent(ast::Ident, /* is_raw */ bool),
+ NtLifetime(ast::Ident),
/// Stuff inside brackets for attributes
NtMeta(ast::MetaItem),
NtPath(ast::Path),
NtGenerics(ast::Generics),
NtWhereClause(ast::WhereClause),
NtArg(ast::Arg),
- NtLifetime(ast::Lifetime),
}
impl fmt::Debug for Nonterminal {
token::NtPat(ref e) => pat_to_string(e),
token::NtIdent(e, false) => ident_to_string(e),
token::NtIdent(e, true) => format!("r#{}", ident_to_string(e)),
+ token::NtLifetime(e) => ident_to_string(e),
token::NtTT(ref tree) => tt_to_string(tree.clone()),
token::NtArm(ref e) => arm_to_string(e),
token::NtImplItem(ref e) => impl_item_to_string(e),
token::NtWhereClause(ref e) => where_clause_to_string(e),
token::NtArg(ref e) => arg_to_string(e),
token::NtVis(ref e) => vis_to_string(e),
- token::NtLifetime(ref e) => lifetime_to_string(e),
token::NtForeignItem(ref e) => foreign_item_to_string(e),
}
}