nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-13 12:36:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

replace self.clone() with self.create_snapshot_for_diagnostic()

Browse Source
This commit is contained in:
Takayuki Maeda 2022-03-10 22:11:00 +09:00
parent 2db8236857
commit 9a6532276e
4 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_parse/src/parser/attr.rs
View File

@ -151,7 +151,7 @@ impl<'a> Parser<'a> {
span: Span,
attr_type: OuterAttributeType,
) -> Option<Span> {
let mut snapshot = self.clone();
let mut snapshot = self.create_snapshot_for_diagnostic();
let lo = span.lo()
+ BytePos(match attr_type {
OuterAttributeType::Attribute => 1,

44
compiler/rustc_parse/src/parser/diagnostics.rs
View File

@ -481,7 +481,7 @@ impl<'a> Parser<'a> {
// fn foo() -> Foo {
// field: value,
// }
let mut snapshot = self.clone();
let mut snapshot = self.create_snapshot_for_diagnostic();
let path =
Path { segments: vec![], span: self.prev_token.span.shrink_to_lo(), tokens: None };
let struct_expr = snapshot.parse_struct_expr(None, path, AttrVec::new(), false);
@ -507,7 +507,7 @@ impl<'a> Parser<'a> {
Applicability::MaybeIncorrect,
)
.emit();
*self = snapshot;
self.restore_snapshot(snapshot);
let mut tail = self.mk_block(
vec![self.mk_stmt_err(expr.span)],
s,
@ -721,7 +721,7 @@ impl<'a> Parser<'a> {
/// angle brackets.
pub(super) fn check_turbofish_missing_angle_brackets(&mut self, segment: &mut PathSegment) {
if token::ModSep == self.token.kind && segment.args.is_none() {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
self.bump();
let lo = self.token.span;
match self.parse_angle_args(None) {
@ -755,14 +755,14 @@ impl<'a> Parser<'a> {
.emit();
} else {
// This doesn't look like an invalid turbofish, can't recover parse state.
*self = snapshot;
self.restore_snapshot(snapshot);
}
}
Err(err) => {
// We couldn't parse generic parameters, unlikely to be a turbofish. Rely on
// generic parse error instead.
err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
}
}
}
@ -868,7 +868,7 @@ impl<'a> Parser<'a> {
// `x == y < z`
(BinOpKind::Eq, AssocOp::Less | AssocOp::LessEqual | AssocOp::Greater | AssocOp::GreaterEqual) => {
// Consume `z`/outer-op-rhs.
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
match self.parse_expr() {
Ok(r2) => {
// We are sure that outer-op-rhs could be consumed, the suggestion is
@ -878,14 +878,14 @@ impl<'a> Parser<'a> {
}
Err(expr_err) => {
expr_err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
false
}
}
}
// `x > y == z`
(BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge, AssocOp::Equal) => {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
// At this point it is always valid to enclose the lhs in parentheses, no
// further checks are necessary.
match self.parse_expr() {
@ -895,7 +895,7 @@ impl<'a> Parser<'a> {
}
Err(expr_err) => {
expr_err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
false
}
}
@ -960,7 +960,7 @@ impl<'a> Parser<'a> {
|| outer_op.node == AssocOp::Greater
{
if outer_op.node == AssocOp::Less {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
self.bump();
// So far we have parsed `foo<bar<`, consume the rest of the type args.
let modifiers =
@ -972,7 +972,7 @@ impl<'a> Parser<'a> {
{
// We don't have `foo< bar >(` or `foo< bar >::`, so we rewind the
// parser and bail out.
*self = snapshot.clone();
self.restore_snapshot(snapshot);
}
}
return if token::ModSep == self.token.kind {
@ -980,7 +980,7 @@ impl<'a> Parser<'a> {
// `foo< bar >::`
suggest(&mut err);
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); // `::`
// Consume the rest of the likely `foo<bar>::new()` or return at `foo<bar>`.
@ -997,7 +997,7 @@ impl<'a> Parser<'a> {
expr_err.cancel();
// Not entirely sure now, but we bubble the error up with the
// suggestion.
*self = snapshot;
self.restore_snapshot(snapshot);
Err(err)
}
}
@ -1051,7 +1051,7 @@ impl<'a> Parser<'a> {
}
fn consume_fn_args(&mut self) -> Result<(), ()> {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); // `(`
// Consume the fn call arguments.
@ -1061,7 +1061,7 @@ impl<'a> Parser<'a> {
if self.token.kind == token::Eof {
// Not entirely sure that what we consumed were fn arguments, rollback.
*self = snapshot;
self.restore_snapshot(snapshot);
Err(())
} else {
// 99% certain that the suggestion is correct, continue parsing.
@ -2002,12 +2002,12 @@ impl<'a> Parser<'a> {
}
fn recover_const_param_decl(&mut self, ty_generics: Option<&Generics>) -> Option<GenericArg> {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
let param = match self.parse_const_param(vec![]) {
Ok(param) => param,
Err(err) => {
err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
return None;
}
};
@ -2099,7 +2099,7 @@ impl<'a> Parser<'a> {
// We perform these checks and early return to avoid taking a snapshot unnecessarily.
return Err(err);
}
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
if is_op_or_dot {
self.bump();
}
@ -2131,7 +2131,7 @@ impl<'a> Parser<'a> {
err.cancel();
}
}
*self = snapshot;
self.restore_snapshot(snapshot);
Err(err)
}
@ -2191,7 +2191,7 @@ impl<'a> Parser<'a> {
let span = self.token.span;
// We only emit "unexpected `:`" error here if we can successfully parse the
// whole pattern correctly in that case.
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
// Create error for "unexpected `:`".
match self.expected_one_of_not_found(&[], &[]) {
@ -2203,7 +2203,7 @@ impl<'a> Parser<'a> {
// reasonable error.
inner_err.cancel();
err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
}
Ok(mut pat) => {
// We've parsed the rest of the pattern.
@ -2282,7 +2282,7 @@ impl<'a> Parser<'a> {
}
_ => {
// Carry on as if we had not done anything. This should be unreachable.
*self = snapshot;
self.restore_snapshot(snapshot);
}
};
first_pat

22
compiler/rustc_parse/src/parser/expr.rs
View File

@ -704,7 +704,7 @@ impl<'a> Parser<'a> {
ExprKind::Path(None, ast::Path { segments, .. }),
TokenKind::Ident(kw::For | kw::Loop | kw::While, false),
) if segments.len() == 1 => {
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
let label = Label {
ident: Ident::from_str_and_span(
&format!("'{}", segments[0].ident),
@ -726,7 +726,7 @@ impl<'a> Parser<'a> {
}
Err(err) => {
err.cancel();
*self = snapshot;
self.restore_snapshot(snapshot);
}
}
}
@ -1886,7 +1886,7 @@ impl<'a> Parser<'a> {
lo: Span,
attrs: AttrVec,
) -> Option<P<Expr>> {
let mut snapshot = self.clone();
let mut snapshot = self.create_snapshot_for_diagnostic();
match snapshot.parse_array_or_repeat_expr(attrs, token::Brace) {
Ok(arr) => {
let hi = snapshot.prev_token.span;
@ -1902,7 +1902,7 @@ impl<'a> Parser<'a> {
.note("to define an array, one would use square brackets instead of curly braces")
.emit();
*self = snapshot;
self.restore_snapshot(snapshot);
Some(self.mk_expr_err(arr.span))
}
Err(e) => {
@ -2370,7 +2370,7 @@ impl<'a> Parser<'a> {
if self.token.kind != token::Semi {
return None;
}
let start_snapshot = self.clone();
let start_snapshot = self.create_snapshot_for_diagnostic();
let semi_sp = self.token.span;
self.bump(); // `;`
let mut stmts =
@ -2418,15 +2418,15 @@ impl<'a> Parser<'a> {
return Some(err(self, stmts));
}
if self.token.kind == token::Comma {
*self = start_snapshot;
self.restore_snapshot(start_snapshot);
return None;
}
let pre_pat_snapshot = self.clone();
let pre_pat_snapshot = self.create_snapshot_for_diagnostic();
match self.parse_pat_no_top_alt(None) {
Ok(_pat) => {
if self.token.kind == token::FatArrow {
// Reached arm end.
*self = pre_pat_snapshot;
self.restore_snapshot(pre_pat_snapshot);
return Some(err(self, stmts));
}
}
@ -2435,21 +2435,21 @@ impl<'a> Parser<'a> {
}
}
*self = pre_pat_snapshot;
self.restore_snapshot(pre_pat_snapshot);
match self.parse_stmt_without_recovery(true, ForceCollect::No) {
// Consume statements for as long as possible.
Ok(Some(stmt)) => {
stmts.push(stmt);
}
Ok(None) => {
*self = start_snapshot;
self.restore_snapshot(start_snapshot);
break;
}
// We couldn't parse either yet another statement missing it's
// enclosing block nor the next arm's pattern or closing brace.
Err(stmt_err) => {
stmt_err.cancel();
*self = start_snapshot;
self.restore_snapshot(start_snapshot);
break;
}
}

4
compiler/rustc_parse/src/parser/path.rs
View File

@ -645,7 +645,7 @@ impl<'a> Parser<'a> {
} else {
// Fall back by trying to parse a const-expr expression. If we successfully do so,
// then we should report an error that it needs to be wrapped in braces.
let snapshot = self.clone();
let snapshot = self.create_snapshot_for_diagnostic();
match self.parse_expr_res(Restrictions::CONST_EXPR, None) {
Ok(expr) => {
return Ok(Some(self.dummy_const_arg_needs_braces(
@ -654,7 +654,7 @@ impl<'a> Parser<'a> {
)));
}
Err(err) => {
*self = snapshot;
self.restore_snapshot(snapshot);
err.cancel();
return Ok(None);
}