bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustc_parse: remove huge error imports

Browse source
This commit is contained in:
est31 2023-02-05 03:26:33 +01:00
parent b4a20abc48
commit 394fa192a9
2 changed files with 111 additions and 121 deletions
Download patch file Download diff file Expand all files Collapse all files

186
compiler/rustc_parse/src/parser/expr.rs
View file

@ -5,26 +5,7 @@ use super::{
AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions, AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions,
SemiColonMode, SeqSep, TokenExpectType, TokenType, TrailingToken, SemiColonMode, SeqSep, TokenExpectType, TokenType, TrailingToken,
}; };
use crate::errors::{ use crate::errors;
ArrayBracketsInsteadOfSpaces, ArrayBracketsInsteadOfSpacesSugg, AsyncBlockIn2015,
AsyncMoveOrderIncorrect, BracesForStructLiteral, CatchAfterTry, CommaAfterBaseStruct,
ComparisonInterpretedAsGeneric, ComparisonOrShiftInterpretedAsGenericSugg,
DoCatchSyntaxRemoved, DotDotDot, EqFieldInit, ExpectedElseBlock, ExpectedEqForLetExpr,
ExpectedExpressionFoundLet, FieldExpressionWithGeneric, FloatLiteralRequiresIntegerPart,
FoundExprWouldBeStmt, HelpUseLatestEdition, IfExpressionLetSomeSub,
IfExpressionMissingCondition, IfExpressionMissingThenBlock, IfExpressionMissingThenBlockSub,
InvalidBlockMacroSegment, InvalidComparisonOperator, InvalidComparisonOperatorSub,
InvalidInterpolatedExpression, InvalidLiteralSuffixOnTupleIndex, InvalidLogicalOperator,
InvalidLogicalOperatorSub, LabeledLoopInBreak, LeadingPlusNotSupported, LeftArrowOperator,
LifetimeInBorrowExpression, MacroInvocationWithQualifiedPath, MalformedLoopLabel,
MatchArmBodyWithoutBraces, MatchArmBodyWithoutBracesSugg, MissingCommaAfterMatchArm,
MissingDotDot, MissingInInForLoop, MissingInInForLoopSub, MissingSemicolonBeforeArray,
NoFieldsForFnCall, NotAsNegationOperator, NotAsNegationOperatorSub,
OuterAttributeNotAllowedOnIfElse, ParenthesesWithStructFields,
RequireColonAfterLabeledExpression, ShiftInterpretedAsGeneric, StructLiteralNotAllowedHere,
StructLiteralNotAllowedHereSugg, TildeAsUnaryOperator, UnexpectedIfWithIf,
UnexpectedTokenAfterLabel, UnexpectedTokenAfterLabelSugg, WrapExpressionInParentheses,
};
use crate::maybe_recover_from_interpolated_ty_qpath; use crate::maybe_recover_from_interpolated_ty_qpath;
use core::mem; use core::mem;
use rustc_ast::ptr::P; use rustc_ast::ptr::P;
@ -244,10 +225,10 @@ impl<'a> Parser<'a> {
} }
.into(); .into();
let invalid = format!("{}=", &sugg); let invalid = format!("{}=", &sugg);
self.sess.emit_err(InvalidComparisonOperator { self.sess.emit_err(errors::InvalidComparisonOperator {
span: sp, span: sp,
invalid: invalid.clone(), invalid: invalid.clone(),
sub: InvalidComparisonOperatorSub::Correctable { sub: errors::InvalidComparisonOperatorSub::Correctable {
span: sp, span: sp,
invalid, invalid,
correct: sugg, correct: sugg,
@ -262,10 +243,10 @@ impl<'a> Parser<'a> {
&& self.prev_token.span.hi() == self.token.span.lo() && self.prev_token.span.hi() == self.token.span.lo()
{ {
let sp = op.span.to(self.token.span); let sp = op.span.to(self.token.span);
self.sess.emit_err(InvalidComparisonOperator { self.sess.emit_err(errors::InvalidComparisonOperator {
span: sp, span: sp,
invalid: "<>".into(), invalid: "<>".into(),
sub: InvalidComparisonOperatorSub::Correctable { sub: errors::InvalidComparisonOperatorSub::Correctable {
span: sp, span: sp,
invalid: "<>".into(), invalid: "<>".into(),
correct: "!=".into(), correct: "!=".into(),
@ -280,10 +261,10 @@ impl<'a> Parser<'a> {
&& self.prev_token.span.hi() == self.token.span.lo() && self.prev_token.span.hi() == self.token.span.lo()
{ {
let sp = op.span.to(self.token.span); let sp = op.span.to(self.token.span);
self.sess.emit_err(InvalidComparisonOperator { self.sess.emit_err(errors::InvalidComparisonOperator {
span: sp, span: sp,
invalid: "<=>".into(), invalid: "<=>".into(),
sub: InvalidComparisonOperatorSub::Spaceship(sp), sub: errors::InvalidComparisonOperatorSub::Spaceship(sp),
}); });
self.bump(); self.bump();
} }
@ -420,7 +401,7 @@ impl<'a> Parser<'a> {
/// but the next token implies this should be parsed as an expression. /// but the next token implies this should be parsed as an expression.
/// For example: `if let Some(x) = x { x } else { 0 } / 2`. /// For example: `if let Some(x) = x { x } else { 0 } / 2`.
fn error_found_expr_would_be_stmt(&self, lhs: &Expr) { fn error_found_expr_would_be_stmt(&self, lhs: &Expr) {
self.sess.emit_err(FoundExprWouldBeStmt { self.sess.emit_err(errors::FoundExprWouldBeStmt {
span: self.token.span, span: self.token.span,
token: self.token.clone(), token: self.token.clone(),
suggestion: ExprParenthesesNeeded::surrounding(lhs.span), suggestion: ExprParenthesesNeeded::surrounding(lhs.span),
@ -447,18 +428,18 @@ impl<'a> Parser<'a> {
} }
(Some(op), _) => (op, self.token.span), (Some(op), _) => (op, self.token.span),
(None, Some((Ident { name: sym::and, span }, false))) if self.may_recover() => { (None, Some((Ident { name: sym::and, span }, false))) if self.may_recover() => {
self.sess.emit_err(InvalidLogicalOperator { self.sess.emit_err(errors::InvalidLogicalOperator {
span: self.token.span, span: self.token.span,
incorrect: "and".into(), incorrect: "and".into(),
sub: InvalidLogicalOperatorSub::Conjunction(self.token.span), sub: errors::InvalidLogicalOperatorSub::Conjunction(self.token.span),
}); });
(AssocOp::LAnd, span) (AssocOp::LAnd, span)
} }
(None, Some((Ident { name: sym::or, span }, false))) if self.may_recover() => { (None, Some((Ident { name: sym::or, span }, false))) if self.may_recover() => {
self.sess.emit_err(InvalidLogicalOperator { self.sess.emit_err(errors::InvalidLogicalOperator {
span: self.token.span, span: self.token.span,
incorrect: "or".into(), incorrect: "or".into(),
sub: InvalidLogicalOperatorSub::Disjunction(self.token.span), sub: errors::InvalidLogicalOperatorSub::Disjunction(self.token.span),
}); });
(AssocOp::LOr, span) (AssocOp::LOr, span)
} }
@ -581,8 +562,11 @@ impl<'a> Parser<'a> {
} }
// `+lit` // `+lit`
token::BinOp(token::Plus) if this.look_ahead(1, |tok| tok.is_numeric_lit()) => { token::BinOp(token::Plus) if this.look_ahead(1, |tok| tok.is_numeric_lit()) => {
let mut err = let mut err = errors::LeadingPlusNotSupported {
LeadingPlusNotSupported { span: lo, remove_plus: None, add_parentheses: None }; span: lo,
remove_plus: None,
add_parentheses: None,
};
// a block on the LHS might have been intended to be an expression instead // a block on the LHS might have been intended to be an expression instead
if let Some(sp) = this.sess.ambiguous_block_expr_parse.borrow().get(&lo) { if let Some(sp) = this.sess.ambiguous_block_expr_parse.borrow().get(&lo) {
@ -633,7 +617,7 @@ impl<'a> Parser<'a> {
/// Recover on `~expr` in favor of `!expr`. /// Recover on `~expr` in favor of `!expr`.
fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> { fn recover_tilde_expr(&mut self, lo: Span) -> PResult<'a, (Span, ExprKind)> {
self.sess.emit_err(TildeAsUnaryOperator(lo)); self.sess.emit_err(errors::TildeAsUnaryOperator(lo));
self.parse_unary_expr(lo, UnOp::Not) self.parse_unary_expr(lo, UnOp::Not)
} }
@ -661,14 +645,14 @@ impl<'a> Parser<'a> {
let negated_token = self.look_ahead(1, |t| t.clone()); let negated_token = self.look_ahead(1, |t| t.clone());
let sub_diag = if negated_token.is_numeric_lit() { let sub_diag = if negated_token.is_numeric_lit() {
NotAsNegationOperatorSub::SuggestNotBitwise errors::NotAsNegationOperatorSub::SuggestNotBitwise
} else if negated_token.is_bool_lit() { } else if negated_token.is_bool_lit() {
NotAsNegationOperatorSub::SuggestNotLogical errors::NotAsNegationOperatorSub::SuggestNotLogical
} else { } else {
NotAsNegationOperatorSub::SuggestNotDefault errors::NotAsNegationOperatorSub::SuggestNotDefault
}; };
self.sess.emit_err(NotAsNegationOperator { self.sess.emit_err(errors::NotAsNegationOperator {
negated: negated_token.span, negated: negated_token.span,
negated_desc: super::token_descr(&negated_token), negated_desc: super::token_descr(&negated_token),
// Span the `not` plus trailing whitespace to avoid // Span the `not` plus trailing whitespace to avoid
@ -739,7 +723,7 @@ impl<'a> Parser<'a> {
match self.parse_labeled_expr(label, false) { match self.parse_labeled_expr(label, false) {
Ok(expr) => { Ok(expr) => {
type_err.cancel(); type_err.cancel();
self.sess.emit_err(MalformedLoopLabel { self.sess.emit_err(errors::MalformedLoopLabel {
span: label.ident.span, span: label.ident.span,
correct_label: label.ident, correct_label: label.ident,
}); });
@ -764,20 +748,22 @@ impl<'a> Parser<'a> {
); );
let args_span = self.look_ahead(1, |t| t.span).to(span_after_type); let args_span = self.look_ahead(1, |t| t.span).to(span_after_type);
let suggestion = ComparisonOrShiftInterpretedAsGenericSugg { let suggestion = errors::ComparisonOrShiftInterpretedAsGenericSugg {
left: expr.span.shrink_to_lo(), left: expr.span.shrink_to_lo(),
right: expr.span.shrink_to_hi(), right: expr.span.shrink_to_hi(),
}; };
match self.token.kind { match self.token.kind {
token::Lt => self.sess.emit_err(ComparisonInterpretedAsGeneric { token::Lt => {
comparison: self.token.span, self.sess.emit_err(errors::ComparisonInterpretedAsGeneric {
r#type: path, comparison: self.token.span,
args: args_span, r#type: path,
suggestion, args: args_span,
}), suggestion,
})
}
token::BinOp(token::Shl) => { token::BinOp(token::Shl) => {
self.sess.emit_err(ShiftInterpretedAsGeneric { self.sess.emit_err(errors::ShiftInterpretedAsGeneric {
shift: self.token.span, shift: self.token.span,
r#type: path, r#type: path,
args: args_span, args: args_span,
@ -918,7 +904,7 @@ impl<'a> Parser<'a> {
} }
fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span) { fn error_remove_borrow_lifetime(&self, span: Span, lt_span: Span) {
self.sess.emit_err(LifetimeInBorrowExpression { span, lifetime_span: lt_span }); self.sess.emit_err(errors::LifetimeInBorrowExpression { span, lifetime_span: lt_span });
} }
/// Parse `mut?` or `raw [ const | mut ]`. /// Parse `mut?` or `raw [ const | mut ]`.
@ -1212,14 +1198,14 @@ impl<'a> Parser<'a> {
let close_paren = self.prev_token.span; let close_paren = self.prev_token.span;
let span = lo.to(self.prev_token.span); let span = lo.to(self.prev_token.span);
if !fields.is_empty() { if !fields.is_empty() {
let mut replacement_err = ParenthesesWithStructFields { let mut replacement_err = errors::ParenthesesWithStructFields {
span, span,
r#type: path, r#type: path,
braces_for_struct: BracesForStructLiteral { braces_for_struct: errors::BracesForStructLiteral {
first: open_paren, first: open_paren,
second: close_paren, second: close_paren,
}, },
no_fields_for_fn: NoFieldsForFnCall { no_fields_for_fn: errors::NoFieldsForFnCall {
fields: fields fields: fields
.into_iter() .into_iter()
.map(|field| field.span.until(field.expr.span)) .map(|field| field.span.until(field.expr.span))
@ -1286,7 +1272,7 @@ impl<'a> Parser<'a> {
} else { } else {
// Field access `expr.f` // Field access `expr.f`
if let Some(args) = seg.args { if let Some(args) = seg.args {
self.sess.emit_err(FieldExpressionWithGeneric(args.span())); self.sess.emit_err(errors::FieldExpressionWithGeneric(args.span()));
} }
let span = lo.to(self.prev_token.span); let span = lo.to(self.prev_token.span);
@ -1500,7 +1486,7 @@ impl<'a> Parser<'a> {
let (span, kind) = if self.eat(&token::Not) { let (span, kind) = if self.eat(&token::Not) {
// MACRO INVOCATION expression // MACRO INVOCATION expression
if qself.is_some() { if qself.is_some() {
self.sess.emit_err(MacroInvocationWithQualifiedPath(path.span)); self.sess.emit_err(errors::MacroInvocationWithQualifiedPath(path.span));
} }
let lo = path.span; let lo = path.span;
let mac = P(MacCall { let mac = P(MacCall {
@ -1550,7 +1536,7 @@ impl<'a> Parser<'a> {
{ {
let (lit, _) = let (lit, _) =
self.recover_unclosed_char(label_.ident, Parser::mk_token_lit_char, |self_| { self.recover_unclosed_char(label_.ident, Parser::mk_token_lit_char, |self_| {
self_.sess.create_err(UnexpectedTokenAfterLabel { self_.sess.create_err(errors::UnexpectedTokenAfterLabel {
span: self_.token.span, span: self_.token.span,
remove_label: None, remove_label: None,
enclose_in_block: None, enclose_in_block: None,
@ -1562,7 +1548,7 @@ impl<'a> Parser<'a> {
&& (self.check_noexpect(&TokenKind::Comma) || self.check_noexpect(&TokenKind::Gt)) && (self.check_noexpect(&TokenKind::Comma) || self.check_noexpect(&TokenKind::Gt))
{ {
// We're probably inside of a `Path<'a>` that needs a turbofish // We're probably inside of a `Path<'a>` that needs a turbofish
self.sess.emit_err(UnexpectedTokenAfterLabel { self.sess.emit_err(errors::UnexpectedTokenAfterLabel {
span: self.token.span, span: self.token.span,
remove_label: None, remove_label: None,
enclose_in_block: None, enclose_in_block: None,
@ -1570,7 +1556,7 @@ impl<'a> Parser<'a> {
consume_colon = false; consume_colon = false;
Ok(self.mk_expr_err(lo)) Ok(self.mk_expr_err(lo))
} else { } else {
let mut err = UnexpectedTokenAfterLabel { let mut err = errors::UnexpectedTokenAfterLabel {
span: self.token.span, span: self.token.span,
remove_label: None, remove_label: None,
enclose_in_block: None, enclose_in_block: None,
@ -1606,7 +1592,7 @@ impl<'a> Parser<'a> {
return expr; return expr;
} }
err.enclose_in_block = Some(UnexpectedTokenAfterLabelSugg { err.enclose_in_block = Some(errors::UnexpectedTokenAfterLabelSugg {
left: span.shrink_to_lo(), left: span.shrink_to_lo(),
right: span.shrink_to_hi(), right: span.shrink_to_hi(),
}); });
@ -1622,7 +1608,7 @@ impl<'a> Parser<'a> {
}?; }?;
if !ate_colon && consume_colon { if !ate_colon && consume_colon {
self.sess.emit_err(RequireColonAfterLabeledExpression { self.sess.emit_err(errors::RequireColonAfterLabeledExpression {
span: expr.span, span: expr.span,
label: lo, label: lo,
label_end: lo.shrink_to_hi(), label_end: lo.shrink_to_hi(),
@ -1671,7 +1657,7 @@ impl<'a> Parser<'a> {
self.bump(); // `catch` self.bump(); // `catch`
let span = lo.to(self.prev_token.span); let span = lo.to(self.prev_token.span);
self.sess.emit_err(DoCatchSyntaxRemoved { span }); self.sess.emit_err(errors::DoCatchSyntaxRemoved { span });
self.parse_try_block(lo) self.parse_try_block(lo)
} }
@ -1719,9 +1705,9 @@ impl<'a> Parser<'a> {
// The value expression can be a labeled loop, see issue #86948, e.g.: // The value expression can be a labeled loop, see issue #86948, e.g.:
// `loop { break 'label: loop { break 'label 42; }; }` // `loop { break 'label: loop { break 'label 42; }; }`
let lexpr = self.parse_labeled_expr(label, true)?; let lexpr = self.parse_labeled_expr(label, true)?;
self.sess.emit_err(LabeledLoopInBreak { self.sess.emit_err(errors::LabeledLoopInBreak {
span: lexpr.span, span: lexpr.span,
sub: WrapExpressionInParentheses { sub: errors::WrapExpressionInParentheses {
left: lexpr.span.shrink_to_lo(), left: lexpr.span.shrink_to_lo(),
right: lexpr.span.shrink_to_hi(), right: lexpr.span.shrink_to_hi(),
}, },
@ -1841,7 +1827,7 @@ impl<'a> Parser<'a> {
}; };
if let Some(expr) = expr { if let Some(expr) = expr {
if matches!(expr.kind, ExprKind::Err) { if matches!(expr.kind, ExprKind::Err) {
let mut err = InvalidInterpolatedExpression { span: self.token.span } let mut err = errors::InvalidInterpolatedExpression { span: self.token.span }
.into_diagnostic(&self.sess.span_diagnostic); .into_diagnostic(&self.sess.span_diagnostic);
err.downgrade_to_delayed_bug(); err.downgrade_to_delayed_bug();
return Err(err); return Err(err);
@ -1902,7 +1888,7 @@ impl<'a> Parser<'a> {
}); });
if let Some(token) = &recovered { if let Some(token) = &recovered {
self.bump(); self.bump();
self.sess.emit_err(FloatLiteralRequiresIntegerPart { self.sess.emit_err(errors::FloatLiteralRequiresIntegerPart {
span: token.span, span: token.span,
correct: pprust::token_to_string(token).into_owned(), correct: pprust::token_to_string(token).into_owned(),
}); });
@ -1963,13 +1949,17 @@ impl<'a> Parser<'a> {
if [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suffix) { if [sym::i32, sym::u32, sym::isize, sym::usize].contains(&suffix) {
// #59553: warn instead of reject out of hand to allow the fix to percolate // #59553: warn instead of reject out of hand to allow the fix to percolate
// through the ecosystem when people fix their macros // through the ecosystem when people fix their macros
self.sess.emit_warning(InvalidLiteralSuffixOnTupleIndex { self.sess.emit_warning(errors::InvalidLiteralSuffixOnTupleIndex {
span, span,
suffix, suffix,
exception: Some(()), exception: Some(()),
}); });
} else { } else {
self.sess.emit_err(InvalidLiteralSuffixOnTupleIndex { span, suffix, exception: None }); self.sess.emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
span,
suffix,
exception: None,
});
} }
} }
@ -2003,9 +1993,9 @@ impl<'a> Parser<'a> {
let mut snapshot = self.create_snapshot_for_diagnostic(); let mut snapshot = self.create_snapshot_for_diagnostic();
match snapshot.parse_array_or_repeat_expr(Delimiter::Brace) { match snapshot.parse_array_or_repeat_expr(Delimiter::Brace) {
Ok(arr) => { Ok(arr) => {
self.sess.emit_err(ArrayBracketsInsteadOfSpaces { self.sess.emit_err(errors::ArrayBracketsInsteadOfSpaces {
span: arr.span, span: arr.span,
sub: ArrayBracketsInsteadOfSpacesSugg { sub: errors::ArrayBracketsInsteadOfSpacesSugg {
left: lo, left: lo,
right: snapshot.prev_token.span, right: snapshot.prev_token.span,
}, },
@ -2051,7 +2041,7 @@ impl<'a> Parser<'a> {
.span_to_snippet(snapshot.token.span) .span_to_snippet(snapshot.token.span)
.map_or(false, |snippet| snippet == "]") => .map_or(false, |snippet| snippet == "]") =>
{ {
return Err(MissingSemicolonBeforeArray { return Err(errors::MissingSemicolonBeforeArray {
open_delim: open_delim_span, open_delim: open_delim_span,
semicolon: prev_span.shrink_to_hi(), semicolon: prev_span.shrink_to_hi(),
}.into_diagnostic(&self.sess.span_diagnostic)); }.into_diagnostic(&self.sess.span_diagnostic));
@ -2077,7 +2067,7 @@ impl<'a> Parser<'a> {
} }
if self.token.is_whole_block() { if self.token.is_whole_block() {
self.sess.emit_err(InvalidBlockMacroSegment { self.sess.emit_err(errors::InvalidBlockMacroSegment {
span: self.token.span, span: self.token.span,
context: lo.to(self.token.span), context: lo.to(self.token.span),
}); });
@ -2181,7 +2171,7 @@ impl<'a> Parser<'a> {
// Check for `move async` and recover // Check for `move async` and recover
if self.check_keyword(kw::Async) { if self.check_keyword(kw::Async) {
let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo); let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
Err(AsyncMoveOrderIncorrect { span: move_async_span } Err(errors::AsyncMoveOrderIncorrect { span: move_async_span }
.into_diagnostic(&self.sess.span_diagnostic)) .into_diagnostic(&self.sess.span_diagnostic))
} else { } else {
Ok(CaptureBy::Value) Ok(CaptureBy::Value)
@ -2259,17 +2249,17 @@ impl<'a> Parser<'a> {
let block = match &mut cond.kind { let block = match &mut cond.kind {
ExprKind::Binary(Spanned { span: binop_span, .. }, _, right) ExprKind::Binary(Spanned { span: binop_span, .. }, _, right)
if let ExprKind::Block(_, None) = right.kind => { if let ExprKind::Block(_, None) = right.kind => {
self.sess.emit_err(IfExpressionMissingThenBlock { self.sess.emit_err(errors::IfExpressionMissingThenBlock {
if_span: lo, if_span: lo,
missing_then_block_sub: missing_then_block_sub:
IfExpressionMissingThenBlockSub::UnfinishedCondition(cond_span.shrink_to_lo().to(*binop_span)), errors::IfExpressionMissingThenBlockSub::UnfinishedCondition(cond_span.shrink_to_lo().to(*binop_span)),
let_else_sub: None, let_else_sub: None,
}); });
std::mem::replace(right, this.mk_expr_err(binop_span.shrink_to_hi())) std::mem::replace(right, this.mk_expr_err(binop_span.shrink_to_hi()))
}, },
ExprKind::Block(_, None) => { ExprKind::Block(_, None) => {
self.sess.emit_err(IfExpressionMissingCondition { self.sess.emit_err(errors::IfExpressionMissingCondition {
if_span: lo.shrink_to_hi(), if_span: lo.shrink_to_hi(),
block_span: self.sess.source_map().start_point(cond_span), block_span: self.sess.source_map().start_point(cond_span),
}); });
@ -2291,11 +2281,11 @@ impl<'a> Parser<'a> {
block block
} else { } else {
let let_else_sub = matches!(cond.kind, ExprKind::Let(..)) let let_else_sub = matches!(cond.kind, ExprKind::Let(..))
.then(|| IfExpressionLetSomeSub { if_span: lo.until(cond_span) }); .then(|| errors::IfExpressionLetSomeSub { if_span: lo.until(cond_span) });
self.sess.emit_err(IfExpressionMissingThenBlock { self.sess.emit_err(errors::IfExpressionMissingThenBlock {
if_span: lo, if_span: lo,
missing_then_block_sub: IfExpressionMissingThenBlockSub::AddThenBlock( missing_then_block_sub: errors::IfExpressionMissingThenBlockSub::AddThenBlock(
cond_span.shrink_to_hi(), cond_span.shrink_to_hi(),
), ),
let_else_sub, let_else_sub,
@ -2351,7 +2341,7 @@ impl<'a> Parser<'a> {
TokenKind::AndAnd | TokenKind::Ident(kw::If, _) | TokenKind::Ident(kw::While, _) TokenKind::AndAnd | TokenKind::Ident(kw::If, _) | TokenKind::Ident(kw::While, _)
); );
if !self.restrictions.contains(Restrictions::ALLOW_LET) || not_in_chain { if !self.restrictions.contains(Restrictions::ALLOW_LET) || not_in_chain {
self.sess.emit_err(ExpectedExpressionFoundLet { span: self.token.span }); self.sess.emit_err(errors::ExpectedExpressionFoundLet { span: self.token.span });
} }
self.bump(); // Eat `let` token self.bump(); // Eat `let` token
@ -2363,7 +2353,7 @@ impl<'a> Parser<'a> {
CommaRecoveryMode::LikelyTuple, CommaRecoveryMode::LikelyTuple,
)?; )?;
if self.token == token::EqEq { if self.token == token::EqEq {
self.sess.emit_err(ExpectedEqForLetExpr { self.sess.emit_err(errors::ExpectedEqForLetExpr {
span: self.token.span, span: self.token.span,
sugg_span: self.token.span, sugg_span: self.token.span,
}); });
@ -2398,7 +2388,7 @@ impl<'a> Parser<'a> {
if self.check(&TokenKind::OpenDelim(Delimiter::Brace)) if self.check(&TokenKind::OpenDelim(Delimiter::Brace))
&& classify::expr_requires_semi_to_be_stmt(&cond) => && classify::expr_requires_semi_to_be_stmt(&cond) =>
{ {
self.sess.emit_err(ExpectedElseBlock { self.sess.emit_err(errors::ExpectedElseBlock {
first_tok_span, first_tok_span,
first_tok, first_tok,
else_span, else_span,
@ -2438,7 +2428,7 @@ impl<'a> Parser<'a> {
[x0 @ xn] | [x0, .., xn] => (x0.span.to(xn.span), xn.span), [x0 @ xn] | [x0, .., xn] => (x0.span.to(xn.span), xn.span),
}; };
let ctx = if is_ctx_else { "else" } else { "if" }; let ctx = if is_ctx_else { "else" } else { "if" };
self.sess.emit_err(OuterAttributeNotAllowedOnIfElse { self.sess.emit_err(errors::OuterAttributeNotAllowedOnIfElse {
last, last,
branch_span, branch_span,
ctx_span, ctx_span,
@ -2451,7 +2441,7 @@ impl<'a> Parser<'a> {
if let ExprKind::Binary(Spanned { span: binop_span, node: binop}, _, right) = &cond.kind && if let ExprKind::Binary(Spanned { span: binop_span, node: binop}, _, right) = &cond.kind &&
let BinOpKind::And = binop && let BinOpKind::And = binop &&
let ExprKind::If(cond, ..) = &right.kind { let ExprKind::If(cond, ..) = &right.kind {
Err(self.sess.create_err(UnexpectedIfWithIf(binop_span.shrink_to_hi().to(cond.span.shrink_to_lo())))) Err(self.sess.create_err(errors::UnexpectedIfWithIf(binop_span.shrink_to_hi().to(cond.span.shrink_to_lo()))))
} else { } else {
Ok(()) Ok(())
} }
@ -2492,12 +2482,12 @@ impl<'a> Parser<'a> {
// Possibly using JS syntax (#75311). // Possibly using JS syntax (#75311).
let span = self.token.span; let span = self.token.span;
self.bump(); self.bump();
(span, MissingInInForLoopSub::InNotOf) (span, errors::MissingInInForLoopSub::InNotOf)
} else { } else {
(self.prev_token.span.between(self.token.span), MissingInInForLoopSub::AddIn) (self.prev_token.span.between(self.token.span), errors::MissingInInForLoopSub::AddIn)
}; };
self.sess.emit_err(MissingInInForLoop { span, sub: sub(span) }); self.sess.emit_err(errors::MissingInInForLoop { span, sub: sub(span) });
} }
/// Parses a `while` or `while let` expression (`while` token already eaten). /// Parses a `while` or `while let` expression (`while` token already eaten).
@ -2601,17 +2591,17 @@ impl<'a> Parser<'a> {
let err = |this: &Parser<'_>, stmts: Vec<ast::Stmt>| { let err = |this: &Parser<'_>, stmts: Vec<ast::Stmt>| {
let span = stmts[0].span.to(stmts[stmts.len() - 1].span); let span = stmts[0].span.to(stmts[stmts.len() - 1].span);
this.sess.emit_err(MatchArmBodyWithoutBraces { this.sess.emit_err(errors::MatchArmBodyWithoutBraces {
statements: span, statements: span,
arrow: arrow_span, arrow: arrow_span,
num_statements: stmts.len(), num_statements: stmts.len(),
sub: if stmts.len() > 1 { sub: if stmts.len() > 1 {
MatchArmBodyWithoutBracesSugg::AddBraces { errors::MatchArmBodyWithoutBracesSugg::AddBraces {
left: span.shrink_to_lo(), left: span.shrink_to_lo(),
right: span.shrink_to_hi(), right: span.shrink_to_hi(),
} }
} else { } else {
MatchArmBodyWithoutBracesSugg::UseComma { semicolon: semi_sp } errors::MatchArmBodyWithoutBracesSugg::UseComma { semicolon: semi_sp }
}, },
}); });
this.mk_expr_err(span) this.mk_expr_err(span)
@ -2802,7 +2792,7 @@ impl<'a> Parser<'a> {
.is_ok(); .is_ok();
if pattern_follows && snapshot.check(&TokenKind::FatArrow) { if pattern_follows && snapshot.check(&TokenKind::FatArrow) {
err.cancel(); err.cancel();
this.sess.emit_err(MissingCommaAfterMatchArm { this.sess.emit_err(errors::MissingCommaAfterMatchArm {
span: hi.shrink_to_hi(), span: hi.shrink_to_hi(),
}); });
return Ok(true); return Ok(true);
@ -2834,7 +2824,7 @@ impl<'a> Parser<'a> {
fn parse_try_block(&mut self, span_lo: Span) -> PResult<'a, P<Expr>> { fn parse_try_block(&mut self, span_lo: Span) -> PResult<'a, P<Expr>> {
let (attrs, body) = self.parse_inner_attrs_and_block()?; let (attrs, body) = self.parse_inner_attrs_and_block()?;
if self.eat_keyword(kw::Catch) { if self.eat_keyword(kw::Catch) {
Err(CatchAfterTry { span: self.prev_token.span } Err(errors::CatchAfterTry { span: self.prev_token.span }
.into_diagnostic(&self.sess.span_diagnostic)) .into_diagnostic(&self.sess.span_diagnostic))
} else { } else {
let span = span_lo.to(body.span); let span = span_lo.to(body.span);
@ -2910,9 +2900,9 @@ impl<'a> Parser<'a> {
let expr = self.parse_struct_expr(qself.clone(), path.clone(), true); let expr = self.parse_struct_expr(qself.clone(), path.clone(), true);
if let (Ok(expr), false) = (&expr, struct_allowed) { if let (Ok(expr), false) = (&expr, struct_allowed) {
// This is a struct literal, but we don't can't accept them here. // This is a struct literal, but we don't can't accept them here.
self.sess.emit_err(StructLiteralNotAllowedHere { self.sess.emit_err(errors::StructLiteralNotAllowedHere {
span: expr.span, span: expr.span,
sub: StructLiteralNotAllowedHereSugg { sub: errors::StructLiteralNotAllowedHereSugg {
left: path.span.shrink_to_lo(), left: path.span.shrink_to_lo(),
right: expr.span.shrink_to_hi(), right: expr.span.shrink_to_hi(),
}, },
@ -2935,8 +2925,8 @@ impl<'a> Parser<'a> {
let mut async_block_err = |e: &mut Diagnostic, span: Span| { let mut async_block_err = |e: &mut Diagnostic, span: Span| {
recover_async = true; recover_async = true;
AsyncBlockIn2015 { span }.add_to_diagnostic(e); errors::AsyncBlockIn2015 { span }.add_to_diagnostic(e);
HelpUseLatestEdition::new().add_to_diagnostic(e); errors::HelpUseLatestEdition::new().add_to_diagnostic(e);
}; };
while self.token != token::CloseDelim(close_delim) { while self.token != token::CloseDelim(close_delim) {
@ -3080,7 +3070,7 @@ impl<'a> Parser<'a> {
if self.token != token::Comma { if self.token != token::Comma {
return; return;
} }
self.sess.emit_err(CommaAfterBaseStruct { self.sess.emit_err(errors::CommaAfterBaseStruct {
span: span.to(self.prev_token.span), span: span.to(self.prev_token.span),
comma: self.token.span, comma: self.token.span,
}); });
@ -3093,7 +3083,7 @@ impl<'a> Parser<'a> {
{ {
// recover from typo of `...`, suggest `..` // recover from typo of `...`, suggest `..`
let span = self.prev_token.span; let span = self.prev_token.span;
self.sess.emit_err(MissingDotDot { token_span: span, sugg_span: span }); self.sess.emit_err(errors::MissingDotDot { token_span: span, sugg_span: span });
return true; return true;
} }
false false
@ -3161,18 +3151,18 @@ impl<'a> Parser<'a> {
return; return;
} }
self.sess.emit_err(EqFieldInit { self.sess.emit_err(errors::EqFieldInit {
span: self.token.span, span: self.token.span,
eq: field_name.span.shrink_to_hi().to(self.token.span), eq: field_name.span.shrink_to_hi().to(self.token.span),
}); });
} }
fn err_dotdotdot_syntax(&self, span: Span) { fn err_dotdotdot_syntax(&self, span: Span) {
self.sess.emit_err(DotDotDot { span }); self.sess.emit_err(errors::DotDotDot { span });
} }
fn err_larrow_operator(&self, span: Span) { fn err_larrow_operator(&self, span: Span) {
self.sess.emit_err(LeftArrowOperator { span }); self.sess.emit_err(errors::LeftArrowOperator { span });
} }
fn mk_assign_op(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind { fn mk_assign_op(&self, binop: BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ExprKind {

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

@ -7,12 +7,7 @@ use super::TrailingToken;
use super::{ use super::{
AttrWrapper, BlockMode, FnParseMode, ForceCollect, Parser, Restrictions, SemiColonMode, AttrWrapper, BlockMode, FnParseMode, ForceCollect, Parser, Restrictions, SemiColonMode,
}; };
use crate::errors::{ use crate::errors;
AssignmentElseNotAllowed, CompoundAssignmentExpressionInLet, ConstLetMutuallyExclusive,
DocCommentDoesNotDocumentAnything, ExpectedStatementAfterOuterAttr, InvalidCurlyInLetElse,
InvalidExpressionInLetElse, InvalidIdentiferStartsWithNumber, InvalidVariableDeclaration,
InvalidVariableDeclarationSub, WrapExpressionInParentheses,
};
use crate::maybe_whole; use crate::maybe_whole;
use rustc_ast as ast; use rustc_ast as ast;
@ -64,29 +59,33 @@ impl<'a> Parser<'a> {
if self.token.is_keyword(kw::Mut) && self.is_keyword_ahead(1, &[kw::Let]) { if self.token.is_keyword(kw::Mut) && self.is_keyword_ahead(1, &[kw::Let]) {
self.bump(); self.bump();
let mut_let_span = lo.to(self.token.span); let mut_let_span = lo.to(self.token.span);
self.sess.emit_err(InvalidVariableDeclaration { self.sess.emit_err(errors::InvalidVariableDeclaration {
span: mut_let_span, span: mut_let_span,
sub: InvalidVariableDeclarationSub::SwitchMutLetOrder(mut_let_span), sub: errors::InvalidVariableDeclarationSub::SwitchMutLetOrder(mut_let_span),
}); });
} }
Ok(Some(if self.token.is_keyword(kw::Let) { Ok(Some(if self.token.is_keyword(kw::Let) {
self.parse_local_mk(lo, attrs, capture_semi, force_collect)? self.parse_local_mk(lo, attrs, capture_semi, force_collect)?
} else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() { } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
self.recover_stmt_local_after_let(lo, attrs, InvalidVariableDeclarationSub::MissingLet)? self.recover_stmt_local_after_let(
lo,
attrs,
errors::InvalidVariableDeclarationSub::MissingLet,
)?
} else if self.is_kw_followed_by_ident(kw::Auto) && self.may_recover() { } else if self.is_kw_followed_by_ident(kw::Auto) && self.may_recover() {
self.bump(); // `auto` self.bump(); // `auto`
self.recover_stmt_local_after_let( self.recover_stmt_local_after_let(
lo, lo,
attrs, attrs,
InvalidVariableDeclarationSub::UseLetNotAuto, errors::InvalidVariableDeclarationSub::UseLetNotAuto,
)? )?
} else if self.is_kw_followed_by_ident(sym::var) && self.may_recover() { } else if self.is_kw_followed_by_ident(sym::var) && self.may_recover() {
self.bump(); // `var` self.bump(); // `var`
self.recover_stmt_local_after_let( self.recover_stmt_local_after_let(
lo, lo,
attrs, attrs,
InvalidVariableDeclarationSub::UseLetNotVar, errors::InvalidVariableDeclarationSub::UseLetNotVar,
)? )?
} else if self.check_path() && !self.token.is_qpath_start() && !self.is_path_start_item() { } else if self.check_path() && !self.token.is_qpath_start() && !self.is_path_start_item() {
// We have avoided contextual keywords like `union`, items with `crate` visibility, // We have avoided contextual keywords like `union`, items with `crate` visibility,
@ -124,7 +123,7 @@ impl<'a> Parser<'a> {
let bl = self.parse_block()?; let bl = self.parse_block()?;
// Destructuring assignment ... else. // Destructuring assignment ... else.
// This is not allowed, but point it out in a nice way. // This is not allowed, but point it out in a nice way.
self.sess.emit_err(AssignmentElseNotAllowed { span: e.span.to(bl.span) }); self.sess.emit_err(errors::AssignmentElseNotAllowed { span: e.span.to(bl.span) });
} }
self.mk_stmt(lo.to(e.span), StmtKind::Expr(e)) self.mk_stmt(lo.to(e.span), StmtKind::Expr(e))
} else { } else {
@ -217,12 +216,12 @@ impl<'a> Parser<'a> {
&& let attrs = attrs.take_for_recovery(self.sess) && let attrs = attrs.take_for_recovery(self.sess)
&& let attrs @ [.., last] = &*attrs { && let attrs @ [.., last] = &*attrs {
if last.is_doc_comment() { if last.is_doc_comment() {
self.sess.emit_err(DocCommentDoesNotDocumentAnything { self.sess.emit_err(errors::DocCommentDoesNotDocumentAnything {
span: last.span, span: last.span,
missing_comma: None, missing_comma: None,
}); });
} else if attrs.iter().any(|a| a.style == AttrStyle::Outer) { } else if attrs.iter().any(|a| a.style == AttrStyle::Outer) {
self.sess.emit_err(ExpectedStatementAfterOuterAttr { span: last.span }); self.sess.emit_err(errors::ExpectedStatementAfterOuterAttr { span: last.span });
} }
} }
} }
@ -231,7 +230,7 @@ impl<'a> Parser<'a> {
&mut self, &mut self,
lo: Span, lo: Span,
attrs: AttrWrapper, attrs: AttrWrapper,
subdiagnostic: fn(Span) -> InvalidVariableDeclarationSub, subdiagnostic: fn(Span) -> errors::InvalidVariableDeclarationSub,
) -> PResult<'a, Stmt> { ) -> PResult<'a, Stmt> {
let stmt = let stmt =
self.collect_tokens_trailing_token(attrs, ForceCollect::Yes, |this, attrs| { self.collect_tokens_trailing_token(attrs, ForceCollect::Yes, |this, attrs| {
@ -242,7 +241,7 @@ impl<'a> Parser<'a> {
TrailingToken::None, TrailingToken::None,
)) ))
})?; })?;
self.sess.emit_err(InvalidVariableDeclaration { span: lo, sub: subdiagnostic(lo) }); self.sess.emit_err(errors::InvalidVariableDeclaration { span: lo, sub: subdiagnostic(lo) });
Ok(stmt) Ok(stmt)
} }
@ -270,7 +269,7 @@ impl<'a> Parser<'a> {
let lo = self.prev_token.span; let lo = self.prev_token.span;
if self.token.is_keyword(kw::Const) && self.look_ahead(1, |t| t.is_ident()) { if self.token.is_keyword(kw::Const) && self.look_ahead(1, |t| t.is_ident()) {
self.sess.emit_err(ConstLetMutuallyExclusive { span: lo.to(self.token.span) }); self.sess.emit_err(errors::ConstLetMutuallyExclusive { span: lo.to(self.token.span) });
self.bump(); self.bump();
} }
@ -373,7 +372,7 @@ impl<'a> Parser<'a> {
rustc_ast::MetaItemLit::from_token(&self.token).is_none() && rustc_ast::MetaItemLit::from_token(&self.token).is_none() &&
(lit.kind == token::LitKind::Integer || lit.kind == token::LitKind::Float) && (lit.kind == token::LitKind::Integer || lit.kind == token::LitKind::Float) &&
self.look_ahead(1, |t| matches!(t.kind, token::Eq) || matches!(t.kind, token::Colon ) ) { self.look_ahead(1, |t| matches!(t.kind, token::Eq) || matches!(t.kind, token::Colon ) ) {
return Err(self.sess.create_err(InvalidIdentiferStartsWithNumber { span: self.token.span })); return Err(self.sess.create_err(errors::InvalidIdentiferStartsWithNumber { span: self.token.span }));
} }
Ok(()) Ok(())
} }
@ -381,10 +380,10 @@ impl<'a> Parser<'a> {
fn check_let_else_init_bool_expr(&self, init: &ast::Expr) { fn check_let_else_init_bool_expr(&self, init: &ast::Expr) {
if let ast::ExprKind::Binary(op, ..) = init.kind { if let ast::ExprKind::Binary(op, ..) = init.kind {
if op.node.lazy() { if op.node.lazy() {
self.sess.emit_err(InvalidExpressionInLetElse { self.sess.emit_err(errors::InvalidExpressionInLetElse {
span: init.span, span: init.span,
operator: op.node.to_string(), operator: op.node.to_string(),
sugg: WrapExpressionInParentheses { sugg: errors::WrapExpressionInParentheses {
left: init.span.shrink_to_lo(), left: init.span.shrink_to_lo(),
right: init.span.shrink_to_hi(), right: init.span.shrink_to_hi(),
}, },
@ -395,9 +394,9 @@ impl<'a> Parser<'a> {
fn check_let_else_init_trailing_brace(&self, init: &ast::Expr) { fn check_let_else_init_trailing_brace(&self, init: &ast::Expr) {
if let Some(trailing) = classify::expr_trailing_brace(init) { if let Some(trailing) = classify::expr_trailing_brace(init) {
self.sess.emit_err(InvalidCurlyInLetElse { self.sess.emit_err(errors::InvalidCurlyInLetElse {
span: trailing.span.with_lo(trailing.span.hi() - BytePos(1)), span: trailing.span.with_lo(trailing.span.hi() - BytePos(1)),
sugg: WrapExpressionInParentheses { sugg: errors::WrapExpressionInParentheses {
left: trailing.span.shrink_to_lo(), left: trailing.span.shrink_to_lo(),
right: trailing.span.shrink_to_hi(), right: trailing.span.shrink_to_hi(),
}, },
@ -410,7 +409,8 @@ impl<'a> Parser<'a> {
let eq_consumed = match self.token.kind { let eq_consumed = match self.token.kind {
token::BinOpEq(..) => { token::BinOpEq(..) => {
// Recover `let x <op>= 1` as `let x = 1` // Recover `let x <op>= 1` as `let x = 1`
self.sess.emit_err(CompoundAssignmentExpressionInLet { span: self.token.span }); self.sess
.emit_err(errors::CompoundAssignmentExpressionInLet { span: self.token.span });
self.bump(); self.bump();
true true
} }