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

Add ErrorGuaranteed to ast::ExprKind::Err

Browse source
This commit is contained in:
Lieselotte 2024-02-25 22:22:11 +01:00
parent a3fce72a27
commit c440a5b814
No known key found for this signature in database
GPG key ID: 43A6A32F83A6F9B1
37 changed files with 660 additions and 602 deletions
Download patch file Download diff file Expand all files Collapse all files

62
compiler/rustc_parse/src/parser/stmt.rs
View file

@ -22,7 +22,7 @@ use rustc_ast::{Block, BlockCheckMode, Expr, ExprKind, HasAttrs, Local, Stmt};
use rustc_ast::{StmtKind, DUMMY_NODE_ID};
use rustc_errors::{Applicability, DiagnosticBuilder, PResult};
use rustc_span::symbol::{kw, sym, Ident};
use rustc_span::{BytePos, Span};
use rustc_span::{BytePos, ErrorGuaranteed, Span};
use std::borrow::Cow;
use std::mem;
@ -610,9 +610,9 @@ impl<'a> Parser<'a> {
}
}
err.emit();
let guar = err.emit();
self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
Some(self.mk_stmt_err(self.token.span))
Some(self.mk_stmt_err(self.token.span, guar))
}
Ok(stmt) => stmt,
Err(err) => return Err(err),
@ -651,10 +651,10 @@ impl<'a> Parser<'a> {
.contains(&self.token.kind) =>
{
// The user has written `#[attr] expr` which is unsupported. (#106020)
self.attr_on_non_tail_expr(&expr);
let guar = self.attr_on_non_tail_expr(&expr);
// We already emitted an error, so don't emit another type error
let sp = expr.span.to(self.prev_token.span);
*expr = self.mk_expr_err(sp);
*expr = self.mk_expr_err(sp, guar);
}
// Expression without semicolon.
@ -666,10 +666,18 @@ impl<'a> Parser<'a> {
let expect_result =
self.expect_one_of(&[], &[token::Semi, token::CloseDelim(Delimiter::Brace)]);
// Try to both emit a better diagnostic, and avoid further errors by replacing
// the `expr` with `ExprKind::Err`.
let replace_with_err = 'break_recover: {
match expect_result {
// Recover from parser, skip type error to avoid extra errors.
Ok(Recovered::Yes) => true,
Ok(Recovered::No) => None,
Ok(Recovered::Yes) => {
// Skip type error to avoid extra errors.
let guar = self
.dcx()
.span_delayed_bug(self.prev_token.span, "expected `;` or `}`");
Some(guar)
}
Err(e) => {
if self.recover_colon_as_semi() {
// recover_colon_as_semi has already emitted a nicer error.
@ -677,7 +685,7 @@ impl<'a> Parser<'a> {
add_semi_to_stmt = true;
eat_semi = false;
break 'break_recover false;
break 'break_recover None;
}
match &expr.kind {
@ -705,13 +713,13 @@ impl<'a> Parser<'a> {
};
match self.parse_expr_labeled(label, false) {
Ok(labeled_expr) => {
e.delay_as_bug();
e.cancel();
self.dcx().emit_err(MalformedLoopLabel {
span: label.ident.span,
correct_label: label.ident,
});
*expr = labeled_expr;
break 'break_recover false;
break 'break_recover None;
}
Err(err) => {
err.cancel();
@ -723,26 +731,26 @@ impl<'a> Parser<'a> {
_ => {}
}
if let Err(e) =
self.check_mistyped_turbofish_with_multiple_type_params(e, expr)
{
if recover.no() {
return Err(e);
}
e.emit();
self.recover_stmt();
}
let res =
self.check_mistyped_turbofish_with_multiple_type_params(e, expr);
true
Some(if recover.no() {
res?
} else {
res.unwrap_or_else(|e| {
let guar = e.emit();
self.recover_stmt();
guar
})
})
}
Ok(Recovered::No) => false,
}
};
if replace_with_err {
if let Some(guar) = replace_with_err {
// We already emitted an error, so don't emit another type error
let sp = expr.span.to(self.prev_token.span);
*expr = self.mk_expr_err(sp);
*expr = self.mk_expr_err(sp, guar);
}
}
StmtKind::Expr(_) | StmtKind::MacCall(_) => {}
@ -791,11 +799,11 @@ impl<'a> Parser<'a> {
Stmt { id: DUMMY_NODE_ID, kind, span }
}
pub(super) fn mk_stmt_err(&self, span: Span) -> Stmt {
self.mk_stmt(span, StmtKind::Expr(self.mk_expr_err(span)))
pub(super) fn mk_stmt_err(&self, span: Span, guar: ErrorGuaranteed) -> Stmt {
self.mk_stmt(span, StmtKind::Expr(self.mk_expr_err(span, guar)))
}
pub(super) fn mk_block_err(&self, span: Span) -> P<Block> {
self.mk_block(thin_vec![self.mk_stmt_err(span)], BlockCheckMode::Default, span)
pub(super) fn mk_block_err(&self, span: Span, guar: ErrorGuaranteed) -> P<Block> {
self.mk_block(thin_vec![self.mk_stmt_err(span, guar)], BlockCheckMode::Default, span)
}
}