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_unmatched_angle_brackets)]
1277pub(crate) struct UnmatchedAngleBrackets {
1278    #[primary_span]
1279    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1280    pub span: Span,
1281    pub num_extra_brackets: usize,
1282}
1283
1284#[derive(Diagnostic)]
1285#[diag(parse_generic_parameters_without_angle_brackets)]
1286pub(crate) struct GenericParamsWithoutAngleBrackets {
1287    #[primary_span]
1288    pub span: Span,
1289    #[subdiagnostic]
1290    pub sugg: GenericParamsWithoutAngleBracketsSugg,
1291}
1292
1293#[derive(Subdiagnostic)]
1294#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1295pub(crate) struct GenericParamsWithoutAngleBracketsSugg {
1296    #[suggestion_part(code = "<")]
1297    pub left: Span,
1298    #[suggestion_part(code = ">")]
1299    pub right: Span,
1300}
1301
1302#[derive(Diagnostic)]
1303#[diag(parse_comparison_operators_cannot_be_chained)]
1304pub(crate) struct ComparisonOperatorsCannotBeChained {
1305    #[primary_span]
1306    pub span: Vec<Span>,
1307    #[suggestion(
1308        parse_sugg_turbofish_syntax,
1309        style = "verbose",
1310        code = "::",
1311        applicability = "maybe-incorrect"
1312    )]
1313    pub suggest_turbofish: Option<Span>,
1314    #[help(parse_sugg_turbofish_syntax)]
1315    #[help(parse_sugg_parentheses_for_function_args)]
1316    pub help_turbofish: bool,
1317    #[subdiagnostic]
1318    pub chaining_sugg: Option<ComparisonOperatorsCannotBeChainedSugg>,
1319}
1320
1321#[derive(Subdiagnostic)]
1322pub(crate) enum ComparisonOperatorsCannotBeChainedSugg {
1323    #[suggestion(
1324        parse_sugg_split_comparison,
1325        style = "verbose",
1326        code = " && {middle_term}",
1327        applicability = "maybe-incorrect"
1328    )]
1329    SplitComparison {
1330        #[primary_span]
1331        span: Span,
1332        middle_term: String,
1333    },
1334    #[multipart_suggestion(parse_sugg_parenthesize, applicability = "maybe-incorrect")]
1335    Parenthesize {
1336        #[suggestion_part(code = "(")]
1337        left: Span,
1338        #[suggestion_part(code = ")")]
1339        right: Span,
1340    },
1341}
1342
1343#[derive(Diagnostic)]
1344#[diag(parse_question_mark_in_type)]
1345pub(crate) struct QuestionMarkInType {
1346    #[primary_span]
1347    #[label]
1348    pub span: Span,
1349    #[subdiagnostic]
1350    pub sugg: QuestionMarkInTypeSugg,
1351}
1352
1353#[derive(Subdiagnostic)]
1354#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1355pub(crate) struct QuestionMarkInTypeSugg {
1356    #[suggestion_part(code = "Option<")]
1357    pub left: Span,
1358    #[suggestion_part(code = ">")]
1359    pub right: Span,
1360}
1361
1362#[derive(Diagnostic)]
1363#[diag(parse_unexpected_parentheses_in_for_head)]
1364pub(crate) struct ParenthesesInForHead {
1365    #[primary_span]
1366    pub span: Vec<Span>,
1367    #[subdiagnostic]
1368    pub sugg: ParenthesesInForHeadSugg,
1369}
1370
1371#[derive(Subdiagnostic)]
1372#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1373pub(crate) struct ParenthesesInForHeadSugg {
1374    #[suggestion_part(code = " ")]
1375    pub left: Span,
1376    #[suggestion_part(code = " ")]
1377    pub right: Span,
1378}
1379
1380#[derive(Diagnostic)]
1381#[diag(parse_unexpected_parentheses_in_match_arm_pattern)]
1382pub(crate) struct ParenthesesInMatchPat {
1383    #[primary_span]
1384    pub span: Vec<Span>,
1385    #[subdiagnostic]
1386    pub sugg: ParenthesesInMatchPatSugg,
1387}
1388
1389#[derive(Subdiagnostic)]
1390#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1391pub(crate) struct ParenthesesInMatchPatSugg {
1392    #[suggestion_part(code = "")]
1393    pub left: Span,
1394    #[suggestion_part(code = "")]
1395    pub right: Span,
1396}
1397
1398#[derive(Diagnostic)]
1399#[diag(parse_doc_comment_on_param_type)]
1400pub(crate) struct DocCommentOnParamType {
1401    #[primary_span]
1402    #[label]
1403    pub span: Span,
1404}
1405
1406#[derive(Diagnostic)]
1407#[diag(parse_attribute_on_param_type)]
1408pub(crate) struct AttributeOnParamType {
1409    #[primary_span]
1410    #[label]
1411    pub span: Span,
1412}
1413
1414#[derive(Diagnostic)]
1415#[diag(parse_pattern_method_param_without_body, code = E0642)]
1416pub(crate) struct PatternMethodParamWithoutBody {
1417    #[primary_span]
1418    #[suggestion(code = "_", applicability = "machine-applicable", style = "verbose")]
1419    pub span: Span,
1420}
1421
1422#[derive(Diagnostic)]
1423#[diag(parse_self_param_not_first)]
1424pub(crate) struct SelfParamNotFirst {
1425    #[primary_span]
1426    #[label]
1427    pub span: Span,
1428}
1429
1430#[derive(Diagnostic)]
1431#[diag(parse_const_generic_without_braces)]
1432pub(crate) struct ConstGenericWithoutBraces {
1433    #[primary_span]
1434    pub span: Span,
1435    #[subdiagnostic]
1436    pub sugg: ConstGenericWithoutBracesSugg,
1437}
1438
1439#[derive(Subdiagnostic)]
1440#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1441pub(crate) struct ConstGenericWithoutBracesSugg {
1442    #[suggestion_part(code = "{{ ")]
1443    pub left: Span,
1444    #[suggestion_part(code = " }}")]
1445    pub right: Span,
1446}
1447
1448#[derive(Diagnostic)]
1449#[diag(parse_unexpected_const_param_declaration)]
1450pub(crate) struct UnexpectedConstParamDeclaration {
1451    #[primary_span]
1452    #[label]
1453    pub span: Span,
1454    #[subdiagnostic]
1455    pub sugg: Option<UnexpectedConstParamDeclarationSugg>,
1456}
1457
1458#[derive(Subdiagnostic)]
1459pub(crate) enum UnexpectedConstParamDeclarationSugg {
1460    #[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1461    AddParam {
1462        #[suggestion_part(code = "<{snippet}>")]
1463        impl_generics: Span,
1464        #[suggestion_part(code = "{ident}")]
1465        incorrect_decl: Span,
1466        snippet: String,
1467        ident: String,
1468    },
1469    #[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1470    AppendParam {
1471        #[suggestion_part(code = ", {snippet}")]
1472        impl_generics_end: Span,
1473        #[suggestion_part(code = "{ident}")]
1474        incorrect_decl: Span,
1475        snippet: String,
1476        ident: String,
1477    },
1478}
1479
1480#[derive(Diagnostic)]
1481#[diag(parse_unexpected_const_in_generic_param)]
1482pub(crate) struct UnexpectedConstInGenericParam {
1483    #[primary_span]
1484    pub span: Span,
1485    #[suggestion(style = "verbose", code = "", applicability = "maybe-incorrect")]
1486    pub to_remove: Option<Span>,
1487}
1488
1489#[derive(Diagnostic)]
1490#[diag(parse_async_move_order_incorrect)]
1491pub(crate) struct AsyncMoveOrderIncorrect {
1492    #[primary_span]
1493    #[suggestion(style = "verbose", code = "async move", applicability = "maybe-incorrect")]
1494    pub span: Span,
1495}
1496
1497#[derive(Diagnostic)]
1498#[diag(parse_async_use_order_incorrect)]
1499pub(crate) struct AsyncUseOrderIncorrect {
1500    #[primary_span]
1501    #[suggestion(style = "verbose", code = "async use", applicability = "maybe-incorrect")]
1502    pub span: Span,
1503}
1504
1505#[derive(Diagnostic)]
1506#[diag(parse_double_colon_in_bound)]
1507pub(crate) struct DoubleColonInBound {
1508    #[primary_span]
1509    pub span: Span,
1510    #[suggestion(code = ": ", applicability = "machine-applicable", style = "verbose")]
1511    pub between: Span,
1512}
1513
1514#[derive(Diagnostic)]
1515#[diag(parse_fn_ptr_with_generics)]
1516pub(crate) struct FnPtrWithGenerics {
1517    #[primary_span]
1518    pub span: Span,
1519    #[subdiagnostic]
1520    pub sugg: Option<FnPtrWithGenericsSugg>,
1521}
1522
1523#[derive(Subdiagnostic)]
1524#[multipart_suggestion(
1525    parse_misplaced_return_type,
1526    style = "verbose",
1527    applicability = "maybe-incorrect"
1528)]
1529pub(crate) struct MisplacedReturnType {
1530    #[suggestion_part(code = " {snippet}")]
1531    pub fn_params_end: Span,
1532    pub snippet: String,
1533    #[suggestion_part(code = "")]
1534    pub ret_ty_span: Span,
1535}
1536
1537#[derive(Subdiagnostic)]
1538#[multipart_suggestion(parse_suggestion, applicability = "maybe-incorrect")]
1539pub(crate) struct FnPtrWithGenericsSugg {
1540    #[suggestion_part(code = "{snippet}")]
1541    pub left: Span,
1542    pub snippet: String,
1543    #[suggestion_part(code = "")]
1544    pub right: Span,
1545    pub arity: usize,
1546    pub for_param_list_exists: bool,
1547}
1548
1549pub(crate) struct FnTraitMissingParen {
1550    pub span: Span,
1551}
1552
1553impl Subdiagnostic for FnTraitMissingParen {
1554    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
1555        self,
1556        diag: &mut Diag<'_, G>,
1557        _: &F,
1558    ) {
1559        diag.span_label(self.span, crate::fluent_generated::parse_fn_trait_missing_paren);
1560        diag.span_suggestion_short(
1561            self.span.shrink_to_hi(),
1562            crate::fluent_generated::parse_add_paren,
1563            "()",
1564            Applicability::MachineApplicable,
1565        );
1566    }
1567}
1568
1569#[derive(Diagnostic)]
1570#[diag(parse_unexpected_if_with_if)]
1571pub(crate) struct UnexpectedIfWithIf(
1572    #[primary_span]
1573    #[suggestion(applicability = "machine-applicable", code = " ", style = "verbose")]
1574    pub Span,
1575);
1576
1577#[derive(Diagnostic)]
1578#[diag(parse_maybe_fn_typo_with_impl)]
1579pub(crate) struct FnTypoWithImpl {
1580    #[primary_span]
1581    #[suggestion(applicability = "maybe-incorrect", code = "impl", style = "verbose")]
1582    pub fn_span: Span,
1583}
1584
1585#[derive(Diagnostic)]
1586#[diag(parse_expected_fn_path_found_fn_keyword)]
1587pub(crate) struct ExpectedFnPathFoundFnKeyword {
1588    #[primary_span]
1589    #[suggestion(applicability = "machine-applicable", code = "Fn", style = "verbose")]
1590    pub fn_token_span: Span,
1591}
1592
1593#[derive(Diagnostic)]
1594#[diag(parse_path_double_colon)]
1595pub(crate) struct PathSingleColon {
1596    #[primary_span]
1597    pub span: Span,
1598
1599    #[suggestion(applicability = "machine-applicable", code = ":", style = "verbose")]
1600    pub suggestion: Span,
1601
1602    #[note(parse_type_ascription_removed)]
1603    pub type_ascription: bool,
1604}
1605
1606#[derive(Diagnostic)]
1607#[diag(parse_path_double_colon)]
1608pub(crate) struct PathTripleColon {
1609    #[primary_span]
1610    #[suggestion(applicability = "maybe-incorrect", code = "", style = "verbose")]
1611    pub span: Span,
1612}
1613
1614#[derive(Diagnostic)]
1615#[diag(parse_colon_as_semi)]
1616pub(crate) struct ColonAsSemi {
1617    #[primary_span]
1618    #[suggestion(applicability = "machine-applicable", code = ";", style = "verbose")]
1619    pub span: Span,
1620
1621    #[note(parse_type_ascription_removed)]
1622    pub type_ascription: bool,
1623}
1624
1625#[derive(Diagnostic)]
1626#[diag(parse_where_clause_before_tuple_struct_body)]
1627pub(crate) struct WhereClauseBeforeTupleStructBody {
1628    #[primary_span]
1629    #[label]
1630    pub span: Span,
1631    #[label(parse_name_label)]
1632    pub name: Span,
1633    #[label(parse_body_label)]
1634    pub body: Span,
1635    #[subdiagnostic]
1636    pub sugg: Option<WhereClauseBeforeTupleStructBodySugg>,
1637}
1638
1639#[derive(Subdiagnostic)]
1640#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1641pub(crate) struct WhereClauseBeforeTupleStructBodySugg {
1642    #[suggestion_part(code = "{snippet}")]
1643    pub left: Span,
1644    pub snippet: String,
1645    #[suggestion_part(code = "")]
1646    pub right: Span,
1647}
1648
1649#[derive(Diagnostic)]
1650#[diag(parse_async_fn_in_2015, code = E0670)]
1651pub(crate) struct AsyncFnIn2015 {
1652    #[primary_span]
1653    #[label]
1654    pub span: Span,
1655    #[subdiagnostic]
1656    pub help: HelpUseLatestEdition,
1657}
1658
1659#[derive(Subdiagnostic)]
1660#[label(parse_async_block_in_2015)]
1661pub(crate) struct AsyncBlockIn2015 {
1662    #[primary_span]
1663    pub span: Span,
1664}
1665
1666#[derive(Diagnostic)]
1667#[diag(parse_async_move_block_in_2015)]
1668pub(crate) struct AsyncMoveBlockIn2015 {
1669    #[primary_span]
1670    pub span: Span,
1671}
1672
1673#[derive(Diagnostic)]
1674#[diag(parse_async_use_block_in_2015)]
1675pub(crate) struct AsyncUseBlockIn2015 {
1676    #[primary_span]
1677    pub span: Span,
1678}
1679
1680#[derive(Diagnostic)]
1681#[diag(parse_async_bound_modifier_in_2015)]
1682pub(crate) struct AsyncBoundModifierIn2015 {
1683    #[primary_span]
1684    pub span: Span,
1685    #[subdiagnostic]
1686    pub help: HelpUseLatestEdition,
1687}
1688
1689#[derive(Diagnostic)]
1690#[diag(parse_self_argument_pointer)]
1691pub(crate) struct SelfArgumentPointer {
1692    #[primary_span]
1693    #[label]
1694    pub span: Span,
1695}
1696
1697#[derive(Diagnostic)]
1698#[diag(parse_unexpected_token_after_dot)]
1699pub(crate) struct UnexpectedTokenAfterDot<'a> {
1700    #[primary_span]
1701    pub span: Span,
1702    pub actual: Cow<'a, str>,
1703}
1704
1705#[derive(Diagnostic)]
1706#[diag(parse_visibility_not_followed_by_item)]
1707#[help]
1708pub(crate) struct VisibilityNotFollowedByItem {
1709    #[primary_span]
1710    #[label]
1711    pub span: Span,
1712    pub vis: Visibility,
1713}
1714
1715#[derive(Diagnostic)]
1716#[diag(parse_default_not_followed_by_item)]
1717#[note]
1718pub(crate) struct DefaultNotFollowedByItem {
1719    #[primary_span]
1720    #[label]
1721    pub span: Span,
1722}
1723
1724#[derive(Diagnostic)]
1725pub(crate) enum MissingKeywordForItemDefinition {
1726    #[diag(parse_missing_enum_for_enum_definition)]
1727    Enum {
1728        #[primary_span]
1729        span: Span,
1730        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "enum ")]
1731        insert_span: Span,
1732        ident: Ident,
1733    },
1734    #[diag(parse_missing_enum_or_struct_for_item_definition)]
1735    EnumOrStruct {
1736        #[primary_span]
1737        span: Span,
1738    },
1739    #[diag(parse_missing_struct_for_struct_definition)]
1740    Struct {
1741        #[primary_span]
1742        span: Span,
1743        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "struct ")]
1744        insert_span: Span,
1745        ident: Ident,
1746    },
1747    #[diag(parse_missing_fn_for_function_definition)]
1748    Function {
1749        #[primary_span]
1750        span: Span,
1751        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
1752        insert_span: Span,
1753        ident: Ident,
1754    },
1755    #[diag(parse_missing_fn_for_method_definition)]
1756    Method {
1757        #[primary_span]
1758        span: Span,
1759        #[suggestion(style = "verbose", applicability = "maybe-incorrect", code = "fn ")]
1760        insert_span: Span,
1761        ident: Ident,
1762    },
1763    #[diag(parse_missing_fn_or_struct_for_item_definition)]
1764    Ambiguous {
1765        #[primary_span]
1766        span: Span,
1767        #[subdiagnostic]
1768        subdiag: Option<AmbiguousMissingKwForItemSub>,
1769    },
1770}
1771
1772#[derive(Subdiagnostic)]
1773pub(crate) enum AmbiguousMissingKwForItemSub {
1774    #[suggestion(
1775        parse_suggestion,
1776        applicability = "maybe-incorrect",
1777        code = "{snippet}!",
1778        style = "verbose"
1779    )]
1780    SuggestMacro {
1781        #[primary_span]
1782        span: Span,
1783        snippet: String,
1784    },
1785    #[help(parse_help)]
1786    HelpMacro,
1787}
1788
1789#[derive(Diagnostic)]
1790#[diag(parse_missing_fn_params)]
1791pub(crate) struct MissingFnParams {
1792    #[primary_span]
1793    #[suggestion(code = "()", applicability = "machine-applicable", style = "verbose")]
1794    pub span: Span,
1795}
1796
1797#[derive(Diagnostic)]
1798#[diag(parse_invalid_path_sep_in_fn_definition)]
1799pub(crate) struct InvalidPathSepInFnDefinition {
1800    #[primary_span]
1801    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
1802    pub span: Span,
1803}
1804
1805#[derive(Diagnostic)]
1806#[diag(parse_missing_trait_in_trait_impl)]
1807pub(crate) struct MissingTraitInTraitImpl {
1808    #[primary_span]
1809    #[suggestion(
1810        parse_suggestion_add_trait,
1811        code = " Trait ",
1812        applicability = "has-placeholders",
1813        style = "verbose"
1814    )]
1815    pub span: Span,
1816    #[suggestion(
1817        parse_suggestion_remove_for,
1818        code = "",
1819        applicability = "maybe-incorrect",
1820        style = "verbose"
1821    )]
1822    pub for_span: Span,
1823}
1824
1825#[derive(Diagnostic)]
1826#[diag(parse_missing_for_in_trait_impl)]
1827pub(crate) struct MissingForInTraitImpl {
1828    #[primary_span]
1829    #[suggestion(style = "verbose", code = " for ", applicability = "machine-applicable")]
1830    pub span: Span,
1831}
1832
1833#[derive(Diagnostic)]
1834#[diag(parse_expected_trait_in_trait_impl_found_type)]
1835pub(crate) struct ExpectedTraitInTraitImplFoundType {
1836    #[primary_span]
1837    pub span: Span,
1838}
1839
1840#[derive(Diagnostic)]
1841#[diag(parse_extra_impl_keyword_in_trait_impl)]
1842pub(crate) struct ExtraImplKeywordInTraitImpl {
1843    #[primary_span]
1844    #[suggestion(code = "", applicability = "maybe-incorrect", style = "short")]
1845    pub extra_impl_kw: Span,
1846    #[note]
1847    pub impl_trait_span: Span,
1848}
1849
1850#[derive(Diagnostic)]
1851#[diag(parse_bounds_not_allowed_on_trait_aliases)]
1852pub(crate) struct BoundsNotAllowedOnTraitAliases {
1853    #[primary_span]
1854    pub span: Span,
1855}
1856
1857#[derive(Diagnostic)]
1858#[diag(parse_trait_alias_cannot_be_auto)]
1859pub(crate) struct TraitAliasCannotBeAuto {
1860    #[primary_span]
1861    #[label(parse_trait_alias_cannot_be_auto)]
1862    pub span: Span,
1863}
1864
1865#[derive(Diagnostic)]
1866#[diag(parse_trait_alias_cannot_be_unsafe)]
1867pub(crate) struct TraitAliasCannotBeUnsafe {
1868    #[primary_span]
1869    #[label(parse_trait_alias_cannot_be_unsafe)]
1870    pub span: Span,
1871}
1872
1873#[derive(Diagnostic)]
1874#[diag(parse_associated_static_item_not_allowed)]
1875pub(crate) struct AssociatedStaticItemNotAllowed {
1876    #[primary_span]
1877    pub span: Span,
1878}
1879
1880#[derive(Diagnostic)]
1881#[diag(parse_extern_crate_name_with_dashes)]
1882pub(crate) struct ExternCrateNameWithDashes {
1883    #[primary_span]
1884    #[label]
1885    pub span: Span,
1886    #[subdiagnostic]
1887    pub sugg: ExternCrateNameWithDashesSugg,
1888}
1889
1890#[derive(Subdiagnostic)]
1891#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
1892pub(crate) struct ExternCrateNameWithDashesSugg {
1893    #[suggestion_part(code = "_")]
1894    pub dashes: Vec<Span>,
1895}
1896
1897#[derive(Diagnostic)]
1898#[diag(parse_extern_item_cannot_be_const)]
1899#[note]
1900pub(crate) struct ExternItemCannotBeConst {
1901    #[primary_span]
1902    pub ident_span: Span,
1903    #[suggestion(code = "static ", applicability = "machine-applicable", style = "verbose")]
1904    pub const_span: Option<Span>,
1905}
1906
1907#[derive(Diagnostic)]
1908#[diag(parse_const_global_cannot_be_mutable)]
1909pub(crate) struct ConstGlobalCannotBeMutable {
1910    #[primary_span]
1911    #[label]
1912    pub ident_span: Span,
1913    #[suggestion(code = "static", style = "verbose", applicability = "maybe-incorrect")]
1914    pub const_span: Span,
1915}
1916
1917#[derive(Diagnostic)]
1918#[diag(parse_missing_const_type)]
1919pub(crate) struct MissingConstType {
1920    #[primary_span]
1921    #[suggestion(code = "{colon} <type>", style = "verbose", applicability = "has-placeholders")]
1922    pub span: Span,
1923
1924    pub kind: &'static str,
1925    pub colon: &'static str,
1926}
1927
1928#[derive(Diagnostic)]
1929#[diag(parse_enum_struct_mutually_exclusive)]
1930pub(crate) struct EnumStructMutuallyExclusive {
1931    #[primary_span]
1932    #[suggestion(code = "enum", style = "verbose", applicability = "machine-applicable")]
1933    pub span: Span,
1934}
1935
1936#[derive(Diagnostic)]
1937pub(crate) enum UnexpectedTokenAfterStructName {
1938    #[diag(parse_unexpected_token_after_struct_name_found_reserved_identifier)]
1939    ReservedIdentifier {
1940        #[primary_span]
1941        #[label(parse_unexpected_token_after_struct_name)]
1942        span: Span,
1943        token: Token,
1944    },
1945    #[diag(parse_unexpected_token_after_struct_name_found_keyword)]
1946    Keyword {
1947        #[primary_span]
1948        #[label(parse_unexpected_token_after_struct_name)]
1949        span: Span,
1950        token: Token,
1951    },
1952    #[diag(parse_unexpected_token_after_struct_name_found_reserved_keyword)]
1953    ReservedKeyword {
1954        #[primary_span]
1955        #[label(parse_unexpected_token_after_struct_name)]
1956        span: Span,
1957        token: Token,
1958    },
1959    #[diag(parse_unexpected_token_after_struct_name_found_doc_comment)]
1960    DocComment {
1961        #[primary_span]
1962        #[label(parse_unexpected_token_after_struct_name)]
1963        span: Span,
1964        token: Token,
1965    },
1966    #[diag(parse_unexpected_token_after_struct_name_found_metavar)]
1967    MetaVar {
1968        #[primary_span]
1969        #[label(parse_unexpected_token_after_struct_name)]
1970        span: Span,
1971    },
1972    #[diag(parse_unexpected_token_after_struct_name_found_other)]
1973    Other {
1974        #[primary_span]
1975        #[label(parse_unexpected_token_after_struct_name)]
1976        span: Span,
1977        token: Token,
1978    },
1979}
1980
1981impl UnexpectedTokenAfterStructName {
1982    pub(crate) fn new(span: Span, token: Token) -> Self {
1983        match TokenDescription::from_token(&token) {
1984            Some(TokenDescription::ReservedIdentifier) => Self::ReservedIdentifier { span, token },
1985            Some(TokenDescription::Keyword) => Self::Keyword { span, token },
1986            Some(TokenDescription::ReservedKeyword) => Self::ReservedKeyword { span, token },
1987            Some(TokenDescription::DocComment) => Self::DocComment { span, token },
1988            Some(TokenDescription::MetaVar(_)) => Self::MetaVar { span },
1989            None => Self::Other { span, token },
1990        }
1991    }
1992}
1993
1994#[derive(Diagnostic)]
1995#[diag(parse_unexpected_self_in_generic_parameters)]
1996#[note]
1997pub(crate) struct UnexpectedSelfInGenericParameters {
1998    #[primary_span]
1999    pub span: Span,
2000}
2001
2002#[derive(Diagnostic)]
2003#[diag(parse_unexpected_default_value_for_lifetime_in_generic_parameters)]
2004pub(crate) struct UnexpectedDefaultValueForLifetimeInGenericParameters {
2005    #[primary_span]
2006    #[label]
2007    pub span: Span,
2008}
2009
2010#[derive(Diagnostic)]
2011#[diag(parse_multiple_where_clauses)]
2012pub(crate) struct MultipleWhereClauses {
2013    #[primary_span]
2014    pub span: Span,
2015    #[label]
2016    pub previous: Span,
2017    #[suggestion(style = "verbose", code = ",", applicability = "maybe-incorrect")]
2018    pub between: Span,
2019}
2020
2021#[derive(Diagnostic)]
2022pub(crate) enum UnexpectedNonterminal {
2023    #[diag(parse_nonterminal_expected_item_keyword)]
2024    Item(#[primary_span] Span),
2025    #[diag(parse_nonterminal_expected_statement)]
2026    Statement(#[primary_span] Span),
2027    #[diag(parse_nonterminal_expected_ident)]
2028    Ident {
2029        #[primary_span]
2030        span: Span,
2031        token: Token,
2032    },
2033    #[diag(parse_nonterminal_expected_lifetime)]
2034    Lifetime {
2035        #[primary_span]
2036        span: Span,
2037        token: Token,
2038    },
2039}
2040
2041#[derive(Diagnostic)]
2042pub(crate) enum TopLevelOrPatternNotAllowed {
2043    #[diag(parse_or_pattern_not_allowed_in_let_binding)]
2044    LetBinding {
2045        #[primary_span]
2046        span: Span,
2047        #[subdiagnostic]
2048        sub: Option<TopLevelOrPatternNotAllowedSugg>,
2049    },
2050    #[diag(parse_or_pattern_not_allowed_in_fn_parameters)]
2051    FunctionParameter {
2052        #[primary_span]
2053        span: Span,
2054        #[subdiagnostic]
2055        sub: Option<TopLevelOrPatternNotAllowedSugg>,
2056    },
2057}
2058
2059#[derive(Diagnostic)]
2060#[diag(parse_cannot_be_raw_ident)]
2061pub(crate) struct CannotBeRawIdent {
2062    #[primary_span]
2063    pub span: Span,
2064    pub ident: Symbol,
2065}
2066
2067#[derive(Diagnostic)]
2068#[diag(parse_cannot_be_raw_lifetime)]
2069pub(crate) struct CannotBeRawLifetime {
2070    #[primary_span]
2071    pub span: Span,
2072    pub ident: Symbol,
2073}
2074
2075#[derive(Diagnostic)]
2076#[diag(parse_keyword_lifetime)]
2077pub(crate) struct KeywordLifetime {
2078    #[primary_span]
2079    pub span: Span,
2080}
2081
2082#[derive(Diagnostic)]
2083#[diag(parse_invalid_label)]
2084pub(crate) struct InvalidLabel {
2085    #[primary_span]
2086    pub span: Span,
2087    pub name: Symbol,
2088}
2089
2090#[derive(Diagnostic)]
2091#[diag(parse_cr_doc_comment)]
2092pub(crate) struct CrDocComment {
2093    #[primary_span]
2094    pub span: Span,
2095    pub block: bool,
2096}
2097
2098#[derive(Diagnostic)]
2099#[diag(parse_no_digits_literal, code = E0768)]
2100pub(crate) struct NoDigitsLiteral {
2101    #[primary_span]
2102    pub span: Span,
2103}
2104
2105#[derive(Diagnostic)]
2106#[diag(parse_invalid_digit_literal)]
2107pub(crate) struct InvalidDigitLiteral {
2108    #[primary_span]
2109    pub span: Span,
2110    pub base: u32,
2111}
2112
2113#[derive(Diagnostic)]
2114#[diag(parse_empty_exponent_float)]
2115pub(crate) struct EmptyExponentFloat {
2116    #[primary_span]
2117    pub span: Span,
2118}
2119
2120#[derive(Diagnostic)]
2121#[diag(parse_float_literal_unsupported_base)]
2122pub(crate) struct FloatLiteralUnsupportedBase {
2123    #[primary_span]
2124    pub span: Span,
2125    pub base: &'static str,
2126}
2127
2128#[derive(Diagnostic)]
2129#[diag(parse_unknown_prefix)]
2130#[note]
2131pub(crate) struct UnknownPrefix<'a> {
2132    #[primary_span]
2133    #[label]
2134    pub span: Span,
2135    pub prefix: &'a str,
2136    #[subdiagnostic]
2137    pub sugg: Option<UnknownPrefixSugg>,
2138}
2139
2140#[derive(Subdiagnostic)]
2141#[note(parse_macro_expands_to_adt_field)]
2142pub(crate) struct MacroExpandsToAdtField<'a> {
2143    pub adt_ty: &'a str,
2144}
2145
2146#[derive(Subdiagnostic)]
2147pub(crate) enum UnknownPrefixSugg {
2148    #[suggestion(
2149        parse_suggestion_br,
2150        code = "br",
2151        applicability = "maybe-incorrect",
2152        style = "verbose"
2153    )]
2154    UseBr(#[primary_span] Span),
2155    #[suggestion(
2156        parse_suggestion_whitespace,
2157        code = " ",
2158        applicability = "maybe-incorrect",
2159        style = "verbose"
2160    )]
2161    Whitespace(#[primary_span] Span),
2162    #[multipart_suggestion(
2163        parse_suggestion_str,
2164        applicability = "maybe-incorrect",
2165        style = "verbose"
2166    )]
2167    MeantStr {
2168        #[suggestion_part(code = "\"")]
2169        start: Span,
2170        #[suggestion_part(code = "\"")]
2171        end: Span,
2172    },
2173}
2174
2175#[derive(Diagnostic)]
2176#[diag(parse_reserved_multihash)]
2177#[note]
2178pub(crate) struct ReservedMultihash {
2179    #[primary_span]
2180    pub span: Span,
2181    #[subdiagnostic]
2182    pub sugg: Option<GuardedStringSugg>,
2183}
2184#[derive(Diagnostic)]
2185#[diag(parse_reserved_string)]
2186#[note]
2187pub(crate) struct ReservedString {
2188    #[primary_span]
2189    pub span: Span,
2190    #[subdiagnostic]
2191    pub sugg: Option<GuardedStringSugg>,
2192}
2193#[derive(Subdiagnostic)]
2194#[suggestion(
2195    parse_suggestion_whitespace,
2196    code = " ",
2197    applicability = "maybe-incorrect",
2198    style = "verbose"
2199)]
2200pub(crate) struct GuardedStringSugg(#[primary_span] pub Span);
2201
2202#[derive(Diagnostic)]
2203#[diag(parse_too_many_hashes)]
2204pub(crate) struct TooManyHashes {
2205    #[primary_span]
2206    pub span: Span,
2207    pub num: u32,
2208}
2209
2210#[derive(Diagnostic)]
2211#[diag(parse_unknown_start_of_token)]
2212pub(crate) struct UnknownTokenStart {
2213    #[primary_span]
2214    pub span: Span,
2215    pub escaped: String,
2216    #[subdiagnostic]
2217    pub sugg: Option<TokenSubstitution>,
2218    #[subdiagnostic]
2219    pub null: Option<UnknownTokenNull>,
2220    #[subdiagnostic]
2221    pub repeat: Option<UnknownTokenRepeat>,
2222}
2223
2224#[derive(Subdiagnostic)]
2225pub(crate) enum TokenSubstitution {
2226    #[suggestion(
2227        parse_sugg_quotes,
2228        code = "{suggestion}",
2229        applicability = "maybe-incorrect",
2230        style = "verbose"
2231    )]
2232    DirectedQuotes {
2233        #[primary_span]
2234        span: Span,
2235        suggestion: String,
2236        ascii_str: &'static str,
2237        ascii_name: &'static str,
2238    },
2239    #[suggestion(
2240        parse_sugg_other,
2241        code = "{suggestion}",
2242        applicability = "maybe-incorrect",
2243        style = "verbose"
2244    )]
2245    Other {
2246        #[primary_span]
2247        span: Span,
2248        suggestion: String,
2249        ch: String,
2250        u_name: &'static str,
2251        ascii_str: &'static str,
2252        ascii_name: &'static str,
2253    },
2254}
2255
2256#[derive(Subdiagnostic)]
2257#[note(parse_note_repeats)]
2258pub(crate) struct UnknownTokenRepeat {
2259    pub repeats: usize,
2260}
2261
2262#[derive(Subdiagnostic)]
2263#[help(parse_help_null)]
2264pub(crate) struct UnknownTokenNull;
2265
2266#[derive(Diagnostic)]
2267pub(crate) enum UnescapeError {
2268    #[diag(parse_invalid_unicode_escape)]
2269    #[help]
2270    InvalidUnicodeEscape {
2271        #[primary_span]
2272        #[label]
2273        span: Span,
2274        surrogate: bool,
2275    },
2276    #[diag(parse_escape_only_char)]
2277    EscapeOnlyChar {
2278        #[primary_span]
2279        span: Span,
2280        #[suggestion(
2281            parse_escape,
2282            applicability = "machine-applicable",
2283            code = "{escaped_sugg}",
2284            style = "verbose"
2285        )]
2286        char_span: Span,
2287        escaped_sugg: String,
2288        escaped_msg: String,
2289        byte: bool,
2290    },
2291    #[diag(parse_bare_cr)]
2292    BareCr {
2293        #[primary_span]
2294        #[suggestion(
2295            parse_escape,
2296            applicability = "machine-applicable",
2297            code = "\\r",
2298            style = "verbose"
2299        )]
2300        span: Span,
2301        double_quotes: bool,
2302    },
2303    #[diag(parse_bare_cr_in_raw_string)]
2304    BareCrRawString(#[primary_span] Span),
2305    #[diag(parse_too_short_hex_escape)]
2306    TooShortHexEscape(#[primary_span] Span),
2307    #[diag(parse_invalid_char_in_escape)]
2308    InvalidCharInEscape {
2309        #[primary_span]
2310        #[label]
2311        span: Span,
2312        is_hex: bool,
2313        ch: String,
2314    },
2315    #[diag(parse_out_of_range_hex_escape)]
2316    OutOfRangeHexEscape(
2317        #[primary_span]
2318        #[label]
2319        Span,
2320    ),
2321    #[diag(parse_leading_underscore_unicode_escape)]
2322    LeadingUnderscoreUnicodeEscape {
2323        #[primary_span]
2324        #[label(parse_leading_underscore_unicode_escape_label)]
2325        span: Span,
2326        ch: String,
2327    },
2328    #[diag(parse_overlong_unicode_escape)]
2329    OverlongUnicodeEscape(
2330        #[primary_span]
2331        #[label]
2332        Span,
2333    ),
2334    #[diag(parse_unclosed_unicode_escape)]
2335    UnclosedUnicodeEscape(
2336        #[primary_span]
2337        #[label]
2338        Span,
2339        #[suggestion(
2340            parse_terminate,
2341            code = "}}",
2342            applicability = "maybe-incorrect",
2343            style = "verbose"
2344        )]
2345        Span,
2346    ),
2347    #[diag(parse_no_brace_unicode_escape)]
2348    NoBraceInUnicodeEscape {
2349        #[primary_span]
2350        span: Span,
2351        #[label]
2352        label: Option<Span>,
2353        #[subdiagnostic]
2354        sub: NoBraceUnicodeSub,
2355    },
2356    #[diag(parse_unicode_escape_in_byte)]
2357    #[help]
2358    UnicodeEscapeInByte(
2359        #[primary_span]
2360        #[label]
2361        Span,
2362    ),
2363    #[diag(parse_empty_unicode_escape)]
2364    EmptyUnicodeEscape(
2365        #[primary_span]
2366        #[label]
2367        Span,
2368    ),
2369    #[diag(parse_zero_chars)]
2370    ZeroChars(
2371        #[primary_span]
2372        #[label]
2373        Span,
2374    ),
2375    #[diag(parse_lone_slash)]
2376    LoneSlash(
2377        #[primary_span]
2378        #[label]
2379        Span,
2380    ),
2381    #[diag(parse_unskipped_whitespace)]
2382    UnskippedWhitespace {
2383        #[primary_span]
2384        span: Span,
2385        #[label]
2386        char_span: Span,
2387        ch: String,
2388    },
2389    #[diag(parse_multiple_skipped_lines)]
2390    MultipleSkippedLinesWarning(
2391        #[primary_span]
2392        #[label]
2393        Span,
2394    ),
2395    #[diag(parse_more_than_one_char)]
2396    MoreThanOneChar {
2397        #[primary_span]
2398        span: Span,
2399        #[subdiagnostic]
2400        note: Option<MoreThanOneCharNote>,
2401        #[subdiagnostic]
2402        suggestion: MoreThanOneCharSugg,
2403    },
2404    #[diag(parse_nul_in_c_str)]
2405    NulInCStr {
2406        #[primary_span]
2407        span: Span,
2408    },
2409}
2410
2411#[derive(Subdiagnostic)]
2412pub(crate) enum MoreThanOneCharSugg {
2413    #[suggestion(
2414        parse_consider_normalized,
2415        code = "{normalized}",
2416        applicability = "machine-applicable",
2417        style = "verbose"
2418    )]
2419    NormalizedForm {
2420        #[primary_span]
2421        span: Span,
2422        ch: String,
2423        normalized: String,
2424    },
2425    #[suggestion(
2426        parse_remove_non,
2427        code = "{ch}",
2428        applicability = "maybe-incorrect",
2429        style = "verbose"
2430    )]
2431    RemoveNonPrinting {
2432        #[primary_span]
2433        span: Span,
2434        ch: String,
2435    },
2436    #[suggestion(
2437        parse_use_double_quotes,
2438        code = "{sugg}",
2439        applicability = "machine-applicable",
2440        style = "verbose"
2441    )]
2442    QuotesFull {
2443        #[primary_span]
2444        span: Span,
2445        is_byte: bool,
2446        sugg: String,
2447    },
2448    #[multipart_suggestion(parse_use_double_quotes, applicability = "machine-applicable")]
2449    Quotes {
2450        #[suggestion_part(code = "{prefix}\"")]
2451        start: Span,
2452        #[suggestion_part(code = "\"")]
2453        end: Span,
2454        is_byte: bool,
2455        prefix: &'static str,
2456    },
2457}
2458
2459#[derive(Subdiagnostic)]
2460pub(crate) enum MoreThanOneCharNote {
2461    #[note(parse_followed_by)]
2462    AllCombining {
2463        #[primary_span]
2464        span: Span,
2465        chr: String,
2466        len: usize,
2467        escaped_marks: String,
2468    },
2469    #[note(parse_non_printing)]
2470    NonPrinting {
2471        #[primary_span]
2472        span: Span,
2473        escaped: String,
2474    },
2475}
2476
2477#[derive(Subdiagnostic)]
2478pub(crate) enum NoBraceUnicodeSub {
2479    #[suggestion(
2480        parse_use_braces,
2481        code = "{suggestion}",
2482        applicability = "maybe-incorrect",
2483        style = "verbose"
2484    )]
2485    Suggestion {
2486        #[primary_span]
2487        span: Span,
2488        suggestion: String,
2489    },
2490    #[help(parse_format_of_unicode)]
2491    Help,
2492}
2493
2494#[derive(Subdiagnostic)]
2495#[multipart_suggestion(parse_sugg_wrap_pattern_in_parens, applicability = "machine-applicable")]
2496pub(crate) struct WrapInParens {
2497    #[suggestion_part(code = "(")]
2498    pub(crate) lo: Span,
2499    #[suggestion_part(code = ")")]
2500    pub(crate) hi: Span,
2501}
2502
2503#[derive(Subdiagnostic)]
2504pub(crate) enum TopLevelOrPatternNotAllowedSugg {
2505    #[suggestion(
2506        parse_sugg_remove_leading_vert_in_pattern,
2507        code = "",
2508        applicability = "machine-applicable",
2509        style = "verbose"
2510    )]
2511    RemoveLeadingVert {
2512        #[primary_span]
2513        span: Span,
2514    },
2515    WrapInParens {
2516        #[primary_span]
2517        span: Span,
2518        #[subdiagnostic]
2519        suggestion: WrapInParens,
2520    },
2521}
2522
2523#[derive(Diagnostic)]
2524#[diag(parse_unexpected_vert_vert_before_function_parameter)]
2525#[note(parse_note_pattern_alternatives_use_single_vert)]
2526pub(crate) struct UnexpectedVertVertBeforeFunctionParam {
2527    #[primary_span]
2528    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2529    pub span: Span,
2530}
2531
2532#[derive(Diagnostic)]
2533#[diag(parse_unexpected_vert_vert_in_pattern)]
2534pub(crate) struct UnexpectedVertVertInPattern {
2535    #[primary_span]
2536    #[suggestion(code = "|", applicability = "machine-applicable", style = "verbose")]
2537    pub span: Span,
2538    #[label(parse_label_while_parsing_or_pattern_here)]
2539    pub start: Option<Span>,
2540}
2541
2542#[derive(Diagnostic)]
2543#[diag(parse_trailing_vert_not_allowed)]
2544pub(crate) struct TrailingVertNotAllowed {
2545    #[primary_span]
2546    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2547    pub span: Span,
2548    #[label(parse_label_while_parsing_or_pattern_here)]
2549    pub start: Option<Span>,
2550    pub token: Token,
2551    #[note(parse_note_pattern_alternatives_use_single_vert)]
2552    pub note_double_vert: bool,
2553}
2554
2555#[derive(Diagnostic)]
2556#[diag(parse_dotdotdot_rest_pattern)]
2557pub(crate) struct DotDotDotRestPattern {
2558    #[primary_span]
2559    #[label]
2560    pub span: Span,
2561    #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
2562    pub suggestion: Span,
2563}
2564
2565#[derive(Diagnostic)]
2566#[diag(parse_pattern_on_wrong_side_of_at)]
2567pub(crate) struct PatternOnWrongSideOfAt {
2568    #[primary_span]
2569    #[suggestion(code = "{whole_pat}", applicability = "machine-applicable", style = "verbose")]
2570    pub whole_span: Span,
2571    pub whole_pat: String,
2572    #[label(parse_label_pattern)]
2573    pub pattern: Span,
2574    #[label(parse_label_binding)]
2575    pub binding: Span,
2576}
2577
2578#[derive(Diagnostic)]
2579#[diag(parse_expected_binding_left_of_at)]
2580#[note]
2581pub(crate) struct ExpectedBindingLeftOfAt {
2582    #[primary_span]
2583    pub whole_span: Span,
2584    #[label(parse_label_lhs)]
2585    pub lhs: Span,
2586    #[label(parse_label_rhs)]
2587    pub rhs: Span,
2588}
2589
2590#[derive(Subdiagnostic)]
2591#[multipart_suggestion(
2592    parse_ambiguous_range_pattern_suggestion,
2593    applicability = "machine-applicable"
2594)]
2595pub(crate) struct ParenRangeSuggestion {
2596    #[suggestion_part(code = "(")]
2597    pub lo: Span,
2598    #[suggestion_part(code = ")")]
2599    pub hi: Span,
2600}
2601
2602#[derive(Diagnostic)]
2603#[diag(parse_ambiguous_range_pattern)]
2604pub(crate) struct AmbiguousRangePattern {
2605    #[primary_span]
2606    pub span: Span,
2607    #[subdiagnostic]
2608    pub suggestion: ParenRangeSuggestion,
2609}
2610
2611#[derive(Diagnostic)]
2612#[diag(parse_unexpected_lifetime_in_pattern)]
2613pub(crate) struct UnexpectedLifetimeInPattern {
2614    #[primary_span]
2615    pub span: Span,
2616    pub symbol: Symbol,
2617    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2618    pub suggestion: Span,
2619}
2620
2621#[derive(Diagnostic)]
2622pub(crate) enum InvalidMutInPattern {
2623    #[diag(parse_mut_on_nested_ident_pattern)]
2624    #[note(parse_note_mut_pattern_usage)]
2625    NestedIdent {
2626        #[primary_span]
2627        #[suggestion(code = "{pat}", applicability = "machine-applicable", style = "verbose")]
2628        span: Span,
2629        pat: String,
2630    },
2631    #[diag(parse_mut_on_non_ident_pattern)]
2632    #[note(parse_note_mut_pattern_usage)]
2633    NonIdent {
2634        #[primary_span]
2635        #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2636        span: Span,
2637    },
2638}
2639
2640#[derive(Diagnostic)]
2641#[diag(parse_repeated_mut_in_pattern)]
2642pub(crate) struct RepeatedMutInPattern {
2643    #[primary_span]
2644    pub span: Span,
2645    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2646    pub suggestion: Span,
2647}
2648
2649#[derive(Diagnostic)]
2650#[diag(parse_dot_dot_dot_range_to_pattern_not_allowed)]
2651pub(crate) struct DotDotDotRangeToPatternNotAllowed {
2652    #[primary_span]
2653    #[suggestion(style = "verbose", code = "..=", applicability = "machine-applicable")]
2654    pub span: Span,
2655}
2656
2657#[derive(Diagnostic)]
2658#[diag(parse_enum_pattern_instead_of_identifier)]
2659pub(crate) struct EnumPatternInsteadOfIdentifier {
2660    #[primary_span]
2661    pub span: Span,
2662}
2663
2664#[derive(Diagnostic)]
2665#[diag(parse_at_dot_dot_in_struct_pattern)]
2666pub(crate) struct AtDotDotInStructPattern {
2667    #[primary_span]
2668    pub span: Span,
2669    #[suggestion(code = "", style = "verbose", applicability = "machine-applicable")]
2670    pub remove: Span,
2671    pub ident: Ident,
2672}
2673
2674#[derive(Diagnostic)]
2675#[diag(parse_at_in_struct_pattern)]
2676#[note]
2677#[help]
2678pub(crate) struct AtInStructPattern {
2679    #[primary_span]
2680    pub span: Span,
2681}
2682
2683#[derive(Diagnostic)]
2684#[diag(parse_dot_dot_dot_for_remaining_fields)]
2685pub(crate) struct DotDotDotForRemainingFields {
2686    #[primary_span]
2687    #[suggestion(code = "..", style = "verbose", applicability = "machine-applicable")]
2688    pub span: Span,
2689    pub token_str: Cow<'static, str>,
2690}
2691
2692#[derive(Diagnostic)]
2693#[diag(parse_expected_comma_after_pattern_field)]
2694pub(crate) struct ExpectedCommaAfterPatternField {
2695    #[primary_span]
2696    pub span: Span,
2697}
2698
2699#[derive(Diagnostic)]
2700#[diag(parse_unexpected_expr_in_pat)]
2701#[note]
2702pub(crate) struct UnexpectedExpressionInPattern {
2703    /// The unexpected expr's span.
2704    #[primary_span]
2705    #[label]
2706    pub span: Span,
2707    /// Was a `RangePatternBound` expected?
2708    pub is_bound: bool,
2709    /// The unexpected expr's precedence (used in match arm guard suggestions).
2710    pub expr_precedence: ExprPrecedence,
2711}
2712
2713#[derive(Subdiagnostic)]
2714pub(crate) enum UnexpectedExpressionInPatternSugg {
2715    #[multipart_suggestion(
2716        parse_unexpected_expr_in_pat_create_guard_sugg,
2717        applicability = "maybe-incorrect"
2718    )]
2719    CreateGuard {
2720        /// Where to put the suggested identifier.
2721        #[suggestion_part(code = "{ident}")]
2722        ident_span: Span,
2723        /// Where to put the match arm.
2724        #[suggestion_part(code = " if {ident} == {expr}")]
2725        pat_hi: Span,
2726        /// The suggested identifier.
2727        ident: String,
2728        /// The unexpected expression.
2729        expr: String,
2730    },
2731
2732    #[multipart_suggestion(
2733        parse_unexpected_expr_in_pat_update_guard_sugg,
2734        applicability = "maybe-incorrect"
2735    )]
2736    UpdateGuard {
2737        /// Where to put the suggested identifier.
2738        #[suggestion_part(code = "{ident}")]
2739        ident_span: Span,
2740        /// The beginning of the match arm guard's expression (insert a `(` if `Some`).
2741        #[suggestion_part(code = "(")]
2742        guard_lo: Option<Span>,
2743        /// The end of the match arm guard's expression.
2744        #[suggestion_part(code = "{guard_hi_paren} && {ident} == {expr}")]
2745        guard_hi: Span,
2746        /// Either `")"` or `""`.
2747        guard_hi_paren: &'static str,
2748        /// The suggested identifier.
2749        ident: String,
2750        /// The unexpected expression.
2751        expr: String,
2752    },
2753
2754    #[multipart_suggestion(
2755        parse_unexpected_expr_in_pat_const_sugg,
2756        applicability = "has-placeholders"
2757    )]
2758    Const {
2759        /// Where to put the extracted constant declaration.
2760        #[suggestion_part(code = "{indentation}const {ident}: /* Type */ = {expr};\n")]
2761        stmt_lo: Span,
2762        /// Where to put the suggested identifier.
2763        #[suggestion_part(code = "{ident}")]
2764        ident_span: Span,
2765        /// The suggested identifier.
2766        ident: String,
2767        /// The unexpected expression.
2768        expr: String,
2769        /// The statement's block's indentation.
2770        indentation: String,
2771    },
2772
2773    #[multipart_suggestion(
2774        parse_unexpected_expr_in_pat_inline_const_sugg,
2775        applicability = "maybe-incorrect"
2776    )]
2777    InlineConst {
2778        #[suggestion_part(code = "const {{ ")]
2779        start_span: Span,
2780        #[suggestion_part(code = " }}")]
2781        end_span: Span,
2782    },
2783}
2784
2785#[derive(Diagnostic)]
2786#[diag(parse_unexpected_paren_in_range_pat)]
2787pub(crate) struct UnexpectedParenInRangePat {
2788    #[primary_span]
2789    pub span: Vec<Span>,
2790    #[subdiagnostic]
2791    pub sugg: UnexpectedParenInRangePatSugg,
2792}
2793
2794#[derive(Subdiagnostic)]
2795#[multipart_suggestion(
2796    parse_unexpected_paren_in_range_pat_sugg,
2797    applicability = "machine-applicable"
2798)]
2799pub(crate) struct UnexpectedParenInRangePatSugg {
2800    #[suggestion_part(code = "")]
2801    pub start_span: Span,
2802    #[suggestion_part(code = "")]
2803    pub end_span: Span,
2804}
2805
2806#[derive(Diagnostic)]
2807#[diag(parse_return_types_use_thin_arrow)]
2808pub(crate) struct ReturnTypesUseThinArrow {
2809    #[primary_span]
2810    pub span: Span,
2811    #[suggestion(style = "verbose", code = " -> ", applicability = "machine-applicable")]
2812    pub suggestion: Span,
2813}
2814
2815#[derive(Diagnostic)]
2816#[diag(parse_need_plus_after_trait_object_lifetime)]
2817pub(crate) struct NeedPlusAfterTraitObjectLifetime {
2818    #[primary_span]
2819    pub span: Span,
2820}
2821
2822#[derive(Diagnostic)]
2823#[diag(parse_expected_mut_or_const_in_raw_pointer_type)]
2824pub(crate) struct ExpectedMutOrConstInRawPointerType {
2825    #[primary_span]
2826    pub span: Span,
2827    #[suggestion(code("mut ", "const "), applicability = "has-placeholders", style = "verbose")]
2828    pub after_asterisk: Span,
2829}
2830
2831#[derive(Diagnostic)]
2832#[diag(parse_lifetime_after_mut)]
2833pub(crate) struct LifetimeAfterMut {
2834    #[primary_span]
2835    pub span: Span,
2836    #[suggestion(code = "&{snippet} mut", applicability = "maybe-incorrect", style = "verbose")]
2837    pub suggest_lifetime: Option<Span>,
2838    pub snippet: String,
2839}
2840
2841#[derive(Diagnostic)]
2842#[diag(parse_dyn_after_mut)]
2843pub(crate) struct DynAfterMut {
2844    #[primary_span]
2845    #[suggestion(code = "&mut dyn", applicability = "machine-applicable", style = "verbose")]
2846    pub span: Span,
2847}
2848
2849#[derive(Diagnostic)]
2850#[diag(parse_fn_pointer_cannot_be_const)]
2851pub(crate) struct FnPointerCannotBeConst {
2852    #[primary_span]
2853    pub span: Span,
2854    #[label]
2855    pub qualifier: Span,
2856    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2857    pub suggestion: Span,
2858}
2859
2860#[derive(Diagnostic)]
2861#[diag(parse_fn_pointer_cannot_be_async)]
2862pub(crate) struct FnPointerCannotBeAsync {
2863    #[primary_span]
2864    pub span: Span,
2865    #[label]
2866    pub qualifier: Span,
2867    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2868    pub suggestion: Span,
2869}
2870
2871#[derive(Diagnostic)]
2872#[diag(parse_nested_c_variadic_type, code = E0743)]
2873pub(crate) struct NestedCVariadicType {
2874    #[primary_span]
2875    pub span: Span,
2876}
2877
2878#[derive(Diagnostic)]
2879#[diag(parse_invalid_dyn_keyword)]
2880#[help]
2881pub(crate) struct InvalidDynKeyword {
2882    #[primary_span]
2883    pub span: Span,
2884    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
2885    pub suggestion: Span,
2886}
2887
2888#[derive(Subdiagnostic)]
2889pub(crate) enum HelpUseLatestEdition {
2890    #[help(parse_help_set_edition_cargo)]
2891    #[note(parse_note_edition_guide)]
2892    Cargo { edition: Edition },
2893    #[help(parse_help_set_edition_standalone)]
2894    #[note(parse_note_edition_guide)]
2895    Standalone { edition: Edition },
2896}
2897
2898impl HelpUseLatestEdition {
2899    pub(crate) fn new() -> Self {
2900        let edition = LATEST_STABLE_EDITION;
2901        if rustc_session::utils::was_invoked_from_cargo() {
2902            Self::Cargo { edition }
2903        } else {
2904            Self::Standalone { edition }
2905        }
2906    }
2907}
2908
2909#[derive(Diagnostic)]
2910#[diag(parse_box_syntax_removed)]
2911pub(crate) struct BoxSyntaxRemoved {
2912    #[primary_span]
2913    pub span: Span,
2914    #[subdiagnostic]
2915    pub sugg: AddBoxNew,
2916}
2917
2918#[derive(Subdiagnostic)]
2919#[multipart_suggestion(
2920    parse_box_syntax_removed_suggestion,
2921    applicability = "machine-applicable",
2922    style = "verbose"
2923)]
2924pub(crate) struct AddBoxNew {
2925    #[suggestion_part(code = "Box::new(")]
2926    pub box_kw_and_lo: Span,
2927    #[suggestion_part(code = ")")]
2928    pub hi: Span,
2929}
2930
2931#[derive(Diagnostic)]
2932#[diag(parse_bad_return_type_notation_output)]
2933pub(crate) struct BadReturnTypeNotationOutput {
2934    #[primary_span]
2935    pub span: Span,
2936    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
2937    pub suggestion: Span,
2938}
2939
2940#[derive(Diagnostic)]
2941#[diag(parse_bad_assoc_type_bounds)]
2942pub(crate) struct BadAssocTypeBounds {
2943    #[primary_span]
2944    #[label]
2945    pub span: Span,
2946}
2947
2948#[derive(Diagnostic)]
2949#[diag(parse_attr_after_generic)]
2950pub(crate) struct AttrAfterGeneric {
2951    #[primary_span]
2952    #[label]
2953    pub span: Span,
2954}
2955
2956#[derive(Diagnostic)]
2957#[diag(parse_attr_without_generics)]
2958pub(crate) struct AttrWithoutGenerics {
2959    #[primary_span]
2960    #[label]
2961    pub span: Span,
2962}
2963
2964#[derive(Diagnostic)]
2965#[diag(parse_where_generics)]
2966pub(crate) struct WhereOnGenerics {
2967    #[primary_span]
2968    #[label]
2969    pub span: Span,
2970}
2971
2972#[derive(Diagnostic)]
2973#[diag(parse_generics_in_path)]
2974pub(crate) struct GenericsInPath {
2975    #[primary_span]
2976    pub span: Vec<Span>,
2977}
2978
2979#[derive(Diagnostic)]
2980#[diag(parse_lifetime_in_eq_constraint)]
2981#[help]
2982pub(crate) struct LifetimeInEqConstraint {
2983    #[primary_span]
2984    #[label]
2985    pub span: Span,
2986    pub lifetime: Ident,
2987    #[label(parse_context_label)]
2988    pub binding_label: Span,
2989    #[suggestion(
2990        parse_colon_sugg,
2991        style = "verbose",
2992        applicability = "maybe-incorrect",
2993        code = ": "
2994    )]
2995    pub colon_sugg: Span,
2996}
2997
2998#[derive(Diagnostic)]
2999#[diag(parse_modifier_lifetime)]
3000pub(crate) struct ModifierLifetime {
3001    #[primary_span]
3002    #[suggestion(style = "tool-only", applicability = "maybe-incorrect", code = "")]
3003    pub span: Span,
3004    pub modifier: &'static str,
3005}
3006
3007#[derive(Subdiagnostic)]
3008#[multipart_suggestion(
3009    parse_parenthesized_lifetime_suggestion,
3010    applicability = "machine-applicable"
3011)]
3012pub(crate) struct RemoveParens {
3013    #[suggestion_part(code = "")]
3014    pub lo: Span,
3015    #[suggestion_part(code = "")]
3016    pub hi: Span,
3017}
3018
3019#[derive(Diagnostic)]
3020#[diag(parse_parenthesized_lifetime)]
3021pub(crate) struct ParenthesizedLifetime {
3022    #[primary_span]
3023    pub span: Span,
3024    #[subdiagnostic]
3025    pub sugg: RemoveParens,
3026}
3027
3028#[derive(Diagnostic)]
3029#[diag(parse_underscore_literal_suffix)]
3030pub(crate) struct UnderscoreLiteralSuffix {
3031    #[primary_span]
3032    pub span: Span,
3033}
3034
3035#[derive(Diagnostic)]
3036#[diag(parse_expect_label_found_ident)]
3037pub(crate) struct ExpectedLabelFoundIdent {
3038    #[primary_span]
3039    pub span: Span,
3040    #[suggestion(code = "'", applicability = "machine-applicable", style = "verbose")]
3041    pub start: Span,
3042}
3043
3044#[derive(Diagnostic)]
3045#[diag(parse_inappropriate_default)]
3046#[note]
3047pub(crate) struct InappropriateDefault {
3048    #[primary_span]
3049    #[label]
3050    pub span: Span,
3051    pub article: &'static str,
3052    pub descr: &'static str,
3053}
3054
3055#[derive(Diagnostic)]
3056#[diag(parse_recover_import_as_use)]
3057pub(crate) struct RecoverImportAsUse {
3058    #[primary_span]
3059    #[suggestion(code = "use", applicability = "machine-applicable", style = "verbose")]
3060    pub span: Span,
3061    pub token_name: String,
3062}
3063
3064#[derive(Diagnostic)]
3065#[diag(parse_single_colon_import_path)]
3066#[note]
3067pub(crate) struct SingleColonImportPath {
3068    #[primary_span]
3069    #[suggestion(code = "::", applicability = "machine-applicable", style = "verbose")]
3070    pub span: Span,
3071}
3072
3073#[derive(Diagnostic)]
3074#[diag(parse_bad_item_kind)]
3075pub(crate) struct BadItemKind {
3076    #[primary_span]
3077    pub span: Span,
3078    pub descr: &'static str,
3079    pub ctx: &'static str,
3080    #[help]
3081    pub help: bool,
3082}
3083
3084#[derive(Diagnostic)]
3085#[diag(parse_macro_rules_missing_bang)]
3086pub(crate) struct MacroRulesMissingBang {
3087    #[primary_span]
3088    pub span: Span,
3089    #[suggestion(code = "!", applicability = "machine-applicable", style = "verbose")]
3090    pub hi: Span,
3091}
3092
3093#[derive(Diagnostic)]
3094#[diag(parse_macro_name_remove_bang)]
3095pub(crate) struct MacroNameRemoveBang {
3096    #[primary_span]
3097    #[suggestion(code = "", applicability = "machine-applicable", style = "short")]
3098    pub span: Span,
3099}
3100
3101#[derive(Diagnostic)]
3102#[diag(parse_macro_rules_visibility)]
3103pub(crate) struct MacroRulesVisibility<'a> {
3104    #[primary_span]
3105    #[suggestion(code = "#[macro_export]", applicability = "maybe-incorrect", style = "verbose")]
3106    pub span: Span,
3107    pub vis: &'a str,
3108}
3109
3110#[derive(Diagnostic)]
3111#[diag(parse_macro_invocation_visibility)]
3112#[help]
3113pub(crate) struct MacroInvocationVisibility<'a> {
3114    #[primary_span]
3115    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
3116    pub span: Span,
3117    pub vis: &'a str,
3118}
3119
3120#[derive(Diagnostic)]
3121#[diag(parse_nested_adt)]
3122pub(crate) struct NestedAdt<'a> {
3123    #[primary_span]
3124    pub span: Span,
3125    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
3126    pub item: Span,
3127    pub keyword: &'a str,
3128    pub kw_str: Cow<'a, str>,
3129}
3130
3131#[derive(Diagnostic)]
3132#[diag(parse_function_body_equals_expr)]
3133pub(crate) struct FunctionBodyEqualsExpr {
3134    #[primary_span]
3135    pub span: Span,
3136    #[subdiagnostic]
3137    pub sugg: FunctionBodyEqualsExprSugg,
3138}
3139
3140#[derive(Subdiagnostic)]
3141#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3142pub(crate) struct FunctionBodyEqualsExprSugg {
3143    #[suggestion_part(code = "{{")]
3144    pub eq: Span,
3145    #[suggestion_part(code = " }}")]
3146    pub semi: Span,
3147}
3148
3149#[derive(Diagnostic)]
3150#[diag(parse_box_not_pat)]
3151pub(crate) struct BoxNotPat {
3152    #[primary_span]
3153    pub span: Span,
3154    #[note]
3155    pub kw: Span,
3156    #[suggestion(code = "r#", applicability = "maybe-incorrect", style = "verbose")]
3157    pub lo: Span,
3158    pub descr: String,
3159}
3160
3161#[derive(Diagnostic)]
3162#[diag(parse_unmatched_angle)]
3163pub(crate) struct UnmatchedAngle {
3164    #[primary_span]
3165    #[suggestion(code = "", applicability = "machine-applicable", style = "verbose")]
3166    pub span: Span,
3167    pub plural: bool,
3168}
3169
3170#[derive(Diagnostic)]
3171#[diag(parse_missing_plus_in_bounds)]
3172pub(crate) struct MissingPlusBounds {
3173    #[primary_span]
3174    pub span: Span,
3175    #[suggestion(code = " +", applicability = "maybe-incorrect", style = "verbose")]
3176    pub hi: Span,
3177    pub sym: Symbol,
3178}
3179
3180#[derive(Diagnostic)]
3181#[diag(parse_incorrect_parens_trait_bounds)]
3182pub(crate) struct IncorrectParensTraitBounds {
3183    #[primary_span]
3184    pub span: Vec<Span>,
3185    #[subdiagnostic]
3186    pub sugg: IncorrectParensTraitBoundsSugg,
3187}
3188
3189#[derive(Subdiagnostic)]
3190#[multipart_suggestion(
3191    parse_incorrect_parens_trait_bounds_sugg,
3192    applicability = "machine-applicable"
3193)]
3194pub(crate) struct IncorrectParensTraitBoundsSugg {
3195    #[suggestion_part(code = " ")]
3196    pub wrong_span: Span,
3197    #[suggestion_part(code = "(")]
3198    pub new_span: Span,
3199}
3200
3201#[derive(Diagnostic)]
3202#[diag(parse_kw_bad_case)]
3203pub(crate) struct KwBadCase<'a> {
3204    #[primary_span]
3205    #[suggestion(code = "{kw}", style = "verbose", applicability = "machine-applicable")]
3206    pub span: Span,
3207    pub kw: &'a str,
3208}
3209
3210#[derive(Diagnostic)]
3211#[diag(parse_meta_bad_delim)]
3212pub(crate) struct MetaBadDelim {
3213    #[primary_span]
3214    pub span: Span,
3215    #[subdiagnostic]
3216    pub sugg: MetaBadDelimSugg,
3217}
3218
3219#[derive(Diagnostic)]
3220#[diag(parse_cfg_attr_bad_delim)]
3221pub(crate) struct CfgAttrBadDelim {
3222    #[primary_span]
3223    pub span: Span,
3224    #[subdiagnostic]
3225    pub sugg: MetaBadDelimSugg,
3226}
3227
3228#[derive(Subdiagnostic)]
3229#[multipart_suggestion(parse_meta_bad_delim_suggestion, applicability = "machine-applicable")]
3230pub(crate) struct MetaBadDelimSugg {
3231    #[suggestion_part(code = "(")]
3232    pub open: Span,
3233    #[suggestion_part(code = ")")]
3234    pub close: Span,
3235}
3236
3237#[derive(Diagnostic)]
3238#[diag(parse_malformed_cfg_attr)]
3239#[note]
3240pub(crate) struct MalformedCfgAttr {
3241    #[primary_span]
3242    #[suggestion(style = "verbose", code = "{sugg}")]
3243    pub span: Span,
3244    pub sugg: &'static str,
3245}
3246
3247#[derive(Diagnostic)]
3248#[diag(parse_unknown_builtin_construct)]
3249pub(crate) struct UnknownBuiltinConstruct {
3250    #[primary_span]
3251    pub span: Span,
3252    pub name: Ident,
3253}
3254
3255#[derive(Diagnostic)]
3256#[diag(parse_expected_builtin_ident)]
3257pub(crate) struct ExpectedBuiltinIdent {
3258    #[primary_span]
3259    pub span: Span,
3260}
3261
3262#[derive(Diagnostic)]
3263#[diag(parse_static_with_generics)]
3264pub(crate) struct StaticWithGenerics {
3265    #[primary_span]
3266    pub span: Span,
3267}
3268
3269#[derive(Diagnostic)]
3270#[diag(parse_where_clause_before_const_body)]
3271pub(crate) struct WhereClauseBeforeConstBody {
3272    #[primary_span]
3273    #[label]
3274    pub span: Span,
3275    #[label(parse_name_label)]
3276    pub name: Span,
3277    #[label(parse_body_label)]
3278    pub body: Span,
3279    #[subdiagnostic]
3280    pub sugg: Option<WhereClauseBeforeConstBodySugg>,
3281}
3282
3283#[derive(Subdiagnostic)]
3284#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3285pub(crate) struct WhereClauseBeforeConstBodySugg {
3286    #[suggestion_part(code = "= {snippet} ")]
3287    pub left: Span,
3288    pub snippet: String,
3289    #[suggestion_part(code = "")]
3290    pub right: Span,
3291}
3292
3293#[derive(Diagnostic)]
3294#[diag(parse_generic_args_in_pat_require_turbofish_syntax)]
3295pub(crate) struct GenericArgsInPatRequireTurbofishSyntax {
3296    #[primary_span]
3297    pub span: Span,
3298    #[suggestion(
3299        parse_sugg_turbofish_syntax,
3300        style = "verbose",
3301        code = "::",
3302        applicability = "maybe-incorrect"
3303    )]
3304    pub suggest_turbofish: Span,
3305}
3306
3307#[derive(Diagnostic)]
3308#[diag(parse_transpose_dyn_or_impl)]
3309pub(crate) struct TransposeDynOrImpl<'a> {
3310    #[primary_span]
3311    pub span: Span,
3312    pub kw: &'a str,
3313    #[subdiagnostic]
3314    pub sugg: TransposeDynOrImplSugg<'a>,
3315}
3316
3317#[derive(Subdiagnostic)]
3318#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3319pub(crate) struct TransposeDynOrImplSugg<'a> {
3320    #[suggestion_part(code = "")]
3321    pub removal_span: Span,
3322    #[suggestion_part(code = "{kw} ")]
3323    pub insertion_span: Span,
3324    pub kw: &'a str,
3325}
3326
3327#[derive(Diagnostic)]
3328#[diag(parse_array_index_offset_of)]
3329pub(crate) struct ArrayIndexInOffsetOf(#[primary_span] pub Span);
3330
3331#[derive(Diagnostic)]
3332#[diag(parse_invalid_offset_of)]
3333pub(crate) struct InvalidOffsetOf(#[primary_span] pub Span);
3334
3335#[derive(Diagnostic)]
3336#[diag(parse_async_impl)]
3337pub(crate) struct AsyncImpl {
3338    #[primary_span]
3339    pub span: Span,
3340}
3341
3342#[derive(Diagnostic)]
3343#[diag(parse_expr_rarrow_call)]
3344#[help]
3345pub(crate) struct ExprRArrowCall {
3346    #[primary_span]
3347    #[suggestion(style = "verbose", applicability = "machine-applicable", code = ".")]
3348    pub span: Span,
3349}
3350
3351#[derive(Diagnostic)]
3352#[diag(parse_dot_dot_range_attribute)]
3353pub(crate) struct DotDotRangeAttribute {
3354    #[primary_span]
3355    pub span: Span,
3356}
3357
3358#[derive(Diagnostic)]
3359#[diag(parse_invalid_attr_unsafe)]
3360#[note]
3361pub(crate) struct InvalidAttrUnsafe {
3362    #[primary_span]
3363    #[label]
3364    pub span: Span,
3365    pub name: Path,
3366}
3367
3368#[derive(Diagnostic)]
3369#[diag(parse_unsafe_attr_outside_unsafe)]
3370pub(crate) struct UnsafeAttrOutsideUnsafe {
3371    #[primary_span]
3372    #[label]
3373    pub span: Span,
3374    #[subdiagnostic]
3375    pub suggestion: UnsafeAttrOutsideUnsafeSuggestion,
3376}
3377
3378#[derive(Subdiagnostic)]
3379#[multipart_suggestion(
3380    parse_unsafe_attr_outside_unsafe_suggestion,
3381    applicability = "machine-applicable"
3382)]
3383pub(crate) struct UnsafeAttrOutsideUnsafeSuggestion {
3384    #[suggestion_part(code = "unsafe(")]
3385    pub left: Span,
3386    #[suggestion_part(code = ")")]
3387    pub right: Span,
3388}
3389
3390#[derive(Diagnostic)]
3391#[diag(parse_binder_before_modifiers)]
3392pub(crate) struct BinderBeforeModifiers {
3393    #[primary_span]
3394    pub binder_span: Span,
3395    #[label]
3396    pub modifiers_span: Span,
3397}
3398
3399#[derive(Diagnostic)]
3400#[diag(parse_binder_and_polarity)]
3401pub(crate) struct BinderAndPolarity {
3402    #[primary_span]
3403    pub polarity_span: Span,
3404    #[label]
3405    pub binder_span: Span,
3406    pub polarity: &'static str,
3407}
3408
3409#[derive(Diagnostic)]
3410#[diag(parse_modifiers_and_polarity)]
3411pub(crate) struct PolarityAndModifiers {
3412    #[primary_span]
3413    pub polarity_span: Span,
3414    #[label]
3415    pub modifiers_span: Span,
3416    pub polarity: &'static str,
3417    pub modifiers_concatenated: String,
3418}
3419
3420#[derive(Diagnostic)]
3421#[diag(parse_incorrect_type_on_self)]
3422pub(crate) struct IncorrectTypeOnSelf {
3423    #[primary_span]
3424    pub span: Span,
3425    #[subdiagnostic]
3426    pub move_self_modifier: MoveSelfModifier,
3427}
3428
3429#[derive(Subdiagnostic)]
3430#[multipart_suggestion(parse_suggestion, applicability = "machine-applicable")]
3431pub(crate) struct MoveSelfModifier {
3432    #[suggestion_part(code = "")]
3433    pub removal_span: Span,
3434    #[suggestion_part(code = "{modifier}")]
3435    pub insertion_span: Span,
3436    pub modifier: String,
3437}