rustc_parse/
errors.rs

1// ignore-tidy-filelength
2
3use std::borrow::Cow;
4
5use rustc_ast::token::Token;
6use rustc_ast::util::parser::ExprPrecedence;
7use rustc_ast::{Path, Visibility};
8use rustc_errors::codes::*;
9use rustc_errors::{
10    Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, SubdiagMessageOp,
11    Subdiagnostic,
12};
13use rustc_macros::{Diagnostic, Subdiagnostic};
14use rustc_session::errors::ExprParenthesesNeeded;
15use rustc_span::edition::{Edition, LATEST_STABLE_EDITION};
16use rustc_span::{Ident, Span, Symbol};
17
18use crate::fluent_generated as fluent;
19use crate::parser::{ForbiddenLetReason, TokenDescription};
20
21#[derive(Diagnostic)]
22#[diag(parse_maybe_report_ambiguous_plus)]
23pub(crate) struct AmbiguousPlus {
24    #[primary_span]
25    pub span: Span,
26    #[subdiagnostic]
27    pub suggestion: AddParen,
28}
29
30#[derive(Diagnostic)]
31#[diag(parse_maybe_recover_from_bad_type_plus, code = E0178)]
32pub(crate) struct BadTypePlus {
33    pub ty: String,
34    #[primary_span]
35    pub span: Span,
36    #[subdiagnostic]
37    pub sub: BadTypePlusSub,
38}
39
40#[derive(Subdiagnostic)]
41#[multipart_suggestion(parse_add_paren, applicability = "machine-applicable")]
42pub(crate) struct AddParen {
43    #[suggestion_part(code = "(")]
44    pub lo: Span,
45    #[suggestion_part(code = ")")]
46    pub hi: Span,
47}
48
49#[derive(Subdiagnostic)]
50pub(crate) enum BadTypePlusSub {
51    AddParen {
52        #[subdiagnostic]
53        suggestion: AddParen,
54    },
55    #[label(parse_forgot_paren)]
56    ForgotParen {
57        #[primary_span]
58        span: Span,
59    },
60    #[label(parse_expect_path)]
61    ExpectPath {
62        #[primary_span]
63        span: Span,
64    },
65}
66
67#[derive(Diagnostic)]
68#[diag(parse_maybe_recover_from_bad_qpath_stage_2)]
69pub(crate) struct BadQPathStage2 {
70    #[primary_span]
71    pub span: Span,
72    #[subdiagnostic]
73    pub wrap: WrapType,
74}
75
76#[derive(Subdiagnostic)]
77#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
78pub(crate) struct WrapType {
79    #[suggestion_part(code = "<")]
80    pub lo: Span,
81    #[suggestion_part(code = ">")]
82    pub hi: Span,
83}
84
85#[derive(Diagnostic)]
86#[diag(parse_incorrect_semicolon)]
87pub(crate) struct IncorrectSemicolon<'a> {
88    #[primary_span]
89    #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
90    pub span: Span,
91    #[help]
92    pub show_help: bool,
93    pub name: &'a str,
94}
95
96#[derive(Diagnostic)]
97#[diag(parse_incorrect_use_of_await)]
98pub(crate) struct IncorrectUseOfAwait {
99    #[primary_span]
100    #[suggestion(
101        parse_parentheses_suggestion,
102        style = "verbose",
103        code = "",
104        applicability = "machine-applicable"
105    )]
106    pub span: Span,
107}
108
109#[derive(Diagnostic)]
110#[diag(parse_incorrect_use_of_use)]
111pub(crate) struct IncorrectUseOfUse {
112    #[primary_span]
113    #[suggestion(
114        parse_parentheses_suggestion,
115        style = "verbose",
116        code = "",
117        applicability = "machine-applicable"
118    )]
119    pub span: Span,
120}
121
122#[derive(Subdiagnostic)]
123#[multipart_suggestion(
124    parse_incorrect_use_of_await_postfix_suggestion,
125    applicability = "machine-applicable"
126)]
127pub(crate) struct AwaitSuggestion {
128    #[suggestion_part(code = "")]
129    pub removal: Span,
130    #[suggestion_part(code = ".await{question_mark}")]
131    pub dot_await: Span,
132    pub question_mark: &'static str,
133}
134
135#[derive(Diagnostic)]
136#[diag(parse_incorrect_use_of_await)]
137pub(crate) struct IncorrectAwait {
138    #[primary_span]
139    pub span: Span,
140    #[subdiagnostic]
141    pub suggestion: AwaitSuggestion,
142}
143
144#[derive(Diagnostic)]
145#[diag(parse_in_in_typo)]
146pub(crate) struct InInTypo {
147    #[primary_span]
148    pub span: Span,
149    #[suggestion(code = "", style = "verbose", applicability = "machine-applicable")]
150    pub sugg_span: Span,
151}
152
153#[derive(Diagnostic)]
154#[diag(parse_invalid_variable_declaration)]
155pub(crate) struct InvalidVariableDeclaration {
156    #[primary_span]
157    pub span: Span,
158    #[subdiagnostic]
159    pub sub: InvalidVariableDeclarationSub,
160}
161
162#[derive(Subdiagnostic)]
163pub(crate) enum InvalidVariableDeclarationSub {
164    #[suggestion(
165        parse_switch_mut_let_order,
166        style = "verbose",
167        applicability = "maybe-incorrect",
168        code = "let mut"
169    )]
170    SwitchMutLetOrder(#[primary_span] Span),
171    #[suggestion(
172        parse_missing_let_before_mut,
173        applicability = "machine-applicable",
174        style = "verbose",
175        code = "let mut"
176    )]
177    MissingLet(#[primary_span] Span),
178    #[suggestion(
179        parse_use_let_not_auto,
180        style = "verbose",
181        applicability = "machine-applicable",
182        code = "let"
183    )]
184    UseLetNotAuto(#[primary_span] Span),
185    #[suggestion(
186        parse_use_let_not_var,
187        style = "verbose",
188        applicability = "machine-applicable",
189        code = "let"
190    )]
191    UseLetNotVar(#[primary_span] Span),
192}
193
194#[derive(Diagnostic)]
195#[diag(parse_switch_ref_box_order)]
196pub(crate) struct SwitchRefBoxOrder {
197    #[primary_span]
198    #[suggestion(applicability = "machine-applicable", style = "verbose", code = "box ref")]
199    pub span: Span,
200}
201
202#[derive(Diagnostic)]
203#[diag(parse_invalid_comparison_operator)]
204pub(crate) struct InvalidComparisonOperator {
205    #[primary_span]
206    pub span: Span,
207    pub invalid: String,
208    #[subdiagnostic]
209    pub sub: InvalidComparisonOperatorSub,
210}
211
212#[derive(Subdiagnostic)]
213pub(crate) enum InvalidComparisonOperatorSub {
214    #[suggestion(
215        parse_use_instead,
216        style = "verbose",
217        applicability = "machine-applicable",
218        code = "{correct}"
219    )]
220    Correctable {
221        #[primary_span]
222        span: Span,
223        invalid: String,
224        correct: String,
225    },
226    #[label(parse_spaceship_operator_invalid)]
227    Spaceship(#[primary_span] Span),
228}
229
230#[derive(Diagnostic)]
231#[diag(parse_invalid_logical_operator)]
232#[note]
233pub(crate) struct InvalidLogicalOperator {
234    #[primary_span]
235    pub span: Span,
236    pub incorrect: String,
237    #[subdiagnostic]
238    pub sub: InvalidLogicalOperatorSub,
239}
240
241#[derive(Subdiagnostic)]
242pub(crate) enum InvalidLogicalOperatorSub {
243    #[suggestion(
244        parse_use_amp_amp_for_conjunction,
245        style = "verbose",
246        applicability = "machine-applicable",
247        code = "&&"
248    )]
249    Conjunction(#[primary_span] Span),
250    #[suggestion(
251        parse_use_pipe_pipe_for_disjunction,
252        style = "verbose",
253        applicability = "machine-applicable",
254        code = "||"
255    )]
256    Disjunction(#[primary_span] Span),
257}
258
259#[derive(Diagnostic)]
260#[diag(parse_tilde_is_not_unary_operator)]
261pub(crate) struct TildeAsUnaryOperator(
262    #[primary_span]
263    #[suggestion(style = "verbose", applicability = "machine-applicable", code = "!")]
264    pub Span,
265);
266
267#[derive(Diagnostic)]
268#[diag(parse_unexpected_token_after_not)]
269pub(crate) struct NotAsNegationOperator {
270    #[primary_span]
271    pub negated: Span,
272    pub negated_desc: String,
273    #[subdiagnostic]
274    pub sub: NotAsNegationOperatorSub,
275}
276
277#[derive(Subdiagnostic)]
278pub(crate) enum NotAsNegationOperatorSub {
279    #[suggestion(
280        parse_unexpected_token_after_not_default,
281        style = "verbose",
282        applicability = "machine-applicable",
283        code = "!"
284    )]
285    SuggestNotDefault(#[primary_span] Span),
286
287    #[suggestion(
288        parse_unexpected_token_after_not_bitwise,
289        style = "verbose",
290        applicability = "machine-applicable",
291        code = "!"
292    )]
293    SuggestNotBitwise(#[primary_span] Span),
294
295    #[suggestion(
296        parse_unexpected_token_after_not_logical,
297        style = "verbose",
298        applicability = "machine-applicable",
299        code = "!"
300    )]
301    SuggestNotLogical(#[primary_span] Span),
302}
303
304#[derive(Diagnostic)]
305#[diag(parse_malformed_loop_label)]
306pub(crate) struct MalformedLoopLabel {
307    #[primary_span]
308    pub span: Span,
309    #[suggestion(applicability = "machine-applicable", code = "'", style = "verbose")]
310    pub suggestion: Span,
311}
312
313#[derive(Diagnostic)]
314#[diag(parse_lifetime_in_borrow_expression)]
315pub(crate) struct LifetimeInBorrowExpression {
316    #[primary_span]
317    pub span: Span,
318    #[suggestion(applicability = "machine-applicable", code = "", style = "verbose")]
319    #[label]
320    pub lifetime_span: Span,
321}
322
323#[derive(Diagnostic)]
324#[diag(parse_field_expression_with_generic)]
325pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span);
326
327#[derive(Diagnostic)]
328#[diag(parse_macro_invocation_with_qualified_path)]
329pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span);
330
331#[derive(Diagnostic)]
332#[diag(parse_unexpected_token_after_label)]
333pub(crate) struct UnexpectedTokenAfterLabel {
334    #[primary_span]
335    #[label(parse_unexpected_token_after_label)]
336    pub span: Span,
337    #[suggestion(parse_suggestion_remove_label, style = "verbose", code = "")]
338    pub remove_label: Option<Span>,
339    #[subdiagnostic]
340    pub enclose_in_block: Option<UnexpectedTokenAfterLabelSugg>,
341}
342
343#[derive(Subdiagnostic)]
344#[multipart_suggestion(parse_suggestion_enclose_in_block, applicability = "machine-applicable")]
345pub(crate) struct UnexpectedTokenAfterLabelSugg {
346    #[suggestion_part(code = "{{ ")]
347    pub left: Span,
348    #[suggestion_part(code = " }}")]
349    pub right: Span,
350}
351
352#[derive(Diagnostic)]
353#[diag(parse_require_colon_after_labeled_expression)]
354#[note]
355pub(crate) struct RequireColonAfterLabeledExpression {
356    #[primary_span]
357    pub span: Span,
358    #[label]
359    pub label: Span,
360    #[suggestion(style = "verbose", applicability = "machine-applicable", code = ": ")]
361    pub label_end: Span,
362}
363
364#[derive(Diagnostic)]
365#[diag(parse_do_catch_syntax_removed)]
366#[note]
367pub(crate) struct DoCatchSyntaxRemoved {
368    #[primary_span]
369    #[suggestion(applicability = "machine-applicable", code = "try", style = "verbose")]
370    pub span: Span,
371}
372
373#[derive(Diagnostic)]
374#[diag(parse_float_literal_requires_integer_part)]
375pub(crate) struct FloatLiteralRequiresIntegerPart {
376    #[primary_span]
377    pub span: Span,
378    #[suggestion(applicability = "machine-applicable", code = "0", style = "verbose")]
379    pub suggestion: Span,
380}
381
382#[derive(Diagnostic)]
383#[diag(parse_missing_semicolon_before_array)]
384pub(crate) struct MissingSemicolonBeforeArray {
385    #[primary_span]
386    pub open_delim: Span,
387    #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = ";")]
388    pub semicolon: Span,
389}
390
391#[derive(Diagnostic)]
392#[diag(parse_expect_dotdot_not_dotdotdot)]
393pub(crate) struct MissingDotDot {
394    #[primary_span]
395    pub token_span: Span,
396    #[suggestion(applicability = "maybe-incorrect", code = "..", style = "verbose")]
397    pub sugg_span: Span,
398}
399
400#[derive(Diagnostic)]
401#[diag(parse_invalid_block_macro_segment)]
402pub(crate) struct InvalidBlockMacroSegment {
403    #[primary_span]
404    pub span: Span,
405    #[label]
406    pub context: Span,
407    #[subdiagnostic]
408    pub wrap: WrapInExplicitBlock,
409}
410
411#[derive(Subdiagnostic)]
412#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
413pub(crate) struct WrapInExplicitBlock {
414    #[suggestion_part(code = "{{ ")]
415    pub lo: Span,
416    #[suggestion_part(code = " }}")]
417    pub hi: Span,
418}
419
420#[derive(Diagnostic)]
421#[diag(parse_if_expression_missing_then_block)]
422pub(crate) struct IfExpressionMissingThenBlock {
423    #[primary_span]
424    pub if_span: Span,
425    #[subdiagnostic]
426    pub missing_then_block_sub: IfExpressionMissingThenBlockSub,
427    #[subdiagnostic]
428    pub let_else_sub: Option<IfExpressionLetSomeSub>,
429}
430
431#[derive(Subdiagnostic)]
432pub(crate) enum IfExpressionMissingThenBlockSub {
433    #[help(parse_condition_possibly_unfinished)]
434    UnfinishedCondition(#[primary_span] Span),
435    #[help(parse_add_then_block)]
436    AddThenBlock(#[primary_span] Span),
437}
438
439#[derive(Diagnostic)]
440#[diag(parse_ternary_operator)]
441#[help]
442pub(crate) struct TernaryOperator {
443    #[primary_span]
444    pub span: Span,
445}
446
447#[derive(Subdiagnostic)]
448#[suggestion(
449    parse_extra_if_in_let_else,
450    applicability = "maybe-incorrect",
451    code = "",
452    style = "verbose"
453)]
454pub(crate) struct IfExpressionLetSomeSub {
455    #[primary_span]
456    pub if_span: Span,
457}
458
459#[derive(Diagnostic)]
460#[diag(parse_if_expression_missing_condition)]
461pub(crate) struct IfExpressionMissingCondition {
462    #[primary_span]
463    #[label(parse_condition_label)]
464    pub if_span: Span,
465    #[label(parse_block_label)]
466    pub block_span: Span,
467}
468
469#[derive(Diagnostic)]
470#[diag(parse_expected_expression_found_let)]
471#[note]
472pub(crate) struct ExpectedExpressionFoundLet {
473    #[primary_span]
474    pub span: Span,
475    #[subdiagnostic]
476    pub reason: ForbiddenLetReason,
477    #[subdiagnostic]
478    pub missing_let: Option<MaybeMissingLet>,
479    #[subdiagnostic]
480    pub comparison: Option<MaybeComparison>,
481}
482
483#[derive(Subdiagnostic, Clone, Copy)]
484#[multipart_suggestion(
485    parse_maybe_missing_let,
486    applicability = "maybe-incorrect",
487    style = "verbose"
488)]
489pub(crate) struct MaybeMissingLet {
490    #[suggestion_part(code = "let ")]
491    pub span: Span,
492}
493
494#[derive(Subdiagnostic, Clone, Copy)]
495#[multipart_suggestion(
496    parse_maybe_comparison,
497    applicability = "maybe-incorrect",
498    style = "verbose"
499)]
500pub(crate) struct MaybeComparison {
501    #[suggestion_part(code = "=")]
502    pub span: Span,
503}
504
505#[derive(Diagnostic)]
506#[diag(parse_expect_eq_instead_of_eqeq)]
507pub(crate) struct ExpectedEqForLetExpr {
508    #[primary_span]
509    pub span: Span,
510    #[suggestion(applicability = "maybe-incorrect", code = "=", style = "verbose")]
511    pub sugg_span: Span,
512}
513
514#[derive(Diagnostic)]
515#[diag(parse_expected_else_block)]
516pub(crate) struct ExpectedElseBlock {
517    #[primary_span]
518    pub first_tok_span: Span,
519    pub first_tok: String,
520    #[label]
521    pub else_span: Span,
522    #[suggestion(applicability = "maybe-incorrect", code = "if ", style = "verbose")]
523    pub condition_start: Span,
524}
525
526#[derive(Diagnostic)]
527#[diag(parse_expected_struct_field)]
528pub(crate) struct ExpectedStructField {
529    #[primary_span]
530    #[label]
531    pub span: Span,
532    pub token: Token,
533    #[label(parse_ident_label)]
534    pub ident_span: Span,
535}
536
537#[derive(Diagnostic)]
538#[diag(parse_outer_attribute_not_allowed_on_if_else)]
539pub(crate) struct OuterAttributeNotAllowedOnIfElse {
540    #[primary_span]
541    pub last: Span,
542
543    #[label(parse_branch_label)]
544    pub branch_span: Span,
545
546    #[label(parse_ctx_label)]
547    pub ctx_span: Span,
548    pub ctx: String,
549
550    #[suggestion(applicability = "machine-applicable", code = "", style = "verbose")]
551    pub attributes: Span,
552}
553
554#[derive(Diagnostic)]
555#[diag(parse_missing_in_in_for_loop)]
556pub(crate) struct MissingInInForLoop {
557    #[primary_span]
558    pub span: Span,
559    #[subdiagnostic]
560    pub sub: MissingInInForLoopSub,
561}
562
563#[derive(Subdiagnostic)]
564pub(crate) enum MissingInInForLoopSub {
565    // Has been misleading, at least in the past (closed Issue #48492), thus maybe-incorrect
566    #[suggestion(
567        parse_use_in_not_of,
568        style = "verbose",
569        applicability = "maybe-incorrect",
570        code = "in"
571    )]
572    InNotOf(#[primary_span] Span),
573    #[suggestion(parse_add_in, style = "verbose", applicability = "maybe-incorrect", code = " in ")]
574    AddIn(#[primary_span] Span),
575}
576
577#[derive(Diagnostic)]
578#[diag(parse_missing_expression_in_for_loop)]
579pub(crate) struct MissingExpressionInForLoop {
580    #[primary_span]
581    #[suggestion(
582        code = "/* expression */ ",
583        applicability = "has-placeholders",
584        style = "verbose"
585    )]
586    pub span: Span,
587}
588
589#[derive(Diagnostic)]
590#[diag(parse_loop_else)]
591#[note]
592pub(crate) struct LoopElseNotSupported {
593    #[primary_span]
594    pub span: Span,
595    pub loop_kind: &'static str,
596    #[label(parse_loop_keyword)]
597    pub loop_kw: Span,
598}
599
600#[derive(Diagnostic)]
601#[diag(parse_missing_comma_after_match_arm)]
602pub(crate) struct MissingCommaAfterMatchArm {
603    #[primary_span]
604    #[suggestion(applicability = "machine-applicable", code = ",", style = "verbose")]
605    pub span: Span,
606}
607
608#[derive(Diagnostic)]
609#[diag(parse_catch_after_try)]
610#[help]
611pub(crate) struct CatchAfterTry {
612    #[primary_span]
613    pub span: Span,
614}
615
616#[derive(Diagnostic)]
617#[diag(parse_comma_after_base_struct)]
618#[note]
619pub(crate) struct CommaAfterBaseStruct {
620    #[primary_span]
621    pub span: Span,
622    #[suggestion(style = "verbose", applicability = "machine-applicable", code = "")]
623    pub comma: Span,
624}
625
626#[derive(Diagnostic)]
627#[diag(parse_eq_field_init)]
628pub(crate) struct EqFieldInit {
629    #[primary_span]
630    pub span: Span,
631    #[suggestion(applicability = "machine-applicable", code = ":", style = "verbose")]
632    pub eq: Span,
633}
634
635#[derive(Diagnostic)]
636#[diag(parse_dotdotdot)]
637pub(crate) struct DotDotDot {
638    #[primary_span]
639    #[suggestion(
640        parse_suggest_exclusive_range,
641        applicability = "maybe-incorrect",
642        code = "..",
643        style = "verbose"
644    )]
645    #[suggestion(
646        parse_suggest_inclusive_range,
647        applicability = "maybe-incorrect",
648        code = "..=",
649        style = "verbose"
650    )]
651    pub span: Span,
652}
653
654#[derive(Diagnostic)]
655#[diag(parse_left_arrow_operator)]
656pub(crate) struct LeftArrowOperator {
657    #[primary_span]
658    #[suggestion(applicability = "maybe-incorrect", code = "< -", style = "verbose")]
659    pub span: Span,
660}
661
662#[derive(Diagnostic)]
663#[diag(parse_remove_let)]
664pub(crate) struct RemoveLet {
665    #[primary_span]
666    pub span: Span,
667    #[suggestion(applicability = "machine-applicable", code = "", style = "verbose")]
668    pub suggestion: Span,
669}
670
671#[derive(Diagnostic)]
672#[diag(parse_use_eq_instead)]
673pub(crate) struct UseEqInstead {
674    #[primary_span]
675    #[suggestion(style = "verbose", applicability = "machine-applicable", code = "=")]
676    pub span: Span,
677}
678
679#[derive(Diagnostic)]
680#[diag(parse_use_empty_block_not_semi)]
681pub(crate) struct UseEmptyBlockNotSemi {
682    #[primary_span]
683    #[suggestion(style = "hidden", applicability = "machine-applicable", code = "{{}}")]
684    pub span: Span,
685}
686
687#[derive(Diagnostic)]
688#[diag(parse_comparison_interpreted_as_generic)]
689pub(crate) struct ComparisonInterpretedAsGeneric {
690    #[primary_span]
691    #[label(parse_label_comparison)]
692    pub comparison: Span,
693    pub r#type: Path,
694    #[label(parse_label_args)]
695    pub args: Span,
696    #[subdiagnostic]
697    pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
698}
699
700#[derive(Diagnostic)]
701#[diag(parse_shift_interpreted_as_generic)]
702pub(crate) struct ShiftInterpretedAsGeneric {
703    #[primary_span]
704    #[label(parse_label_comparison)]
705    pub shift: Span,
706    pub r#type: Path,
707    #[label(parse_label_args)]
708    pub args: Span,
709    #[subdiagnostic]
710    pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
711}
712
713#[derive(Subdiagnostic)]
714#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
715pub(crate) struct ComparisonOrShiftInterpretedAsGenericSugg {
716    #[suggestion_part(code = "(")]
717    pub left: Span,
718    #[suggestion_part(code = ")")]
719    pub right: Span,
720}
721
722#[derive(Diagnostic)]
723#[diag(parse_found_expr_would_be_stmt)]
724pub(crate) struct FoundExprWouldBeStmt {
725    #[primary_span]
726    #[label]
727    pub span: Span,
728    pub token: Token,
729    #[subdiagnostic]
730    pub suggestion: ExprParenthesesNeeded,
731}
732
733#[derive(Diagnostic)]
734#[diag(parse_leading_plus_not_supported)]
735pub(crate) struct LeadingPlusNotSupported {
736    #[primary_span]
737    #[label]
738    pub span: Span,
739    #[suggestion(
740        parse_suggestion_remove_plus,
741        style = "verbose",
742        code = "",
743        applicability = "machine-applicable"
744    )]
745    pub remove_plus: Option<Span>,
746    #[subdiagnostic]
747    pub add_parentheses: Option<ExprParenthesesNeeded>,
748}
749
750#[derive(Diagnostic)]
751#[diag(parse_parentheses_with_struct_fields)]
752pub(crate) struct ParenthesesWithStructFields {
753    #[primary_span]
754    pub span: Span,
755    pub r#type: Path,
756    #[subdiagnostic]
757    pub braces_for_struct: BracesForStructLiteral,
758    #[subdiagnostic]
759    pub no_fields_for_fn: NoFieldsForFnCall,
760}
761
762#[derive(Subdiagnostic)]
763#[multipart_suggestion(parse_suggestion_braces_for_struct, applicability = "maybe-incorrect")]
764pub(crate) struct BracesForStructLiteral {
765    #[suggestion_part(code = " {{ ")]
766    pub first: Span,
767    #[suggestion_part(code = " }}")]
768    pub second: Span,
769}
770
771#[derive(Subdiagnostic)]
772#[multipart_suggestion(parse_suggestion_no_fields_for_fn, applicability = "maybe-incorrect")]
773pub(crate) struct NoFieldsForFnCall {
774    #[suggestion_part(code = "")]
775    pub fields: Vec<Span>,
776}
777
778#[derive(Diagnostic)]
779#[diag(parse_labeled_loop_in_break)]
780pub(crate) struct LabeledLoopInBreak {
781    #[primary_span]
782    pub span: Span,
783    #[subdiagnostic]
784    pub sub: WrapInParentheses,
785}
786
787#[derive(Subdiagnostic)]
788pub(crate) enum WrapInParentheses {
789    #[multipart_suggestion(
790        parse_sugg_wrap_expression_in_parentheses,
791        applicability = "machine-applicable"
792    )]
793    Expression {
794        #[suggestion_part(code = "(")]
795        left: Span,
796        #[suggestion_part(code = ")")]
797        right: Span,
798    },
799    #[multipart_suggestion(
800        parse_sugg_wrap_macro_in_parentheses,
801        applicability = "machine-applicable"
802    )]
803    MacroArgs {
804        #[suggestion_part(code = "(")]
805        left: Span,
806        #[suggestion_part(code = ")")]
807        right: Span,
808    },
809}
810
811#[derive(Diagnostic)]
812#[diag(parse_array_brackets_instead_of_braces)]
813pub(crate) struct ArrayBracketsInsteadOfSpaces {
814    #[primary_span]
815    pub span: Span,
816    #[subdiagnostic]
817    pub sub: ArrayBracketsInsteadOfSpacesSugg,
818}
819
820#[derive(Subdiagnostic)]
821#[multipart_suggestion(parse_suggestion, applicability = "maybe-incorrect")]
822pub(crate) struct ArrayBracketsInsteadOfSpacesSugg {
823    #[suggestion_part(code = "[")]
824    pub left: Span,
825    #[suggestion_part(code = "]")]
826    pub right: Span,
827}
828
829#[derive(Diagnostic)]
830#[diag(parse_match_arm_body_without_braces)]
831pub(crate) struct MatchArmBodyWithoutBraces {
832    #[primary_span]
833    #[label(parse_label_statements)]
834    pub statements: Span,
835    #[label(parse_label_arrow)]
836    pub arrow: Span,
837    pub num_statements: usize,
838    #[subdiagnostic]
839    pub sub: MatchArmBodyWithoutBracesSugg,
840}
841
842#[derive(Diagnostic)]
843#[diag(parse_inclusive_range_extra_equals)]
844#[note]
845pub(crate) struct InclusiveRangeExtraEquals {
846    #[primary_span]
847    #[suggestion(
848        parse_suggestion_remove_eq,
849        style = "verbose",
850        code = "..=",
851        applicability = "maybe-incorrect"
852    )]
853    pub span: Span,
854}
855
856#[derive(Diagnostic)]
857#[diag(parse_inclusive_range_match_arrow)]
858pub(crate) struct InclusiveRangeMatchArrow {
859    #[primary_span]
860    pub arrow: Span,
861    #[label]
862    pub span: Span,
863    #[suggestion(style = "verbose", code = " ", applicability = "machine-applicable")]
864    pub after_pat: Span,
865}
866
867#[derive(Diagnostic)]
868#[diag(parse_inclusive_range_no_end, code = E0586)]
869#[note]
870pub(crate) struct InclusiveRangeNoEnd {
871    #[primary_span]
872    pub span: Span,
873    #[suggestion(
874        parse_suggestion_open_range,
875        code = "",
876        applicability = "machine-applicable",
877        style = "verbose"
878    )]
879    pub suggestion: Span,
880}
881
882#[derive(Subdiagnostic)]
883pub(crate) enum MatchArmBodyWithoutBracesSugg {
884    #[multipart_suggestion(parse_suggestion_add_braces, applicability = "machine-applicable")]
885    AddBraces {
886        #[suggestion_part(code = "{{ ")]
887        left: Span,
888        #[suggestion_part(code = " }}")]
889        right: Span,
890    },
891    #[suggestion(
892        parse_suggestion_use_comma_not_semicolon,
893        code = ",",
894        applicability = "machine-applicable",
895        style = "verbose"
896    )]
897    UseComma {
898        #[primary_span]
899        semicolon: Span,
900    },
901}
902
903#[derive(Diagnostic)]
904#[diag(parse_struct_literal_not_allowed_here)]
905pub(crate) struct StructLiteralNotAllowedHere {
906    #[primary_span]
907    pub span: Span,
908    #[subdiagnostic]
909    pub sub: StructLiteralNotAllowedHereSugg,
910}
911
912#[derive(Subdiagnostic)]
913#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
914pub(crate) struct StructLiteralNotAllowedHereSugg {
915    #[suggestion_part(code = "(")]
916    pub left: Span,
917    #[suggestion_part(code = ")")]
918    pub right: Span,
919}
920
921#[derive(Diagnostic)]
922#[diag(parse_invalid_literal_suffix_on_tuple_index)]
923pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
924    #[primary_span]
925    #[label]
926    pub span: Span,
927    pub suffix: Symbol,
928    #[help(parse_tuple_exception_line_1)]
929    #[help(parse_tuple_exception_line_2)]
930    #[help(parse_tuple_exception_line_3)]
931    pub exception: bool,
932}
933
934#[derive(Diagnostic)]
935#[diag(parse_non_string_abi_literal)]
936pub(crate) struct NonStringAbiLiteral {
937    #[primary_span]
938    #[suggestion(code = "\"C\"", applicability = "maybe-incorrect", style = "verbose")]
939    pub span: Span,
940}
941
942#[derive(Diagnostic)]
943#[diag(parse_mismatched_closing_delimiter)]
944pub(crate) struct MismatchedClosingDelimiter {
945    #[primary_span]
946    pub spans: Vec<Span>,
947    pub delimiter: String,
948    #[label(parse_label_unmatched)]
949    pub unmatched: Span,
950    #[label(parse_label_opening_candidate)]
951    pub opening_candidate: Option<Span>,
952    #[label(parse_label_unclosed)]
953    pub unclosed: Option<Span>,
954}
955
956#[derive(Diagnostic)]
957#[diag(parse_incorrect_visibility_restriction, code = E0704)]
958#[help]
959pub(crate) struct IncorrectVisibilityRestriction {
960    #[primary_span]
961    #[suggestion(code = "in {inner_str}", applicability = "machine-applicable", style = "verbose")]
962    pub span: Span,
963    pub inner_str: String,
964}
965
966#[derive(Diagnostic)]
967#[diag(parse_assignment_else_not_allowed)]
968pub(crate) struct AssignmentElseNotAllowed {
969    #[primary_span]
970    pub span: Span,
971}
972
973#[derive(Diagnostic)]
974#[diag(parse_expected_statement_after_outer_attr)]
975pub(crate) struct ExpectedStatementAfterOuterAttr {
976    #[primary_span]
977    pub span: Span,
978}
979
980#[derive(Diagnostic)]
981#[diag(parse_doc_comment_does_not_document_anything, code = E0585)]
982#[help]
983pub(crate) struct DocCommentDoesNotDocumentAnything {
984    #[primary_span]
985    pub span: Span,
986    #[suggestion(code = ",", applicability = "machine-applicable", style = "verbose")]
987    pub missing_comma: Option<Span>,
988}
989
990#[derive(Diagnostic)]
991#[diag(parse_const_let_mutually_exclusive)]
992pub(crate) struct ConstLetMutuallyExclusive {
993    #[primary_span]
994    #[suggestion(code = "const", applicability = "maybe-incorrect", style = "verbose")]
995    pub span: Span,
996}
997
998#[derive(Diagnostic)]
999#[diag(parse_invalid_expression_in_let_else)]
1000pub(crate) struct InvalidExpressionInLetElse {
1001    #[primary_span]
1002    pub span: Span,
1003    pub operator: &'static str,
1004    #[subdiagnostic]
1005    pub sugg: WrapInParentheses,
1006}
1007
1008#[derive(Diagnostic)]
1009#[diag(parse_invalid_curly_in_let_else)]
1010pub(crate) struct InvalidCurlyInLetElse {
1011    #[primary_span]
1012    pub span: Span,
1013    #[subdiagnostic]
1014    pub sugg: WrapInParentheses,
1015}
1016
1017#[derive(Diagnostic)]
1018#[diag(parse_compound_assignment_expression_in_let)]
1019#[help]
1020pub(crate) struct CompoundAssignmentExpressionInLet {
1021    #[primary_span]
1022    pub span: Span,
1023    #[suggestion(style = "verbose", code = "", applicability = "maybe-incorrect")]
1024    pub suggestion: Span,
1025}
1026
1027#[derive(Diagnostic)]
1028#[diag(parse_suffixed_literal_in_attribute)]
1029#[help]
1030pub(crate) struct SuffixedLiteralInAttribute {
1031    #[primary_span]
1032    pub span: Span,
1033}
1034
1035#[derive(Diagnostic)]
1036#[diag(parse_invalid_meta_item)]
1037pub(crate) struct InvalidMetaItem {
1038    #[primary_span]
1039    pub span: Span,
1040    pub descr: String,
1041    #[subdiagnostic]
1042    pub quote_ident_sugg: Option<InvalidMetaItemQuoteIdentSugg>,
1043}
1044
1045#[derive(Subdiagnostic)]
1046#[multipart_suggestion(parse_quote_ident_sugg, applicability = "machine-applicable")]
1047pub(crate) struct InvalidMetaItemQuoteIdentSugg {
1048    #[suggestion_part(code = "\"")]
1049    pub before: Span,
1050    #[suggestion_part(code = "\"")]
1051    pub after: Span,
1052}
1053
1054#[derive(Subdiagnostic)]
1055#[suggestion(
1056    parse_sugg_escape_identifier,
1057    style = "verbose",
1058    applicability = "maybe-incorrect",
1059    code = "r#"
1060)]
1061pub(crate) struct SuggEscapeIdentifier {
1062    #[primary_span]
1063    pub span: Span,
1064    pub ident_name: String,
1065}
1066
1067#[derive(Subdiagnostic)]
1068#[suggestion(
1069    parse_sugg_remove_comma,
1070    applicability = "machine-applicable",
1071    code = "",
1072    style = "verbose"
1073)]
1074pub(crate) struct SuggRemoveComma {
1075    #[primary_span]
1076    pub span: Span,
1077}
1078
1079#[derive(Subdiagnostic)]
1080#[suggestion(
1081    parse_sugg_add_let_for_stmt,
1082    style = "verbose",
1083    applicability = "maybe-incorrect",
1084    code = "let "
1085)]
1086pub(crate) struct SuggAddMissingLetStmt {
1087    #[primary_span]
1088    pub span: Span,
1089}
1090
1091#[derive(Subdiagnostic)]
1092pub(crate) enum ExpectedIdentifierFound {
1093    #[label(parse_expected_identifier_found_reserved_identifier)]
1094    ReservedIdentifier(#[primary_span] Span),
1095    #[label(parse_expected_identifier_found_keyword)]
1096    Keyword(#[primary_span] Span),
1097    #[label(parse_expected_identifier_found_reserved_keyword)]
1098    ReservedKeyword(#[primary_span] Span),
1099    #[label(parse_expected_identifier_found_doc_comment)]
1100    DocComment(#[primary_span] Span),
1101    #[label(parse_expected_identifier_found_metavar)]
1102    MetaVar(#[primary_span] Span),
1103    #[label(parse_expected_identifier)]
1104    Other(#[primary_span] Span),
1105}
1106
1107impl ExpectedIdentifierFound {
1108    pub(crate) fn new(token_descr: Option<TokenDescription>, span: Span) -> Self {
1109        (match token_descr {
1110            Some(TokenDescription::ReservedIdentifier) => {
1111                ExpectedIdentifierFound::ReservedIdentifier
1112            }
1113            Some(TokenDescription::Keyword) => ExpectedIdentifierFound::Keyword,
1114            Some(TokenDescription::ReservedKeyword) => ExpectedIdentifierFound::ReservedKeyword,
1115            Some(TokenDescription::DocComment) => ExpectedIdentifierFound::DocComment,
1116            Some(TokenDescription::MetaVar(_)) => ExpectedIdentifierFound::MetaVar,
1117            None => ExpectedIdentifierFound::Other,
1118        })(span)
1119    }
1120}
1121
1122pub(crate) struct ExpectedIdentifier {
1123    pub span: Span,
1124    pub token: Token,
1125    pub suggest_raw: Option<SuggEscapeIdentifier>,
1126    pub suggest_remove_comma: Option<SuggRemoveComma>,
1127    pub help_cannot_start_number: Option<HelpIdentifierStartsWithNumber>,
1128}
1129
1130impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedIdentifier {
1131    #[track_caller]
1132    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1133        let token_descr = TokenDescription::from_token(&self.token);
1134
1135        let mut add_token = true;
1136        let mut diag = Diag::new(
1137            dcx,
1138            level,
1139            match token_descr {
1140                Some(TokenDescription::ReservedIdentifier) => {
1141                    fluent::parse_expected_identifier_found_reserved_identifier_str
1142                }
1143                Some(TokenDescription::Keyword) => {
1144                    fluent::parse_expected_identifier_found_keyword_str
1145                }
1146                Some(TokenDescription::ReservedKeyword) => {
1147                    fluent::parse_expected_identifier_found_reserved_keyword_str
1148                }
1149                Some(TokenDescription::DocComment) => {
1150                    fluent::parse_expected_identifier_found_doc_comment_str
1151                }
1152                Some(TokenDescription::MetaVar(_)) => {
1153                    add_token = false;
1154                    fluent::parse_expected_identifier_found_metavar_str
1155                }
1156                None => fluent::parse_expected_identifier_found_str,
1157            },
1158        );
1159        diag.span(self.span);
1160        if add_token {
1161            diag.arg("token", self.token);
1162        }
1163
1164        if let Some(sugg) = self.suggest_raw {
1165            sugg.add_to_diag(&mut diag);
1166        }
1167
1168        ExpectedIdentifierFound::new(token_descr, self.span).add_to_diag(&mut diag);
1169
1170        if let Some(sugg) = self.suggest_remove_comma {
1171            sugg.add_to_diag(&mut diag);
1172        }
1173
1174        if let Some(help) = self.help_cannot_start_number {
1175            help.add_to_diag(&mut diag);
1176        }
1177
1178        diag
1179    }
1180}
1181
1182#[derive(Subdiagnostic)]
1183#[help(parse_invalid_identifier_with_leading_number)]
1184pub(crate) struct HelpIdentifierStartsWithNumber {
1185    #[primary_span]
1186    pub num_span: Span,
1187}
1188
1189pub(crate) struct ExpectedSemi {
1190    pub span: Span,
1191    pub token: Token,
1192
1193    pub unexpected_token_label: Option<Span>,
1194    pub sugg: ExpectedSemiSugg,
1195}
1196
1197impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for ExpectedSemi {
1198    #[track_caller]
1199    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
1200        let token_descr = TokenDescription::from_token(&self.token);
1201
1202        let mut add_token = true;
1203        let mut diag = Diag::new(
1204            dcx,
1205            level,
1206            match token_descr {
1207                Some(TokenDescription::ReservedIdentifier) => {
1208                    fluent::parse_expected_semi_found_reserved_identifier_str
1209                }
1210                Some(TokenDescription::Keyword) => fluent::parse_expected_semi_found_keyword_str,
1211                Some(TokenDescription::ReservedKeyword) => {
1212                    fluent::parse_expected_semi_found_reserved_keyword_str
1213                }
1214                Some(TokenDescription::DocComment) => {
1215                    fluent::parse_expected_semi_found_doc_comment_str
1216                }
1217                Some(TokenDescription::MetaVar(_)) => {
1218                    add_token = false;
1219                    fluent::parse_expected_semi_found_metavar_str
1220                }
1221                None => fluent::parse_expected_semi_found_str,
1222            },
1223        );
1224        diag.span(self.span);
1225        if add_token {
1226            diag.arg("token", self.token);
1227        }
1228
1229        if let Some(unexpected_token_label) = self.unexpected_token_label {
1230            diag.span_label(unexpected_token_label, fluent::parse_label_unexpected_token);
1231        }
1232
1233        self.sugg.add_to_diag(&mut diag);
1234
1235        diag
1236    }
1237}
1238
1239#[derive(Subdiagnostic)]
1240pub(crate) enum ExpectedSemiSugg {
1241    #[suggestion(
1242        parse_sugg_change_this_to_semi,
1243        code = ";",
1244        applicability = "machine-applicable",
1245        style = "short"
1246    )]
1247    ChangeToSemi(#[primary_span] Span),
1248    #[suggestion(
1249        parse_sugg_add_semi,
1250        code = ";",
1251        applicability = "machine-applicable",
1252        style = "short"
1253    )]
1254    AddSemi(#[primary_span] Span),
1255}
1256
1257#[derive(Diagnostic)]
1258#[diag(parse_struct_literal_body_without_path)]
1259pub(crate) struct StructLiteralBodyWithoutPath {
1260    #[primary_span]
1261    pub span: Span,
1262    #[subdiagnostic]
1263    pub sugg: StructLiteralBodyWithoutPathSugg,
1264}
1265
1266#[derive(Subdiagnostic)]
1267#[multipart_suggestion(parse_suggestion, applicability = "has-placeholders")]
1268pub(crate) struct StructLiteralBodyWithoutPathSugg {
1269    #[suggestion_part(code = "{{ SomeStruct ")]
1270    pub before: Span,
1271    #[suggestion_part(code = " }}")]
1272    pub after: Span,
1273}
1274
1275#[derive(Diagnostic)]
1276#[diag(parse_struct_literal_needing_parens)]
1277pub(crate) struct StructLiteralNeedingParens {
1278    #[primary_span]
1279    pub span: Span,
1280    #[subdiagnostic]
1281    pub sugg: StructLiteralNeedingParensSugg,
1282}
1283
1284#[derive(Subdiagnostic)]
1285#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1286pub(crate) struct StructLiteralNeedingParensSugg {
1287    #[suggestion_part(code = "(")]
1288    pub before: Span,
1289    #[suggestion_part(code = ")")]
1290    pub after: Span,
1291}
1292
1293#[derive(Diagnostic)]
1294#[diag(parse_unmatched_angle_brackets)]
1295pub(crate) struct UnmatchedAngleBrackets {
1296    #[primary_span]
1297    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1298    pub span: Span,
1299    pub num_extra_brackets: usize,
1300}
1301
1302#[derive(Diagnostic)]
1303#[diag(parse_generic_parameters_without_angle_brackets)]
1304pub(crate) struct GenericParamsWithoutAngleBrackets {
1305    #[primary_span]
1306    pub span: Span,
1307    #[subdiagnostic]
1308    pub sugg: GenericParamsWithoutAngleBracketsSugg,
1309}
1310
1311#[derive(Subdiagnostic)]
1312#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1313pub(crate) struct GenericParamsWithoutAngleBracketsSugg {
1314    #[suggestion_part(code = "<")]
1315    pub left: Span,
1316    #[suggestion_part(code = ">")]
1317    pub right: Span,
1318}
1319
1320#[derive(Diagnostic)]
1321#[diag(parse_comparison_operators_cannot_be_chained)]
1322pub(crate) struct ComparisonOperatorsCannotBeChained {
1323    #[primary_span]
1324    pub span: Vec<Span>,
1325    #[suggestion(
1326        parse_sugg_turbofish_syntax,
1327        style = "verbose",
1328        code = "::",
1329        applicability = "maybe-incorrect"
1330    )]
1331    pub suggest_turbofish: Option<Span>,
1332    #[help(parse_sugg_turbofish_syntax)]
1333    #[help(parse_sugg_parentheses_for_function_args)]
1334    pub help_turbofish: bool,
1335    #[subdiagnostic]
1336    pub chaining_sugg: Option<ComparisonOperatorsCannotBeChainedSugg>,
1337}
1338
1339#[derive(Subdiagnostic)]
1340pub(crate) enum ComparisonOperatorsCannotBeChainedSugg {
1341    #[suggestion(
1342        parse_sugg_split_comparison,
1343        style = "verbose",
1344        code = " && {middle_term}",
1345        applicability = "maybe-incorrect"
1346    )]
1347    SplitComparison {
1348        #[primary_span]
1349        span: Span,
1350        middle_term: String,
1351    },
1352    #[multipart_suggestion(parse_sugg_parenthesize, applicability = "maybe-incorrect")]
1353    Parenthesize {
1354        #[suggestion_part(code = "(")]
1355        left: Span,
1356        #[suggestion_part(code = ")")]
1357        right: Span,
1358    },
1359}
1360
1361#[derive(Diagnostic)]
1362#[diag(parse_question_mark_in_type)]
1363pub(crate) struct QuestionMarkInType {
1364    #[primary_span]
1365    #[label]
1366    pub span: Span,
1367    #[subdiagnostic]
1368    pub sugg: QuestionMarkInTypeSugg,
1369}
1370
1371#[derive(Subdiagnostic)]
1372#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1373pub(crate) struct QuestionMarkInTypeSugg {
1374    #[suggestion_part(code = "Option<")]
1375    pub left: Span,
1376    #[suggestion_part(code = ">")]
1377    pub right: Span,
1378}
1379
1380#[derive(Diagnostic)]
1381#[diag(parse_unexpected_parentheses_in_for_head)]
1382pub(crate) struct ParenthesesInForHead {
1383    #[primary_span]
1384    pub span: Vec<Span>,
1385    #[subdiagnostic]
1386    pub sugg: ParenthesesInForHeadSugg,
1387}
1388
1389#[derive(Subdiagnostic)]
1390#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1391pub(crate) struct ParenthesesInForHeadSugg {
1392    #[suggestion_part(code = " ")]
1393    pub left: Span,
1394    #[suggestion_part(code = " ")]
1395    pub right: Span,
1396}
1397
1398#[derive(Diagnostic)]
1399#[diag(parse_unexpected_parentheses_in_match_arm_pattern)]
1400pub(crate) struct ParenthesesInMatchPat {
1401    #[primary_span]
1402    pub span: Vec<Span>,
1403    #[subdiagnostic]
1404    pub sugg: ParenthesesInMatchPatSugg,
1405}
1406
1407#[derive(Subdiagnostic)]
1408#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1409pub(crate) struct ParenthesesInMatchPatSugg {
1410    #[suggestion_part(code = "")]
1411    pub left: Span,
1412    #[suggestion_part(code = "")]
1413    pub right: Span,
1414}
1415
1416#[derive(Diagnostic)]
1417#[diag(parse_doc_comment_on_param_type)]
1418pub(crate) struct DocCommentOnParamType {
1419    #[primary_span]
1420    #[label]
1421    pub span: Span,
1422}
1423
1424#[derive(Diagnostic)]
1425#[diag(parse_attribute_on_param_type)]
1426pub(crate) struct AttributeOnParamType {
1427    #[primary_span]
1428    #[label]
1429    pub span: Span,
1430}
1431
1432#[derive(Diagnostic)]
1433#[diag(parse_pattern_method_param_without_body, code = E0642)]
1434pub(crate) struct PatternMethodParamWithoutBody {
1435    #[primary_span]
1436    #[suggestion(code = "_", applicability = "machine-applicable", style = "verbose")]
1437    pub span: Span,
1438}
1439
1440#[derive(Diagnostic)]
1441#[diag(parse_self_param_not_first)]
1442pub(crate) struct SelfParamNotFirst {
1443    #[primary_span]
1444    #[label]
1445    pub span: Span,
1446}
1447
1448#[derive(Diagnostic)]
1449#[diag(parse_const_generic_without_braces)]
1450pub(crate) struct ConstGenericWithoutBraces {
1451    #[primary_span]
1452    pub span: Span,
1453    #[subdiagnostic]
1454    pub sugg: ConstGenericWithoutBracesSugg,
1455}
1456
1457#[derive(Subdiagnostic)]
1458#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1459pub(crate) struct ConstGenericWithoutBracesSugg {
1460    #[suggestion_part(code = "{{ ")]
1461    pub left: Span,
1462    #[suggestion_part(code = " }}")]
1463    pub right: Span,
1464}
1465
1466#[derive(Diagnostic)]
1467#[diag(parse_unexpected_const_param_declaration)]
1468pub(crate) struct UnexpectedConstParamDeclaration {
1469    #[primary_span]
1470    #[label]
1471    pub span: Span,
1472    #[subdiagnostic]
1473    pub sugg: Option<UnexpectedConstParamDeclarationSugg>,
1474}
1475
1476#[derive(Subdiagnostic)]
1477pub(crate) enum UnexpectedConstParamDeclarationSugg {
1478    #[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1479    AddParam {
1480        #[suggestion_part(code = "<{snippet}>")]
1481        impl_generics: Span,
1482        #[suggestion_part(code = "{ident}")]
1483        incorrect_decl: Span,
1484        snippet: String,
1485        ident: String,
1486    },
1487    #[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1488    AppendParam {
1489        #[suggestion_part(code = ", {snippet}")]
1490        impl_generics_end: Span,
1491        #[suggestion_part(code = "{ident}")]
1492        incorrect_decl: Span,
1493        snippet: String,
1494        ident: String,
1495    },
1496}
1497
1498#[derive(Diagnostic)]
1499#[diag(parse_unexpected_const_in_generic_param)]
1500pub(crate) struct UnexpectedConstInGenericParam {
1501    #[primary_span]
1502    pub span: Span,
1503    #[suggestion(style = "verbose", code = "", applicability = "maybe-incorrect")]
1504    pub to_remove: Option<Span>,
1505}
1506
1507#[derive(Diagnostic)]
1508#[diag(parse_async_move_order_incorrect)]
1509pub(crate) struct AsyncMoveOrderIncorrect {
1510    #[primary_span]
1511    #[suggestion(style = "verbose", code = "async move", applicability = "maybe-incorrect")]
1512    pub span: Span,
1513}
1514
1515#[derive(Diagnostic)]
1516#[diag(parse_async_use_order_incorrect)]
1517pub(crate) struct AsyncUseOrderIncorrect {
1518    #[primary_span]
1519    #[suggestion(style = "verbose", code = "async use", applicability = "maybe-incorrect")]
1520    pub span: Span,
1521}
1522
1523#[derive(Diagnostic)]
1524#[diag(parse_double_colon_in_bound)]
1525pub(crate) struct DoubleColonInBound {
1526    #[primary_span]
1527    pub span: Span,
1528    #[suggestion(code = ": ", applicability = "machine-applicable", style = "verbose")]
1529    pub between: Span,
1530}
1531
1532#[derive(Diagnostic)]
1533#[diag(parse_fn_ptr_with_generics)]
1534pub(crate) struct FnPtrWithGenerics {
1535    #[primary_span]
1536    pub span: Span,
1537    #[subdiagnostic]
1538    pub sugg: Option<FnPtrWithGenericsSugg>,
1539}
1540
1541#[derive(Subdiagnostic)]
1542#[multipart_suggestion(
1543    parse_misplaced_return_type,
1544    style = "verbose",
1545    applicability = "maybe-incorrect"
1546)]
1547pub(crate) struct MisplacedReturnType {
1548    #[suggestion_part(code = " {snippet}")]
1549    pub fn_params_end: Span,
1550    pub snippet: String,
1551    #[suggestion_part(code = "")]
1552    pub ret_ty_span: Span,
1553}
1554
1555#[derive(Subdiagnostic)]
1556#[multipart_suggestion(parse_suggestion, applicability = "maybe-incorrect")]
1557pub(crate) struct FnPtrWithGenericsSugg {
1558    #[suggestion_part(code = "{snippet}")]
1559    pub left: Span,
1560    pub snippet: String,
1561    #[suggestion_part(code = "")]
1562    pub right: Span,
1563    pub arity: usize,
1564    pub for_param_list_exists: bool,
1565}
1566
1567pub(crate) struct FnTraitMissingParen {
1568    pub span: Span,
1569}
1570
1571impl Subdiagnostic for FnTraitMissingParen {
1572    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
1573        self,
1574        diag: &mut Diag<'_, G>,
1575        _: &F,
1576    ) {
1577        diag.span_label(self.span, crate::fluent_generated::parse_fn_trait_missing_paren);
1578        diag.span_suggestion_short(
1579            self.span.shrink_to_hi(),
1580            crate::fluent_generated::parse_add_paren,
1581            "()",
1582            Applicability::MachineApplicable,
1583        );
1584    }
1585}
1586
1587#[derive(Diagnostic)]
1588#[diag(parse_unexpected_if_with_if)]
1589pub(crate) struct UnexpectedIfWithIf(
1590    #[primary_span]
1591    #[suggestion(applicability = "machine-applicable", code = " ", style = "verbose")]
1592    pub Span,
1593);
1594
1595#[derive(Diagnostic)]
1596#[diag(parse_maybe_fn_typo_with_impl)]
1597pub(crate) struct FnTypoWithImpl {
1598    #[primary_span]
1599    #[suggestion(applicability = "maybe-incorrect", code = "impl", style = "verbose")]
1600    pub fn_span: Span,
1601}
1602
1603#[derive(Diagnostic)]
1604#[diag(parse_expected_fn_path_found_fn_keyword)]
1605pub(crate) struct ExpectedFnPathFoundFnKeyword {
1606    #[primary_span]
1607    #[suggestion(applicability = "machine-applicable", code = "Fn", style = "verbose")]
1608    pub fn_token_span: Span,
1609}
1610
1611#[derive(Diagnostic)]
1612#[diag(parse_path_double_colon)]
1613pub(crate) struct PathSingleColon {
1614    #[primary_span]
1615    pub span: Span,
1616
1617    #[suggestion(applicability = "machine-applicable", code = ":", style = "verbose")]
1618    pub suggestion: Span,
1619
1620    #[note(parse_type_ascription_removed)]
1621    pub type_ascription: bool,
1622}
1623
1624#[derive(Diagnostic)]
1625#[diag(parse_path_double_colon)]
1626pub(crate) struct PathTripleColon {
1627    #[primary_span]
1628    #[suggestion(applicability = "maybe-incorrect", code = "", style = "verbose")]
1629    pub span: Span,
1630}
1631
1632#[derive(Diagnostic)]
1633#[diag(parse_colon_as_semi)]
1634pub(crate) struct ColonAsSemi {
1635    #[primary_span]
1636    #[suggestion(applicability = "machine-applicable", code = ";", style = "verbose")]
1637    pub span: Span,
1638
1639    #[note(parse_type_ascription_removed)]
1640    pub type_ascription: bool,
1641}
1642
1643#[derive(Diagnostic)]
1644#[diag(parse_where_clause_before_tuple_struct_body)]
1645pub(crate) struct WhereClauseBeforeTupleStructBody {
1646    #[primary_span]
1647    #[label]
1648    pub span: Span,
1649    #[label(parse_name_label)]
1650    pub name: Span,
1651    #[label(parse_body_label)]
1652    pub body: Span,
1653    #[subdiagnostic]
1654    pub sugg: Option<WhereClauseBeforeTupleStructBodySugg>,
1655}
1656
1657#[derive(Subdiagnostic)]
1658#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1659pub(crate) struct WhereClauseBeforeTupleStructBodySugg {
1660    #[suggestion_part(code = "{snippet}")]
1661    pub left: Span,
1662    pub snippet: String,
1663    #[suggestion_part(code = "")]
1664    pub right: Span,
1665}
1666
1667#[derive(Diagnostic)]
1668#[diag(parse_async_fn_in_2015, code = E0670)]
1669pub(crate) struct AsyncFnIn2015 {
1670    #[primary_span]
1671    #[label]
1672    pub span: Span,
1673    #[subdiagnostic]
1674    pub help: HelpUseLatestEdition,
1675}
1676
1677#[derive(Subdiagnostic)]
1678#[label(parse_async_block_in_2015)]
1679pub(crate) struct AsyncBlockIn2015 {
1680    #[primary_span]
1681    pub span: Span,
1682}
1683
1684#[derive(Diagnostic)]
1685#[diag(parse_async_move_block_in_2015)]
1686pub(crate) struct AsyncMoveBlockIn2015 {
1687    #[primary_span]
1688    pub span: Span,
1689}
1690
1691#[derive(Diagnostic)]
1692#[diag(parse_async_use_block_in_2015)]
1693pub(crate) struct AsyncUseBlockIn2015 {
1694    #[primary_span]
1695    pub span: Span,
1696}
1697
1698#[derive(Diagnostic)]
1699#[diag(parse_async_bound_modifier_in_2015)]
1700pub(crate) struct AsyncBoundModifierIn2015 {
1701    #[primary_span]
1702    pub span: Span,
1703    #[subdiagnostic]
1704    pub help: HelpUseLatestEdition,
1705}
1706
1707#[derive(Diagnostic)]
1708#[diag(parse_self_argument_pointer)]
1709pub(crate) struct SelfArgumentPointer {
1710    #[primary_span]
1711    #[label]
1712    pub span: Span,
1713}
1714
1715#[derive(Diagnostic)]
1716#[diag(parse_unexpected_token_after_dot)]
1717pub(crate) struct UnexpectedTokenAfterDot<'a> {
1718    #[primary_span]
1719    pub span: Span,
1720    pub actual: Cow<'a, str>,
1721}
1722
1723#[derive(Diagnostic)]
1724#[diag(parse_visibility_not_followed_by_item)]
1725#[help]
1726pub(crate) struct VisibilityNotFollowedByItem {
1727    #[primary_span]
1728    #[label]
1729    pub span: Span,
1730    pub vis: Visibility,
1731}
1732
1733#[derive(Diagnostic)]
1734#[diag(parse_default_not_followed_by_item)]
1735#[note]
1736pub(crate) struct DefaultNotFollowedByItem {
1737    #[primary_span]
1738    #[label]
1739    pub span: Span,
1740}
1741
1742#[derive(Diagnostic)]
1743pub(crate) enum MissingKeywordForItemDefinition {
1744    #[diag(parse_missing_enum_for_enum_definition)]
1745    Enum {
1746        #[primary_span]
1747        span: Span,
1748        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "enum ")]
1749        insert_span: Span,
1750        ident: Ident,
1751    },
1752    #[diag(parse_missing_enum_or_struct_for_item_definition)]
1753    EnumOrStruct {
1754        #[primary_span]
1755        span: Span,
1756    },
1757    #[diag(parse_missing_struct_for_struct_definition)]
1758    Struct {
1759        #[primary_span]
1760        span: Span,
1761        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "struct ")]
1762        insert_span: Span,
1763        ident: Ident,
1764    },
1765    #[diag(parse_missing_fn_for_function_definition)]
1766    Function {
1767        #[primary_span]
1768        span: Span,
1769        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
1770        insert_span: Span,
1771        ident: Ident,
1772    },
1773    #[diag(parse_missing_fn_for_method_definition)]
1774    Method {
1775        #[primary_span]
1776        span: Span,
1777        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
1778        insert_span: Span,
1779        ident: Ident,
1780    },
1781    #[diag(parse_missing_fn_or_struct_for_item_definition)]
1782    Ambiguous {
1783        #[primary_span]
1784        span: Span,
1785        #[subdiagnostic]
1786        subdiag: Option<AmbiguousMissingKwForItemSub>,
1787    },
1788}
1789
1790#[derive(Subdiagnostic)]
1791pub(crate) enum AmbiguousMissingKwForItemSub {
1792    #[suggestion(
1793        parse_suggestion,
1794        applicability = "maybe-incorrect",
1795        code = "{snippet}!",
1796        style = "verbose"
1797    )]
1798    SuggestMacro {
1799        #[primary_span]
1800        span: Span,
1801        snippet: String,
1802    },
1803    #[help(parse_help)]
1804    HelpMacro,
1805}
1806
1807#[derive(Diagnostic)]
1808#[diag(parse_missing_fn_params)]
1809pub(crate) struct MissingFnParams {
1810    #[primary_span]
1811    #[suggestion(code = "()", applicability = "machine-applicable", style = "verbose")]
1812    pub span: Span,
1813}
1814
1815#[derive(Diagnostic)]
1816#[diag(parse_invalid_path_sep_in_fn_definition)]
1817pub(crate) struct InvalidPathSepInFnDefinition {
1818    #[primary_span]
1819    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1820    pub span: Span,
1821}
1822
1823#[derive(Diagnostic)]
1824#[diag(parse_missing_trait_in_trait_impl)]
1825pub(crate) struct MissingTraitInTraitImpl {
1826    #[primary_span]
1827    #[suggestion(
1828        parse_suggestion_add_trait,
1829        code = " Trait ",
1830        applicability = "has-placeholders",
1831        style = "verbose"
1832    )]
1833    pub span: Span,
1834    #[suggestion(
1835        parse_suggestion_remove_for,
1836        code = "",
1837        applicability = "maybe-incorrect",
1838        style = "verbose"
1839    )]
1840    pub for_span: Span,
1841}
1842
1843#[derive(Diagnostic)]
1844#[diag(parse_missing_for_in_trait_impl)]
1845pub(crate) struct MissingForInTraitImpl {
1846    #[primary_span]
1847    #[suggestion(style = "verbose", code = " for ", applicability = "machine-applicable")]
1848    pub span: Span,
1849}
1850
1851#[derive(Diagnostic)]
1852#[diag(parse_expected_trait_in_trait_impl_found_type)]
1853pub(crate) struct ExpectedTraitInTraitImplFoundType {
1854    #[primary_span]
1855    pub span: Span,
1856}
1857
1858#[derive(Diagnostic)]
1859#[diag(parse_extra_impl_keyword_in_trait_impl)]
1860pub(crate) struct ExtraImplKeywordInTraitImpl {
1861    #[primary_span]
1862    #[suggestion(code = "", applicability = "maybe-incorrect", style = "short")]
1863    pub extra_impl_kw: Span,
1864    #[note]
1865    pub impl_trait_span: Span,
1866}
1867
1868#[derive(Diagnostic)]
1869#[diag(parse_bounds_not_allowed_on_trait_aliases)]
1870pub(crate) struct BoundsNotAllowedOnTraitAliases {
1871    #[primary_span]
1872    pub span: Span,
1873}
1874
1875#[derive(Diagnostic)]
1876#[diag(parse_trait_alias_cannot_be_auto)]
1877pub(crate) struct TraitAliasCannotBeAuto {
1878    #[primary_span]
1879    #[label(parse_trait_alias_cannot_be_auto)]
1880    pub span: Span,
1881}
1882
1883#[derive(Diagnostic)]
1884#[diag(parse_trait_alias_cannot_be_unsafe)]
1885pub(crate) struct TraitAliasCannotBeUnsafe {
1886    #[primary_span]
1887    #[label(parse_trait_alias_cannot_be_unsafe)]
1888    pub span: Span,
1889}
1890
1891#[derive(Diagnostic)]
1892#[diag(parse_associated_static_item_not_allowed)]
1893pub(crate) struct AssociatedStaticItemNotAllowed {
1894    #[primary_span]
1895    pub span: Span,
1896}
1897
1898#[derive(Diagnostic)]
1899#[diag(parse_extern_crate_name_with_dashes)]
1900pub(crate) struct ExternCrateNameWithDashes {
1901    #[primary_span]
1902    #[label]
1903    pub span: Span,
1904    #[subdiagnostic]
1905    pub sugg: ExternCrateNameWithDashesSugg,
1906}
1907
1908#[derive(Subdiagnostic)]
1909#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1910pub(crate) struct ExternCrateNameWithDashesSugg {
1911    #[suggestion_part(code = "_")]
1912    pub dashes: Vec<Span>,
1913}
1914
1915#[derive(Diagnostic)]
1916#[diag(parse_extern_item_cannot_be_const)]
1917#[note]
1918pub(crate) struct ExternItemCannotBeConst {
1919    #[primary_span]
1920    pub ident_span: Span,
1921    #[suggestion(code = "static ", applicability = "machine-applicable", style = "verbose")]
1922    pub const_span: Option<Span>,
1923}
1924
1925#[derive(Diagnostic)]
1926#[diag(parse_const_global_cannot_be_mutable)]
1927pub(crate) struct ConstGlobalCannotBeMutable {
1928    #[primary_span]
1929    #[label]
1930    pub ident_span: Span,
1931    #[suggestion(code = "static", style = "verbose", applicability = "maybe-incorrect")]
1932    pub const_span: Span,
1933}
1934
1935#[derive(Diagnostic)]
1936#[diag(parse_missing_const_type)]
1937pub(crate) struct MissingConstType {
1938    #[primary_span]
1939    #[suggestion(code = "{colon} <type>", style = "verbose", applicability = "has-placeholders")]
1940    pub span: Span,
1941
1942    pub kind: &'static str,
1943    pub colon: &'static str,
1944}
1945
1946#[derive(Diagnostic)]
1947#[diag(parse_enum_struct_mutually_exclusive)]
1948pub(crate) struct EnumStructMutuallyExclusive {
1949    #[primary_span]
1950    #[suggestion(code = "enum", style = "verbose", applicability = "machine-applicable")]
1951    pub span: Span,
1952}
1953
1954#[derive(Diagnostic)]
1955pub(crate) enum UnexpectedTokenAfterStructName {
1956    #[diag(parse_unexpected_token_after_struct_name_found_reserved_identifier)]
1957    ReservedIdentifier {
1958        #[primary_span]
1959        #[label(parse_unexpected_token_after_struct_name)]
1960        span: Span,
1961        token: Token,
1962    },
1963    #[diag(parse_unexpected_token_after_struct_name_found_keyword)]
1964    Keyword {
1965        #[primary_span]
1966        #[label(parse_unexpected_token_after_struct_name)]
1967        span: Span,
1968        token: Token,
1969    },
1970    #[diag(parse_unexpected_token_after_struct_name_found_reserved_keyword)]
1971    ReservedKeyword {
1972        #[primary_span]
1973        #[label(parse_unexpected_token_after_struct_name)]
1974        span: Span,
1975        token: Token,
1976    },
1977    #[diag(parse_unexpected_token_after_struct_name_found_doc_comment)]
1978    DocComment {
1979        #[primary_span]
1980        #[label(parse_unexpected_token_after_struct_name)]
1981        span: Span,
1982        token: Token,
1983    },
1984    #[diag(parse_unexpected_token_after_struct_name_found_metavar)]
1985    MetaVar {
1986        #[primary_span]
1987        #[label(parse_unexpected_token_after_struct_name)]
1988        span: Span,
1989    },
1990    #[diag(parse_unexpected_token_after_struct_name_found_other)]
1991    Other {
1992        #[primary_span]
1993        #[label(parse_unexpected_token_after_struct_name)]
1994        span: Span,
1995        token: Token,
1996    },
1997}
1998
1999impl UnexpectedTokenAfterStructName {
2000    pub(crate) fn new(span: Span, token: Token) -> Self {
2001        match TokenDescription::from_token(&token) {
2002            Some(TokenDescription::ReservedIdentifier) => Self::ReservedIdentifier { span, token },
2003            Some(TokenDescription::Keyword) => Self::Keyword { span, token },
2004            Some(TokenDescription::ReservedKeyword) => Self::ReservedKeyword { span, token },
2005            Some(TokenDescription::DocComment) => Self::DocComment { span, token },
2006            Some(TokenDescription::MetaVar(_)) => Self::MetaVar { span },
2007            None => Self::Other { span, token },
2008        }
2009    }
2010}
2011
2012#[derive(Diagnostic)]
2013#[diag(parse_unexpected_self_in_generic_parameters)]
2014#[note]
2015pub(crate) struct UnexpectedSelfInGenericParameters {
2016    #[primary_span]
2017    pub span: Span,
2018}
2019
2020#[derive(Diagnostic)]
2021#[diag(parse_unexpected_default_value_for_lifetime_in_generic_parameters)]
2022pub(crate) struct UnexpectedDefaultValueForLifetimeInGenericParameters {
2023    #[primary_span]
2024    #[label]
2025    pub span: Span,
2026}
2027
2028#[derive(Diagnostic)]
2029#[diag(parse_multiple_where_clauses)]
2030pub(crate) struct MultipleWhereClauses {
2031    #[primary_span]
2032    pub span: Span,
2033    #[label]
2034    pub previous: Span,
2035    #[suggestion(style = "verbose", code = ",", applicability = "maybe-incorrect")]
2036    pub between: Span,
2037}
2038
2039#[derive(Diagnostic)]
2040pub(crate) enum UnexpectedNonterminal {
2041    #[diag(parse_nonterminal_expected_item_keyword)]
2042    Item(#[primary_span] Span),
2043    #[diag(parse_nonterminal_expected_statement)]
2044    Statement(#[primary_span] Span),
2045    #[diag(parse_nonterminal_expected_ident)]
2046    Ident {
2047        #[primary_span]
2048        span: Span,
2049        token: Token,
2050    },
2051    #[diag(parse_nonterminal_expected_lifetime)]
2052    Lifetime {
2053        #[primary_span]
2054        span: Span,
2055        token: Token,
2056    },
2057}
2058
2059#[derive(Diagnostic)]
2060pub(crate) enum TopLevelOrPatternNotAllowed {
2061    #[diag(parse_or_pattern_not_allowed_in_let_binding)]
2062    LetBinding {
2063        #[primary_span]
2064        span: Span,
2065        #[subdiagnostic]
2066        sub: Option<TopLevelOrPatternNotAllowedSugg>,
2067    },
2068    #[diag(parse_or_pattern_not_allowed_in_fn_parameters)]
2069    FunctionParameter {
2070        #[primary_span]
2071        span: Span,
2072        #[subdiagnostic]
2073        sub: Option<TopLevelOrPatternNotAllowedSugg>,
2074    },
2075}
2076
2077#[derive(Diagnostic)]
2078#[diag(parse_cannot_be_raw_ident)]
2079pub(crate) struct CannotBeRawIdent {
2080    #[primary_span]
2081    pub span: Span,
2082    pub ident: Symbol,
2083}
2084
2085#[derive(Diagnostic)]
2086#[diag(parse_cannot_be_raw_lifetime)]
2087pub(crate) struct CannotBeRawLifetime {
2088    #[primary_span]
2089    pub span: Span,
2090    pub ident: Symbol,
2091}
2092
2093#[derive(Diagnostic)]
2094#[diag(parse_keyword_lifetime)]
2095pub(crate) struct KeywordLifetime {
2096    #[primary_span]
2097    pub span: Span,
2098}
2099
2100#[derive(Diagnostic)]
2101#[diag(parse_invalid_label)]
2102pub(crate) struct InvalidLabel {
2103    #[primary_span]
2104    pub span: Span,
2105    pub name: Symbol,
2106}
2107
2108#[derive(Diagnostic)]
2109#[diag(parse_cr_doc_comment)]
2110pub(crate) struct CrDocComment {
2111    #[primary_span]
2112    pub span: Span,
2113    pub block: bool,
2114}
2115
2116#[derive(Diagnostic)]
2117#[diag(parse_no_digits_literal, code = E0768)]
2118pub(crate) struct NoDigitsLiteral {
2119    #[primary_span]
2120    pub span: Span,
2121}
2122
2123#[derive(Diagnostic)]
2124#[diag(parse_invalid_digit_literal)]
2125pub(crate) struct InvalidDigitLiteral {
2126    #[primary_span]
2127    pub span: Span,
2128    pub base: u32,
2129}
2130
2131#[derive(Diagnostic)]
2132#[diag(parse_empty_exponent_float)]
2133pub(crate) struct EmptyExponentFloat {
2134    #[primary_span]
2135    pub span: Span,
2136}
2137
2138#[derive(Diagnostic)]
2139#[diag(parse_float_literal_unsupported_base)]
2140pub(crate) struct FloatLiteralUnsupportedBase {
2141    #[primary_span]
2142    pub span: Span,
2143    pub base: &'static str,
2144}
2145
2146#[derive(Diagnostic)]
2147#[diag(parse_unknown_prefix)]
2148#[note]
2149pub(crate) struct UnknownPrefix<'a> {
2150    #[primary_span]
2151    #[label]
2152    pub span: Span,
2153    pub prefix: &'a str,
2154    #[subdiagnostic]
2155    pub sugg: Option<UnknownPrefixSugg>,
2156}
2157
2158#[derive(Subdiagnostic)]
2159#[note(parse_macro_expands_to_adt_field)]
2160pub(crate) struct MacroExpandsToAdtField<'a> {
2161    pub adt_ty: &'a str,
2162}
2163
2164#[derive(Subdiagnostic)]
2165pub(crate) enum UnknownPrefixSugg {
2166    #[suggestion(
2167        parse_suggestion_br,
2168        code = "br",
2169        applicability = "maybe-incorrect",
2170        style = "verbose"
2171    )]
2172    UseBr(#[primary_span] Span),
2173    #[suggestion(
2174        parse_suggestion_whitespace,
2175        code = " ",
2176        applicability = "maybe-incorrect",
2177        style = "verbose"
2178    )]
2179    Whitespace(#[primary_span] Span),
2180    #[multipart_suggestion(
2181        parse_suggestion_str,
2182        applicability = "maybe-incorrect",
2183        style = "verbose"
2184    )]
2185    MeantStr {
2186        #[suggestion_part(code = "\"")]
2187        start: Span,
2188        #[suggestion_part(code = "\"")]
2189        end: Span,
2190    },
2191}
2192
2193#[derive(Diagnostic)]
2194#[diag(parse_reserved_multihash)]
2195#[note]
2196pub(crate) struct ReservedMultihash {
2197    #[primary_span]
2198    pub span: Span,
2199    #[subdiagnostic]
2200    pub sugg: Option<GuardedStringSugg>,
2201}
2202#[derive(Diagnostic)]
2203#[diag(parse_reserved_string)]
2204#[note]
2205pub(crate) struct ReservedString {
2206    #[primary_span]
2207    pub span: Span,
2208    #[subdiagnostic]
2209    pub sugg: Option<GuardedStringSugg>,
2210}
2211#[derive(Subdiagnostic)]
2212#[suggestion(
2213    parse_suggestion_whitespace,
2214    code = " ",
2215    applicability = "maybe-incorrect",
2216    style = "verbose"
2217)]
2218pub(crate) struct GuardedStringSugg(#[primary_span] pub Span);
2219
2220#[derive(Diagnostic)]
2221#[diag(parse_too_many_hashes)]
2222pub(crate) struct TooManyHashes {
2223    #[primary_span]
2224    pub span: Span,
2225    pub num: u32,
2226}
2227
2228#[derive(Diagnostic)]
2229#[diag(parse_unknown_start_of_token)]
2230pub(crate) struct UnknownTokenStart {
2231    #[primary_span]
2232    pub span: Span,
2233    pub escaped: String,
2234    #[subdiagnostic]
2235    pub sugg: Option<TokenSubstitution>,
2236    #[subdiagnostic]
2237    pub null: Option<UnknownTokenNull>,
2238    #[subdiagnostic]
2239    pub repeat: Option<UnknownTokenRepeat>,
2240}
2241
2242#[derive(Subdiagnostic)]
2243pub(crate) enum TokenSubstitution {
2244    #[suggestion(
2245        parse_sugg_quotes,
2246        code = "{suggestion}",
2247        applicability = "maybe-incorrect",
2248        style = "verbose"
2249    )]
2250    DirectedQuotes {
2251        #[primary_span]
2252        span: Span,
2253        suggestion: String,
2254        ascii_str: &'static str,
2255        ascii_name: &'static str,
2256    },
2257    #[suggestion(
2258        parse_sugg_other,
2259        code = "{suggestion}",
2260        applicability = "maybe-incorrect",
2261        style = "verbose"
2262    )]
2263    Other {
2264        #[primary_span]
2265        span: Span,
2266        suggestion: String,
2267        ch: String,
2268        u_name: &'static str,
2269        ascii_str: &'static str,
2270        ascii_name: &'static str,
2271    },
2272}
2273
2274#[derive(Subdiagnostic)]
2275#[note(parse_note_repeats)]
2276pub(crate) struct UnknownTokenRepeat {
2277    pub repeats: usize,
2278}
2279
2280#[derive(Subdiagnostic)]
2281#[help(parse_help_null)]
2282pub(crate) struct UnknownTokenNull;
2283
2284#[derive(Diagnostic)]
2285pub(crate) enum UnescapeError {
2286    #[diag(parse_invalid_unicode_escape)]
2287    #[help]
2288    InvalidUnicodeEscape {
2289        #[primary_span]
2290        #[label]
2291        span: Span,
2292        surrogate: bool,
2293    },
2294    #[diag(parse_escape_only_char)]
2295    EscapeOnlyChar {
2296        #[primary_span]
2297        span: Span,
2298        #[suggestion(
2299            parse_escape,
2300            applicability = "machine-applicable",
2301            code = "{escaped_sugg}",
2302            style = "verbose"
2303        )]
2304        char_span: Span,
2305        escaped_sugg: String,
2306        escaped_msg: String,
2307        byte: bool,
2308    },
2309    #[diag(parse_bare_cr)]
2310    BareCr {
2311        #[primary_span]
2312        #[suggestion(
2313            parse_escape,
2314            applicability = "machine-applicable",
2315            code = "\\r",
2316            style = "verbose"
2317        )]
2318        span: Span,
2319        double_quotes: bool,
2320    },
2321    #[diag(parse_bare_cr_in_raw_string)]
2322    BareCrRawString(#[primary_span] Span),
2323    #[diag(parse_too_short_hex_escape)]
2324    TooShortHexEscape(#[primary_span] Span),
2325    #[diag(parse_invalid_char_in_escape)]
2326    InvalidCharInEscape {
2327        #[primary_span]
2328        #[label]
2329        span: Span,
2330        is_hex: bool,
2331        ch: String,
2332    },
2333    #[diag(parse_out_of_range_hex_escape)]
2334    OutOfRangeHexEscape(
2335        #[primary_span]
2336        #[label]
2337        Span,
2338    ),
2339    #[diag(parse_leading_underscore_unicode_escape)]
2340    LeadingUnderscoreUnicodeEscape {
2341        #[primary_span]
2342        #[label(parse_leading_underscore_unicode_escape_label)]
2343        span: Span,
2344        ch: String,
2345    },
2346    #[diag(parse_overlong_unicode_escape)]
2347    OverlongUnicodeEscape(
2348        #[primary_span]
2349        #[label]
2350        Span,
2351    ),
2352    #[diag(parse_unclosed_unicode_escape)]
2353    UnclosedUnicodeEscape(
2354        #[primary_span]
2355        #[label]
2356        Span,
2357        #[suggestion(
2358            parse_terminate,
2359            code = "}}",
2360            applicability = "maybe-incorrect",
2361            style = "verbose"
2362        )]
2363        Span,
2364    ),
2365    #[diag(parse_no_brace_unicode_escape)]
2366    NoBraceInUnicodeEscape {
2367        #[primary_span]
2368        span: Span,
2369        #[label]
2370        label: Option<Span>,
2371        #[subdiagnostic]
2372        sub: NoBraceUnicodeSub,
2373    },
2374    #[diag(parse_unicode_escape_in_byte)]
2375    #[help]
2376    UnicodeEscapeInByte(
2377        #[primary_span]
2378        #[label]
2379        Span,
2380    ),
2381    #[diag(parse_empty_unicode_escape)]
2382    EmptyUnicodeEscape(
2383        #[primary_span]
2384        #[label]
2385        Span,
2386    ),
2387    #[diag(parse_zero_chars)]
2388    ZeroChars(
2389        #[primary_span]
2390        #[label]
2391        Span,
2392    ),
2393    #[diag(parse_lone_slash)]
2394    LoneSlash(
2395        #[primary_span]
2396        #[label]
2397        Span,
2398    ),
2399    #[diag(parse_unskipped_whitespace)]
2400    UnskippedWhitespace {
2401        #[primary_span]
2402        span: Span,
2403        #[label]
2404        char_span: Span,
2405        ch: String,
2406    },
2407    #[diag(parse_multiple_skipped_lines)]
2408    MultipleSkippedLinesWarning(
2409        #[primary_span]
2410        #[label]
2411        Span,
2412    ),
2413    #[diag(parse_more_than_one_char)]
2414    MoreThanOneChar {
2415        #[primary_span]
2416        span: Span,
2417        #[subdiagnostic]
2418        note: Option<MoreThanOneCharNote>,
2419        #[subdiagnostic]
2420        suggestion: MoreThanOneCharSugg,
2421    },
2422    #[diag(parse_nul_in_c_str)]
2423    NulInCStr {
2424        #[primary_span]
2425        span: Span,
2426    },
2427}
2428
2429#[derive(Subdiagnostic)]
2430pub(crate) enum MoreThanOneCharSugg {
2431    #[suggestion(
2432        parse_consider_normalized,
2433        code = "{normalized}",
2434        applicability = "machine-applicable",
2435        style = "verbose"
2436    )]
2437    NormalizedForm {
2438        #[primary_span]
2439        span: Span,
2440        ch: String,
2441        normalized: String,
2442    },
2443    #[suggestion(
2444        parse_remove_non,
2445        code = "{ch}",
2446        applicability = "maybe-incorrect",
2447        style = "verbose"
2448    )]
2449    RemoveNonPrinting {
2450        #[primary_span]
2451        span: Span,
2452        ch: String,
2453    },
2454    #[suggestion(
2455        parse_use_double_quotes,
2456        code = "{sugg}",
2457        applicability = "machine-applicable",
2458        style = "verbose"
2459    )]
2460    QuotesFull {
2461        #[primary_span]
2462        span: Span,
2463        is_byte: bool,
2464        sugg: String,
2465    },
2466    #[multipart_suggestion(parse_use_double_quotes, applicability = "machine-applicable")]
2467    Quotes {
2468        #[suggestion_part(code = "{prefix}\"")]
2469        start: Span,
2470        #[suggestion_part(code = "\"")]
2471        end: Span,
2472        is_byte: bool,
2473        prefix: &'static str,
2474    },
2475}
2476
2477#[derive(Subdiagnostic)]
2478pub(crate) enum MoreThanOneCharNote {
2479    #[note(parse_followed_by)]
2480    AllCombining {
2481        #[primary_span]
2482        span: Span,
2483        chr: String,
2484        len: usize,
2485        escaped_marks: String,
2486    },
2487    #[note(parse_non_printing)]
2488    NonPrinting {
2489        #[primary_span]
2490        span: Span,
2491        escaped: String,
2492    },
2493}
2494
2495#[derive(Subdiagnostic)]
2496pub(crate) enum NoBraceUnicodeSub {
2497    #[suggestion(
2498        parse_use_braces,
2499        code = "{suggestion}",
2500        applicability = "maybe-incorrect",
2501        style = "verbose"
2502    )]
2503    Suggestion {
2504        #[primary_span]
2505        span: Span,
2506        suggestion: String,
2507    },
2508    #[help(parse_format_of_unicode)]
2509    Help,
2510}
2511
2512#[derive(Subdiagnostic)]
2513#[multipart_suggestion(parse_sugg_wrap_pattern_in_parens, applicability = "machine-applicable")]
2514pub(crate) struct WrapInParens {
2515    #[suggestion_part(code = "(")]
2516    pub(crate) lo: Span,
2517    #[suggestion_part(code = ")")]
2518    pub(crate) hi: Span,
2519}
2520
2521#[derive(Subdiagnostic)]
2522pub(crate) enum TopLevelOrPatternNotAllowedSugg {
2523    #[suggestion(
2524        parse_sugg_remove_leading_vert_in_pattern,
2525        code = "",
2526        applicability = "machine-applicable",
2527        style = "verbose"
2528    )]
2529    RemoveLeadingVert {
2530        #[primary_span]
2531        span: Span,
2532    },
2533    WrapInParens {
2534        #[primary_span]
2535        span: Span,
2536        #[subdiagnostic]
2537        suggestion: WrapInParens,
2538    },
2539}
2540
2541#[derive(Diagnostic)]
2542#[diag(parse_unexpected_vert_vert_before_function_parameter)]
2543#[note(parse_note_pattern_alternatives_use_single_vert)]
2544pub(crate) struct UnexpectedVertVertBeforeFunctionParam {
2545    #[primary_span]
2546    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2547    pub span: Span,
2548}
2549
2550#[derive(Diagnostic)]
2551#[diag(parse_unexpected_vert_vert_in_pattern)]
2552pub(crate) struct UnexpectedVertVertInPattern {
2553    #[primary_span]
2554    #[suggestion(code = "|", applicability = "machine-applicable", style = "verbose")]
2555    pub span: Span,
2556    #[label(parse_label_while_parsing_or_pattern_here)]
2557    pub start: Option<Span>,
2558}
2559
2560#[derive(Diagnostic)]
2561#[diag(parse_trailing_vert_not_allowed)]
2562pub(crate) struct TrailingVertNotAllowed {
2563    #[primary_span]
2564    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2565    pub span: Span,
2566    #[label(parse_label_while_parsing_or_pattern_here)]
2567    pub start: Option<Span>,
2568    pub token: Token,
2569    #[note(parse_note_pattern_alternatives_use_single_vert)]
2570    pub note_double_vert: bool,
2571}
2572
2573#[derive(Diagnostic)]
2574#[diag(parse_dotdotdot_rest_pattern)]
2575pub(crate) struct DotDotDotRestPattern {
2576    #[primary_span]
2577    #[label]
2578    pub span: Span,
2579    #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
2580    pub suggestion: Span,
2581}
2582
2583#[derive(Diagnostic)]
2584#[diag(parse_pattern_on_wrong_side_of_at)]
2585pub(crate) struct PatternOnWrongSideOfAt {
2586    #[primary_span]
2587    #[suggestion(code = "{whole_pat}", applicability = "machine-applicable", style = "verbose")]
2588    pub whole_span: Span,
2589    pub whole_pat: String,
2590    #[label(parse_label_pattern)]
2591    pub pattern: Span,
2592    #[label(parse_label_binding)]
2593    pub binding: Span,
2594}
2595
2596#[derive(Diagnostic)]
2597#[diag(parse_expected_binding_left_of_at)]
2598#[note]
2599pub(crate) struct ExpectedBindingLeftOfAt {
2600    #[primary_span]
2601    pub whole_span: Span,
2602    #[label(parse_label_lhs)]
2603    pub lhs: Span,
2604    #[label(parse_label_rhs)]
2605    pub rhs: Span,
2606}
2607
2608#[derive(Subdiagnostic)]
2609#[multipart_suggestion(
2610    parse_ambiguous_range_pattern_suggestion,
2611    applicability = "machine-applicable"
2612)]
2613pub(crate) struct ParenRangeSuggestion {
2614    #[suggestion_part(code = "(")]
2615    pub lo: Span,
2616    #[suggestion_part(code = ")")]
2617    pub hi: Span,
2618}
2619
2620#[derive(Diagnostic)]
2621#[diag(parse_ambiguous_range_pattern)]
2622pub(crate) struct AmbiguousRangePattern {
2623    #[primary_span]
2624    pub span: Span,
2625    #[subdiagnostic]
2626    pub suggestion: ParenRangeSuggestion,
2627}
2628
2629#[derive(Diagnostic)]
2630#[diag(parse_unexpected_lifetime_in_pattern)]
2631pub(crate) struct UnexpectedLifetimeInPattern {
2632    #[primary_span]
2633    pub span: Span,
2634    pub symbol: Symbol,
2635    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2636    pub suggestion: Span,
2637}
2638
2639#[derive(Diagnostic)]
2640pub(crate) enum InvalidMutInPattern {
2641    #[diag(parse_mut_on_nested_ident_pattern)]
2642    #[note(parse_note_mut_pattern_usage)]
2643    NestedIdent {
2644        #[primary_span]
2645        #[suggestion(code = "{pat}", applicability = "machine-applicable", style = "verbose")]
2646        span: Span,
2647        pat: String,
2648    },
2649    #[diag(parse_mut_on_non_ident_pattern)]
2650    #[note(parse_note_mut_pattern_usage)]
2651    NonIdent {
2652        #[primary_span]
2653        #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2654        span: Span,
2655    },
2656}
2657
2658#[derive(Diagnostic)]
2659#[diag(parse_repeated_mut_in_pattern)]
2660pub(crate) struct RepeatedMutInPattern {
2661    #[primary_span]
2662    pub span: Span,
2663    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2664    pub suggestion: Span,
2665}
2666
2667#[derive(Diagnostic)]
2668#[diag(parse_dot_dot_dot_range_to_pattern_not_allowed)]
2669pub(crate) struct DotDotDotRangeToPatternNotAllowed {
2670    #[primary_span]
2671    #[suggestion(style = "verbose", code = "..=", applicability = "machine-applicable")]
2672    pub span: Span,
2673}
2674
2675#[derive(Diagnostic)]
2676#[diag(parse_enum_pattern_instead_of_identifier)]
2677pub(crate) struct EnumPatternInsteadOfIdentifier {
2678    #[primary_span]
2679    pub span: Span,
2680}
2681
2682#[derive(Diagnostic)]
2683#[diag(parse_at_dot_dot_in_struct_pattern)]
2684pub(crate) struct AtDotDotInStructPattern {
2685    #[primary_span]
2686    pub span: Span,
2687    #[suggestion(code = "", style = "verbose", applicability = "machine-applicable")]
2688    pub remove: Span,
2689    pub ident: Ident,
2690}
2691
2692#[derive(Diagnostic)]
2693#[diag(parse_at_in_struct_pattern)]
2694#[note]
2695#[help]
2696pub(crate) struct AtInStructPattern {
2697    #[primary_span]
2698    pub span: Span,
2699}
2700
2701#[derive(Diagnostic)]
2702#[diag(parse_dot_dot_dot_for_remaining_fields)]
2703pub(crate) struct DotDotDotForRemainingFields {
2704    #[primary_span]
2705    #[suggestion(code = "..", style = "verbose", applicability = "machine-applicable")]
2706    pub span: Span,
2707    pub token_str: Cow<'static, str>,
2708}
2709
2710#[derive(Diagnostic)]
2711#[diag(parse_expected_comma_after_pattern_field)]
2712pub(crate) struct ExpectedCommaAfterPatternField {
2713    #[primary_span]
2714    pub span: Span,
2715}
2716
2717#[derive(Diagnostic)]
2718#[diag(parse_unexpected_expr_in_pat)]
2719#[note]
2720pub(crate) struct UnexpectedExpressionInPattern {
2721    /// The unexpected expr's span.
2722    #[primary_span]
2723    #[label]
2724    pub span: Span,
2725    /// Was a `RangePatternBound` expected?
2726    pub is_bound: bool,
2727    /// The unexpected expr's precedence (used in match arm guard suggestions).
2728    pub expr_precedence: ExprPrecedence,
2729}
2730
2731#[derive(Subdiagnostic)]
2732pub(crate) enum UnexpectedExpressionInPatternSugg {
2733    #[multipart_suggestion(
2734        parse_unexpected_expr_in_pat_create_guard_sugg,
2735        applicability = "maybe-incorrect"
2736    )]
2737    CreateGuard {
2738        /// Where to put the suggested identifier.
2739        #[suggestion_part(code = "{ident}")]
2740        ident_span: Span,
2741        /// Where to put the match arm.
2742        #[suggestion_part(code = " if {ident} == {expr}")]
2743        pat_hi: Span,
2744        /// The suggested identifier.
2745        ident: String,
2746        /// The unexpected expression.
2747        expr: String,
2748    },
2749
2750    #[multipart_suggestion(
2751        parse_unexpected_expr_in_pat_update_guard_sugg,
2752        applicability = "maybe-incorrect"
2753    )]
2754    UpdateGuard {
2755        /// Where to put the suggested identifier.
2756        #[suggestion_part(code = "{ident}")]
2757        ident_span: Span,
2758        /// The beginning of the match arm guard's expression (insert a `(` if `Some`).
2759        #[suggestion_part(code = "(")]
2760        guard_lo: Option<Span>,
2761        /// The end of the match arm guard's expression.
2762        #[suggestion_part(code = "{guard_hi_paren} && {ident} == {expr}")]
2763        guard_hi: Span,
2764        /// Either `")"` or `""`.
2765        guard_hi_paren: &'static str,
2766        /// The suggested identifier.
2767        ident: String,
2768        /// The unexpected expression.
2769        expr: String,
2770    },
2771
2772    #[multipart_suggestion(
2773        parse_unexpected_expr_in_pat_const_sugg,
2774        applicability = "has-placeholders"
2775    )]
2776    Const {
2777        /// Where to put the extracted constant declaration.
2778        #[suggestion_part(code = "{indentation}const {ident}: /* Type */ = {expr};\n")]
2779        stmt_lo: Span,
2780        /// Where to put the suggested identifier.
2781        #[suggestion_part(code = "{ident}")]
2782        ident_span: Span,
2783        /// The suggested identifier.
2784        ident: String,
2785        /// The unexpected expression.
2786        expr: String,
2787        /// The statement's block's indentation.
2788        indentation: String,
2789    },
2790
2791    #[multipart_suggestion(
2792        parse_unexpected_expr_in_pat_inline_const_sugg,
2793        applicability = "maybe-incorrect"
2794    )]
2795    InlineConst {
2796        #[suggestion_part(code = "const {{ ")]
2797        start_span: Span,
2798        #[suggestion_part(code = " }}")]
2799        end_span: Span,
2800    },
2801}
2802
2803#[derive(Diagnostic)]
2804#[diag(parse_unexpected_paren_in_range_pat)]
2805pub(crate) struct UnexpectedParenInRangePat {
2806    #[primary_span]
2807    pub span: Vec<Span>,
2808    #[subdiagnostic]
2809    pub sugg: UnexpectedParenInRangePatSugg,
2810}
2811
2812#[derive(Subdiagnostic)]
2813#[multipart_suggestion(
2814    parse_unexpected_paren_in_range_pat_sugg,
2815    applicability = "machine-applicable"
2816)]
2817pub(crate) struct UnexpectedParenInRangePatSugg {
2818    #[suggestion_part(code = "")]
2819    pub start_span: Span,
2820    #[suggestion_part(code = "")]
2821    pub end_span: Span,
2822}
2823
2824#[derive(Diagnostic)]
2825#[diag(parse_return_types_use_thin_arrow)]
2826pub(crate) struct ReturnTypesUseThinArrow {
2827    #[primary_span]
2828    pub span: Span,
2829    #[suggestion(style = "verbose", code = " -> ", applicability = "machine-applicable")]
2830    pub suggestion: Span,
2831}
2832
2833#[derive(Diagnostic)]
2834#[diag(parse_need_plus_after_trait_object_lifetime)]
2835pub(crate) struct NeedPlusAfterTraitObjectLifetime {
2836    #[primary_span]
2837    pub span: Span,
2838}
2839
2840#[derive(Diagnostic)]
2841#[diag(parse_expected_mut_or_const_in_raw_pointer_type)]
2842pub(crate) struct ExpectedMutOrConstInRawPointerType {
2843    #[primary_span]
2844    pub span: Span,
2845    #[suggestion(code("mut ", "const "), applicability = "has-placeholders", style = "verbose")]
2846    pub after_asterisk: Span,
2847}
2848
2849#[derive(Diagnostic)]
2850#[diag(parse_lifetime_after_mut)]
2851pub(crate) struct LifetimeAfterMut {
2852    #[primary_span]
2853    pub span: Span,
2854    #[suggestion(code = "&{snippet} mut", applicability = "maybe-incorrect", style = "verbose")]
2855    pub suggest_lifetime: Option<Span>,
2856    pub snippet: String,
2857}
2858
2859#[derive(Diagnostic)]
2860#[diag(parse_dyn_after_mut)]
2861pub(crate) struct DynAfterMut {
2862    #[primary_span]
2863    #[suggestion(code = "&mut dyn", applicability = "machine-applicable", style = "verbose")]
2864    pub span: Span,
2865}
2866
2867#[derive(Diagnostic)]
2868#[diag(parse_fn_pointer_cannot_be_const)]
2869pub(crate) struct FnPointerCannotBeConst {
2870    #[primary_span]
2871    pub span: Span,
2872    #[label]
2873    pub qualifier: Span,
2874    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2875    pub suggestion: Span,
2876}
2877
2878#[derive(Diagnostic)]
2879#[diag(parse_fn_pointer_cannot_be_async)]
2880pub(crate) struct FnPointerCannotBeAsync {
2881    #[primary_span]
2882    pub span: Span,
2883    #[label]
2884    pub qualifier: Span,
2885    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2886    pub suggestion: Span,
2887}
2888
2889#[derive(Diagnostic)]
2890#[diag(parse_nested_c_variadic_type, code = E0743)]
2891pub(crate) struct NestedCVariadicType {
2892    #[primary_span]
2893    pub span: Span,
2894}
2895
2896#[derive(Diagnostic)]
2897#[diag(parse_invalid_dyn_keyword)]
2898#[help]
2899pub(crate) struct InvalidDynKeyword {
2900    #[primary_span]
2901    pub span: Span,
2902    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2903    pub suggestion: Span,
2904}
2905
2906#[derive(Subdiagnostic)]
2907pub(crate) enum HelpUseLatestEdition {
2908    #[help(parse_help_set_edition_cargo)]
2909    #[note(parse_note_edition_guide)]
2910    Cargo { edition: Edition },
2911    #[help(parse_help_set_edition_standalone)]
2912    #[note(parse_note_edition_guide)]
2913    Standalone { edition: Edition },
2914}
2915
2916impl HelpUseLatestEdition {
2917    pub(crate) fn new() -> Self {
2918        let edition = LATEST_STABLE_EDITION;
2919        if rustc_session::utils::was_invoked_from_cargo() {
2920            Self::Cargo { edition }
2921        } else {
2922            Self::Standalone { edition }
2923        }
2924    }
2925}
2926
2927#[derive(Diagnostic)]
2928#[diag(parse_box_syntax_removed)]
2929pub(crate) struct BoxSyntaxRemoved {
2930    #[primary_span]
2931    pub span: Span,
2932    #[subdiagnostic]
2933    pub sugg: AddBoxNew,
2934}
2935
2936#[derive(Subdiagnostic)]
2937#[multipart_suggestion(
2938    parse_box_syntax_removed_suggestion,
2939    applicability = "machine-applicable",
2940    style = "verbose"
2941)]
2942pub(crate) struct AddBoxNew {
2943    #[suggestion_part(code = "Box::new(")]
2944    pub box_kw_and_lo: Span,
2945    #[suggestion_part(code = ")")]
2946    pub hi: Span,
2947}
2948
2949#[derive(Diagnostic)]
2950#[diag(parse_bad_return_type_notation_output)]
2951pub(crate) struct BadReturnTypeNotationOutput {
2952    #[primary_span]
2953    pub span: Span,
2954    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2955    pub suggestion: Span,
2956}
2957
2958#[derive(Diagnostic)]
2959#[diag(parse_bad_assoc_type_bounds)]
2960pub(crate) struct BadAssocTypeBounds {
2961    #[primary_span]
2962    #[label]
2963    pub span: Span,
2964}
2965
2966#[derive(Diagnostic)]
2967#[diag(parse_attr_after_generic)]
2968pub(crate) struct AttrAfterGeneric {
2969    #[primary_span]
2970    #[label]
2971    pub span: Span,
2972}
2973
2974#[derive(Diagnostic)]
2975#[diag(parse_attr_without_generics)]
2976pub(crate) struct AttrWithoutGenerics {
2977    #[primary_span]
2978    #[label]
2979    pub span: Span,
2980}
2981
2982#[derive(Diagnostic)]
2983#[diag(parse_where_generics)]
2984pub(crate) struct WhereOnGenerics {
2985    #[primary_span]
2986    #[label]
2987    pub span: Span,
2988}
2989
2990#[derive(Diagnostic)]
2991#[diag(parse_generics_in_path)]
2992pub(crate) struct GenericsInPath {
2993    #[primary_span]
2994    pub span: Vec<Span>,
2995}
2996
2997#[derive(Diagnostic)]
2998#[diag(parse_lifetime_in_eq_constraint)]
2999#[help]
3000pub(crate) struct LifetimeInEqConstraint {
3001    #[primary_span]
3002    #[label]
3003    pub span: Span,
3004    pub lifetime: Ident,
3005    #[label(parse_context_label)]
3006    pub binding_label: Span,
3007    #[suggestion(
3008        parse_colon_sugg,
3009        style = "verbose",
3010        applicability = "maybe-incorrect",
3011        code = ": "
3012    )]
3013    pub colon_sugg: Span,
3014}
3015
3016#[derive(Diagnostic)]
3017#[diag(parse_modifier_lifetime)]
3018pub(crate) struct ModifierLifetime {
3019    #[primary_span]
3020    #[suggestion(style = "tool-only", applicability = "maybe-incorrect", code = "")]
3021    pub span: Span,
3022    pub modifier: &'static str,
3023}
3024
3025#[derive(Subdiagnostic)]
3026#[multipart_suggestion(
3027    parse_parenthesized_lifetime_suggestion,
3028    applicability = "machine-applicable"
3029)]
3030pub(crate) struct RemoveParens {
3031    #[suggestion_part(code = "")]
3032    pub lo: Span,
3033    #[suggestion_part(code = "")]
3034    pub hi: Span,
3035}
3036
3037#[derive(Diagnostic)]
3038#[diag(parse_parenthesized_lifetime)]
3039pub(crate) struct ParenthesizedLifetime {
3040    #[primary_span]
3041    pub span: Span,
3042    #[subdiagnostic]
3043    pub sugg: RemoveParens,
3044}
3045
3046#[derive(Diagnostic)]
3047#[diag(parse_underscore_literal_suffix)]
3048pub(crate) struct UnderscoreLiteralSuffix {
3049    #[primary_span]
3050    pub span: Span,
3051}
3052
3053#[derive(Diagnostic)]
3054#[diag(parse_expect_label_found_ident)]
3055pub(crate) struct ExpectedLabelFoundIdent {
3056    #[primary_span]
3057    pub span: Span,
3058    #[suggestion(code = "'", applicability = "machine-applicable", style = "verbose")]
3059    pub start: Span,
3060}
3061
3062#[derive(Diagnostic)]
3063#[diag(parse_inappropriate_default)]
3064#[note]
3065pub(crate) struct InappropriateDefault {
3066    #[primary_span]
3067    #[label]
3068    pub span: Span,
3069    pub article: &'static str,
3070    pub descr: &'static str,
3071}
3072
3073#[derive(Diagnostic)]
3074#[diag(parse_recover_import_as_use)]
3075pub(crate) struct RecoverImportAsUse {
3076    #[primary_span]
3077    #[suggestion(code = "use", applicability = "machine-applicable", style = "verbose")]
3078    pub span: Span,
3079    pub token_name: String,
3080}
3081
3082#[derive(Diagnostic)]
3083#[diag(parse_single_colon_import_path)]
3084#[note]
3085pub(crate) struct SingleColonImportPath {
3086    #[primary_span]
3087    #[suggestion(code = "::", applicability = "machine-applicable", style = "verbose")]
3088    pub span: Span,
3089}
3090
3091#[derive(Diagnostic)]
3092#[diag(parse_bad_item_kind)]
3093pub(crate) struct BadItemKind {
3094    #[primary_span]
3095    pub span: Span,
3096    pub descr: &'static str,
3097    pub ctx: &'static str,
3098    #[help]
3099    pub help: bool,
3100}
3101
3102#[derive(Diagnostic)]
3103#[diag(parse_macro_rules_missing_bang)]
3104pub(crate) struct MacroRulesMissingBang {
3105    #[primary_span]
3106    pub span: Span,
3107    #[suggestion(code = "!", applicability = "machine-applicable", style = "verbose")]
3108    pub hi: Span,
3109}
3110
3111#[derive(Diagnostic)]
3112#[diag(parse_macro_name_remove_bang)]
3113pub(crate) struct MacroNameRemoveBang {
3114    #[primary_span]
3115    #[suggestion(code = "", applicability = "machine-applicable", style = "short")]
3116    pub span: Span,
3117}
3118
3119#[derive(Diagnostic)]
3120#[diag(parse_macro_rules_visibility)]
3121pub(crate) struct MacroRulesVisibility<'a> {
3122    #[primary_span]
3123    #[suggestion(code = "#[macro_export]", applicability = "maybe-incorrect", style = "verbose")]
3124    pub span: Span,
3125    pub vis: &'a str,
3126}
3127
3128#[derive(Diagnostic)]
3129#[diag(parse_macro_invocation_visibility)]
3130#[help]
3131pub(crate) struct MacroInvocationVisibility<'a> {
3132    #[primary_span]
3133    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
3134    pub span: Span,
3135    pub vis: &'a str,
3136}
3137
3138#[derive(Diagnostic)]
3139#[diag(parse_nested_adt)]
3140pub(crate) struct NestedAdt<'a> {
3141    #[primary_span]
3142    pub span: Span,
3143    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
3144    pub item: Span,
3145    pub keyword: &'a str,
3146    pub kw_str: Cow<'a, str>,
3147}
3148
3149#[derive(Diagnostic)]
3150#[diag(parse_function_body_equals_expr)]
3151pub(crate) struct FunctionBodyEqualsExpr {
3152    #[primary_span]
3153    pub span: Span,
3154    #[subdiagnostic]
3155    pub sugg: FunctionBodyEqualsExprSugg,
3156}
3157
3158#[derive(Subdiagnostic)]
3159#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3160pub(crate) struct FunctionBodyEqualsExprSugg {
3161    #[suggestion_part(code = "{{")]
3162    pub eq: Span,
3163    #[suggestion_part(code = " }}")]
3164    pub semi: Span,
3165}
3166
3167#[derive(Diagnostic)]
3168#[diag(parse_box_not_pat)]
3169pub(crate) struct BoxNotPat {
3170    #[primary_span]
3171    pub span: Span,
3172    #[note]
3173    pub kw: Span,
3174    #[suggestion(code = "r#", applicability = "maybe-incorrect", style = "verbose")]
3175    pub lo: Span,
3176    pub descr: String,
3177}
3178
3179#[derive(Diagnostic)]
3180#[diag(parse_unmatched_angle)]
3181pub(crate) struct UnmatchedAngle {
3182    #[primary_span]
3183    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
3184    pub span: Span,
3185    pub plural: bool,
3186}
3187
3188#[derive(Diagnostic)]
3189#[diag(parse_missing_plus_in_bounds)]
3190pub(crate) struct MissingPlusBounds {
3191    #[primary_span]
3192    pub span: Span,
3193    #[suggestion(code = " +", applicability = "maybe-incorrect", style = "verbose")]
3194    pub hi: Span,
3195    pub sym: Symbol,
3196}
3197
3198#[derive(Diagnostic)]
3199#[diag(parse_incorrect_parens_trait_bounds)]
3200pub(crate) struct IncorrectParensTraitBounds {
3201    #[primary_span]
3202    pub span: Vec<Span>,
3203    #[subdiagnostic]
3204    pub sugg: IncorrectParensTraitBoundsSugg,
3205}
3206
3207#[derive(Subdiagnostic)]
3208#[multipart_suggestion(
3209    parse_incorrect_parens_trait_bounds_sugg,
3210    applicability = "machine-applicable"
3211)]
3212pub(crate) struct IncorrectParensTraitBoundsSugg {
3213    #[suggestion_part(code = " ")]
3214    pub wrong_span: Span,
3215    #[suggestion_part(code = "(")]
3216    pub new_span: Span,
3217}
3218
3219#[derive(Diagnostic)]
3220#[diag(parse_kw_bad_case)]
3221pub(crate) struct KwBadCase<'a> {
3222    #[primary_span]
3223    #[suggestion(code = "{kw}", style = "verbose", applicability = "machine-applicable")]
3224    pub span: Span,
3225    pub kw: &'a str,
3226}
3227
3228#[derive(Diagnostic)]
3229#[diag(parse_meta_bad_delim)]
3230pub(crate) struct MetaBadDelim {
3231    #[primary_span]
3232    pub span: Span,
3233    #[subdiagnostic]
3234    pub sugg: MetaBadDelimSugg,
3235}
3236
3237#[derive(Diagnostic)]
3238#[diag(parse_cfg_attr_bad_delim)]
3239pub(crate) struct CfgAttrBadDelim {
3240    #[primary_span]
3241    pub span: Span,
3242    #[subdiagnostic]
3243    pub sugg: MetaBadDelimSugg,
3244}
3245
3246#[derive(Subdiagnostic)]
3247#[multipart_suggestion(parse_meta_bad_delim_suggestion, applicability = "machine-applicable")]
3248pub(crate) struct MetaBadDelimSugg {
3249    #[suggestion_part(code = "(")]
3250    pub open: Span,
3251    #[suggestion_part(code = ")")]
3252    pub close: Span,
3253}
3254
3255#[derive(Diagnostic)]
3256#[diag(parse_malformed_cfg_attr)]
3257#[note]
3258pub(crate) struct MalformedCfgAttr {
3259    #[primary_span]
3260    #[suggestion(style = "verbose", code = "{sugg}")]
3261    pub span: Span,
3262    pub sugg: &'static str,
3263}
3264
3265#[derive(Diagnostic)]
3266#[diag(parse_unknown_builtin_construct)]
3267pub(crate) struct UnknownBuiltinConstruct {
3268    #[primary_span]
3269    pub span: Span,
3270    pub name: Ident,
3271}
3272
3273#[derive(Diagnostic)]
3274#[diag(parse_expected_builtin_ident)]
3275pub(crate) struct ExpectedBuiltinIdent {
3276    #[primary_span]
3277    pub span: Span,
3278}
3279
3280#[derive(Diagnostic)]
3281#[diag(parse_static_with_generics)]
3282pub(crate) struct StaticWithGenerics {
3283    #[primary_span]
3284    pub span: Span,
3285}
3286
3287#[derive(Diagnostic)]
3288#[diag(parse_where_clause_before_const_body)]
3289pub(crate) struct WhereClauseBeforeConstBody {
3290    #[primary_span]
3291    #[label]
3292    pub span: Span,
3293    #[label(parse_name_label)]
3294    pub name: Span,
3295    #[label(parse_body_label)]
3296    pub body: Span,
3297    #[subdiagnostic]
3298    pub sugg: Option<WhereClauseBeforeConstBodySugg>,
3299}
3300
3301#[derive(Subdiagnostic)]
3302#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3303pub(crate) struct WhereClauseBeforeConstBodySugg {
3304    #[suggestion_part(code = "= {snippet} ")]
3305    pub left: Span,
3306    pub snippet: String,
3307    #[suggestion_part(code = "")]
3308    pub right: Span,
3309}
3310
3311#[derive(Diagnostic)]
3312#[diag(parse_generic_args_in_pat_require_turbofish_syntax)]
3313pub(crate) struct GenericArgsInPatRequireTurbofishSyntax {
3314    #[primary_span]
3315    pub span: Span,
3316    #[suggestion(
3317        parse_sugg_turbofish_syntax,
3318        style = "verbose",
3319        code = "::",
3320        applicability = "maybe-incorrect"
3321    )]
3322    pub suggest_turbofish: Span,
3323}
3324
3325#[derive(Diagnostic)]
3326#[diag(parse_transpose_dyn_or_impl)]
3327pub(crate) struct TransposeDynOrImpl<'a> {
3328    #[primary_span]
3329    pub span: Span,
3330    pub kw: &'a str,
3331    #[subdiagnostic]
3332    pub sugg: TransposeDynOrImplSugg<'a>,
3333}
3334
3335#[derive(Subdiagnostic)]
3336#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3337pub(crate) struct TransposeDynOrImplSugg<'a> {
3338    #[suggestion_part(code = "")]
3339    pub removal_span: Span,
3340    #[suggestion_part(code = "{kw} ")]
3341    pub insertion_span: Span,
3342    pub kw: &'a str,
3343}
3344
3345#[derive(Diagnostic)]
3346#[diag(parse_array_index_offset_of)]
3347pub(crate) struct ArrayIndexInOffsetOf(#[primary_span] pub Span);
3348
3349#[derive(Diagnostic)]
3350#[diag(parse_invalid_offset_of)]
3351pub(crate) struct InvalidOffsetOf(#[primary_span] pub Span);
3352
3353#[derive(Diagnostic)]
3354#[diag(parse_async_impl)]
3355pub(crate) struct AsyncImpl {
3356    #[primary_span]
3357    pub span: Span,
3358}
3359
3360#[derive(Diagnostic)]
3361#[diag(parse_expr_rarrow_call)]
3362#[help]
3363pub(crate) struct ExprRArrowCall {
3364    #[primary_span]
3365    #[suggestion(style = "verbose", applicability = "machine-applicable", code = ".")]
3366    pub span: Span,
3367}
3368
3369#[derive(Diagnostic)]
3370#[diag(parse_dot_dot_range_attribute)]
3371pub(crate) struct DotDotRangeAttribute {
3372    #[primary_span]
3373    pub span: Span,
3374}
3375
3376#[derive(Diagnostic)]
3377#[diag(parse_invalid_attr_unsafe)]
3378#[note]
3379pub(crate) struct InvalidAttrUnsafe {
3380    #[primary_span]
3381    #[label]
3382    pub span: Span,
3383    pub name: Path,
3384}
3385
3386#[derive(Diagnostic)]
3387#[diag(parse_unsafe_attr_outside_unsafe)]
3388pub(crate) struct UnsafeAttrOutsideUnsafe {
3389    #[primary_span]
3390    #[label]
3391    pub span: Span,
3392    #[subdiagnostic]
3393    pub suggestion: UnsafeAttrOutsideUnsafeSuggestion,
3394}
3395
3396#[derive(Subdiagnostic)]
3397#[multipart_suggestion(
3398    parse_unsafe_attr_outside_unsafe_suggestion,
3399    applicability = "machine-applicable"
3400)]
3401pub(crate) struct UnsafeAttrOutsideUnsafeSuggestion {
3402    #[suggestion_part(code = "unsafe(")]
3403    pub left: Span,
3404    #[suggestion_part(code = ")")]
3405    pub right: Span,
3406}
3407
3408#[derive(Diagnostic)]
3409#[diag(parse_binder_before_modifiers)]
3410pub(crate) struct BinderBeforeModifiers {
3411    #[primary_span]
3412    pub binder_span: Span,
3413    #[label]
3414    pub modifiers_span: Span,
3415}
3416
3417#[derive(Diagnostic)]
3418#[diag(parse_binder_and_polarity)]
3419pub(crate) struct BinderAndPolarity {
3420    #[primary_span]
3421    pub polarity_span: Span,
3422    #[label]
3423    pub binder_span: Span,
3424    pub polarity: &'static str,
3425}
3426
3427#[derive(Diagnostic)]
3428#[diag(parse_modifiers_and_polarity)]
3429pub(crate) struct PolarityAndModifiers {
3430    #[primary_span]
3431    pub polarity_span: Span,
3432    #[label]
3433    pub modifiers_span: Span,
3434    pub polarity: &'static str,
3435    pub modifiers_concatenated: String,
3436}
3437
3438#[derive(Diagnostic)]
3439#[diag(parse_incorrect_type_on_self)]
3440pub(crate) struct IncorrectTypeOnSelf {
3441    #[primary_span]
3442    pub span: Span,
3443    #[subdiagnostic]
3444    pub move_self_modifier: MoveSelfModifier,
3445}
3446
3447#[derive(Subdiagnostic)]
3448#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3449pub(crate) struct MoveSelfModifier {
3450    #[suggestion_part(code = "")]
3451    pub removal_span: Span,
3452    #[suggestion_part(code = "{modifier}")]
3453    pub insertion_span: Span,
3454    pub modifier: String,
3455}