diff options
| -rw-r--r-- | compiler/rustc_parse/src/parser/attr.rs | 2 | ||||
| -rw-r--r-- | compiler/rustc_parse/src/parser/diagnostics.rs | 44 | ||||
| -rw-r--r-- | compiler/rustc_parse/src/parser/expr.rs | 22 | ||||
| -rw-r--r-- | compiler/rustc_parse/src/parser/path.rs | 4 |
4 files changed, 36 insertions, 36 deletions
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs index 379e47077ea..a90eff02210 100644 --- a/compiler/rustc_parse/src/parser/attr.rs +++ b/compiler/rustc_parse/src/parser/attr.rs @@ -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, diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs index e042df98edf..250050a48f0 100644 --- a/compiler/rustc_parse/src/parser/diagnostics.rs +++ b/compiler/rustc_parse/src/parser/diagnostics.rs @@ -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 diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs index df865d77b9b..e160385d3a4 100644 --- a/compiler/rustc_parse/src/parser/expr.rs +++ b/compiler/rustc_parse/src/parser/expr.rs @@ -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; } } diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs index 5d41d808336..17c57867cf9 100644 --- a/compiler/rustc_parse/src/parser/path.rs +++ b/compiler/rustc_parse/src/parser/path.rs @@ -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); } |