compiler/rustc_parse/src/errors.rs

   1 use rustc_ast::token::Token;
   2 use rustc_ast::Path;
   3 use rustc_errors::{fluent, AddToDiagnostic, Applicability, EmissionGuarantee, IntoDiagnostic};
   4 use rustc_macros::{Diagnostic, Subdiagnostic};
   5 use rustc_session::errors::ExprParenthesesNeeded;
   6 use rustc_span::symbol::Ident;
   7 use rustc_span::{Span, Symbol};
   8
   9 use crate::parser::TokenDescription;
  10
  11 #[derive(Diagnostic)]
  12 #[diag(parse_maybe_report_ambiguous_plus)]
  13 pub(crate) struct AmbiguousPlus {
  14     pub sum_ty: String,
  15     #[primary_span]
  16     #[suggestion(code = "({sum_ty})")]
  17     pub span: Span,
  18 }
  19
  20 #[derive(Diagnostic)]
  21 #[diag(parse_maybe_recover_from_bad_type_plus, code = "E0178")]
  22 pub(crate) struct BadTypePlus {
  23     pub ty: String,
  24     #[primary_span]
  25     pub span: Span,
  26     #[subdiagnostic]
  27     pub sub: BadTypePlusSub,
  28 }
  29
  30 #[derive(Subdiagnostic)]
  31 pub(crate) enum BadTypePlusSub {
  32     #[suggestion(
  33         parse_add_paren,
  34         code = "{sum_with_parens}",
  35         applicability = "machine-applicable"
  36     )]
  37     AddParen {
  38         sum_with_parens: String,
  39         #[primary_span]
  40         span: Span,
  41     },
  42     #[label(parse_forgot_paren)]
  43     ForgotParen {
  44         #[primary_span]
  45         span: Span,
  46     },
  47     #[label(parse_expect_path)]
  48     ExpectPath {
  49         #[primary_span]
  50         span: Span,
  51     },
  52 }
  53
  54 #[derive(Diagnostic)]
  55 #[diag(parse_maybe_recover_from_bad_qpath_stage_2)]
  56 pub(crate) struct BadQPathStage2 {
  57     #[primary_span]
  58     #[suggestion(code = "", applicability = "maybe-incorrect")]
  59     pub span: Span,
  60     pub ty: String,
  61 }
  62
  63 #[derive(Diagnostic)]
  64 #[diag(parse_incorrect_semicolon)]
  65 pub(crate) struct IncorrectSemicolon<'a> {
  66     #[primary_span]
  67     #[suggestion(style = "short", code = "", applicability = "machine-applicable")]
  68     pub span: Span,
  69     #[help]
  70     pub opt_help: Option<()>,
  71     pub name: &'a str,
  72 }
  73
  74 #[derive(Diagnostic)]
  75 #[diag(parse_incorrect_use_of_await)]
  76 pub(crate) struct IncorrectUseOfAwait {
  77     #[primary_span]
  78     #[suggestion(parentheses_suggestion, code = "", applicability = "machine-applicable")]
  79     pub span: Span,
  80 }
  81
  82 #[derive(Diagnostic)]
  83 #[diag(parse_incorrect_use_of_await)]
  84 pub(crate) struct IncorrectAwait {
  85     #[primary_span]
  86     pub span: Span,
  87     #[suggestion(postfix_suggestion, code = "{expr}.await{question_mark}")]
  88     pub sugg_span: (Span, Applicability),
  89     pub expr: String,
  90     pub question_mark: &'static str,
  91 }
  92
  93 #[derive(Diagnostic)]
  94 #[diag(parse_in_in_typo)]
  95 pub(crate) struct InInTypo {
  96     #[primary_span]
  97     pub span: Span,
  98     #[suggestion(code = "", applicability = "machine-applicable")]
  99     pub sugg_span: Span,
 100 }
 101
 102 #[derive(Diagnostic)]
 103 #[diag(parse_invalid_variable_declaration)]
 104 pub(crate) struct InvalidVariableDeclaration {
 105     #[primary_span]
 106     pub span: Span,
 107     #[subdiagnostic]
 108     pub sub: InvalidVariableDeclarationSub,
 109 }
 110
 111 #[derive(Subdiagnostic)]
 112 pub(crate) enum InvalidVariableDeclarationSub {
 113     #[suggestion(parse_switch_mut_let_order, applicability = "maybe-incorrect", code = "let mut")]
 114     SwitchMutLetOrder(#[primary_span] Span),
 115     #[suggestion(
 116         parse_missing_let_before_mut,
 117         applicability = "machine-applicable",
 118         code = "let mut"
 119     )]
 120     MissingLet(#[primary_span] Span),
 121     #[suggestion(parse_use_let_not_auto, applicability = "machine-applicable", code = "let")]
 122     UseLetNotAuto(#[primary_span] Span),
 123     #[suggestion(parse_use_let_not_var, applicability = "machine-applicable", code = "let")]
 124     UseLetNotVar(#[primary_span] Span),
 125 }
 126
 127 #[derive(Diagnostic)]
 128 #[diag(parse_invalid_comparison_operator)]
 129 pub(crate) struct InvalidComparisonOperator {
 130     #[primary_span]
 131     pub span: Span,
 132     pub invalid: String,
 133     #[subdiagnostic]
 134     pub sub: InvalidComparisonOperatorSub,
 135 }
 136
 137 #[derive(Subdiagnostic)]
 138 pub(crate) enum InvalidComparisonOperatorSub {
 139     #[suggestion(
 140         use_instead,
 141         style = "short",
 142         applicability = "machine-applicable",
 143         code = "{correct}"
 144     )]
 145     Correctable {
 146         #[primary_span]
 147         span: Span,
 148         invalid: String,
 149         correct: String,
 150     },
 151     #[label(spaceship_operator_invalid)]
 152     Spaceship(#[primary_span] Span),
 153 }
 154
 155 #[derive(Diagnostic)]
 156 #[diag(parse_invalid_logical_operator)]
 157 #[note]
 158 pub(crate) struct InvalidLogicalOperator {
 159     #[primary_span]
 160     pub span: Span,
 161     pub incorrect: String,
 162     #[subdiagnostic]
 163     pub sub: InvalidLogicalOperatorSub,
 164 }
 165
 166 #[derive(Subdiagnostic)]
 167 pub(crate) enum InvalidLogicalOperatorSub {
 168     #[suggestion(
 169         use_amp_amp_for_conjunction,
 170         style = "short",
 171         applicability = "machine-applicable",
 172         code = "&&"
 173     )]
 174     Conjunction(#[primary_span] Span),
 175     #[suggestion(
 176         use_pipe_pipe_for_disjunction,
 177         style = "short",
 178         applicability = "machine-applicable",
 179         code = "||"
 180     )]
 181     Disjunction(#[primary_span] Span),
 182 }
 183
 184 #[derive(Diagnostic)]
 185 #[diag(parse_tilde_is_not_unary_operator)]
 186 pub(crate) struct TildeAsUnaryOperator(
 187     #[primary_span]
 188     #[suggestion(style = "short", applicability = "machine-applicable", code = "!")]
 189     pub Span,
 190 );
 191
 192 #[derive(Diagnostic)]
 193 #[diag(parse_unexpected_token_after_not)]
 194 pub(crate) struct NotAsNegationOperator {
 195     #[primary_span]
 196     pub negated: Span,
 197     pub negated_desc: String,
 198     #[subdiagnostic]
 199     pub sub: NotAsNegationOperatorSub,
 200 }
 201
 202 #[derive(Subdiagnostic)]
 203 pub enum NotAsNegationOperatorSub {
 204     #[suggestion(
 205         parse_unexpected_token_after_not_default,
 206         style = "short",
 207         applicability = "machine-applicable",
 208         code = "!"
 209     )]
 210     SuggestNotDefault(#[primary_span] Span),
 211
 212     #[suggestion(
 213         parse_unexpected_token_after_not_bitwise,
 214         style = "short",
 215         applicability = "machine-applicable",
 216         code = "!"
 217     )]
 218     SuggestNotBitwise(#[primary_span] Span),
 219
 220     #[suggestion(
 221         parse_unexpected_token_after_not_logical,
 222         style = "short",
 223         applicability = "machine-applicable",
 224         code = "!"
 225     )]
 226     SuggestNotLogical(#[primary_span] Span),
 227 }
 228
 229 #[derive(Diagnostic)]
 230 #[diag(parse_malformed_loop_label)]
 231 pub(crate) struct MalformedLoopLabel {
 232     #[primary_span]
 233     #[suggestion(applicability = "machine-applicable", code = "{correct_label}")]
 234     pub span: Span,
 235     pub correct_label: Ident,
 236 }
 237
 238 #[derive(Diagnostic)]
 239 #[diag(parse_lifetime_in_borrow_expression)]
 240 pub(crate) struct LifetimeInBorrowExpression {
 241     #[primary_span]
 242     pub span: Span,
 243     #[suggestion(applicability = "machine-applicable", code = "")]
 244     #[label]
 245     pub lifetime_span: Span,
 246 }
 247
 248 #[derive(Diagnostic)]
 249 #[diag(parse_field_expression_with_generic)]
 250 pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span);
 251
 252 #[derive(Diagnostic)]
 253 #[diag(parse_macro_invocation_with_qualified_path)]
 254 pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span);
 255
 256 #[derive(Diagnostic)]
 257 #[diag(parse_unexpected_token_after_label)]
 258 pub(crate) struct UnexpectedTokenAfterLabel {
 259     #[primary_span]
 260     #[label(parse_unexpected_token_after_label)]
 261     pub span: Span,
 262     #[suggestion(suggestion_remove_label, style = "verbose", code = "")]
 263     pub remove_label: Option<Span>,
 264     #[subdiagnostic]
 265     pub enclose_in_block: Option<UnexpectedTokenAfterLabelSugg>,
 266 }
 267
 268 #[derive(Subdiagnostic)]
 269 #[multipart_suggestion(suggestion_enclose_in_block, applicability = "machine-applicable")]
 270 pub(crate) struct UnexpectedTokenAfterLabelSugg {
 271     #[suggestion_part(code = "{{ ")]
 272     pub left: Span,
 273     #[suggestion_part(code = " }}")]
 274     pub right: Span,
 275 }
 276
 277 #[derive(Diagnostic)]
 278 #[diag(parse_require_colon_after_labeled_expression)]
 279 #[note]
 280 pub(crate) struct RequireColonAfterLabeledExpression {
 281     #[primary_span]
 282     pub span: Span,
 283     #[label]
 284     pub label: Span,
 285     #[suggestion(style = "short", applicability = "machine-applicable", code = ": ")]
 286     pub label_end: Span,
 287 }
 288
 289 #[derive(Diagnostic)]
 290 #[diag(parse_do_catch_syntax_removed)]
 291 #[note]
 292 pub(crate) struct DoCatchSyntaxRemoved {
 293     #[primary_span]
 294     #[suggestion(applicability = "machine-applicable", code = "try")]
 295     pub span: Span,
 296 }
 297
 298 #[derive(Diagnostic)]
 299 #[diag(parse_float_literal_requires_integer_part)]
 300 pub(crate) struct FloatLiteralRequiresIntegerPart {
 301     #[primary_span]
 302     #[suggestion(applicability = "machine-applicable", code = "{correct}")]
 303     pub span: Span,
 304     pub correct: String,
 305 }
 306
 307 #[derive(Diagnostic)]
 308 #[diag(parse_missing_semicolon_before_array)]
 309 pub(crate) struct MissingSemicolonBeforeArray {
 310     #[primary_span]
 311     pub open_delim: Span,
 312     #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = ";")]
 313     pub semicolon: Span,
 314 }
 315
 316 #[derive(Diagnostic)]
 317 #[diag(parse_expect_dotdot_not_dotdotdot)]
 318 pub(crate) struct MissingDotDot {
 319     #[primary_span]
 320     pub token_span: Span,
 321     #[suggestion(applicability = "maybe-incorrect", code = "..", style = "verbose")]
 322     pub sugg_span: Span,
 323 }
 324
 325 #[derive(Diagnostic)]
 326 #[diag(parse_invalid_block_macro_segment)]
 327 pub(crate) struct InvalidBlockMacroSegment {
 328     #[primary_span]
 329     pub span: Span,
 330     #[label]
 331     pub context: Span,
 332 }
 333
 334 #[derive(Diagnostic)]
 335 #[diag(parse_if_expression_missing_then_block)]
 336 pub(crate) struct IfExpressionMissingThenBlock {
 337     #[primary_span]
 338     pub if_span: Span,
 339     #[subdiagnostic]
 340     pub missing_then_block_sub: IfExpressionMissingThenBlockSub,
 341     #[subdiagnostic]
 342     pub let_else_sub: Option<IfExpressionLetSomeSub>,
 343 }
 344
 345 #[derive(Subdiagnostic)]
 346 pub(crate) enum IfExpressionMissingThenBlockSub {
 347     #[help(condition_possibly_unfinished)]
 348     UnfinishedCondition(#[primary_span] Span),
 349     #[help(add_then_block)]
 350     AddThenBlock(#[primary_span] Span),
 351 }
 352
 353 #[derive(Subdiagnostic)]
 354 #[help(parse_extra_if_in_let_else)]
 355 pub(crate) struct IfExpressionLetSomeSub {
 356     #[primary_span]
 357     pub if_span: Span,
 358 }
 359
 360 #[derive(Diagnostic)]
 361 #[diag(parse_if_expression_missing_condition)]
 362 pub(crate) struct IfExpressionMissingCondition {
 363     #[primary_span]
 364     #[label(condition_label)]
 365     pub if_span: Span,
 366     #[label(block_label)]
 367     pub block_span: Span,
 368 }
 369
 370 #[derive(Diagnostic)]
 371 #[diag(parse_expected_expression_found_let)]
 372 pub(crate) struct ExpectedExpressionFoundLet {
 373     #[primary_span]
 374     pub span: Span,
 375 }
 376
 377 #[derive(Diagnostic)]
 378 #[diag(parse_expect_eq_instead_of_eqeq)]
 379 pub(crate) struct ExpectedEqForLetExpr {
 380     #[primary_span]
 381     pub span: Span,
 382     #[suggestion(applicability = "maybe-incorrect", code = "=", style = "verbose")]
 383     pub sugg_span: Span,
 384 }
 385
 386 #[derive(Diagnostic)]
 387 #[diag(parse_expected_else_block)]
 388 pub(crate) struct ExpectedElseBlock {
 389     #[primary_span]
 390     pub first_tok_span: Span,
 391     pub first_tok: String,
 392     #[label]
 393     pub else_span: Span,
 394     #[suggestion(applicability = "maybe-incorrect", code = "if ")]
 395     pub condition_start: Span,
 396 }
 397
 398 #[derive(Diagnostic)]
 399 #[diag(parse_outer_attribute_not_allowed_on_if_else)]
 400 pub(crate) struct OuterAttributeNotAllowedOnIfElse {
 401     #[primary_span]
 402     pub last: Span,
 403
 404     #[label(branch_label)]
 405     pub branch_span: Span,
 406
 407     #[label(ctx_label)]
 408     pub ctx_span: Span,
 409     pub ctx: String,
 410
 411     #[suggestion(applicability = "machine-applicable", code = "")]
 412     pub attributes: Span,
 413 }
 414
 415 #[derive(Diagnostic)]
 416 #[diag(parse_missing_in_in_for_loop)]
 417 pub(crate) struct MissingInInForLoop {
 418     #[primary_span]
 419     pub span: Span,
 420     #[subdiagnostic]
 421     pub sub: MissingInInForLoopSub,
 422 }
 423
 424 #[derive(Subdiagnostic)]
 425 pub(crate) enum MissingInInForLoopSub {
 426     // Has been misleading, at least in the past (closed Issue #48492), thus maybe-incorrect
 427     #[suggestion(use_in_not_of, style = "short", applicability = "maybe-incorrect", code = "in")]
 428     InNotOf(#[primary_span] Span),
 429     #[suggestion(add_in, style = "short", applicability = "maybe-incorrect", code = " in ")]
 430     AddIn(#[primary_span] Span),
 431 }
 432
 433 #[derive(Diagnostic)]
 434 #[diag(parse_missing_comma_after_match_arm)]
 435 pub(crate) struct MissingCommaAfterMatchArm {
 436     #[primary_span]
 437     #[suggestion(applicability = "machine-applicable", code = ",")]
 438     pub span: Span,
 439 }
 440
 441 #[derive(Diagnostic)]
 442 #[diag(parse_catch_after_try)]
 443 #[help]
 444 pub(crate) struct CatchAfterTry {
 445     #[primary_span]
 446     pub span: Span,
 447 }
 448
 449 #[derive(Diagnostic)]
 450 #[diag(parse_comma_after_base_struct)]
 451 #[note]
 452 pub(crate) struct CommaAfterBaseStruct {
 453     #[primary_span]
 454     pub span: Span,
 455     #[suggestion(style = "short", applicability = "machine-applicable", code = "")]
 456     pub comma: Span,
 457 }
 458
 459 #[derive(Diagnostic)]
 460 #[diag(parse_eq_field_init)]
 461 pub(crate) struct EqFieldInit {
 462     #[primary_span]
 463     pub span: Span,
 464     #[suggestion(applicability = "machine-applicable", code = ":")]
 465     pub eq: Span,
 466 }
 467
 468 #[derive(Diagnostic)]
 469 #[diag(parse_dotdotdot)]
 470 pub(crate) struct DotDotDot {
 471     #[primary_span]
 472     #[suggestion(suggest_exclusive_range, applicability = "maybe-incorrect", code = "..")]
 473     #[suggestion(suggest_inclusive_range, applicability = "maybe-incorrect", code = "..=")]
 474     pub span: Span,
 475 }
 476
 477 #[derive(Diagnostic)]
 478 #[diag(parse_left_arrow_operator)]
 479 pub(crate) struct LeftArrowOperator {
 480     #[primary_span]
 481     #[suggestion(applicability = "maybe-incorrect", code = "< -")]
 482     pub span: Span,
 483 }
 484
 485 #[derive(Diagnostic)]
 486 #[diag(parse_remove_let)]
 487 pub(crate) struct RemoveLet {
 488     #[primary_span]
 489     #[suggestion(applicability = "machine-applicable", code = "")]
 490     pub span: Span,
 491 }
 492
 493 #[derive(Diagnostic)]
 494 #[diag(parse_use_eq_instead)]
 495 pub(crate) struct UseEqInstead {
 496     #[primary_span]
 497     #[suggestion(style = "short", applicability = "machine-applicable", code = "=")]
 498     pub span: Span,
 499 }
 500
 501 #[derive(Diagnostic)]
 502 #[diag(parse_use_empty_block_not_semi)]
 503 pub(crate) struct UseEmptyBlockNotSemi {
 504     #[primary_span]
 505     #[suggestion(style = "hidden", applicability = "machine-applicable", code = "{{}}")]
 506     pub span: Span,
 507 }
 508
 509 #[derive(Diagnostic)]
 510 #[diag(parse_comparison_interpreted_as_generic)]
 511 pub(crate) struct ComparisonInterpretedAsGeneric {
 512     #[primary_span]
 513     #[label(label_comparison)]
 514     pub comparison: Span,
 515     pub r#type: Path,
 516     #[label(label_args)]
 517     pub args: Span,
 518     #[subdiagnostic]
 519     pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
 520 }
 521
 522 #[derive(Diagnostic)]
 523 #[diag(parse_shift_interpreted_as_generic)]
 524 pub(crate) struct ShiftInterpretedAsGeneric {
 525     #[primary_span]
 526     #[label(label_comparison)]
 527     pub shift: Span,
 528     pub r#type: Path,
 529     #[label(label_args)]
 530     pub args: Span,
 531     #[subdiagnostic]
 532     pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
 533 }
 534
 535 #[derive(Subdiagnostic)]
 536 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
 537 pub(crate) struct ComparisonOrShiftInterpretedAsGenericSugg {
 538     #[suggestion_part(code = "(")]
 539     pub left: Span,
 540     #[suggestion_part(code = ")")]
 541     pub right: Span,
 542 }
 543
 544 #[derive(Diagnostic)]
 545 #[diag(parse_found_expr_would_be_stmt)]
 546 pub(crate) struct FoundExprWouldBeStmt {
 547     #[primary_span]
 548     #[label]
 549     pub span: Span,
 550     pub token: Token,
 551     #[subdiagnostic]
 552     pub suggestion: ExprParenthesesNeeded,
 553 }
 554
 555 #[derive(Diagnostic)]
 556 #[diag(parse_leading_plus_not_supported)]
 557 pub(crate) struct LeadingPlusNotSupported {
 558     #[primary_span]
 559     #[label]
 560     pub span: Span,
 561     #[suggestion(
 562         suggestion_remove_plus,
 563         style = "verbose",
 564         code = "",
 565         applicability = "machine-applicable"
 566     )]
 567     pub remove_plus: Option<Span>,
 568     #[subdiagnostic]
 569     pub add_parentheses: Option<ExprParenthesesNeeded>,
 570 }
 571
 572 #[derive(Diagnostic)]
 573 #[diag(parse_parentheses_with_struct_fields)]
 574 pub(crate) struct ParenthesesWithStructFields {
 575     #[primary_span]
 576     pub span: Span,
 577     pub r#type: Path,
 578     #[subdiagnostic]
 579     pub braces_for_struct: BracesForStructLiteral,
 580     #[subdiagnostic]
 581     pub no_fields_for_fn: NoFieldsForFnCall,
 582 }
 583
 584 #[derive(Subdiagnostic)]
 585 #[multipart_suggestion(suggestion_braces_for_struct, applicability = "maybe-incorrect")]
 586 pub(crate) struct BracesForStructLiteral {
 587     #[suggestion_part(code = " {{ ")]
 588     pub first: Span,
 589     #[suggestion_part(code = " }}")]
 590     pub second: Span,
 591 }
 592
 593 #[derive(Subdiagnostic)]
 594 #[multipart_suggestion(suggestion_no_fields_for_fn, applicability = "maybe-incorrect")]
 595 pub(crate) struct NoFieldsForFnCall {
 596     #[suggestion_part(code = "")]
 597     pub fields: Vec<Span>,
 598 }
 599
 600 #[derive(Diagnostic)]
 601 #[diag(parse_labeled_loop_in_break)]
 602 pub(crate) struct LabeledLoopInBreak {
 603     #[primary_span]
 604     pub span: Span,
 605     #[subdiagnostic]
 606     pub sub: WrapExpressionInParentheses,
 607 }
 608
 609 #[derive(Subdiagnostic)]
 610 #[multipart_suggestion(
 611     parse_sugg_wrap_expression_in_parentheses,
 612     applicability = "machine-applicable"
 613 )]
 614 pub(crate) struct WrapExpressionInParentheses {
 615     #[suggestion_part(code = "(")]
 616     pub left: Span,
 617     #[suggestion_part(code = ")")]
 618     pub right: Span,
 619 }
 620
 621 #[derive(Diagnostic)]
 622 #[diag(parse_array_brackets_instead_of_braces)]
 623 pub(crate) struct ArrayBracketsInsteadOfSpaces {
 624     #[primary_span]
 625     pub span: Span,
 626     #[subdiagnostic]
 627     pub sub: ArrayBracketsInsteadOfSpacesSugg,
 628 }
 629
 630 #[derive(Subdiagnostic)]
 631 #[multipart_suggestion(suggestion, applicability = "maybe-incorrect")]
 632 pub(crate) struct ArrayBracketsInsteadOfSpacesSugg {
 633     #[suggestion_part(code = "[")]
 634     pub left: Span,
 635     #[suggestion_part(code = "]")]
 636     pub right: Span,
 637 }
 638
 639 #[derive(Diagnostic)]
 640 #[diag(parse_match_arm_body_without_braces)]
 641 pub(crate) struct MatchArmBodyWithoutBraces {
 642     #[primary_span]
 643     #[label(label_statements)]
 644     pub statements: Span,
 645     #[label(label_arrow)]
 646     pub arrow: Span,
 647     pub num_statements: usize,
 648     #[subdiagnostic]
 649     pub sub: MatchArmBodyWithoutBracesSugg,
 650 }
 651
 652 #[derive(Subdiagnostic)]
 653 pub(crate) enum MatchArmBodyWithoutBracesSugg {
 654     #[multipart_suggestion(suggestion_add_braces, applicability = "machine-applicable")]
 655     AddBraces {
 656         #[suggestion_part(code = "{{ ")]
 657         left: Span,
 658         #[suggestion_part(code = " }}")]
 659         right: Span,
 660     },
 661     #[suggestion(
 662         suggestion_use_comma_not_semicolon,
 663         code = ",",
 664         applicability = "machine-applicable"
 665     )]
 666     UseComma {
 667         #[primary_span]
 668         semicolon: Span,
 669     },
 670 }
 671
 672 #[derive(Diagnostic)]
 673 #[diag(parse_struct_literal_not_allowed_here)]
 674 pub(crate) struct StructLiteralNotAllowedHere {
 675     #[primary_span]
 676     pub span: Span,
 677     #[subdiagnostic]
 678     pub sub: StructLiteralNotAllowedHereSugg,
 679 }
 680
 681 #[derive(Subdiagnostic)]
 682 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
 683 pub(crate) struct StructLiteralNotAllowedHereSugg {
 684     #[suggestion_part(code = "(")]
 685     pub left: Span,
 686     #[suggestion_part(code = ")")]
 687     pub right: Span,
 688 }
 689
 690 #[derive(Diagnostic)]
 691 #[diag(parse_invalid_interpolated_expression)]
 692 pub(crate) struct InvalidInterpolatedExpression {
 693     #[primary_span]
 694     pub span: Span,
 695 }
 696
 697 #[derive(Diagnostic)]
 698 #[diag(parse_invalid_literal_suffix_on_tuple_index)]
 699 pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
 700     #[primary_span]
 701     #[label]
 702     pub span: Span,
 703     pub suffix: Symbol,
 704     #[help(tuple_exception_line_1)]
 705     #[help(tuple_exception_line_2)]
 706     #[help(tuple_exception_line_3)]
 707     pub exception: Option<()>,
 708 }
 709
 710 #[derive(Diagnostic)]
 711 #[diag(parse_non_string_abi_literal)]
 712 pub(crate) struct NonStringAbiLiteral {
 713     #[primary_span]
 714     #[suggestion(code = "\"C\"", applicability = "maybe-incorrect")]
 715     pub span: Span,
 716 }
 717
 718 #[derive(Diagnostic)]
 719 #[diag(parse_mismatched_closing_delimiter)]
 720 pub(crate) struct MismatchedClosingDelimiter {
 721     #[primary_span]
 722     pub spans: Vec<Span>,
 723     pub delimiter: String,
 724     #[label(label_unmatched)]
 725     pub unmatched: Span,
 726     #[label(label_opening_candidate)]
 727     pub opening_candidate: Option<Span>,
 728     #[label(label_unclosed)]
 729     pub unclosed: Option<Span>,
 730 }
 731
 732 #[derive(Diagnostic)]
 733 #[diag(parse_incorrect_visibility_restriction, code = "E0704")]
 734 #[help]
 735 pub(crate) struct IncorrectVisibilityRestriction {
 736     #[primary_span]
 737     #[suggestion(code = "in {inner_str}", applicability = "machine-applicable")]
 738     pub span: Span,
 739     pub inner_str: String,
 740 }
 741
 742 #[derive(Diagnostic)]
 743 #[diag(parse_assignment_else_not_allowed)]
 744 pub(crate) struct AssignmentElseNotAllowed {
 745     #[primary_span]
 746     pub span: Span,
 747 }
 748
 749 #[derive(Diagnostic)]
 750 #[diag(parse_expected_statement_after_outer_attr)]
 751 pub(crate) struct ExpectedStatementAfterOuterAttr {
 752     #[primary_span]
 753     pub span: Span,
 754 }
 755
 756 #[derive(Diagnostic)]
 757 #[diag(parse_doc_comment_does_not_document_anything, code = "E0585")]
 758 #[help]
 759 pub(crate) struct DocCommentDoesNotDocumentAnything {
 760     #[primary_span]
 761     pub span: Span,
 762     #[suggestion(code = ",", applicability = "machine-applicable")]
 763     pub missing_comma: Option<Span>,
 764 }
 765
 766 #[derive(Diagnostic)]
 767 #[diag(parse_const_let_mutually_exclusive)]
 768 pub(crate) struct ConstLetMutuallyExclusive {
 769     #[primary_span]
 770     #[suggestion(code = "const", applicability = "maybe-incorrect")]
 771     pub span: Span,
 772 }
 773
 774 #[derive(Diagnostic)]
 775 #[diag(parse_invalid_expression_in_let_else)]
 776 pub(crate) struct InvalidExpressionInLetElse {
 777     #[primary_span]
 778     pub span: Span,
 779     pub operator: &'static str,
 780     #[subdiagnostic]
 781     pub sugg: WrapExpressionInParentheses,
 782 }
 783
 784 #[derive(Diagnostic)]
 785 #[diag(parse_invalid_curly_in_let_else)]
 786 pub(crate) struct InvalidCurlyInLetElse {
 787     #[primary_span]
 788     pub span: Span,
 789     #[subdiagnostic]
 790     pub sugg: WrapExpressionInParentheses,
 791 }
 792
 793 #[derive(Diagnostic)]
 794 #[diag(parse_compound_assignment_expression_in_let)]
 795 #[help]
 796 pub(crate) struct CompoundAssignmentExpressionInLet {
 797     #[primary_span]
 798     #[suggestion(style = "short", code = "=", applicability = "maybe-incorrect")]
 799     pub span: Span,
 800 }
 801
 802 #[derive(Diagnostic)]
 803 #[diag(parse_suffixed_literal_in_attribute)]
 804 #[help]
 805 pub(crate) struct SuffixedLiteralInAttribute {
 806     #[primary_span]
 807     pub span: Span,
 808 }
 809
 810 #[derive(Diagnostic)]
 811 #[diag(parse_invalid_meta_item)]
 812 pub(crate) struct InvalidMetaItem {
 813     #[primary_span]
 814     pub span: Span,
 815     pub token: Token,
 816 }
 817
 818 #[derive(Subdiagnostic)]
 819 #[suggestion(
 820     parse_sugg_escape_to_use_as_identifier,
 821     style = "verbose",
 822     applicability = "maybe-incorrect",
 823     code = "r#"
 824 )]
 825 pub(crate) struct SuggEscapeToUseAsIdentifier {
 826     #[primary_span]
 827     pub span: Span,
 828     pub ident_name: String,
 829 }
 830
 831 #[derive(Subdiagnostic)]
 832 #[suggestion(parse_sugg_remove_comma, applicability = "machine-applicable", code = "")]
 833 pub(crate) struct SuggRemoveComma {
 834     #[primary_span]
 835     pub span: Span,
 836 }
 837
 838 #[derive(Subdiagnostic)]
 839 pub(crate) enum ExpectedIdentifierFound {
 840     #[label(parse_expected_identifier_found_reserved_identifier)]
 841     ReservedIdentifier(#[primary_span] Span),
 842     #[label(parse_expected_identifier_found_keyword)]
 843     Keyword(#[primary_span] Span),
 844     #[label(parse_expected_identifier_found_reserved_keyword)]
 845     ReservedKeyword(#[primary_span] Span),
 846     #[label(parse_expected_identifier_found_doc_comment)]
 847     DocComment(#[primary_span] Span),
 848     #[label(parse_expected_identifier)]
 849     Other(#[primary_span] Span),
 850 }
 851
 852 impl ExpectedIdentifierFound {
 853     pub fn new(token_descr: Option<TokenDescription>, span: Span) -> Self {
 854         (match token_descr {
 855             Some(TokenDescription::ReservedIdentifier) => {
 856                 ExpectedIdentifierFound::ReservedIdentifier
 857             }
 858             Some(TokenDescription::Keyword) => ExpectedIdentifierFound::Keyword,
 859             Some(TokenDescription::ReservedKeyword) => ExpectedIdentifierFound::ReservedKeyword,
 860             Some(TokenDescription::DocComment) => ExpectedIdentifierFound::DocComment,
 861             None => ExpectedIdentifierFound::Other,
 862         })(span)
 863     }
 864 }
 865
 866 pub(crate) struct ExpectedIdentifier {
 867     pub span: Span,
 868     pub token: Token,
 869     pub suggest_raw: Option<SuggEscapeToUseAsIdentifier>,
 870     pub suggest_remove_comma: Option<SuggRemoveComma>,
 871 }
 872
 873 impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedIdentifier {
 874     #[track_caller]
 875     fn into_diagnostic(
 876         self,
 877         handler: &'a rustc_errors::Handler,
 878     ) -> rustc_errors::DiagnosticBuilder<'a, G> {
 879         let token_descr = super::parser::TokenDescription::from_token(&self.token);
 880
 881         let mut diag = handler.struct_diagnostic(match token_descr {
 882             Some(TokenDescription::ReservedIdentifier) => {
 883                 fluent::parse_expected_identifier_found_reserved_identifier_str
 884             }
 885             Some(TokenDescription::Keyword) => fluent::parse_expected_identifier_found_keyword_str,
 886             Some(TokenDescription::ReservedKeyword) => {
 887                 fluent::parse_expected_identifier_found_reserved_keyword_str
 888             }
 889             Some(TokenDescription::DocComment) => {
 890                 fluent::parse_expected_identifier_found_doc_comment_str
 891             }
 892             None => fluent::parse_expected_identifier_found_str,
 893         });
 894         diag.set_span(self.span);
 895         diag.set_arg("token", self.token);
 896
 897         if let Some(sugg) = self.suggest_raw {
 898             sugg.add_to_diagnostic(&mut diag);
 899         }
 900
 901         ExpectedIdentifierFound::new(token_descr, self.span).add_to_diagnostic(&mut diag);
 902
 903         if let Some(sugg) = self.suggest_remove_comma {
 904             sugg.add_to_diagnostic(&mut diag);
 905         }
 906
 907         diag
 908     }
 909 }
 910
 911 pub(crate) struct ExpectedSemi {
 912     pub span: Span,
 913     pub token: Token,
 914
 915     pub unexpected_token_label: Option<Span>,
 916     pub sugg: ExpectedSemiSugg,
 917 }
 918
 919 impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedSemi {
 920     #[track_caller]
 921     fn into_diagnostic(
 922         self,
 923         handler: &'a rustc_errors::Handler,
 924     ) -> rustc_errors::DiagnosticBuilder<'a, G> {
 925         let token_descr = super::parser::TokenDescription::from_token(&self.token);
 926
 927         let mut diag = handler.struct_diagnostic(match token_descr {
 928             Some(TokenDescription::ReservedIdentifier) => {
 929                 fluent::parse_expected_semi_found_reserved_identifier_str
 930             }
 931             Some(TokenDescription::Keyword) => fluent::parse_expected_semi_found_keyword_str,
 932             Some(TokenDescription::ReservedKeyword) => {
 933                 fluent::parse_expected_semi_found_reserved_keyword_str
 934             }
 935             Some(TokenDescription::DocComment) => fluent::parse_expected_semi_found_doc_comment_str,
 936             None => fluent::parse_expected_semi_found_str,
 937         });
 938         diag.set_span(self.span);
 939         diag.set_arg("token", self.token);
 940
 941         if let Some(unexpected_token_label) = self.unexpected_token_label {
 942             diag.span_label(unexpected_token_label, fluent::parse_label_unexpected_token);
 943         }
 944
 945         self.sugg.add_to_diagnostic(&mut diag);
 946
 947         diag
 948     }
 949 }
 950
 951 #[derive(Subdiagnostic)]
 952 pub(crate) enum ExpectedSemiSugg {
 953     #[suggestion(parse_sugg_change_this_to_semi, code = ";", applicability = "machine-applicable")]
 954     ChangeToSemi(#[primary_span] Span),
 955     #[suggestion(
 956         parse_sugg_add_semi,
 957         style = "short",
 958         code = ";",
 959         applicability = "machine-applicable"
 960     )]
 961     AddSemi(#[primary_span] Span),
 962 }
 963
 964 #[derive(Diagnostic)]
 965 #[diag(parse_struct_literal_body_without_path)]
 966 pub(crate) struct StructLiteralBodyWithoutPath {
 967     #[primary_span]
 968     pub span: Span,
 969     #[subdiagnostic]
 970     pub sugg: StructLiteralBodyWithoutPathSugg,
 971 }
 972
 973 #[derive(Subdiagnostic)]
 974 #[multipart_suggestion(suggestion, applicability = "has-placeholders")]
 975 pub(crate) struct StructLiteralBodyWithoutPathSugg {
 976     #[suggestion_part(code = "{{ SomeStruct ")]
 977     pub before: Span,
 978     #[suggestion_part(code = " }}")]
 979     pub after: Span,
 980 }
 981
 982 #[derive(Diagnostic)]
 983 #[diag(parse_struct_literal_needing_parens)]
 984 pub(crate) struct StructLiteralNeedingParens {
 985     #[primary_span]
 986     pub span: Span,
 987     #[subdiagnostic]
 988     pub sugg: StructLiteralNeedingParensSugg,
 989 }
 990
 991 #[derive(Subdiagnostic)]
 992 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
 993 pub(crate) struct StructLiteralNeedingParensSugg {
 994     #[suggestion_part(code = "(")]
 995     pub before: Span,
 996     #[suggestion_part(code = ")")]
 997     pub after: Span,
 998 }
 999
1000 #[derive(Diagnostic)]
1001 #[diag(parse_unmatched_angle_brackets)]
1002 pub(crate) struct UnmatchedAngleBrackets {
1003     #[primary_span]
1004     #[suggestion(code = "", applicability = "machine-applicable")]
1005     pub span: Span,
1006     pub num_extra_brackets: usize,
1007 }
1008
1009 #[derive(Diagnostic)]
1010 #[diag(parse_generic_parameters_without_angle_brackets)]
1011 pub(crate) struct GenericParamsWithoutAngleBrackets {
1012     #[primary_span]
1013     pub span: Span,
1014     #[subdiagnostic]
1015     pub sugg: GenericParamsWithoutAngleBracketsSugg,
1016 }
1017
1018 #[derive(Subdiagnostic)]
1019 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1020 pub(crate) struct GenericParamsWithoutAngleBracketsSugg {
1021     #[suggestion_part(code = "<")]
1022     pub left: Span,
1023     #[suggestion_part(code = ">")]
1024     pub right: Span,
1025 }
1026
1027 #[derive(Diagnostic)]
1028 #[diag(parse_comparison_operators_cannot_be_chained)]
1029 pub(crate) struct ComparisonOperatorsCannotBeChained {
1030     #[primary_span]
1031     pub span: Vec<Span>,
1032     #[suggestion(
1033         parse_sugg_turbofish_syntax,
1034         style = "verbose",
1035         code = "::",
1036         applicability = "maybe-incorrect"
1037     )]
1038     pub suggest_turbofish: Option<Span>,
1039     #[help(parse_sugg_turbofish_syntax)]
1040     #[help(sugg_parentheses_for_function_args)]
1041     pub help_turbofish: Option<()>,
1042     #[subdiagnostic]
1043     pub chaining_sugg: Option<ComparisonOperatorsCannotBeChainedSugg>,
1044 }
1045
1046 #[derive(Subdiagnostic)]
1047 pub(crate) enum ComparisonOperatorsCannotBeChainedSugg {
1048     #[suggestion(
1049         sugg_split_comparison,
1050         style = "verbose",
1051         code = " && {middle_term}",
1052         applicability = "maybe-incorrect"
1053     )]
1054     SplitComparison {
1055         #[primary_span]
1056         span: Span,
1057         middle_term: String,
1058     },
1059     #[multipart_suggestion(sugg_parenthesize, applicability = "maybe-incorrect")]
1060     Parenthesize {
1061         #[suggestion_part(code = "(")]
1062         left: Span,
1063         #[suggestion_part(code = ")")]
1064         right: Span,
1065     },
1066 }
1067
1068 #[derive(Diagnostic)]
1069 #[diag(parse_question_mark_in_type)]
1070 pub(crate) struct QuestionMarkInType {
1071     #[primary_span]
1072     #[label]
1073     pub span: Span,
1074     #[subdiagnostic]
1075     pub sugg: QuestionMarkInTypeSugg,
1076 }
1077
1078 #[derive(Subdiagnostic)]
1079 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1080 pub(crate) struct QuestionMarkInTypeSugg {
1081     #[suggestion_part(code = "Option<")]
1082     pub left: Span,
1083     #[suggestion_part(code = ">")]
1084     pub right: Span,
1085 }
1086
1087 #[derive(Diagnostic)]
1088 #[diag(parse_unexpected_parentheses_in_for_head)]
1089 pub(crate) struct ParenthesesInForHead {
1090     #[primary_span]
1091     pub span: Vec<Span>,
1092     #[subdiagnostic]
1093     pub sugg: ParenthesesInForHeadSugg,
1094 }
1095
1096 #[derive(Subdiagnostic)]
1097 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1098 pub(crate) struct ParenthesesInForHeadSugg {
1099     #[suggestion_part(code = "{left_snippet}")]
1100     pub left: Span,
1101     pub left_snippet: String,
1102     #[suggestion_part(code = "{right_snippet}")]
1103     pub right: Span,
1104     pub right_snippet: String,
1105 }
1106
1107 #[derive(Diagnostic)]
1108 #[diag(parse_doc_comment_on_param_type)]
1109 pub(crate) struct DocCommentOnParamType {
1110     #[primary_span]
1111     #[label]
1112     pub span: Span,
1113 }
1114
1115 #[derive(Diagnostic)]
1116 #[diag(parse_attribute_on_param_type)]
1117 pub(crate) struct AttributeOnParamType {
1118     #[primary_span]
1119     #[label]
1120     pub span: Span,
1121 }
1122
1123 #[derive(Diagnostic)]
1124 #[diag(parse_pattern_method_param_without_body, code = "E0642")]
1125 pub(crate) struct PatternMethodParamWithoutBody {
1126     #[primary_span]
1127     #[suggestion(code = "_", applicability = "machine-applicable")]
1128     pub span: Span,
1129 }
1130
1131 #[derive(Diagnostic)]
1132 #[diag(parse_self_param_not_first)]
1133 pub(crate) struct SelfParamNotFirst {
1134     #[primary_span]
1135     #[label]
1136     pub span: Span,
1137 }
1138
1139 #[derive(Diagnostic)]
1140 #[diag(parse_invalid_identifier_with_leading_number)]
1141 pub(crate) struct InvalidIdentiferStartsWithNumber {
1142     #[primary_span]
1143     #[label]
1144     pub span: Span,
1145 }
1146
1147 #[derive(Diagnostic)]
1148 #[diag(parse_const_generic_without_braces)]
1149 pub(crate) struct ConstGenericWithoutBraces {
1150     #[primary_span]
1151     pub span: Span,
1152     #[subdiagnostic]
1153     pub sugg: ConstGenericWithoutBracesSugg,
1154 }
1155
1156 #[derive(Subdiagnostic)]
1157 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1158 pub(crate) struct ConstGenericWithoutBracesSugg {
1159     #[suggestion_part(code = "{{ ")]
1160     pub left: Span,
1161     #[suggestion_part(code = " }}")]
1162     pub right: Span,
1163 }
1164
1165 #[derive(Diagnostic)]
1166 #[diag(parse_unexpected_const_param_declaration)]
1167 pub(crate) struct UnexpectedConstParamDeclaration {
1168     #[primary_span]
1169     #[label]
1170     pub span: Span,
1171     #[subdiagnostic]
1172     pub sugg: Option<UnexpectedConstParamDeclarationSugg>,
1173 }
1174
1175 #[derive(Subdiagnostic)]
1176 pub(crate) enum UnexpectedConstParamDeclarationSugg {
1177     #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1178     AddParam {
1179         #[suggestion_part(code = "<{snippet}>")]
1180         impl_generics: Span,
1181         #[suggestion_part(code = "{ident}")]
1182         incorrect_decl: Span,
1183         snippet: String,
1184         ident: String,
1185     },
1186     #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1187     AppendParam {
1188         #[suggestion_part(code = ", {snippet}")]
1189         impl_generics_end: Span,
1190         #[suggestion_part(code = "{ident}")]
1191         incorrect_decl: Span,
1192         snippet: String,
1193         ident: String,
1194     },
1195 }
1196
1197 #[derive(Diagnostic)]
1198 #[diag(parse_unexpected_const_in_generic_param)]
1199 pub(crate) struct UnexpectedConstInGenericParam {
1200     #[primary_span]
1201     pub span: Span,
1202     #[suggestion(style = "verbose", code = "", applicability = "maybe-incorrect")]
1203     pub to_remove: Option<Span>,
1204 }
1205
1206 #[derive(Diagnostic)]
1207 #[diag(parse_async_move_order_incorrect)]
1208 pub(crate) struct AsyncMoveOrderIncorrect {
1209     #[primary_span]
1210     #[suggestion(style = "verbose", code = "async move", applicability = "maybe-incorrect")]
1211     pub span: Span,
1212 }
1213
1214 #[derive(Diagnostic)]
1215 #[diag(parse_double_colon_in_bound)]
1216 pub(crate) struct DoubleColonInBound {
1217     #[primary_span]
1218     pub span: Span,
1219     #[suggestion(code = ": ", applicability = "machine-applicable")]
1220     pub between: Span,
1221 }
1222
1223 #[derive(Diagnostic)]
1224 #[diag(parse_fn_ptr_with_generics)]
1225 pub(crate) struct FnPtrWithGenerics {
1226     #[primary_span]
1227     pub span: Span,
1228     #[subdiagnostic]
1229     pub sugg: Option<FnPtrWithGenericsSugg>,
1230 }
1231
1232 #[derive(Subdiagnostic)]
1233 #[multipart_suggestion(suggestion, applicability = "maybe-incorrect")]
1234 pub(crate) struct FnPtrWithGenericsSugg {
1235     #[suggestion_part(code = "{snippet}")]
1236     pub left: Span,
1237     pub snippet: String,
1238     #[suggestion_part(code = "")]
1239     pub right: Span,
1240     pub arity: usize,
1241     pub for_param_list_exists: bool,
1242 }
1243
1244 #[derive(Diagnostic)]
1245 #[diag(parse_unexpected_if_with_if)]
1246 pub(crate) struct UnexpectedIfWithIf(
1247     #[primary_span]
1248     #[suggestion(applicability = "machine-applicable", code = " ", style = "verbose")]
1249     pub Span,
1250 );
1251
1252 #[derive(Diagnostic)]
1253 #[diag(parse_maybe_fn_typo_with_impl)]
1254 pub(crate) struct FnTypoWithImpl {
1255     #[primary_span]
1256     #[suggestion(applicability = "maybe-incorrect", code = "impl", style = "verbose")]
1257     pub fn_span: Span,
1258 }
1259
1260 #[derive(Diagnostic)]
1261 #[diag(parse_expected_fn_path_found_fn_keyword)]
1262 pub(crate) struct ExpectedFnPathFoundFnKeyword {
1263     #[primary_span]
1264     #[suggestion(applicability = "machine-applicable", code = "Fn", style = "verbose")]
1265     pub fn_token_span: Span,
1266 }
1267
1268 #[derive(Diagnostic)]
1269 #[diag(parse_where_clause_before_tuple_struct_body)]
1270 pub(crate) struct WhereClauseBeforeTupleStructBody {
1271     #[primary_span]
1272     #[label]
1273     pub span: Span,
1274     #[label(name_label)]
1275     pub name: Span,
1276     #[label(body_label)]
1277     pub body: Span,
1278     #[subdiagnostic]
1279     pub sugg: Option<WhereClauseBeforeTupleStructBodySugg>,
1280 }
1281
1282 #[derive(Subdiagnostic)]
1283 #[multipart_suggestion(suggestion, applicability = "machine-applicable")]
1284 pub(crate) struct WhereClauseBeforeTupleStructBodySugg {
1285     #[suggestion_part(code = "{snippet}")]
1286     pub left: Span,
1287     pub snippet: String,
1288     #[suggestion_part(code = "")]
1289     pub right: Span,
1290 }