bjoernager/rust
bjoernager/rust
1
Fork 0
Code 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
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, span: Span,
attr_type: OuterAttributeType, attr_type: OuterAttributeType,
) -> Option<Span> { ) -> Option<Span> {
let mut snapshot = self.clone(); let mut snapshot = self.create_snapshot_for_diagnostic();
let lo = span.lo() let lo = span.lo()
+ BytePos(match attr_type { + BytePos(match attr_type {
OuterAttributeType::Attribute => 1, OuterAttributeType::Attribute => 1,

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

@ -481,7 +481,7 @@ impl<'a> Parser<'a> {
// fn foo() -> Foo { // fn foo() -> Foo {
// field: value, // field: value,
// } // }
let mut snapshot = self.clone(); let mut snapshot = self.create_snapshot_for_diagnostic();
let path = let path =
Path { segments: vec![], span: self.prev_token.span.shrink_to_lo(), tokens: None }; 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); let struct_expr = snapshot.parse_struct_expr(None, path, AttrVec::new(), false);
@ -507,7 +507,7 @@ impl<'a> Parser<'a> {
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
) )
.emit(); .emit();
*self = snapshot; self.restore_snapshot(snapshot);
let mut tail = self.mk_block( let mut tail = self.mk_block(
vec![self.mk_stmt_err(expr.span)], vec![self.mk_stmt_err(expr.span)],
s, s,
@ -721,7 +721,7 @@ impl<'a> Parser<'a> {
/// angle brackets. /// angle brackets.
pub(super) fn check_turbofish_missing_angle_brackets(&mut self, segment: &mut PathSegment) { pub(super) fn check_turbofish_missing_angle_brackets(&mut self, segment: &mut PathSegment) {
if token::ModSep == self.token.kind && segment.args.is_none() { if token::ModSep == self.token.kind && segment.args.is_none() {
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); self.bump();
let lo = self.token.span; let lo = self.token.span;
match self.parse_angle_args(None) { match self.parse_angle_args(None) {
@ -755,14 +755,14 @@ impl<'a> Parser<'a> {
.emit(); .emit();
} else { } else {
// This doesn't look like an invalid turbofish, can't recover parse state. // This doesn't look like an invalid turbofish, can't recover parse state.
*self = snapshot; self.restore_snapshot(snapshot);
} }
} }
Err(err) => { Err(err) => {
// We couldn't parse generic parameters, unlikely to be a turbofish. Rely on // We couldn't parse generic parameters, unlikely to be a turbofish. Rely on
// generic parse error instead. // generic parse error instead.
err.cancel(); err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
} }
} }
} }
@ -868,7 +868,7 @@ impl<'a> Parser<'a> {
// `x == y < z` // `x == y < z`
(BinOpKind::Eq, AssocOp::Less | AssocOp::LessEqual | AssocOp::Greater | AssocOp::GreaterEqual) => { (BinOpKind::Eq, AssocOp::Less | AssocOp::LessEqual | AssocOp::Greater | AssocOp::GreaterEqual) => {
// Consume `z`/outer-op-rhs. // Consume `z`/outer-op-rhs.
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
match self.parse_expr() { match self.parse_expr() {
Ok(r2) => { Ok(r2) => {
// We are sure that outer-op-rhs could be consumed, the suggestion is // We are sure that outer-op-rhs could be consumed, the suggestion is
@ -878,14 +878,14 @@ impl<'a> Parser<'a> {
} }
Err(expr_err) => { Err(expr_err) => {
expr_err.cancel(); expr_err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
false false
} }
} }
} }
// `x > y == z` // `x > y == z`
(BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge, AssocOp::Equal) => { (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 // At this point it is always valid to enclose the lhs in parentheses, no
// further checks are necessary. // further checks are necessary.
match self.parse_expr() { match self.parse_expr() {
@ -895,7 +895,7 @@ impl<'a> Parser<'a> {
} }
Err(expr_err) => { Err(expr_err) => {
expr_err.cancel(); expr_err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
false false
} }
} }
@ -960,7 +960,7 @@ impl<'a> Parser<'a> {
|| outer_op.node == AssocOp::Greater || outer_op.node == AssocOp::Greater
{ {
if outer_op.node == AssocOp::Less { if outer_op.node == AssocOp::Less {
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); self.bump();
// So far we have parsed `foo<bar<`, consume the rest of the type args. // So far we have parsed `foo<bar<`, consume the rest of the type args.
let modifiers = let modifiers =
@ -972,7 +972,7 @@ impl<'a> Parser<'a> {
{ {
// We don't have `foo< bar >(` or `foo< bar >::`, so we rewind the // We don't have `foo< bar >(` or `foo< bar >::`, so we rewind the
// parser and bail out. // parser and bail out.
*self = snapshot.clone(); self.restore_snapshot(snapshot);
} }
} }
return if token::ModSep == self.token.kind { return if token::ModSep == self.token.kind {
@ -980,7 +980,7 @@ impl<'a> Parser<'a> {
// `foo< bar >::` // `foo< bar >::`
suggest(&mut err); suggest(&mut err);
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); // `::` self.bump(); // `::`
// Consume the rest of the likely `foo<bar>::new()` or return at `foo<bar>`. // 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(); expr_err.cancel();
// Not entirely sure now, but we bubble the error up with the // Not entirely sure now, but we bubble the error up with the
// suggestion. // suggestion.
*self = snapshot; self.restore_snapshot(snapshot);
Err(err) Err(err)
} }
} }
@ -1051,7 +1051,7 @@ impl<'a> Parser<'a> {
} }
fn consume_fn_args(&mut self) -> Result<(), ()> { fn consume_fn_args(&mut self) -> Result<(), ()> {
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
self.bump(); // `(` self.bump(); // `(`
// Consume the fn call arguments. // Consume the fn call arguments.
@ -1061,7 +1061,7 @@ impl<'a> Parser<'a> {
if self.token.kind == token::Eof { if self.token.kind == token::Eof {
// Not entirely sure that what we consumed were fn arguments, rollback. // Not entirely sure that what we consumed were fn arguments, rollback.
*self = snapshot; self.restore_snapshot(snapshot);
Err(()) Err(())
} else { } else {
// 99% certain that the suggestion is correct, continue parsing. // 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> { 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![]) { let param = match self.parse_const_param(vec![]) {
Ok(param) => param, Ok(param) => param,
Err(err) => { Err(err) => {
err.cancel(); err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
return None; return None;
} }
}; };
@ -2099,7 +2099,7 @@ impl<'a> Parser<'a> {
// We perform these checks and early return to avoid taking a snapshot unnecessarily. // We perform these checks and early return to avoid taking a snapshot unnecessarily.
return Err(err); return Err(err);
} }
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
if is_op_or_dot { if is_op_or_dot {
self.bump(); self.bump();
} }
@ -2131,7 +2131,7 @@ impl<'a> Parser<'a> {
err.cancel(); err.cancel();
} }
} }
*self = snapshot; self.restore_snapshot(snapshot);
Err(err) Err(err)
} }
@ -2191,7 +2191,7 @@ impl<'a> Parser<'a> {
let span = self.token.span; let span = self.token.span;
// We only emit "unexpected `:`" error here if we can successfully parse the // We only emit "unexpected `:`" error here if we can successfully parse the
// whole pattern correctly in that case. // whole pattern correctly in that case.
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
// Create error for "unexpected `:`". // Create error for "unexpected `:`".
match self.expected_one_of_not_found(&[], &[]) { match self.expected_one_of_not_found(&[], &[]) {
@ -2203,7 +2203,7 @@ impl<'a> Parser<'a> {
// reasonable error. // reasonable error.
inner_err.cancel(); inner_err.cancel();
err.cancel(); err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
} }
Ok(mut pat) => { Ok(mut pat) => {
// We've parsed the rest of the pattern. // 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. // Carry on as if we had not done anything. This should be unreachable.
*self = snapshot; self.restore_snapshot(snapshot);
} }
}; };
first_pat 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, .. }), ExprKind::Path(None, ast::Path { segments, .. }),
TokenKind::Ident(kw::For | kw::Loop | kw::While, false), TokenKind::Ident(kw::For | kw::Loop | kw::While, false),
) if segments.len() == 1 => { ) if segments.len() == 1 => {
let snapshot = self.clone(); let snapshot = self.create_snapshot_for_diagnostic();
let label = Label { let label = Label {
ident: Ident::from_str_and_span( ident: Ident::from_str_and_span(
&format!("'{}", segments[0].ident), &format!("'{}", segments[0].ident),
@ -726,7 +726,7 @@ impl<'a> Parser<'a> {
} }
Err(err) => { Err(err) => {
err.cancel(); err.cancel();
*self = snapshot; self.restore_snapshot(snapshot);
} }
} }
} }
@ -1886,7 +1886,7 @@ impl<'a> Parser<'a> {
lo: Span, lo: Span,
attrs: AttrVec, attrs: AttrVec,
) -> Option<P<Expr>> { ) -> 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) { match snapshot.parse_array_or_repeat_expr(attrs, token::Brace) {
Ok(arr) => { Ok(arr) => {
let hi = snapshot.prev_token.span; 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") .note("to define an array, one would use square brackets instead of curly braces")
.emit(); .emit();
*self = snapshot; self.restore_snapshot(snapshot);
Some(self.mk_expr_err(arr.span)) Some(self.mk_expr_err(arr.span))
} }
Err(e) => { Err(e) => {
@ -2370,7 +2370,7 @@ impl<'a> Parser<'a> {
if self.token.kind != token::Semi { if self.token.kind != token::Semi {
return None; return None;
} }
let start_snapshot = self.clone(); let start_snapshot = self.create_snapshot_for_diagnostic();
let semi_sp = self.token.span; let semi_sp = self.token.span;
self.bump(); // `;` self.bump(); // `;`
let mut stmts = let mut stmts =
@ -2418,15 +2418,15 @@ impl<'a> Parser<'a> {
return Some(err(self, stmts)); return Some(err(self, stmts));
} }
if self.token.kind == token::Comma { if self.token.kind == token::Comma {
*self = start_snapshot; self.restore_snapshot(start_snapshot);
return None; 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) { match self.parse_pat_no_top_alt(None) {
Ok(_pat) => { Ok(_pat) => {
if self.token.kind == token::FatArrow { if self.token.kind == token::FatArrow {
// Reached arm end. // Reached arm end.
*self = pre_pat_snapshot; self.restore_snapshot(pre_pat_snapshot);
return Some(err(self, stmts)); 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) { match self.parse_stmt_without_recovery(true, ForceCollect::No) {
// Consume statements for as long as possible. // Consume statements for as long as possible.
Ok(Some(stmt)) => { Ok(Some(stmt)) => {
stmts.push(stmt); stmts.push(stmt);
} }
Ok(None) => { Ok(None) => {
*self = start_snapshot; self.restore_snapshot(start_snapshot);
break; break;
} }
// We couldn't parse either yet another statement missing it's // We couldn't parse either yet another statement missing it's
// enclosing block nor the next arm's pattern or closing brace. // enclosing block nor the next arm's pattern or closing brace.
Err(stmt_err) => { Err(stmt_err) => {
stmt_err.cancel(); stmt_err.cancel();
*self = start_snapshot; self.restore_snapshot(start_snapshot);
break; break;
} }
} }

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

@ -645,7 +645,7 @@ impl<'a> Parser<'a> {
} else { } else {
// Fall back by trying to parse a const-expr expression. If we successfully do so, // 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. // 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) { match self.parse_expr_res(Restrictions::CONST_EXPR, None) {
Ok(expr) => { Ok(expr) => {
return Ok(Some(self.dummy_const_arg_needs_braces( return Ok(Some(self.dummy_const_arg_needs_braces(
@ -654,7 +654,7 @@ impl<'a> Parser<'a> {
))); )));
} }
Err(err) => { Err(err) => {
*self = snapshot; self.restore_snapshot(snapshot);
err.cancel(); err.cancel();
return Ok(None); return Ok(None);
} }