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