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