1 use rustc_ast::token::Token;
3 use rustc_errors::{fluent, AddToDiagnostic, Applicability, EmissionGuarantee, IntoDiagnostic};
4 use rustc_macros::{Diagnostic, Subdiagnostic};
5 use rustc_session::errors::ExprParenthesesNeeded;
6 use rustc_span::symbol::Ident;
7 use rustc_span::{Span, Symbol};
9 use crate::parser::TokenDescription;
12 #[diag(parser::maybe_report_ambiguous_plus)]
13 pub(crate) struct AmbiguousPlus {
16 #[suggestion(code = "({sum_ty})")]
21 #[diag(parser::maybe_recover_from_bad_type_plus, code = "E0178")]
22 pub(crate) struct BadTypePlus {
27 pub sub: BadTypePlusSub,
30 #[derive(Subdiagnostic)]
31 pub(crate) enum BadTypePlusSub {
34 code = "{sum_with_parens}",
35 applicability = "machine-applicable"
38 sum_with_parens: String,
42 #[label(parser::forgot_paren)]
47 #[label(parser::expect_path)]
55 #[diag(parser::maybe_recover_from_bad_qpath_stage_2)]
56 pub(crate) struct BadQPathStage2 {
58 #[suggestion(code = "", applicability = "maybe-incorrect")]
64 #[diag(parser::incorrect_semicolon)]
65 pub(crate) struct IncorrectSemicolon<'a> {
67 #[suggestion_short(code = "", applicability = "machine-applicable")]
70 pub opt_help: Option<()>,
75 #[diag(parser::incorrect_use_of_await)]
76 pub(crate) struct IncorrectUseOfAwait {
78 #[suggestion(parser::parentheses_suggestion, code = "", applicability = "machine-applicable")]
83 #[diag(parser::incorrect_use_of_await)]
84 pub(crate) struct IncorrectAwait {
87 #[suggestion(parser::postfix_suggestion, code = "{expr}.await{question_mark}")]
88 pub sugg_span: (Span, Applicability),
90 pub question_mark: &'static str,
94 #[diag(parser::in_in_typo)]
95 pub(crate) struct InInTypo {
98 #[suggestion(code = "", applicability = "machine-applicable")]
102 #[derive(Diagnostic)]
103 #[diag(parser::invalid_variable_declaration)]
104 pub(crate) struct InvalidVariableDeclaration {
108 pub sub: InvalidVariableDeclarationSub,
111 #[derive(Subdiagnostic)]
112 pub(crate) enum InvalidVariableDeclarationSub {
114 parser::switch_mut_let_order,
115 applicability = "maybe-incorrect",
118 SwitchMutLetOrder(#[primary_span] Span),
120 parser::missing_let_before_mut,
121 applicability = "machine-applicable",
124 MissingLet(#[primary_span] Span),
125 #[suggestion(parser::use_let_not_auto, applicability = "machine-applicable", code = "let")]
126 UseLetNotAuto(#[primary_span] Span),
127 #[suggestion(parser::use_let_not_var, applicability = "machine-applicable", code = "let")]
128 UseLetNotVar(#[primary_span] Span),
131 #[derive(Diagnostic)]
132 #[diag(parser::invalid_comparison_operator)]
133 pub(crate) struct InvalidComparisonOperator {
138 pub sub: InvalidComparisonOperatorSub,
141 #[derive(Subdiagnostic)]
142 pub(crate) enum InvalidComparisonOperatorSub {
145 applicability = "machine-applicable",
154 #[label(parser::spaceship_operator_invalid)]
155 Spaceship(#[primary_span] Span),
158 #[derive(Diagnostic)]
159 #[diag(parser::invalid_logical_operator)]
161 pub(crate) struct InvalidLogicalOperator {
164 pub incorrect: String,
166 pub sub: InvalidLogicalOperatorSub,
169 #[derive(Subdiagnostic)]
170 pub(crate) enum InvalidLogicalOperatorSub {
172 parser::use_amp_amp_for_conjunction,
173 applicability = "machine-applicable",
176 Conjunction(#[primary_span] Span),
178 parser::use_pipe_pipe_for_disjunction,
179 applicability = "machine-applicable",
182 Disjunction(#[primary_span] Span),
185 #[derive(Diagnostic)]
186 #[diag(parser::tilde_is_not_unary_operator)]
187 pub(crate) struct TildeAsUnaryOperator(
189 #[suggestion_short(applicability = "machine-applicable", code = "!")]
193 #[derive(Diagnostic)]
194 #[diag(parser::unexpected_token_after_not)]
195 pub(crate) struct NotAsNegationOperator {
198 pub negated_desc: String,
200 pub sub: NotAsNegationOperatorSub,
203 #[derive(Subdiagnostic)]
204 pub enum NotAsNegationOperatorSub {
206 parser::unexpected_token_after_not_default,
207 applicability = "machine-applicable",
210 SuggestNotDefault(#[primary_span] Span),
213 parser::unexpected_token_after_not_bitwise,
214 applicability = "machine-applicable",
217 SuggestNotBitwise(#[primary_span] Span),
220 parser::unexpected_token_after_not_logical,
221 applicability = "machine-applicable",
224 SuggestNotLogical(#[primary_span] Span),
227 #[derive(Diagnostic)]
228 #[diag(parser::malformed_loop_label)]
229 pub(crate) struct MalformedLoopLabel {
231 #[suggestion(applicability = "machine-applicable", code = "{correct_label}")]
233 pub correct_label: Ident,
236 #[derive(Diagnostic)]
237 #[diag(parser::lifetime_in_borrow_expression)]
238 pub(crate) struct LifetimeInBorrowExpression {
241 #[suggestion(applicability = "machine-applicable", code = "")]
243 pub lifetime_span: Span,
246 #[derive(Diagnostic)]
247 #[diag(parser::field_expression_with_generic)]
248 pub(crate) struct FieldExpressionWithGeneric(#[primary_span] pub Span);
250 #[derive(Diagnostic)]
251 #[diag(parser::macro_invocation_with_qualified_path)]
252 pub(crate) struct MacroInvocationWithQualifiedPath(#[primary_span] pub Span);
254 #[derive(Diagnostic)]
255 #[diag(parser::unexpected_token_after_label)]
256 pub(crate) struct UnexpectedTokenAfterLabel {
258 #[label(parser::unexpected_token_after_label)]
260 #[suggestion_verbose(parser::suggestion_remove_label, code = "")]
261 pub remove_label: Option<Span>,
263 pub enclose_in_block: Option<UnexpectedTokenAfterLabelSugg>,
266 #[derive(Subdiagnostic)]
267 #[multipart_suggestion(parser::suggestion_enclose_in_block, applicability = "machine-applicable")]
268 pub(crate) struct UnexpectedTokenAfterLabelSugg {
269 #[suggestion_part(code = "{{ ")]
271 #[suggestion_part(code = " }}")]
275 #[derive(Diagnostic)]
276 #[diag(parser::require_colon_after_labeled_expression)]
278 pub(crate) struct RequireColonAfterLabeledExpression {
283 #[suggestion_short(applicability = "machine-applicable", code = ": ")]
287 #[derive(Diagnostic)]
288 #[diag(parser::do_catch_syntax_removed)]
290 pub(crate) struct DoCatchSyntaxRemoved {
292 #[suggestion(applicability = "machine-applicable", code = "try")]
296 #[derive(Diagnostic)]
297 #[diag(parser::float_literal_requires_integer_part)]
298 pub(crate) struct FloatLiteralRequiresIntegerPart {
300 #[suggestion(applicability = "machine-applicable", code = "{correct}")]
305 #[derive(Diagnostic)]
306 #[diag(parser::invalid_int_literal_width)]
308 pub(crate) struct InvalidIntLiteralWidth {
314 #[derive(Diagnostic)]
315 #[diag(parser::invalid_num_literal_base_prefix)]
317 pub(crate) struct InvalidNumLiteralBasePrefix {
319 #[suggestion(applicability = "maybe-incorrect", code = "{fixed}")]
324 #[derive(Diagnostic)]
325 #[diag(parser::invalid_num_literal_suffix)]
327 pub(crate) struct InvalidNumLiteralSuffix {
334 #[derive(Diagnostic)]
335 #[diag(parser::invalid_float_literal_width)]
337 pub(crate) struct InvalidFloatLiteralWidth {
343 #[derive(Diagnostic)]
344 #[diag(parser::invalid_float_literal_suffix)]
346 pub(crate) struct InvalidFloatLiteralSuffix {
353 #[derive(Diagnostic)]
354 #[diag(parser::int_literal_too_large)]
355 pub(crate) struct IntLiteralTooLarge {
360 #[derive(Diagnostic)]
361 #[diag(parser::missing_semicolon_before_array)]
362 pub(crate) struct MissingSemicolonBeforeArray {
364 pub open_delim: Span,
365 #[suggestion_verbose(applicability = "maybe-incorrect", code = ";")]
369 #[derive(Diagnostic)]
370 #[diag(parser::invalid_block_macro_segment)]
371 pub(crate) struct InvalidBlockMacroSegment {
378 #[derive(Diagnostic)]
379 #[diag(parser::if_expression_missing_then_block)]
380 pub(crate) struct IfExpressionMissingThenBlock {
384 pub sub: IfExpressionMissingThenBlockSub,
387 #[derive(Subdiagnostic)]
388 pub(crate) enum IfExpressionMissingThenBlockSub {
389 #[help(parser::condition_possibly_unfinished)]
390 UnfinishedCondition(#[primary_span] Span),
391 #[help(parser::add_then_block)]
392 AddThenBlock(#[primary_span] Span),
395 #[derive(Diagnostic)]
396 #[diag(parser::if_expression_missing_condition)]
397 pub(crate) struct IfExpressionMissingCondition {
399 #[label(parser::condition_label)]
401 #[label(parser::block_label)]
402 pub block_span: Span,
405 #[derive(Diagnostic)]
406 #[diag(parser::expected_expression_found_let)]
407 pub(crate) struct ExpectedExpressionFoundLet {
412 #[derive(Diagnostic)]
413 #[diag(parser::expected_else_block)]
414 pub(crate) struct ExpectedElseBlock {
416 pub first_tok_span: Span,
417 pub first_tok: String,
420 #[suggestion(applicability = "maybe-incorrect", code = "if ")]
421 pub condition_start: Span,
424 #[derive(Diagnostic)]
425 #[diag(parser::outer_attribute_not_allowed_on_if_else)]
426 pub(crate) struct OuterAttributeNotAllowedOnIfElse {
430 #[label(parser::branch_label)]
431 pub branch_span: Span,
433 #[label(parser::ctx_label)]
437 #[suggestion(applicability = "machine-applicable", code = "")]
438 pub attributes: Span,
441 #[derive(Diagnostic)]
442 #[diag(parser::missing_in_in_for_loop)]
443 pub(crate) struct MissingInInForLoop {
447 pub sub: MissingInInForLoopSub,
450 #[derive(Subdiagnostic)]
451 pub(crate) enum MissingInInForLoopSub {
452 // Has been misleading, at least in the past (closed Issue #48492), thus maybe-incorrect
453 #[suggestion_short(parser::use_in_not_of, applicability = "maybe-incorrect", code = "in")]
454 InNotOf(#[primary_span] Span),
455 #[suggestion_short(parser::add_in, applicability = "maybe-incorrect", code = " in ")]
456 AddIn(#[primary_span] Span),
459 #[derive(Diagnostic)]
460 #[diag(parser::missing_comma_after_match_arm)]
461 pub(crate) struct MissingCommaAfterMatchArm {
463 #[suggestion(applicability = "machine-applicable", code = ",")]
467 #[derive(Diagnostic)]
468 #[diag(parser::catch_after_try)]
470 pub(crate) struct CatchAfterTry {
475 #[derive(Diagnostic)]
476 #[diag(parser::comma_after_base_struct)]
478 pub(crate) struct CommaAfterBaseStruct {
481 #[suggestion_short(applicability = "machine-applicable", code = "")]
485 #[derive(Diagnostic)]
486 #[diag(parser::eq_field_init)]
487 pub(crate) struct EqFieldInit {
490 #[suggestion(applicability = "machine-applicable", code = ":")]
494 #[derive(Diagnostic)]
495 #[diag(parser::dotdotdot)]
496 pub(crate) struct DotDotDot {
498 #[suggestion(parser::suggest_exclusive_range, applicability = "maybe-incorrect", code = "..")]
499 #[suggestion(parser::suggest_inclusive_range, applicability = "maybe-incorrect", code = "..=")]
503 #[derive(Diagnostic)]
504 #[diag(parser::left_arrow_operator)]
505 pub(crate) struct LeftArrowOperator {
507 #[suggestion(applicability = "maybe-incorrect", code = "< -")]
511 #[derive(Diagnostic)]
512 #[diag(parser::remove_let)]
513 pub(crate) struct RemoveLet {
515 #[suggestion(applicability = "machine-applicable", code = "")]
519 #[derive(Diagnostic)]
520 #[diag(parser::use_eq_instead)]
521 pub(crate) struct UseEqInstead {
523 #[suggestion_short(applicability = "machine-applicable", code = "=")]
527 #[derive(Diagnostic)]
528 #[diag(parser::use_empty_block_not_semi)]
529 pub(crate) struct UseEmptyBlockNotSemi {
531 #[suggestion_hidden(applicability = "machine-applicable", code = "{{}}")]
535 #[derive(Diagnostic)]
536 #[diag(parser::comparison_interpreted_as_generic)]
537 pub(crate) struct ComparisonInterpretedAsGeneric {
539 #[label(parser::label_comparison)]
540 pub comparison: Span,
542 #[label(parser::label_args)]
545 pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
548 #[derive(Diagnostic)]
549 #[diag(parser::shift_interpreted_as_generic)]
550 pub(crate) struct ShiftInterpretedAsGeneric {
552 #[label(parser::label_comparison)]
555 #[label(parser::label_args)]
558 pub suggestion: ComparisonOrShiftInterpretedAsGenericSugg,
561 #[derive(Subdiagnostic)]
562 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
563 pub(crate) struct ComparisonOrShiftInterpretedAsGenericSugg {
564 #[suggestion_part(code = "(")]
566 #[suggestion_part(code = ")")]
570 #[derive(Diagnostic)]
571 #[diag(parser::found_expr_would_be_stmt)]
572 pub(crate) struct FoundExprWouldBeStmt {
578 pub suggestion: ExprParenthesesNeeded,
581 #[derive(Diagnostic)]
582 #[diag(parser::leading_plus_not_supported)]
583 pub(crate) struct LeadingPlusNotSupported {
587 #[suggestion_verbose(
588 parser::suggestion_remove_plus,
590 applicability = "machine-applicable"
592 pub remove_plus: Option<Span>,
594 pub add_parentheses: Option<ExprParenthesesNeeded>,
597 #[derive(Diagnostic)]
598 #[diag(parser::parentheses_with_struct_fields)]
599 pub(crate) struct ParenthesesWithStructFields {
604 pub braces_for_struct: BracesForStructLiteral,
606 pub no_fields_for_fn: NoFieldsForFnCall,
609 #[derive(Subdiagnostic)]
610 #[multipart_suggestion(parser::suggestion_braces_for_struct, applicability = "maybe-incorrect")]
611 pub(crate) struct BracesForStructLiteral {
612 #[suggestion_part(code = " {{ ")]
614 #[suggestion_part(code = " }}")]
618 #[derive(Subdiagnostic)]
619 #[multipart_suggestion(parser::suggestion_no_fields_for_fn, applicability = "maybe-incorrect")]
620 pub(crate) struct NoFieldsForFnCall {
621 #[suggestion_part(code = "")]
622 pub fields: Vec<Span>,
625 #[derive(Diagnostic)]
626 #[diag(parser::labeled_loop_in_break)]
627 pub(crate) struct LabeledLoopInBreak {
631 pub sub: WrapExpressionInParentheses,
634 #[derive(Subdiagnostic)]
635 #[multipart_suggestion(
636 parser::sugg_wrap_expression_in_parentheses,
637 applicability = "machine-applicable"
639 pub(crate) struct WrapExpressionInParentheses {
640 #[suggestion_part(code = "(")]
642 #[suggestion_part(code = ")")]
646 #[derive(Diagnostic)]
647 #[diag(parser::array_brackets_instead_of_braces)]
648 pub(crate) struct ArrayBracketsInsteadOfSpaces {
652 pub sub: ArrayBracketsInsteadOfSpacesSugg,
655 #[derive(Subdiagnostic)]
656 #[multipart_suggestion(parser::suggestion, applicability = "maybe-incorrect")]
657 pub(crate) struct ArrayBracketsInsteadOfSpacesSugg {
658 #[suggestion_part(code = "[")]
660 #[suggestion_part(code = "]")]
664 #[derive(Diagnostic)]
665 #[diag(parser::match_arm_body_without_braces)]
666 pub(crate) struct MatchArmBodyWithoutBraces {
668 #[label(parser::label_statements)]
669 pub statements: Span,
670 #[label(parser::label_arrow)]
672 pub num_statements: usize,
674 pub sub: MatchArmBodyWithoutBracesSugg,
677 #[derive(Subdiagnostic)]
678 pub(crate) enum MatchArmBodyWithoutBracesSugg {
679 #[multipart_suggestion(parser::suggestion_add_braces, applicability = "machine-applicable")]
681 #[suggestion_part(code = "{{ ")]
683 #[suggestion_part(code = " }}")]
687 parser::suggestion_use_comma_not_semicolon,
689 applicability = "machine-applicable"
697 #[derive(Diagnostic)]
698 #[diag(parser::struct_literal_not_allowed_here)]
699 pub(crate) struct StructLiteralNotAllowedHere {
703 pub sub: StructLiteralNotAllowedHereSugg,
706 #[derive(Subdiagnostic)]
707 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
708 pub(crate) struct StructLiteralNotAllowedHereSugg {
709 #[suggestion_part(code = "(")]
711 #[suggestion_part(code = ")")]
715 #[derive(Diagnostic)]
716 #[diag(parser::invalid_interpolated_expression)]
717 pub(crate) struct InvalidInterpolatedExpression {
722 #[derive(Diagnostic)]
723 #[diag(parser::hexadecimal_float_literal_not_supported)]
724 pub(crate) struct HexadecimalFloatLiteralNotSupported {
726 #[label(parser::not_supported)]
730 #[derive(Diagnostic)]
731 #[diag(parser::octal_float_literal_not_supported)]
732 pub(crate) struct OctalFloatLiteralNotSupported {
734 #[label(parser::not_supported)]
738 #[derive(Diagnostic)]
739 #[diag(parser::binary_float_literal_not_supported)]
740 pub(crate) struct BinaryFloatLiteralNotSupported {
742 #[label(parser::not_supported)]
746 #[derive(Diagnostic)]
747 #[diag(parser::invalid_literal_suffix)]
748 pub(crate) struct InvalidLiteralSuffix {
757 #[derive(Diagnostic)]
758 #[diag(parser::invalid_literal_suffix_on_tuple_index)]
759 pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
764 #[help(parser::tuple_exception_line_1)]
765 #[help(parser::tuple_exception_line_2)]
766 #[help(parser::tuple_exception_line_3)]
767 pub exception: Option<()>,
770 #[derive(Diagnostic)]
771 #[diag(parser::non_string_abi_literal)]
772 pub(crate) struct NonStringAbiLiteral {
774 #[suggestion(code = "\"C\"", applicability = "maybe-incorrect")]
778 #[derive(Diagnostic)]
779 #[diag(parser::mismatched_closing_delimiter)]
780 pub(crate) struct MismatchedClosingDelimiter {
782 pub spans: Vec<Span>,
783 pub delimiter: String,
784 #[label(parser::label_unmatched)]
786 #[label(parser::label_opening_candidate)]
787 pub opening_candidate: Option<Span>,
788 #[label(parser::label_unclosed)]
789 pub unclosed: Option<Span>,
792 #[derive(Diagnostic)]
793 #[diag(parser::incorrect_visibility_restriction, code = "E0704")]
795 pub(crate) struct IncorrectVisibilityRestriction {
797 #[suggestion(code = "in {inner_str}", applicability = "machine-applicable")]
799 pub inner_str: String,
802 #[derive(Diagnostic)]
803 #[diag(parser::assignment_else_not_allowed)]
804 pub(crate) struct AssignmentElseNotAllowed {
809 #[derive(Diagnostic)]
810 #[diag(parser::expected_statement_after_outer_attr)]
811 pub(crate) struct ExpectedStatementAfterOuterAttr {
816 #[derive(Diagnostic)]
817 #[diag(parser::doc_comment_does_not_document_anything, code = "E0585")]
819 pub(crate) struct DocCommentDoesNotDocumentAnything {
822 #[suggestion(code = ",", applicability = "machine-applicable")]
823 pub missing_comma: Option<Span>,
826 #[derive(Diagnostic)]
827 #[diag(parser::const_let_mutually_exclusive)]
828 pub(crate) struct ConstLetMutuallyExclusive {
830 #[suggestion(code = "const", applicability = "maybe-incorrect")]
834 #[derive(Diagnostic)]
835 #[diag(parser::invalid_expression_in_let_else)]
836 pub(crate) struct InvalidExpressionInLetElse {
839 pub operator: &'static str,
841 pub sugg: WrapExpressionInParentheses,
844 #[derive(Diagnostic)]
845 #[diag(parser::invalid_curly_in_let_else)]
846 pub(crate) struct InvalidCurlyInLetElse {
850 pub sugg: WrapExpressionInParentheses,
853 #[derive(Diagnostic)]
854 #[diag(parser::compound_assignment_expression_in_let)]
856 pub(crate) struct CompoundAssignmentExpressionInLet {
858 #[suggestion_short(code = "=", applicability = "maybe-incorrect")]
862 #[derive(Diagnostic)]
863 #[diag(parser::suffixed_literal_in_attribute)]
865 pub(crate) struct SuffixedLiteralInAttribute {
870 #[derive(Diagnostic)]
871 #[diag(parser::invalid_meta_item)]
872 pub(crate) struct InvalidMetaItem {
878 #[derive(Subdiagnostic)]
879 #[suggestion_verbose(
880 parser::sugg_escape_to_use_as_identifier,
881 applicability = "maybe-incorrect",
884 pub(crate) struct SuggEscapeToUseAsIdentifier {
887 pub ident_name: String,
890 #[derive(Subdiagnostic)]
891 #[suggestion(parser::sugg_remove_comma, applicability = "machine-applicable", code = "")]
892 pub(crate) struct SuggRemoveComma {
897 #[derive(Subdiagnostic)]
898 pub(crate) enum ExpectedIdentifierFound {
899 #[label(parser::expected_identifier_found_reserved_identifier)]
900 ReservedIdentifier(#[primary_span] Span),
901 #[label(parser::expected_identifier_found_keyword)]
902 Keyword(#[primary_span] Span),
903 #[label(parser::expected_identifier_found_reserved_keyword)]
904 ReservedKeyword(#[primary_span] Span),
905 #[label(parser::expected_identifier_found_doc_comment)]
906 DocComment(#[primary_span] Span),
907 #[label(parser::expected_identifier)]
908 Other(#[primary_span] Span),
911 impl ExpectedIdentifierFound {
912 pub fn new(token_descr: Option<TokenDescription>, span: Span) -> Self {
914 Some(TokenDescription::ReservedIdentifier) => {
915 ExpectedIdentifierFound::ReservedIdentifier
917 Some(TokenDescription::Keyword) => ExpectedIdentifierFound::Keyword,
918 Some(TokenDescription::ReservedKeyword) => ExpectedIdentifierFound::ReservedKeyword,
919 Some(TokenDescription::DocComment) => ExpectedIdentifierFound::DocComment,
920 None => ExpectedIdentifierFound::Other,
925 pub(crate) struct ExpectedIdentifier {
928 pub suggest_raw: Option<SuggEscapeToUseAsIdentifier>,
929 pub suggest_remove_comma: Option<SuggRemoveComma>,
932 impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedIdentifier {
935 handler: &'a rustc_errors::Handler,
936 ) -> rustc_errors::DiagnosticBuilder<'a, G> {
937 let token_descr = super::parser::TokenDescription::from_token(&self.token);
939 let mut diag = handler.struct_diagnostic(match token_descr {
940 Some(TokenDescription::ReservedIdentifier) => {
941 fluent::parser::expected_identifier_found_reserved_identifier_str
943 Some(TokenDescription::Keyword) => {
944 fluent::parser::expected_identifier_found_keyword_str
946 Some(TokenDescription::ReservedKeyword) => {
947 fluent::parser::expected_identifier_found_reserved_keyword_str
949 Some(TokenDescription::DocComment) => {
950 fluent::parser::expected_identifier_found_doc_comment_str
952 None => fluent::parser::expected_identifier_found_str,
954 diag.set_span(self.span);
955 diag.set_arg("token", self.token);
957 if let Some(sugg) = self.suggest_raw {
958 sugg.add_to_diagnostic(&mut diag);
961 ExpectedIdentifierFound::new(token_descr, self.span).add_to_diagnostic(&mut diag);
963 if let Some(sugg) = self.suggest_remove_comma {
964 sugg.add_to_diagnostic(&mut diag);
971 pub(crate) struct ExpectedSemi {
975 pub unexpected_token_label: Option<Span>,
976 pub sugg: ExpectedSemiSugg,
979 impl<'a, G: EmissionGuarantee> IntoDiagnostic<'a, G> for ExpectedSemi {
982 handler: &'a rustc_errors::Handler,
983 ) -> rustc_errors::DiagnosticBuilder<'a, G> {
984 let token_descr = super::parser::TokenDescription::from_token(&self.token);
986 let mut diag = handler.struct_diagnostic(match token_descr {
987 Some(TokenDescription::ReservedIdentifier) => {
988 fluent::parser::expected_semi_found_reserved_identifier_str
990 Some(TokenDescription::Keyword) => fluent::parser::expected_semi_found_keyword_str,
991 Some(TokenDescription::ReservedKeyword) => {
992 fluent::parser::expected_semi_found_reserved_keyword_str
994 Some(TokenDescription::DocComment) => {
995 fluent::parser::expected_semi_found_doc_comment_str
997 None => fluent::parser::expected_semi_found_str,
999 diag.set_span(self.span);
1000 diag.set_arg("token", self.token);
1002 if let Some(unexpected_token_label) = self.unexpected_token_label {
1003 diag.span_label(unexpected_token_label, fluent::parser::label_unexpected_token);
1006 self.sugg.add_to_diagnostic(&mut diag);
1012 #[derive(Subdiagnostic)]
1013 pub(crate) enum ExpectedSemiSugg {
1015 parser::sugg_change_this_to_semi,
1017 applicability = "machine-applicable"
1019 ChangeToSemi(#[primary_span] Span),
1020 #[suggestion_short(parser::sugg_add_semi, code = ";", applicability = "machine-applicable")]
1021 AddSemi(#[primary_span] Span),
1024 #[derive(Diagnostic)]
1025 #[diag(parser::struct_literal_body_without_path)]
1026 pub(crate) struct StructLiteralBodyWithoutPath {
1030 pub sugg: StructLiteralBodyWithoutPathSugg,
1033 #[derive(Subdiagnostic)]
1034 #[multipart_suggestion(parser::suggestion, applicability = "has-placeholders")]
1035 pub(crate) struct StructLiteralBodyWithoutPathSugg {
1036 #[suggestion_part(code = "{{ SomeStruct ")]
1038 #[suggestion_part(code = " }}")]
1042 #[derive(Diagnostic)]
1043 #[diag(parser::unmatched_angle_brackets)]
1044 pub(crate) struct UnmatchedAngleBrackets {
1046 #[suggestion(code = "", applicability = "machine-applicable")]
1048 pub num_extra_brackets: usize,
1051 #[derive(Diagnostic)]
1052 #[diag(parser::generic_parameters_without_angle_brackets)]
1053 pub(crate) struct GenericParamsWithoutAngleBrackets {
1057 pub sugg: GenericParamsWithoutAngleBracketsSugg,
1060 #[derive(Subdiagnostic)]
1061 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1062 pub(crate) struct GenericParamsWithoutAngleBracketsSugg {
1063 #[suggestion_part(code = "<")]
1065 #[suggestion_part(code = ">")]
1069 #[derive(Diagnostic)]
1070 #[diag(parser::comparison_operators_cannot_be_chained)]
1071 pub(crate) struct ComparisonOperatorsCannotBeChained {
1073 pub span: Vec<Span>,
1074 #[suggestion_verbose(
1075 parser::sugg_turbofish_syntax,
1077 applicability = "maybe-incorrect"
1079 pub suggest_turbofish: Option<Span>,
1080 #[help(parser::sugg_turbofish_syntax)]
1081 #[help(parser::sugg_parentheses_for_function_args)]
1082 pub help_turbofish: Option<()>,
1084 pub chaining_sugg: Option<ComparisonOperatorsCannotBeChainedSugg>,
1087 #[derive(Subdiagnostic)]
1088 pub(crate) enum ComparisonOperatorsCannotBeChainedSugg {
1089 #[suggestion_verbose(
1090 parser::sugg_split_comparison,
1091 code = " && {middle_term}",
1092 applicability = "maybe-incorrect"
1097 middle_term: String,
1099 #[multipart_suggestion(parser::sugg_parenthesize, applicability = "maybe-incorrect")]
1101 #[suggestion_part(code = "(")]
1103 #[suggestion_part(code = ")")]
1108 #[derive(Diagnostic)]
1109 #[diag(parser::question_mark_in_type)]
1110 pub(crate) struct QuestionMarkInType {
1115 pub sugg: QuestionMarkInTypeSugg,
1118 #[derive(Subdiagnostic)]
1119 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1120 pub(crate) struct QuestionMarkInTypeSugg {
1121 #[suggestion_part(code = "Option<")]
1123 #[suggestion_part(code = ">")]
1127 #[derive(Diagnostic)]
1128 #[diag(parser::unexpected_parentheses_in_for_head)]
1129 pub(crate) struct ParenthesesInForHead {
1131 pub span: Vec<Span>,
1133 pub sugg: ParenthesesInForHeadSugg,
1136 #[derive(Subdiagnostic)]
1137 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1138 pub(crate) struct ParenthesesInForHeadSugg {
1139 #[suggestion_part(code = "")]
1141 #[suggestion_part(code = "")]
1145 #[derive(Diagnostic)]
1146 #[diag(parser::doc_comment_on_param_type)]
1147 pub(crate) struct DocCommentOnParamType {
1153 #[derive(Diagnostic)]
1154 #[diag(parser::attribute_on_param_type)]
1155 pub(crate) struct AttributeOnParamType {
1161 #[derive(Diagnostic)]
1162 #[diag(parser::pattern_method_param_without_body, code = "E0642")]
1163 pub(crate) struct PatternMethodParamWithoutBody {
1165 #[suggestion(code = "_", applicability = "machine-applicable")]
1169 #[derive(Diagnostic)]
1170 #[diag(parser::self_param_not_first)]
1171 pub(crate) struct SelfParamNotFirst {
1177 #[derive(Diagnostic)]
1178 #[diag(parser::const_generic_without_braces)]
1179 pub(crate) struct ConstGenericWithoutBraces {
1183 pub sugg: ConstGenericWithoutBracesSugg,
1186 #[derive(Subdiagnostic)]
1187 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1188 pub(crate) struct ConstGenericWithoutBracesSugg {
1189 #[suggestion_part(code = "{{ ")]
1191 #[suggestion_part(code = " }}")]
1195 #[derive(Diagnostic)]
1196 #[diag(parser::unexpected_const_param_declaration)]
1197 pub(crate) struct UnexpectedConstParamDeclaration {
1202 pub sugg: Option<UnexpectedConstParamDeclarationSugg>,
1205 #[derive(Subdiagnostic)]
1206 pub(crate) enum UnexpectedConstParamDeclarationSugg {
1207 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1209 #[suggestion_part(code = "<{snippet}>")]
1210 impl_generics: Span,
1211 #[suggestion_part(code = "{ident}")]
1212 incorrect_decl: Span,
1216 #[multipart_suggestion(parser::suggestion, applicability = "machine-applicable")]
1218 #[suggestion_part(code = ", {snippet}")]
1219 impl_generics_end: Span,
1220 #[suggestion_part(code = "{ident}")]
1221 incorrect_decl: Span,
1227 #[derive(Diagnostic)]
1228 #[diag(parser::unexpected_const_in_generic_param)]
1229 pub(crate) struct UnexpectedConstInGenericParam {
1232 #[suggestion_verbose(code = "", applicability = "maybe-incorrect")]
1233 pub to_remove: Option<Span>,
1236 #[derive(Diagnostic)]
1237 #[diag(parser::async_move_order_incorrect)]
1238 pub(crate) struct AsyncMoveOrderIncorrect {
1240 #[suggestion_verbose(code = "async move", applicability = "maybe-incorrect")]
1244 #[derive(Diagnostic)]
1245 #[diag(parser::double_colon_in_bound)]
1246 pub(crate) struct DoubleColonInBound {
1249 #[suggestion(code = ": ", applicability = "machine-applicable")]