bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

rustc_errors: take self by value in DiagnosticBuilder::cancel.

Browse source
This commit is contained in:
Eduard-Mihai Burtescu 2022-01-26 03:39:14 +00:00
parent 8562d6b752
commit 0b9d70cf6d
31 changed files with 176 additions and 146 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -461,12 +461,12 @@ impl<'a> Parser<'a> {
tail.could_be_bare_literal = true;
Ok(tail)
}
(Err(mut err), Ok(tail)) => {
(Err(err), Ok(tail)) => {
// We have a block tail that contains a somehow valid type ascription expr.
err.cancel();
Ok(tail)
}
(Err(mut snapshot_err), Err(err)) => {
(Err(snapshot_err), Err(err)) => {
// We don't know what went wrong, emit the normal error.
snapshot_err.cancel();
self.consume_block(token::Brace, ConsumeClosingDelim::Yes);
@ -537,7 +537,7 @@ impl<'a> Parser<'a> {
/// Eats and discards tokens until one of `kets` is encountered. Respects token trees,
/// passes through any errors encountered. Used for error recovery.
pub(super) fn eat_to_tokens(&mut self, kets: &[&TokenKind]) {
if let Err(ref mut err) =
if let Err(err) =
self.parse_seq_to_before_tokens(kets, SeqSep::none(), TokenExpectType::Expect, |p| {
Ok(p.parse_token_tree())
})
@ -703,7 +703,7 @@ impl<'a> Parser<'a> {
*self = snapshot;
}
}
Err(mut err) => {
Err(err) => {
// We couldn't parse generic parameters, unlikely to be a turbofish. Rely on
// generic parse error instead.
err.cancel();
@ -744,14 +744,14 @@ impl<'a> Parser<'a> {
self.mk_expr_err(expr.span.to(self.prev_token.span));
return Ok(());
}
Err(mut err) => {
Err(err) => {
*expr = self.mk_expr_err(expr.span);
err.cancel();
}
}
}
}
Err(mut err) => {
Err(err) => {
err.cancel();
}
_ => {}
@ -821,7 +821,7 @@ impl<'a> Parser<'a> {
enclose(r1.span, r2.span);
true
}
Err(mut expr_err) => {
Err(expr_err) => {
expr_err.cancel();
*self = snapshot;
false
@ -838,7 +838,7 @@ impl<'a> Parser<'a> {
enclose(l1.span, r1.span);
true
}
Err(mut expr_err) => {
Err(expr_err) => {
expr_err.cancel();
*self = snapshot;
false
@ -938,7 +938,7 @@ impl<'a> Parser<'a> {
// `ExprKind::Err` placeholder.
mk_err_expr(self, inner_op.span.to(self.prev_token.span))
}
Err(mut expr_err) => {
Err(expr_err) => {
expr_err.cancel();
// Not entirely sure now, but we bubble the error up with the
// suggestion.
@ -1946,17 +1946,14 @@ impl<'a> Parser<'a> {
Ok(expr)
}
fn recover_const_param_decl(
&mut self,
ty_generics: Option<&Generics>,
) -> PResult<'a, Option<GenericArg>> {
fn recover_const_param_decl(&mut self, ty_generics: Option<&Generics>) -> Option<GenericArg> {
let snapshot = self.clone();
let param = match self.parse_const_param(vec![]) {
Ok(param) => param,
Err(mut err) => {
Err(err) => {
err.cancel();
*self = snapshot;
return Err(err);
return None;
}
};
let mut err =
@ -1977,7 +1974,7 @@ impl<'a> Parser<'a> {
}
let value = self.mk_expr_err(param.span());
err.emit();
return Ok(Some(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value })));
Some(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }))
}
pub fn recover_const_param_declaration(
@ -1985,8 +1982,8 @@ impl<'a> Parser<'a> {
ty_generics: Option<&Generics>,
) -> PResult<'a, Option<GenericArg>> {
// We have to check for a few different cases.
if let Ok(arg) = self.recover_const_param_decl(ty_generics) {
return Ok(arg);
if let Some(arg) = self.recover_const_param_decl(ty_generics) {
return Ok(Some(arg));
}
// We haven't consumed `const` yet.
@ -2085,7 +2082,7 @@ impl<'a> Parser<'a> {
return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }));
}
}
Err(mut err) => {
Err(err) => {
err.cancel();
}
}
@ -2139,7 +2136,7 @@ impl<'a> Parser<'a> {
Err(mut err) => {
self.bump(); // Skip the `:`.
match self.parse_pat_no_top_alt(expected) {
Err(mut inner_err) => {
Err(inner_err) => {
// Carry on as if we had not done anything, callers will emit a
// reasonable error.
inner_err.cancel();
@ -2246,7 +2243,7 @@ impl<'a> Parser<'a> {
// suggestion-enhanced error here rather than choking on the comma later.
let comma_span = self.token.span;
self.bump();
if let Err(mut err) = self.skip_pat_list() {
if let Err(err) = self.skip_pat_list() {
// We didn't expect this to work anyway; we just wanted to advance to the
// end of the comma-sequence so we know the span to suggest parenthesizing.
err.cancel();