use super::ty::AllowPlus;
use super::{BlockMode, Parser, PathStyle, SemiColonMode, SeqSep, TokenExpectType, TokenType};
+use rustc_ast::ast::{
+ self, BinOpKind, BindingMode, BlockCheckMode, Expr, ExprKind, Ident, Item, Param,
+};
+use rustc_ast::ast::{AttrVec, ItemKind, Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind};
+use rustc_ast::ptr::P;
+use rustc_ast::token::{self, TokenKind};
+use rustc_ast::util::parser::AssocOp;
use rustc_ast_pretty::pprust;
use rustc_data_structures::fx::FxHashSet;
use rustc_errors::{pluralize, struct_span_err};
use rustc_span::source_map::Spanned;
use rustc_span::symbol::kw;
use rustc_span::{MultiSpan, Span, SpanSnippetError, DUMMY_SP};
-use syntax::ast::{
- self, BinOpKind, BindingMode, BlockCheckMode, Expr, ExprKind, Ident, Item, Param,
-};
-use syntax::ast::{AttrVec, ItemKind, Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind};
-use syntax::ptr::P;
-use syntax::token::{self, TokenKind};
-use syntax::util::parser::AssocOp;
use log::{debug, trace};
use std::mem;
};
(
format!("expected one of {}, found {}", expect, actual),
- (self.prev_span.shrink_to_hi(), format!("expected one of {}", short_expect)),
+ (self.prev_token.span.shrink_to_hi(), format!("expected one of {}", short_expect)),
)
} else if expected.is_empty() {
(
format!("unexpected token: {}", actual),
- (self.prev_span, "unexpected token after this".to_string()),
+ (self.prev_token.span, "unexpected token after this".to_string()),
)
} else {
(
format!("expected {}, found {}", expect, actual),
- (self.prev_span.shrink_to_hi(), format!("expected {}", expect)),
+ (self.prev_token.span.shrink_to_hi(), format!("expected {}", expect)),
)
};
self.last_unexpected_token_span = Some(self.token.span);
let mut err = self.struct_span_err(self.token.span, &msg_exp);
let sp = if self.token == token::Eof {
// This is EOF; don't want to point at the following char, but rather the last token.
- self.prev_span
+ self.prev_token.span
} else {
label_sp
};
}
let sm = self.sess.source_map();
- if self.prev_span == DUMMY_SP {
+ if self.prev_token.span == DUMMY_SP {
// Account for macro context where the previous span might not be
// available to avoid incorrect output (#54841).
err.span_label(self.token.span, label_exp);
match inner_op.kind {
ExprKind::Binary(op, _, _) if op.node.is_comparison() => {
// Respan to include both operators.
- let op_span = op.span.to(self.prev_span);
+ let op_span = op.span.to(self.prev_token.span);
let mut err =
self.struct_span_err(op_span, "comparison operators cannot be chained");
// FIXME: actually check that the two expressions in the binop are
// paths and resynthesize new fn call expression instead of using
// `ExprKind::Err` placeholder.
- mk_err_expr(self, inner_op.span.to(self.prev_span))
+ mk_err_expr(self, inner_op.span.to(self.prev_token.span))
}
Err(mut expr_err) => {
expr_err.cancel();
// FIXME: actually check that the two expressions in the binop are
// paths and resynthesize new fn call expression instead of using
// `ExprKind::Err` placeholder.
- mk_err_expr(self, inner_op.span.to(self.prev_span))
+ mk_err_expr(self, inner_op.span.to(self.prev_token.span))
}
}
} else {
self.bump(); // `+`
let bounds = self.parse_generic_bounds(None)?;
- let sum_span = ty.span.to(self.prev_span);
+ let sum_span = ty.span.to(self.prev_token.span);
let mut err = struct_span_err!(
self.sess.span_diagnostic,
let mut path = ast::Path { segments: Vec::new(), span: DUMMY_SP };
self.parse_path_segments(&mut path.segments, T::PATH_STYLE)?;
- path.span = ty_span.to(self.prev_span);
+ path.span = ty_span.to(self.prev_token.span);
let ty_str = self.span_to_snippet(ty_span).unwrap_or_else(|_| pprust::ty_to_string(&ty));
self.struct_span_err(path.span, "missing angle brackets in associated item path")
pub(super) fn maybe_consume_incorrect_semicolon(&mut self, items: &[P<Item>]) -> bool {
if self.eat(&token::Semi) {
- let mut err = self.struct_span_err(self.prev_span, "expected item, found `;`");
+ let mut err = self.struct_span_err(self.prev_token.span, "expected item, found `;`");
err.span_suggestion_short(
- self.prev_span,
+ self.prev_token.span,
"remove this semicolon",
String::new(),
Applicability::MachineApplicable,
}
// We don't want to point at the following span after DUMMY_SP.
// This happens when the parser finds an empty TokenStream.
- _ if self.prev_span == DUMMY_SP => (self.token.span, self.token.span),
+ _ if self.prev_token.span == DUMMY_SP => (self.token.span, self.token.span),
// EOF, don't want to point at the following char, but rather the last token.
- (token::Eof, None) => (self.prev_span, self.token.span),
- _ => (self.prev_span.shrink_to_hi(), self.token.span),
+ (token::Eof, None) => (self.prev_token.span, self.token.span),
+ _ => (self.prev_token.span.shrink_to_hi(), self.token.span),
};
let msg = format!(
"expected `{}`, found {}",
let sm = self.sess.source_map();
let msg = format!("expected `;`, found `{}`", super::token_descr(&self.token));
let appl = Applicability::MachineApplicable;
- if self.token.span == DUMMY_SP || self.prev_span == DUMMY_SP {
+ if self.token.span == DUMMY_SP || self.prev_token.span == DUMMY_SP {
// Likely inside a macro, can't provide meaninful suggestions.
return self.expect(&token::Semi).map(drop);
- } else if !sm.is_multiline(self.prev_span.until(self.token.span)) {
+ } else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) {
// The current token is in the same line as the prior token, not recoverable.
} else if self.look_ahead(1, |t| {
t == &token::CloseDelim(token::Brace) || t.can_begin_expr() && t.kind != token::Colon
// let x = 32:
// let y = 42;
self.bump();
- let sp = self.prev_span;
+ let sp = self.prev_token.span;
self.struct_span_err(sp, &msg)
.span_suggestion(sp, "change this to `;`", ";".to_string(), appl)
.emit();
//
// let x = 32
// let y = 42;
- let sp = self.prev_span.shrink_to_hi();
+ let sp = self.prev_token.span.shrink_to_hi();
self.struct_span_err(sp, &msg)
.span_label(self.token.span, "unexpected token")
.span_suggestion_short(sp, "add `;` here", ";".to_string(), appl)
self.expect(&token::OpenDelim(token::Paren))?;
let expr = self.parse_expr()?;
self.expect(&token::CloseDelim(token::Paren))?;
- Ok((self.prev_span, expr, false))
+ Ok((self.prev_token.span, expr, false))
}
fn recover_await_prefix(&mut self, await_sp: Span) -> PResult<'a, (Span, P<Expr>, bool)> {
.span_to_snippet(pat.span.trim_start(begin_par_sp).unwrap())
.unwrap_or_else(|_| pprust::pat_to_string(&pat));
- self.struct_span_err(self.prev_span, "unexpected closing `)`")
+ self.struct_span_err(self.prev_token.span, "unexpected closing `)`")
.span_label(begin_par_sp, "opening `(`")
.span_suggestion(
- begin_par_sp.to(self.prev_span),
+ begin_par_sp.to(self.prev_token.span),
"remove parenthesis in `for` loop",
format!("{} in {}", pat_str, pprust::expr_to_string(&expr)),
// With e.g. `for (x) in y)` this would replace `(x) in y)`
err.emit();
// Recover from parse error, callers expect the closing delim to be consumed.
self.consume_block(delim, ConsumeClosingDelim::Yes);
- self.mk_expr(lo.to(self.prev_span), ExprKind::Err, AttrVec::new())
+ self.mk_expr(lo.to(self.prev_token.span), ExprKind::Err, AttrVec::new())
}
}
}
err.span_label(sp, "unclosed delimiter");
}
err.span_suggestion_short(
- self.prev_span.shrink_to_hi(),
+ self.prev_token.span.shrink_to_hi(),
&format!("{} may belong here", delim.to_string()),
delim.to_string(),
Applicability::MaybeIncorrect,
pub(super) fn check_for_for_in_in_typo(&mut self, in_span: Span) {
if self.eat_keyword(kw::In) {
// a common typo: `for _ in in bar {}`
- self.struct_span_err(self.prev_span, "expected iterable, found keyword `in`")
+ self.struct_span_err(self.prev_token.span, "expected iterable, found keyword `in`")
.span_suggestion_short(
- in_span.until(self.prev_span),
+ in_span.until(self.prev_token.span),
"remove the duplicated `in`",
String::new(),
Applicability::MachineApplicable,
projects / rust.git / blobdiff