Copy over latest parser.rs
diff --git a/tests/cases/parser.rs b/tests/cases/parser.rs
index 7efba40..9980566 100644
--- a/tests/cases/parser.rs
+++ b/tests/cases/parser.rs
@@ -48,8 +48,7 @@
use parse::common::SeqSep;
use parse::lexer::{Reader, TokenAndSpan};
use parse::obsolete::ObsoleteSyntax;
-use parse::token::{self, intern, MatchNt, SubstNt, SpecialVarNt, InternedString};
-use parse::token::{keywords, SpecialMacroVar};
+use parse::token::{self, intern, keywords, MatchNt, SubstNt, InternedString};
use parse::{new_sub_parser_from_file, ParseSess};
use util::parser::{AssocOp, Fixity};
use print::pprust;
@@ -238,7 +237,7 @@
}
#[derive(PartialEq)]
-enum LastTokenKind {
+enum PrevTokenKind {
DocComment,
Comma,
Interpolated,
@@ -246,6 +245,22 @@
Other,
}
+// Simple circular buffer used for keeping few next tokens.
+#[derive(Default)]
+struct LookaheadBuffer {
+ buffer: [TokenAndSpan; LOOKAHEAD_BUFFER_CAPACITY],
+ start: usize,
+ end: usize,
+}
+
+const LOOKAHEAD_BUFFER_CAPACITY: usize = 8;
+
+impl LookaheadBuffer {
+ fn len(&self) -> usize {
+ (LOOKAHEAD_BUFFER_CAPACITY + self.end - self.start) % LOOKAHEAD_BUFFER_CAPACITY
+ }
+}
+
/* ident is handled by common.rs */
pub struct Parser<'a> {
@@ -254,14 +269,12 @@
pub token: token::Token,
/// the span of the current token:
pub span: Span,
- /// the span of the prior token:
- pub last_span: Span,
+ /// the span of the previous token:
+ pub prev_span: Span,
pub cfg: CrateConfig,
/// the previous token kind
- last_token_kind: LastTokenKind,
- pub buffer: [TokenAndSpan; 4],
- pub buffer_start: isize,
- pub buffer_end: isize,
+ prev_token_kind: PrevTokenKind,
+ lookahead_buffer: LookaheadBuffer,
pub tokens_consumed: usize,
pub restrictions: Restrictions,
pub quote_depth: usize, // not (yet) related to the quasiquoter
@@ -357,10 +370,6 @@
_ => PathBuf::from(sess.codemap().span_to_filename(span)),
};
directory.pop();
- let placeholder = TokenAndSpan {
- tok: token::Underscore,
- sp: span,
- };
Parser {
reader: rdr,
@@ -368,16 +377,9 @@
cfg: cfg,
token: tok0.tok,
span: span,
- last_span: span,
- last_token_kind: LastTokenKind::Other,
- buffer: [
- placeholder.clone(),
- placeholder.clone(),
- placeholder.clone(),
- placeholder.clone(),
- ],
- buffer_start: 0,
- buffer_end: 0,
+ prev_span: span,
+ prev_token_kind: PrevTokenKind::Other,
+ lookahead_buffer: Default::default(),
tokens_consumed: 0,
restrictions: Restrictions::empty(),
quote_depth: 0,
@@ -414,8 +416,7 @@
pub fn unexpected_last<T>(&self, t: &token::Token) -> PResult<'a, T> {
let token_str = Parser::token_to_string(t);
- let last_span = self.last_span;
- Err(self.span_fatal(last_span, &format!("unexpected token: `{}`", token_str)))
+ Err(self.span_fatal(self.prev_span, &format!("unexpected token: `{}`", token_str)))
}
pub fn unexpected<T>(&mut self) -> PResult<'a, T> {
@@ -505,8 +506,8 @@
expr: PResult<'a, P<Expr>>)
-> PResult<'a, (Span, P<Expr>)> {
expr.map(|e| {
- if self.last_token_kind == LastTokenKind::Interpolated {
- (self.last_span, e)
+ if self.prev_token_kind == PrevTokenKind::Interpolated {
+ (self.prev_span, e)
} else {
(e.span, e)
}
@@ -525,8 +526,8 @@
self.bug("ident interpolation not converted to real token");
}
_ => {
- Err(if self.last_token_kind == LastTokenKind::DocComment {
- self.span_fatal_help(self.last_span,
+ Err(if self.prev_token_kind == PrevTokenKind::DocComment {
+ self.span_fatal_help(self.prev_span,
"found a documentation comment that doesn't document anything",
"doc comments must come before what they document, maybe a comment was intended with `//`?")
} else {
@@ -741,7 +742,7 @@
// would encounter a `>` and stop. This lets the parser handle trailing
// commas in generic parameters, because it can stop either after
// parsing a type or after parsing a comma.
- for i in (0..) {
+ for i in 0.. {
if self.check(&token::Gt)
|| self.token == token::BinOp(token::Shr)
|| self.token == token::Ge
@@ -922,35 +923,29 @@
/// Advance the parser by one token
pub fn bump(&mut self) {
- if self.last_token_kind == LastTokenKind::Eof {
+ if self.prev_token_kind == PrevTokenKind::Eof {
// Bumping after EOF is a bad sign, usually an infinite loop.
self.bug("attempted to bump the parser past EOF (may be stuck in a loop)");
}
- self.last_span = self.span;
+ self.prev_span = self.span;
// Record last token kind for possible error recovery.
- self.last_token_kind = match self.token {
- token::DocComment(..) => LastTokenKind::DocComment,
- token::Comma => LastTokenKind::Comma,
- token::Interpolated(..) => LastTokenKind::Interpolated,
- token::Eof => LastTokenKind::Eof,
- _ => LastTokenKind::Other,
+ self.prev_token_kind = match self.token {
+ token::DocComment(..) => PrevTokenKind::DocComment,
+ token::Comma => PrevTokenKind::Comma,
+ token::Interpolated(..) => PrevTokenKind::Interpolated,
+ token::Eof => PrevTokenKind::Eof,
+ _ => PrevTokenKind::Other,
};
- let next = if self.buffer_start == self.buffer_end {
+ let next = if self.lookahead_buffer.start == self.lookahead_buffer.end {
self.reader.real_token()
} else {
// Avoid token copies with `replace`.
- let buffer_start = self.buffer_start as usize;
- let next_index = (buffer_start + 1) & 3;
- self.buffer_start = next_index as isize;
-
- let placeholder = TokenAndSpan {
- tok: token::Underscore,
- sp: self.span,
- };
- mem::replace(&mut self.buffer[buffer_start], placeholder)
+ let old_start = self.lookahead_buffer.start;
+ self.lookahead_buffer.start = (old_start + 1) % LOOKAHEAD_BUFFER_CAPACITY;
+ mem::replace(&mut self.lookahead_buffer.buffer[old_start], Default::default())
};
self.span = next.sp;
self.token = next.tok;
@@ -973,31 +968,32 @@
next: token::Token,
lo: BytePos,
hi: BytePos) {
- self.last_span = mk_sp(self.span.lo, lo);
+ self.prev_span = mk_sp(self.span.lo, lo);
// It would be incorrect to record the kind of the current token, but
// fortunately for tokens currently using `bump_with`, the
- // last_token_kind will be of no use anyway.
- self.last_token_kind = LastTokenKind::Other;
+ // prev_token_kind will be of no use anyway.
+ self.prev_token_kind = PrevTokenKind::Other;
self.span = mk_sp(lo, hi);
self.token = next;
self.expected_tokens.clear();
}
- pub fn buffer_length(&mut self) -> isize {
- if self.buffer_start <= self.buffer_end {
- return self.buffer_end - self.buffer_start;
- }
- return (4 - self.buffer_start) + self.buffer_end;
- }
- pub fn look_ahead<R, F>(&mut self, distance: usize, f: F) -> R where
+ pub fn look_ahead<R, F>(&mut self, dist: usize, f: F) -> R where
F: FnOnce(&token::Token) -> R,
{
- let dist = distance as isize;
- while self.buffer_length() < dist {
- self.buffer[self.buffer_end as usize] = self.reader.real_token();
- self.buffer_end = (self.buffer_end + 1) & 3;
+ if dist == 0 {
+ f(&self.token)
+ } else if dist < LOOKAHEAD_BUFFER_CAPACITY {
+ while self.lookahead_buffer.len() < dist {
+ self.lookahead_buffer.buffer[self.lookahead_buffer.end] = self.reader.real_token();
+ self.lookahead_buffer.end =
+ (self.lookahead_buffer.end + 1) % LOOKAHEAD_BUFFER_CAPACITY;
+ }
+ let index = (self.lookahead_buffer.start + dist - 1) % LOOKAHEAD_BUFFER_CAPACITY;
+ f(&self.lookahead_buffer.buffer[index].tok)
+ } else {
+ self.bug("lookahead distance is too large");
}
- f(&self.buffer[((self.buffer_start + dist - 1) & 3) as usize].tok)
}
pub fn fatal(&self, m: &str) -> DiagnosticBuilder<'a> {
self.sess.span_diagnostic.struct_span_fatal(self.span, m)
@@ -1113,14 +1109,12 @@
let bounds = self.parse_ty_param_bounds(BoundParsingMode::Modified)?;
if !bounds.iter().any(|b| if let TraitTyParamBound(..) = *b { true } else { false }) {
- let last_span = self.last_span;
- self.span_err(last_span, "at least one trait must be specified");
+ self.span_err(self.prev_span, "at least one trait must be specified");
}
Ok(ast::TyKind::ImplTrait(bounds))
}
-
pub fn parse_ty_path(&mut self) -> PResult<'a, TyKind> {
Ok(TyKind::Path(None, self.parse_path(PathStyle::Type)?))
}
@@ -1212,7 +1206,7 @@
self.expect(&token::Semi)?
}
- let mac = spanned(lo, self.last_span.hi, Mac_ { path: pth, tts: tts });
+ let mac = spanned(lo, self.prev_span.hi, Mac_ { path: pth, tts: tts });
(keywords::Invalid.ident(), ast::TraitItemKind::Macro(mac))
} else {
let (constness, unsafety, abi) = match self.parse_fn_front_matter() {
@@ -1282,7 +1276,7 @@
ident: name,
attrs: attrs,
node: node,
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
})
}
@@ -1329,12 +1323,12 @@
// In type grammar, `+` is treated like a binary operator,
// and hence both L and R side are required.
if bounds.is_empty() {
- let last_span = self.last_span;
- self.span_err(last_span,
+ let prev_span = self.prev_span;
+ self.span_err(prev_span,
"at least one type parameter bound must be specified");
}
- let sp = mk_sp(lo, self.last_span.hi);
+ let sp = mk_sp(lo, self.prev_span.hi);
let sum = ast::TyKind::ObjectSum(lhs, bounds);
Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
}
@@ -1436,7 +1430,7 @@
return Err(self.fatal(&msg));
};
- let sp = mk_sp(lo, self.last_span.hi);
+ let sp = mk_sp(lo, self.prev_span.hi);
Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: t, span: sp}))
}
@@ -1454,7 +1448,7 @@
} else if self.eat_keyword(keywords::Const) {
Mutability::Immutable
} else {
- let span = self.last_span;
+ let span = self.prev_span;
self.span_err(span,
"expected mut or const in raw pointer type (use `*mut T` or `*const T` as appropriate)");
Mutability::Immutable
@@ -1496,7 +1490,7 @@
pat
} else {
debug!("parse_arg_general ident_to_pat");
- let sp = self.last_span;
+ let sp = self.prev_span;
let spanned = Spanned { span: sp, node: keywords::Invalid.ident() };
P(Pat {
id: ast::DUMMY_NODE_ID,
@@ -1621,7 +1615,7 @@
let lit = self.parse_lit_token()?;
lit
};
- Ok(codemap::Spanned { node: lit, span: mk_sp(lo, self.last_span.hi) })
+ Ok(codemap::Spanned { node: lit, span: mk_sp(lo, self.prev_span.hi) })
}
/// matches '-' lit | lit
@@ -1630,11 +1624,11 @@
let minus_present = self.eat(&token::BinOp(token::Minus));
let lo = self.span.lo;
let literal = P(self.parse_lit()?);
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let expr = self.mk_expr(lo, hi, ExprKind::Lit(literal), ThinVec::new());
if minus_present {
- let minus_hi = self.last_span.hi;
+ let minus_hi = self.prev_span.hi;
let unary = self.mk_unary(UnOp::Neg, expr);
Ok(self.mk_expr(minus_lo, minus_hi, unary, ThinVec::new()))
} else {
@@ -1669,7 +1663,7 @@
/// `<T as U>::F::a::<S>`
pub fn parse_qualified_path(&mut self, mode: PathStyle)
-> PResult<'a, (QSelf, ast::Path)> {
- let span = self.last_span;
+ let span = self.prev_span;
let self_type = self.parse_ty_sum()?;
let mut path = if self.eat_keyword(keywords::As) {
self.parse_path(PathStyle::Type)?
@@ -1702,7 +1696,7 @@
};
path.segments.extend(segments);
- path.span.hi = self.last_span.hi;
+ path.span.hi = self.prev_span.hi;
Ok((qself, path))
}
@@ -1740,7 +1734,7 @@
};
// Assemble the span.
- let span = mk_sp(lo, self.last_span.hi);
+ let span = mk_sp(lo, self.prev_span.hi);
// Assemble the result.
Ok(ast::Path {
@@ -1770,7 +1764,7 @@
bindings: P::from_vec(bindings),
})
} else if self.eat(&token::OpenDelim(token::Paren)) {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
let inputs = self.parse_seq_to_end(
&token::CloseDelim(token::Paren),
@@ -1783,7 +1777,7 @@
None
};
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
ast::PathParameters::Parenthesized(ast::ParenthesizedParameterData {
span: mk_sp(lo, hi),
@@ -2013,7 +2007,7 @@
pub fn parse_field(&mut self) -> PResult<'a, Field> {
let lo = self.span.lo;
let i = self.parse_field_name()?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
self.expect(&token::Colon)?;
let e = self.parse_expr()?;
Ok(ast::Field {
@@ -2167,7 +2161,7 @@
}
self.bump();
- hi = self.last_span.hi;
+ hi = self.prev_span.hi;
return if es.len() == 1 && !trailing_comma {
Ok(self.mk_expr(lo, hi, ExprKind::Paren(es.into_iter().nth(0).unwrap()), attrs))
} else {
@@ -2216,7 +2210,7 @@
ex = ExprKind::Vec(vec!(first_expr));
}
}
- hi = self.last_span.hi;
+ hi = self.prev_span.hi;
}
_ => {
if self.eat_lt() {
@@ -2226,18 +2220,18 @@
return Ok(self.mk_expr(lo, hi, ExprKind::Path(Some(qself), path), attrs));
}
if self.eat_keyword(keywords::Move) {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
return self.parse_lambda_expr(lo, CaptureBy::Value, attrs);
}
if self.eat_keyword(keywords::If) {
return self.parse_if_expr(attrs);
}
if self.eat_keyword(keywords::For) {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
return self.parse_for_expr(None, lo, attrs);
}
if self.eat_keyword(keywords::While) {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
return self.parse_while_expr(None, lo, attrs);
}
if self.token.is_lifetime() {
@@ -2258,7 +2252,7 @@
return Err(self.fatal("expected `while`, `for`, or `loop` after a label"))
}
if self.eat_keyword(keywords::Loop) {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
return self.parse_loop_expr(None, lo, attrs);
}
if self.eat_keyword(keywords::Continue) {
@@ -2272,7 +2266,7 @@
} else {
ExprKind::Continue(None)
};
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
return Ok(self.mk_expr(lo, hi, ex, attrs));
}
if self.eat_keyword(keywords::Match) {
@@ -2302,7 +2296,7 @@
} else {
ex = ExprKind::Break(None);
}
- hi = self.last_span.hi;
+ hi = self.prev_span.hi;
} else if self.token.is_keyword(keywords::Let) {
// Catch this syntax error here, instead of in `check_strict_keywords`, so
// that we can explicitly mention that let is not to be used as an expression
@@ -2319,7 +2313,7 @@
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(),
|p| p.parse_token_tree())?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
return Ok(self.mk_mac_expr(lo, hi, Mac_ { path: pth, tts: tts }, attrs));
}
if self.check(&token::OpenDelim(token::Brace)) {
@@ -2483,8 +2477,8 @@
};
if !bindings.is_empty() {
- let last_span = self.last_span;
- self.span_err(last_span, "type bindings are only permitted on trait paths");
+ let prev_span = self.prev_span;
+ self.span_err(prev_span, "type bindings are only permitted on trait paths");
}
Ok(match self.token {
@@ -2496,7 +2490,7 @@
SeqSep::trailing_allowed(token::Comma),
|p| Ok(p.parse_expr()?)
)?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
es.insert(0, self_value);
let id = spanned(ident_span.lo, ident_span.hi, ident);
@@ -2506,8 +2500,8 @@
// Field access.
_ => {
if !tys.is_empty() {
- let last_span = self.last_span;
- self.span_err(last_span,
+ let prev_span = self.prev_span;
+ self.span_err(prev_span,
"field expressions may not have type parameters");
}
@@ -2524,7 +2518,7 @@
loop {
// expr?
while self.eat(&token::Question) {
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
e = self.mk_expr(lo, hi, ExprKind::Try(e), ThinVec::new());
}
@@ -2532,7 +2526,7 @@
if self.eat(&token::Dot) {
match self.token {
token::Ident(i) => {
- let dot_pos = self.last_span.hi;
+ let dot_pos = self.prev_span.hi;
hi = self.span.hi;
self.bump();
@@ -2544,7 +2538,7 @@
// A tuple index may not have a suffix
self.expect_no_suffix(sp, "tuple index", suf);
- let dot = self.last_span.hi;
+ let dot = self.prev_span.hi;
hi = self.span.hi;
self.bump();
@@ -2556,16 +2550,16 @@
e = self.mk_expr(lo, hi, field, ThinVec::new());
}
None => {
- let last_span = self.last_span;
- self.span_err(last_span, "invalid tuple or tuple struct index");
+ let prev_span = self.prev_span;
+ self.span_err(prev_span, "invalid tuple or tuple struct index");
}
}
}
token::Literal(token::Float(n), _suf) => {
self.bump();
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let fstr = n.as_str();
- let mut err = self.diagnostic().struct_span_err(last_span,
+ let mut err = self.diagnostic().struct_span_err(prev_span,
&format!("unexpected token: `{}`", n.as_str()));
if fstr.chars().all(|x| "0123456789.".contains(x)) {
let float = match fstr.parse::<f64>().ok() {
@@ -2584,7 +2578,7 @@
let actual = self.this_token_to_string();
self.span_err(self.span, &format!("unexpected token: `{}`", actual));
- let dot_pos = self.last_span.hi;
+ let dot_pos = self.prev_span.hi;
e = self.parse_dot_suffix(keywords::Invalid.ident(),
mk_sp(dot_pos, dot_pos),
e, lo)?;
@@ -2602,7 +2596,7 @@
SeqSep::trailing_allowed(token::Comma),
|p| Ok(p.parse_expr()?)
)?;
- hi = self.last_span.hi;
+ hi = self.prev_span.hi;
let nd = self.mk_call(e, es);
e = self.mk_expr(lo, hi, nd, ThinVec::new());
@@ -2648,8 +2642,12 @@
num_captures: name_num
})));
} else if self.token.is_keyword(keywords::Crate) {
+ let ident = match self.token {
+ token::Ident(id) => ast::Ident { name: token::intern("$crate"), ..id },
+ _ => unreachable!(),
+ };
self.bump();
- return Ok(TokenTree::Token(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar)));
+ return Ok(TokenTree::Token(sp, token::Ident(ident)));
} else {
sp = mk_sp(sp.lo, self.span.hi);
self.parse_ident().unwrap_or_else(|mut e| {
@@ -2945,8 +2943,8 @@
self.expected_tokens.push(TokenType::Operator);
while let Some(op) = AssocOp::from_token(&self.token) {
- let lhs_span = if self.last_token_kind == LastTokenKind::Interpolated {
- self.last_span
+ let lhs_span = if self.prev_token_kind == PrevTokenKind::Interpolated {
+ self.prev_span
} else {
lhs.span
};
@@ -3139,7 +3137,7 @@
if self.check_keyword(keywords::Let) {
return self.parse_if_let_expr(attrs);
}
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
let cond = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL, None)?;
let thn = self.parse_block()?;
let mut els: Option<P<Expr>> = None;
@@ -3155,7 +3153,7 @@
/// Parse an 'if let' expression ('if' token already eaten)
pub fn parse_if_let_expr(&mut self, attrs: ThinVec<Attribute>)
-> PResult<'a, P<Expr>> {
- let lo = self.last_span.lo;
+ let lo = self.prev_span.lo;
self.expect_keyword(keywords::Let)?;
let pat = self.parse_pat()?;
self.expect(&token::Eq)?;
@@ -3178,7 +3176,7 @@
-> PResult<'a, P<Expr>>
{
let decl = self.parse_fn_block_decl()?;
- let decl_hi = self.last_span.hi;
+ let decl_hi = self.prev_span.hi;
let body = match decl.output {
FunctionRetTy::Default(_) => {
// If no explicit return type is given, parse any
@@ -3231,7 +3229,7 @@
let (iattrs, loop_block) = self.parse_inner_attrs_and_block()?;
attrs.extend(iattrs);
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
Ok(self.mk_expr(span_lo, hi,
ExprKind::ForLoop(pat, expr, loop_block, opt_ident),
@@ -3279,8 +3277,8 @@
// `match` token already eaten
fn parse_match_expr(&mut self, mut attrs: ThinVec<Attribute>) -> PResult<'a, P<Expr>> {
- let match_span = self.last_span;
- let lo = self.last_span.lo;
+ let match_span = self.prev_span;
+ let lo = self.prev_span.lo;
let discriminant = self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL,
None)?;
if let Err(mut e) = self.expect(&token::OpenDelim(token::Brace)) {
@@ -3402,7 +3400,7 @@
}
} else if ddpos.is_some() && self.eat(&token::DotDot) {
// Emit a friendly error, ignore `..` and continue parsing
- self.span_err(self.last_span, "`..` can only be used once per tuple or tuple struct pattern");
+ self.span_err(self.prev_span, "`..` can only be used once per tuple or tuple struct pattern");
} else {
fields.push(self.parse_pat()?);
}
@@ -3512,7 +3510,7 @@
let is_ref = self.eat_keyword(keywords::Ref);
let is_mut = self.eat_keyword(keywords::Mut);
let fieldname = self.parse_ident()?;
- hi = self.last_span.hi;
+ hi = self.prev_span.hi;
let bind_type = match (is_ref, is_mut) {
(true, true) => BindingMode::ByRef(Mutability::Mutable),
@@ -3520,7 +3518,7 @@
(false, true) => BindingMode::ByValue(Mutability::Mutable),
(false, false) => BindingMode::ByValue(Mutability::Immutable),
};
- let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
+ let fieldpath = codemap::Spanned{span:self.prev_span, node:fieldname};
let fieldpat = P(ast::Pat{
id: ast::DUMMY_NODE_ID,
node: PatKind::Ident(bind_type, fieldpath, None),
@@ -3559,7 +3557,7 @@
// Parse an unqualified path
(None, self.parse_path(PathStyle::Expr)?)
};
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
Ok(self.mk_expr(lo, hi, ExprKind::Path(qself, path), ThinVec::new()))
} else {
self.parse_pat_literal_maybe_minus()
@@ -3614,7 +3612,7 @@
// Parse box pat
let subpat = self.parse_pat()?;
pat = PatKind::Box(subpat);
- } else if self.token.is_ident() && self.token.is_path_start() &&
+ } else if self.token.is_ident() && !self.token.is_any_keyword() &&
self.look_ahead(1, |t| match *t {
token::OpenDelim(token::Paren) | token::OpenDelim(token::Brace) |
token::DotDotDot | token::ModSep | token::Not => false,
@@ -3643,12 +3641,12 @@
let tts = self.parse_seq_to_end(&token::CloseDelim(delim),
SeqSep::none(),
|p| p.parse_token_tree())?;
- let mac = spanned(lo, self.last_span.hi, Mac_ { path: path, tts: tts });
+ let mac = spanned(lo, self.prev_span.hi, Mac_ { path: path, tts: tts });
pat = PatKind::Mac(mac);
}
token::DotDotDot => {
// Parse range
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let begin =
self.mk_expr(lo, hi, ExprKind::Path(qself, path), ThinVec::new());
self.bump();
@@ -3701,7 +3699,7 @@
}
}
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
Ok(P(ast::Pat {
id: ast::DUMMY_NODE_ID,
node: pat,
@@ -3716,8 +3714,8 @@
binding_mode: ast::BindingMode)
-> PResult<'a, PatKind> {
let ident = self.parse_ident()?;
- let last_span = self.last_span;
- let name = codemap::Spanned{span: last_span, node: ident};
+ let prev_span = self.prev_span;
+ let name = codemap::Spanned{span: prev_span, node: ident};
let sub = if self.eat(&token::At) {
Some(self.parse_pat()?)
} else {
@@ -3731,9 +3729,8 @@
// binding mode then we do not end up here, because the lookahead
// will direct us over to parse_enum_variant()
if self.token == token::OpenDelim(token::Paren) {
- let last_span = self.last_span;
return Err(self.span_fatal(
- last_span,
+ self.prev_span,
"expected identifier, found enum pattern"))
}
@@ -3755,7 +3752,7 @@
pat: pat,
init: init,
id: ast::DUMMY_NODE_ID,
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
attrs: attrs,
}))
}
@@ -3770,7 +3767,7 @@
self.expect(&token::Colon)?;
let ty = self.parse_ty_sum()?;
Ok(StructField {
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
ident: Some(name),
vis: vis,
id: ast::DUMMY_NODE_ID,
@@ -3788,7 +3785,7 @@
_ => "expected item after attributes",
};
- self.span_err(self.last_span, message);
+ self.span_err(self.prev_span, message);
}
/// Parse a statement. This stops just before trailing semicolons on everything but items.
@@ -3866,6 +3863,11 @@
})
}
+ fn is_union_item(&mut self) -> bool {
+ self.token.is_keyword(keywords::Union) &&
+ self.look_ahead(1, |t| t.is_ident() && !t.is_any_keyword())
+ }
+
fn parse_stmt_without_recovery(&mut self,
macro_legacy_warnings: bool)
-> PResult<'a, Option<Stmt>> {
@@ -3878,19 +3880,19 @@
Stmt {
id: ast::DUMMY_NODE_ID,
node: StmtKind::Local(self.parse_local(attrs.into())?),
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
}
- } else if self.token.is_path_start() && self.token != token::Lt && {
- !self.check_keyword(keywords::Union) ||
- self.look_ahead(1, |t| *t == token::Not || *t == token::ModSep)
- } {
+ // Starts like a simple path, but not a union item.
+ } else if self.token.is_path_start() &&
+ !self.token.is_qpath_start() &&
+ !self.is_union_item() {
let pth = self.parse_path(PathStyle::Expr)?;
if !self.eat(&token::Not) {
let expr = if self.check(&token::OpenDelim(token::Brace)) {
self.parse_struct_expr(lo, pth, ThinVec::new())?
} else {
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
self.mk_expr(lo, hi, ExprKind::Path(None, pth), ThinVec::new())
};
@@ -3902,7 +3904,7 @@
return Ok(Some(Stmt {
id: ast::DUMMY_NODE_ID,
node: StmtKind::Expr(expr),
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
}));
}
@@ -3938,7 +3940,7 @@
SeqSep::none(),
|p| p.parse_token_tree()
)?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let style = if delim == token::Brace {
MacStmtStyle::Braces
@@ -3983,8 +3985,7 @@
// Require a semicolon or braces.
if style != MacStmtStyle::Braces {
if !self.eat(&token::Semi) {
- let last_span = self.last_span;
- self.span_err(last_span,
+ self.span_err(self.prev_span,
"macros that expand to items must either be surrounded with braces or followed by a semicolon");
}
}
@@ -4013,8 +4014,8 @@
None => {
let unused_attrs = |attrs: &[_], s: &mut Self| {
if attrs.len() > 0 {
- if s.last_token_kind == LastTokenKind::DocComment {
- s.span_err_help(s.last_span,
+ if s.prev_token_kind == PrevTokenKind::DocComment {
+ s.span_err_help(s.prev_span,
"found a documentation comment that doesn't document anything",
"doc comments must come before what they document, maybe a comment was intended with `//`?");
} else {
@@ -4076,7 +4077,7 @@
let mut stmt_span = stmt.span;
// expand the span to include the semicolon, if it exists
if self.eat(&token::Semi) {
- stmt_span.hi = self.last_span.hi;
+ stmt_span.hi = self.prev_span.hi;
}
e.span_help(stmt_span, "try placing this code inside a block");
}
@@ -4122,7 +4123,7 @@
stmts: stmts,
id: ast::DUMMY_NODE_ID,
rules: s,
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
}))
}
@@ -4161,7 +4162,7 @@
stmt = stmt.add_trailing_semicolon();
}
- stmt.span.hi = self.last_span.hi;
+ stmt.span.hi = self.prev_span.hi;
Ok(Some(stmt))
}
@@ -4297,8 +4298,8 @@
if ty_param.default.is_some() {
seen_default = true;
} else if seen_default {
- let last_span = p.last_span;
- p.span_err(last_span,
+ let prev_span = p.prev_span;
+ p.span_err(prev_span,
"type parameters with a default must be trailing");
}
Ok(ty_param)
@@ -4316,7 +4317,7 @@
id: ast::DUMMY_NODE_ID,
predicates: Vec::new(),
},
- span: mk_sp(span_lo, self.last_span.hi),
+ span: mk_sp(span_lo, self.prev_span.hi),
})
} else {
Ok(ast::Generics::default())
@@ -4331,7 +4332,7 @@
let missing_comma = !lifetimes.is_empty() &&
!self.token.is_like_gt() &&
- self.last_token_kind != LastTokenKind::Comma;
+ self.prev_token_kind != PrevTokenKind::Comma;
if missing_comma {
@@ -4434,7 +4435,7 @@
let bounds =
self.parse_lifetimes(token::BinOp(token::Plus))?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let span = mk_sp(lo, hi);
where_clause.predicates.push(ast::WherePredicate::RegionPredicate(
@@ -4463,7 +4464,7 @@
if self.eat(&token::Colon) {
let bounds = self.parse_ty_param_bounds(BoundParsingMode::Bare)?;
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let span = mk_sp(lo, hi);
if bounds.is_empty() {
@@ -4482,7 +4483,7 @@
parsed_something = true;
} else if self.eat(&token::Eq) {
// let ty = try!(self.parse_ty());
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let span = mk_sp(lo, hi);
// where_clause.predicates.push(
// ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
@@ -4496,8 +4497,8 @@
self.span_err(span,
"equality constraints are not yet supported in where clauses (#20041)");
} else {
- let last_span = self.last_span;
- self.span_err(last_span,
+ let prev_span = self.prev_span;
+ self.span_err(prev_span,
"unexpected token in `where` clause");
}
}
@@ -4509,8 +4510,8 @@
}
if !parsed_something {
- let last_span = self.last_span;
- self.span_err(last_span,
+ let prev_span = self.prev_span;
+ self.span_err(prev_span,
"a `where` clause must have at least one predicate in it");
}
@@ -4582,9 +4583,13 @@
fn parse_self_arg(&mut self) -> PResult<'a, Option<Arg>> {
let expect_ident = |this: &mut Self| match this.token {
// Preserve hygienic context.
- token::Ident(ident) => { this.bump(); codemap::respan(this.last_span, ident) }
+ token::Ident(ident) => { this.bump(); codemap::respan(this.prev_span, ident) }
_ => unreachable!()
};
+ let isolated_self = |this: &mut Self, n| {
+ this.look_ahead(n, |t| t.is_keyword(keywords::SelfValue)) &&
+ this.look_ahead(n + 1, |t| t != &token::ModSep)
+ };
// Parse optional self parameter of a method.
// Only a limited set of initial token sequences is considered self parameters, anything
@@ -4597,22 +4602,22 @@
// &'lt self
// &'lt mut self
// ¬_self
- if self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
+ if isolated_self(self, 1) {
self.bump();
(SelfKind::Region(None, Mutability::Immutable), expect_ident(self))
} else if self.look_ahead(1, |t| t.is_keyword(keywords::Mut)) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
+ isolated_self(self, 2) {
self.bump();
self.bump();
(SelfKind::Region(None, Mutability::Mutable), expect_ident(self))
} else if self.look_ahead(1, |t| t.is_lifetime()) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
+ isolated_self(self, 2) {
self.bump();
let lt = self.parse_lifetime()?;
(SelfKind::Region(Some(lt), Mutability::Immutable), expect_ident(self))
} else if self.look_ahead(1, |t| t.is_lifetime()) &&
self.look_ahead(2, |t| t.is_keyword(keywords::Mut)) &&
- self.look_ahead(3, |t| t.is_keyword(keywords::SelfValue)) {
+ isolated_self(self, 3) {
self.bump();
let lt = self.parse_lifetime()?;
self.bump();
@@ -4627,12 +4632,12 @@
// *mut self
// *not_self
// Emit special error for `self` cases.
- if self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
+ if isolated_self(self, 1) {
self.bump();
self.span_err(self.span, "cannot pass `self` by raw pointer");
(SelfKind::Value(Mutability::Immutable), expect_ident(self))
} else if self.look_ahead(1, |t| t.is_mutability()) &&
- self.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
+ isolated_self(self, 2) {
self.bump();
self.bump();
self.span_err(self.span, "cannot pass `self` by raw pointer");
@@ -4642,7 +4647,7 @@
}
}
token::Ident(..) => {
- if self.token.is_keyword(keywords::SelfValue) {
+ if isolated_self(self, 0) {
// self
// self: TYPE
let eself_ident = expect_ident(self);
@@ -4653,7 +4658,7 @@
(SelfKind::Value(Mutability::Immutable), eself_ident)
}
} else if self.token.is_keyword(keywords::Mut) &&
- self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
+ isolated_self(self, 1) {
// mut self
// mut self: TYPE
self.bump();
@@ -4671,7 +4676,7 @@
_ => return Ok(None),
};
- let eself = codemap::respan(mk_sp(eself_lo, self.last_span.hi), eself);
+ let eself = codemap::respan(mk_sp(eself_lo, self.prev_span.hi), eself);
Ok(Some(Arg::from_self(eself, eself_ident)))
}
@@ -4789,7 +4794,7 @@
ast::Unsafety,
abi::Abi)> {
let is_const_fn = self.eat_keyword(keywords::Const);
- let const_span = self.last_span;
+ let const_span = self.prev_span;
let unsafety = self.parse_unsafety()?;
let (constness, unsafety, abi) = if is_const_fn {
(respan(const_span, Constness::Const), unsafety, Abi::Rust)
@@ -4799,7 +4804,7 @@
} else {
Abi::Rust
};
- (respan(self.last_span, Constness::NotConst), unsafety, abi)
+ (respan(self.prev_span, Constness::NotConst), unsafety, abi)
};
self.expect_keyword(keywords::Fn)?;
Ok((constness, unsafety, abi))
@@ -4836,7 +4841,7 @@
Ok(ImplItem {
id: ast::DUMMY_NODE_ID,
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
ident: name,
vis: vis,
defaultness: defaultness,
@@ -4873,8 +4878,8 @@
if self.token.is_path_start() {
// method macro.
- let last_span = self.last_span;
- self.complain_if_pub_macro(&vis, last_span);
+ let prev_span = self.prev_span;
+ self.complain_if_pub_macro(&vis, prev_span);
let lo = self.span.lo;
let pth = self.parse_path(PathStyle::Mod)?;
@@ -4889,7 +4894,7 @@
self.expect(&token::Semi)?
}
- let mac = spanned(lo, self.last_span.hi, Mac_ { path: pth, tts: tts });
+ let mac = spanned(lo, self.prev_span.hi, Mac_ { path: pth, tts: tts });
Ok((keywords::Invalid.ident(), vec![], ast::ImplItemKind::Macro(mac)))
} else {
let (constness, unsafety, abi) = self.parse_fn_front_matter()?;
@@ -5029,7 +5034,7 @@
Ok(ast::PolyTraitRef {
bound_lifetimes: lifetime_defs,
trait_ref: self.parse_trait_ref()?,
- span: mk_sp(lo, self.last_span.hi),
+ span: mk_sp(lo, self.prev_span.hi),
})
}
@@ -5191,7 +5196,7 @@
// If `allow_path` is false, just parse the `pub` in `pub(path)` (but still parse `pub(crate)`)
fn parse_visibility(&mut self, allow_path: bool) -> PResult<'a, Visibility> {
let pub_crate = |this: &mut Self| {
- let span = this.last_span;
+ let span = this.prev_span;
this.expect(&token::CloseDelim(token::Paren))?;
Ok(Visibility::Crate(span))
};
@@ -5242,7 +5247,7 @@
let hi = if self.span == syntax_pos::DUMMY_SP {
inner_lo
} else {
- self.last_span.hi
+ self.prev_span.hi
};
Ok(ast::Mod {
@@ -5509,9 +5514,9 @@
};
self.expect(&token::Semi)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
Ok(self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
ItemKind::ExternCrate(maybe_path),
visibility,
@@ -5546,13 +5551,13 @@
}
self.expect(&token::CloseDelim(token::Brace))?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let m = ast::ForeignMod {
abi: abi,
items: foreign_items
};
Ok(self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
keywords::Invalid.ident(),
ItemKind::ForeignMod(m),
visibility,
@@ -5605,7 +5610,7 @@
data: struct_def,
disr_expr: disr_expr,
};
- variants.push(spanned(vlo, self.last_span.hi, vr));
+ variants.push(spanned(vlo, self.prev_span.hi, vr));
if !self.eat(&token::Comma) { break; }
}
@@ -5642,9 +5647,9 @@
match abi::lookup(&s.as_str()) {
Some(abi) => Ok(Some(abi)),
None => {
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
self.span_err(
- last_span,
+ prev_span,
&format!("invalid ABI: expected one of [{}], found `{}`",
abi::all_names().join(", "),
s));
@@ -5685,9 +5690,9 @@
let item_ = ItemKind::Use(self.parse_view_path()?);
self.expect(&token::Semi)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
keywords::Invalid.ident(),
item_,
visibility,
@@ -5704,15 +5709,15 @@
if self.eat_keyword(keywords::Fn) {
// EXTERN FUNCTION ITEM
- let fn_span = self.last_span;
+ let fn_span = self.prev_span;
let abi = opt_abi.unwrap_or(Abi::C);
let (ident, item_, extra_attrs) =
self.parse_item_fn(Unsafety::Normal,
respan(fn_span, Constness::NotConst),
abi)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5733,9 +5738,9 @@
Mutability::Immutable
};
let (ident, item_, extra_attrs) = self.parse_item_const(Some(m))?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5743,7 +5748,7 @@
return Ok(Some(item));
}
if self.eat_keyword(keywords::Const) {
- let const_span = self.last_span;
+ let const_span = self.prev_span;
if self.check_keyword(keywords::Fn)
|| (self.check_keyword(keywords::Unsafe)
&& self.look_ahead(1, |t| t.is_keyword(keywords::Fn))) {
@@ -5758,9 +5763,9 @@
self.parse_item_fn(unsafety,
respan(const_span, Constness::Const),
Abi::Rust)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5770,15 +5775,15 @@
// CONST ITEM
if self.eat_keyword(keywords::Mut) {
- let last_span = self.last_span;
- self.diagnostic().struct_span_err(last_span, "const globals cannot be mutable")
+ let prev_span = self.prev_span;
+ self.diagnostic().struct_span_err(prev_span, "const globals cannot be mutable")
.help("did you mean to declare a static?")
.emit();
}
let (ident, item_, extra_attrs) = self.parse_item_const(None)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5793,9 +5798,9 @@
self.expect_keyword(keywords::Trait)?;
let (ident, item_, extra_attrs) =
self.parse_item_trait(ast::Unsafety::Unsafe)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5809,9 +5814,9 @@
self.expect_keyword(keywords::Unsafe)?;
self.expect_keyword(keywords::Impl)?;
let (ident, item_, extra_attrs) = self.parse_item_impl(ast::Unsafety::Unsafe)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5821,14 +5826,14 @@
if self.check_keyword(keywords::Fn) {
// FUNCTION ITEM
self.bump();
- let fn_span = self.last_span;
+ let fn_span = self.prev_span;
let (ident, item_, extra_attrs) =
self.parse_item_fn(Unsafety::Normal,
respan(fn_span, Constness::NotConst),
Abi::Rust)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5845,14 +5850,14 @@
Abi::Rust
};
self.expect_keyword(keywords::Fn)?;
- let fn_span = self.last_span;
+ let fn_span = self.prev_span;
let (ident, item_, extra_attrs) =
self.parse_item_fn(Unsafety::Unsafe,
respan(fn_span, Constness::NotConst),
abi)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5863,9 +5868,9 @@
// MODULE ITEM
let (ident, item_, extra_attrs) =
self.parse_item_mod(&attrs[..])?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5875,9 +5880,9 @@
if self.eat_keyword(keywords::Type) {
// TYPE ITEM
let (ident, item_, extra_attrs) = self.parse_item_type()?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5887,9 +5892,9 @@
if self.eat_keyword(keywords::Enum) {
// ENUM ITEM
let (ident, item_, extra_attrs) = self.parse_item_enum()?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5900,9 +5905,9 @@
// TRAIT ITEM
let (ident, item_, extra_attrs) =
self.parse_item_trait(ast::Unsafety::Normal)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5912,9 +5917,9 @@
if self.eat_keyword(keywords::Impl) {
// IMPL ITEM
let (ident, item_, extra_attrs) = self.parse_item_impl(ast::Unsafety::Normal)?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5924,23 +5929,22 @@
if self.eat_keyword(keywords::Struct) {
// STRUCT ITEM
let (ident, item_, extra_attrs) = self.parse_item_struct()?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
maybe_append(attrs, extra_attrs));
return Ok(Some(item));
}
- if self.check_keyword(keywords::Union) &&
- self.look_ahead(1, |t| t.is_ident() && !t.is_any_keyword()) {
+ if self.is_union_item() {
// UNION ITEM
self.bump();
let (ident, item_, extra_attrs) = self.parse_item_union()?;
- let last_span = self.last_span;
+ let prev_span = self.prev_span;
let item = self.mk_item(lo,
- last_span.hi,
+ prev_span.hi,
ident,
item_,
visibility,
@@ -5986,8 +5990,8 @@
if macros_allowed && self.token.is_path_start() {
// MACRO INVOCATION ITEM
- let last_span = self.last_span;
- self.complain_if_pub_macro(&visibility, last_span);
+ let prev_span = self.prev_span;
+ self.complain_if_pub_macro(&visibility, prev_span);
let mac_lo = self.span.lo;
@@ -6010,13 +6014,13 @@
|p| p.parse_token_tree())?;
if delim != token::Brace {
if !self.eat(&token::Semi) {
- let last_span = self.last_span;
- self.span_err(last_span,
+ let prev_span = self.prev_span;
+ self.span_err(prev_span,
"macros that expand to items must either be surrounded with braces or followed by a semicolon");
}
}
- let hi = self.last_span.hi;
+ let hi = self.prev_span.hi;
let mac = spanned(mac_lo, hi, Mac_ { path: pth, tts: tts });
let item = self.mk_item(lo, hi, id, ItemKind::Mac(mac), visibility, attrs);
return Ok(Some(item));
@@ -6026,8 +6030,8 @@
match visibility {
Visibility::Inherited => {}
_ => {
- let last_span = self.last_span;
- return Err(self.span_fatal(last_span, "unmatched visibility `pub`"));
+ let prev_span = self.prev_span;
+ return Err(self.span_fatal(prev_span, "unmatched visibility `pub`"));
}
}
@@ -6058,7 +6062,7 @@
rename: rename,
id: ast::DUMMY_NODE_ID
};
- let hi = this.last_span.hi;
+ let hi = this.prev_span.hi;
Ok(spanned(lo, hi, node))
})
}
@@ -6103,7 +6107,7 @@
// `foo::bar` or `foo::bar as baz`
let rename = self.parse_rename()?.
unwrap_or(prefix.segments.last().unwrap().identifier);
- Ok(P(spanned(lo, self.last_span.hi, ViewPathSimple(rename, prefix))))
+ Ok(P(spanned(lo, self.prev_span.hi, ViewPathSimple(rename, prefix))))
}
}
}
@@ -6151,7 +6155,7 @@
pub fn parse_str(&mut self) -> PResult<'a, (InternedString, StrStyle)> {
match self.parse_optional_str() {
Some((s, style, suf)) => {
- let sp = self.last_span;
+ let sp = self.prev_span;
self.expect_no_suffix(sp, "string literal", suf);
Ok((s, style))
}