Reorder diagnostics in code order, then alphabetical order

compiler/rustc_attr/src/builtin.rs

@@ -827,9 +827,6 @@ where
                                 ),
                             );
                         } else {
-                            // FIXME: This diagnostic is identical to `IncorrectMetaItem`, barring
-                            // the error code. Consider changing this to `IncorrectMetaItem`. See
-                            // #51489.
                             sess.emit_err(session_diagnostics::IncorrectMetaItem2 {
                                 span: meta.span,
                             });

compiler/rustc_attr/src/session_diagnostics.rs

@@ -3,103 +3,10 @@ use std::num::IntErrorKind;
 use rustc_errors::{error_code, fluent, Applicability, DiagnosticBuilder, ErrorGuaranteed};
 use rustc_macros::SessionDiagnostic;
 use rustc_session::{parse::ParseSess, SessionDiagnostic};
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 use crate::UnsupportedLiteralReason;
 
-#[derive(SessionDiagnostic)]
-#[error(attr::multiple_item, code = "E0538")]
-pub(crate) struct MultipleItem {
-    #[primary_span]
-    pub span: Span,
-
-    pub item: String,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::missing_since, code = "E0542")]
-pub(crate) struct MissingSince {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::non_ident_feature, code = "E0546")]
-pub(crate) struct NonIdentFeature {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::missing_feature, code = "E0546")]
-pub(crate) struct MissingFeature {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::multiple_stability_levels, code = "E0544")]
-pub(crate) struct MultipleStabilityLevels {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::invalid_meta_item, code = "E0539")]
-pub(crate) struct InvalidMetaItem {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::missing_issue, code = "E0547")]
-pub(crate) struct MissingIssue {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::rustc_promotable_pairing, code = "E0717")]
-pub(crate) struct RustcPromotablePairing {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::rustc_allowed_unstable_pairing, code = "E0789")]
-pub(crate) struct RustcAllowedUnstablePairing {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::soft_no_args)]
-pub(crate) struct SoftNoArgs {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::expected_version_literal)]
-pub(crate) struct ExpectedVersionLiteral {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[error(attr::expected_single_version_literal)]
-pub(crate) struct ExpectedSingleVersionLiteral {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(SessionDiagnostic)]
-#[warning(attr::unknown_version_literal)]
-pub(crate) struct UnknownVersionLiteral {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(SessionDiagnostic)]
 #[error(attr::expected_one_cfg_pattern, code = "E0536")]
 pub(crate) struct ExpectedOneCfgPattern {
@@ -117,21 +24,49 @@ pub(crate) struct InvalidPredicate {
 }
 
 #[derive(SessionDiagnostic)]
-#[error(attr::cfg_predicate_identifier)]
+#[error(attr::multiple_item, code = "E0538")]
-pub(crate) struct CfgPredicateIdentifier {
+pub(crate) struct MultipleItem {
+    #[primary_span]
+    pub span: Span,
+
+    pub item: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::incorrect_meta_item, code = "E0539")]
+pub(crate) struct IncorrectMetaItem {
     #[primary_span]
     pub span: Span,
 }
 
+// Error code: E0541
+pub(crate) struct UnknownMetaItem<'a> {
+    pub span: Span,
+    pub item: String,
+    pub expected: &'a [&'a str],
+}
+
+// Manual implementation to be able to format `expected` items correctly.
+impl<'a> SessionDiagnostic<'a> for UnknownMetaItem<'_> {
+    fn into_diagnostic(self, sess: &'a ParseSess) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
+        let expected = self.expected.iter().map(|name| format!("`{}`", name)).collect::<Vec<_>>();
+        let mut diag = sess.span_diagnostic.struct_span_err_with_code(
+            self.span,
+            fluent::attr::unknown_meta_item,
+            error_code!(E0541),
+        );
+        diag.set_arg("item", self.item);
+        diag.set_arg("expected", expected.join(", "));
+        diag.span_label(self.span, fluent::attr::label);
+        diag
+    }
+}
+
 #[derive(SessionDiagnostic)]
-#[error(attr::deprecated_item_suggestion)]
+#[error(attr::missing_since, code = "E0542")]
-#[note]
+pub(crate) struct MissingSince {
-pub(crate) struct DeprecatedItemSuggestion {
     #[primary_span]
     pub span: Span,
-
-    #[help]
-    pub is_nightly: Option<()>,
 }
 
 #[derive(SessionDiagnostic)]
@@ -141,6 +76,13 @@ pub(crate) struct MissingNote {
     pub span: Span,
 }
 
+#[derive(SessionDiagnostic)]
+#[error(attr::multiple_stability_levels, code = "E0544")]
+pub(crate) struct MultipleStabilityLevels {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(SessionDiagnostic)]
 #[error(attr::invalid_issue_string, code = "E0545")]
 pub(crate) struct InvalidIssueString {
@@ -199,28 +141,64 @@ impl InvalidIssueStringCause {
     }
 }
 
-pub(crate) struct UnknownMetaItem<'a> {
+#[derive(SessionDiagnostic)]
+#[error(attr::missing_feature, code = "E0546")]
+pub(crate) struct MissingFeature {
+    #[primary_span]
     pub span: Span,
-    pub item: String,
-    pub expected: &'a [&'a str],
 }
 
-// Manual implementation to be able to format `expected` items correctly.
+#[derive(SessionDiagnostic)]
-impl<'a> SessionDiagnostic<'a> for UnknownMetaItem<'_> {
+#[error(attr::non_ident_feature, code = "E0546")]
-    fn into_diagnostic(self, sess: &'a ParseSess) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
+pub(crate) struct NonIdentFeature {
-        let expected = self.expected.iter().map(|name| format!("`{}`", name)).collect::<Vec<_>>();
+    #[primary_span]
-        let mut diag = sess.span_diagnostic.struct_span_err_with_code(
+    pub span: Span,
-            self.span,
-            fluent::attr::unknown_meta_item,
-            error_code!(E0541),
-        );
-        diag.set_arg("item", self.item);
-        diag.set_arg("expected", expected.join(", "));
-        diag.span_label(self.span, fluent::attr::label);
-        diag
-    }
 }
 
+#[derive(SessionDiagnostic)]
+#[error(attr::missing_issue, code = "E0547")]
+pub(crate) struct MissingIssue {
+    #[primary_span]
+    pub span: Span,
+}
+
+// FIXME: This diagnostic is identical to `IncorrectMetaItem`, barring the error code. Consider
+// changing this to `IncorrectMetaItem`. See #51489.
+#[derive(SessionDiagnostic)]
+#[error(attr::incorrect_meta_item, code = "E0551")]
+pub(crate) struct IncorrectMetaItem2 {
+    #[primary_span]
+    pub span: Span,
+}
+
+// FIXME: Why is this the same error code as `InvalidReprHintNoParen` and `InvalidReprHintNoValue`?
+// It is more similar to `IncorrectReprFormatGeneric`.
+#[derive(SessionDiagnostic)]
+#[error(attr::incorrect_repr_format_packed_one_or_zero_arg, code = "E0552")]
+pub(crate) struct IncorrectReprFormatPackedOneOrZeroArg {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::invalid_repr_hint_no_paren, code = "E0552")]
+pub(crate) struct InvalidReprHintNoParen {
+    #[primary_span]
+    pub span: Span,
+
+    pub name: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::invalid_repr_hint_no_value, code = "E0552")]
+pub(crate) struct InvalidReprHintNoValue {
+    #[primary_span]
+    pub span: Span,
+
+    pub name: String,
+}
+
+// Error code: E0565
 pub(crate) struct UnsupportedLiteral {
     pub span: Span,
     pub reason: UnsupportedLiteralReason,
@@ -256,3 +234,148 @@ impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral {
         diag
     }
 }
+#[derive(SessionDiagnostic)]
+#[error(attr::invalid_repr_align_need_arg, code = "E0589")]
+pub(crate) struct InvalidReprAlignNeedArg {
+    #[primary_span]
+    #[suggestion(code = "align(...)", applicability = "has-placeholders")]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::invalid_repr_generic, code = "E0589")]
+pub(crate) struct InvalidReprGeneric<'a> {
+    #[primary_span]
+    pub span: Span,
+
+    pub repr_arg: String,
+    pub error_part: &'a str,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::incorrect_repr_format_align_one_arg, code = "E0693")]
+pub(crate) struct IncorrectReprFormatAlignOneArg {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::incorrect_repr_format_generic, code = "E0693")]
+pub(crate) struct IncorrectReprFormatGeneric<'a> {
+    #[primary_span]
+    pub span: Span,
+
+    pub repr_arg: &'a str,
+
+    #[subdiagnostic]
+    pub cause: Option<IncorrectReprFormatGenericCause<'a>>,
+}
+
+#[derive(SessionSubdiagnostic)]
+pub(crate) enum IncorrectReprFormatGenericCause<'a> {
+    #[suggestion(attr::suggestion, code = "{name}({int})", applicability = "machine-applicable")]
+    Int {
+        #[primary_span]
+        span: Span,
+
+        #[skip_arg]
+        name: &'a str,
+
+        #[skip_arg]
+        int: u128,
+    },
+
+    #[suggestion(
+        attr::suggestion,
+        code = "{name}({symbol})",
+        applicability = "machine-applicable"
+    )]
+    Symbol {
+        #[primary_span]
+        span: Span,
+
+        #[skip_arg]
+        name: &'a str,
+
+        #[skip_arg]
+        symbol: Symbol,
+    },
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::rustc_promotable_pairing, code = "E0717")]
+pub(crate) struct RustcPromotablePairing {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::rustc_allowed_unstable_pairing, code = "E0789")]
+pub(crate) struct RustcAllowedUnstablePairing {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::cfg_predicate_identifier)]
+pub(crate) struct CfgPredicateIdentifier {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::deprecated_item_suggestion)]
+#[note]
+pub(crate) struct DeprecatedItemSuggestion {
+    #[primary_span]
+    pub span: Span,
+
+    #[help]
+    pub is_nightly: Option<()>,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::expected_single_version_literal)]
+pub(crate) struct ExpectedSingleVersionLiteral {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::expected_version_literal)]
+pub(crate) struct ExpectedVersionLiteral {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::expects_feature_list)]
+pub(crate) struct ExpectsFeatureList {
+    #[primary_span]
+    pub span: Span,
+
+    pub name: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::expects_features)]
+pub(crate) struct ExpectsFeatures {
+    #[primary_span]
+    pub span: Span,
+
+    pub name: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(attr::soft_no_args)]
+pub(crate) struct SoftNoArgs {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[warning(attr::unknown_version_literal)]
+pub(crate) struct UnknownVersionLiteral {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_error_messages/locales/en-US/attr.ftl

@@ -1,6 +1,15 @@
+attr_expected_one_cfg_pattern =
+    expected 1 cfg-pattern
+
+attr_invalid_predicate =
+    invalid predicate `{$predicate}`
+
 attr_multiple_item =
     multiple '{$item}' items
 
+attr_incorrect_meta_item =
+    incorrect meta item
+
 attr_unknown_meta_item =
     unknown meta item '{$item}'
     .label = expected one of {$expected}
@@ -8,14 +17,37 @@ attr_unknown_meta_item =
 attr_missing_since =
     missing 'since'
 
-attr_non_ident_feature =
+attr_missing_note =
-    'feature' is not an identifier
+    missing 'note'
+
+attr_multiple_stability_levels =
+    multiple stability levels
+
+attr_invalid_issue_string =
+    `issue` must be a non-zero numeric string or "none"
+    .must_not_be_zero = `issue` must not be "0", use "none" instead
+    .empty = cannot parse integer from empty string
+    .invalid_digit = invalid digit found in string
+    .pos_overflow = number too large to fit in target type
+    .neg_overflow = number too small to fit in target type
 
 attr_missing_feature =
     missing 'feature'
 
-attr_multiple_stability_levels =
+attr_non_ident_feature =
-    multiple stability levels
+    'feature' is not an identifier
+
+attr_missing_issue =
+    missing 'issue'
+
+attr_incorrect_repr_format_packed_one_or_zero_arg =
+    incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all
+
+attr_invalid_repr_hint_no_paren =
+    invalid representation hint: `{$name}` does not take a parenthesized argument list
+
+attr_invalid_repr_hint_no_value =
+    invalid representation hint: `{$name}` does not take a value
 
 attr_unsupported_literal_generic =
     unsupported literal
@@ -28,19 +60,19 @@ attr_unsupported_literal_deprecated_kv_pair =
 attr_unsupported_literal_suggestion =
     consider removing the prefix
 
-attr_incorrect_meta_item =
+attr_invalid_repr_align_need_arg =
-    incorrect meta item
+    invalid `repr(align)` attribute: `align` needs an argument
+    .suggestion = supply an argument here
 
-attr_invalid_issue_string =
+attr_invalid_repr_generic =
-    `issue` must be a non-zero numeric string or "none"
+    invalid `repr({$repr_arg})` attribute: {$error_part}
-    .must_not_be_zero = `issue` must not be "0", use "none" instead
-    .empty = cannot parse integer from empty string
-    .invalid_digit = invalid digit found in string
-    .pos_overflow = number too large to fit in target type
-    .neg_overflow = number too small to fit in target type
 
-attr_missing_issue =
+attr_incorrect_repr_format_align_one_arg =
-    missing 'issue'
+    incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
+
+attr_incorrect_repr_format_generic =
+    incorrect `repr({$repr_arg})` attribute format
+    .suggestion = use parentheses instead
 
 attr_rustc_promotable_pairing =
     `rustc_promotable` attribute must be paired with either a `rustc_const_unstable` or a `rustc_const_stable` attribute
@@ -48,24 +80,6 @@ attr_rustc_promotable_pairing =
 attr_rustc_allowed_unstable_pairing =
     `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
 
-attr_soft_no_args =
-    `soft` should not have any arguments
-
-attr_expected_version_literal =
-    expected a version literal
-
-attr_expected_single_version_literal =
-    expected single version literal
-
-attr_unknown_version_literal =
-    unknown version literal format, assuming it refers to a future version
-
-attr_expected_one_cfg_pattern =
-    expected 1 cfg-pattern
-
-attr_invalid_predicate =
-    invalid predicate `{$predicate}`
-
 attr_cfg_predicate_identifier =
     `cfg` predicate key must be an identifier
 
@@ -74,34 +88,20 @@ attr_deprecated_item_suggestion =
     .help = add `#![feature(deprecated_suggestion)]` to the crate root
     .note = see #94785 for more details
 
-attr_missing_note =
+attr_expected_single_version_literal =
-    missing 'note'
+    expected single version literal
 
-attr_invalid_repr_align_need_arg =
+attr_expected_version_literal =
-    invalid `repr(align)` attribute: `align` needs an argument
+    expected a version literal
-    .suggestion = supply an argument here
-
-attr_invalid_repr_generic =
-    invalid `repr({$repr_arg})` attribute: {$error_part}
-
-attr_invalid_repr_hint_no_paren =
-    invalid representation hint: `{$name}` does not take a parenthesized argument list
-
-attr_invalid_repr_hint_no_value =
-    invalid representation hint: `{$name}` does not take a value
-
-attr_incorrect_repr_format_generic =
-    incorrect `repr({$repr_arg})` attribute format
-    .suggestion = use parentheses instead
-
-attr_incorrect_repr_format_align_one_arg =
-    incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
-
-attr_incorrect_repr_format_packed_one_or_zero_arg =
-    incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all
 
 attr_expects_feature_list =
     `{$name}` expects a list of feature names
 
 attr_expects_features =
     `{$name}` expects feature names
+
+attr_soft_no_args =
+    `soft` should not have any arguments
+
+attr_unknown_version_literal =
+    unknown version literal format, assuming it refers to a future version