Merging upstream version 1.66.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 78 insertions, 83 deletions

diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs
index 085175d4b..edccfa1c8 100644
--- a/compiler/rustc_attr/src/session_diagnostics.rs
+++ b/compiler/rustc_attr/src/session_diagnostics.rs
@@ -2,23 +2,22 @@ use std::num::IntErrorKind;
 
 use rustc_ast as ast;
 use rustc_errors::{
-    error_code, fluent, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler,
+    error_code, fluent, Applicability, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic,
 };
-use rustc_macros::SessionDiagnostic;
-use rustc_session::SessionDiagnostic;
+use rustc_macros::Diagnostic;
 use rustc_span::{Span, Symbol};
 
 use crate::UnsupportedLiteralReason;
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::expected_one_cfg_pattern, code = "E0536")]
+#[derive(Diagnostic)]
+#[diag(attr_expected_one_cfg_pattern, code = "E0536")]
 pub(crate) struct ExpectedOneCfgPattern {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::invalid_predicate, code = "E0537")]
+#[derive(Diagnostic)]
+#[diag(attr_invalid_predicate, code = "E0537")]
 pub(crate) struct InvalidPredicate {
     #[primary_span]
     pub span: Span,
@@ -26,8 +25,8 @@ pub(crate) struct InvalidPredicate {
     pub predicate: String,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::multiple_item, code = "E0538")]
+#[derive(Diagnostic)]
+#[diag(attr_multiple_item, code = "E0538")]
 pub(crate) struct MultipleItem {
     #[primary_span]
     pub span: Span,
@@ -35,8 +34,8 @@ pub(crate) struct MultipleItem {
     pub item: String,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::incorrect_meta_item, code = "E0539")]
+#[derive(Diagnostic)]
+#[diag(attr_incorrect_meta_item, code = "E0539")]
 pub(crate) struct IncorrectMetaItem {
     #[primary_span]
     pub span: Span,
@@ -50,44 +49,44 @@ pub(crate) struct UnknownMetaItem<'a> {
 }
 
 // Manual implementation to be able to format `expected` items correctly.
-impl<'a> SessionDiagnostic<'a> for UnknownMetaItem<'_> {
+impl<'a> IntoDiagnostic<'a> for UnknownMetaItem<'_> {
     fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
         let expected = self.expected.iter().map(|name| format!("`{}`", name)).collect::<Vec<_>>();
         let mut diag = handler.struct_span_err_with_code(
             self.span,
-            fluent::attr::unknown_meta_item,
+            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.span_label(self.span, fluent::label);
         diag
     }
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::missing_since, code = "E0542")]
+#[derive(Diagnostic)]
+#[diag(attr_missing_since, code = "E0542")]
 pub(crate) struct MissingSince {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::missing_note, code = "E0543")]
+#[derive(Diagnostic)]
+#[diag(attr_missing_note, code = "E0543")]
 pub(crate) struct MissingNote {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::multiple_stability_levels, code = "E0544")]
+#[derive(Diagnostic)]
+#[diag(attr_multiple_stability_levels, code = "E0544")]
 pub(crate) struct MultipleStabilityLevels {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::invalid_issue_string, code = "E0545")]
+#[derive(Diagnostic)]
+#[diag(attr_invalid_issue_string, code = "E0545")]
 pub(crate) struct InvalidIssueString {
     #[primary_span]
     pub span: Span,
@@ -98,33 +97,33 @@ pub(crate) struct InvalidIssueString {
 
 // The error kinds of `IntErrorKind` are duplicated here in order to allow the messages to be
 // translatable.
-#[derive(SessionSubdiagnostic)]
+#[derive(Subdiagnostic)]
 pub(crate) enum InvalidIssueStringCause {
-    #[label(attr::must_not_be_zero)]
+    #[label(must_not_be_zero)]
     MustNotBeZero {
         #[primary_span]
         span: Span,
     },
 
-    #[label(attr::empty)]
+    #[label(empty)]
     Empty {
         #[primary_span]
         span: Span,
     },
 
-    #[label(attr::invalid_digit)]
+    #[label(invalid_digit)]
     InvalidDigit {
         #[primary_span]
         span: Span,
     },
 
-    #[label(attr::pos_overflow)]
+    #[label(pos_overflow)]
     PosOverflow {
         #[primary_span]
         span: Span,
     },
 
-    #[label(attr::neg_overflow)]
+    #[label(neg_overflow)]
     NegOverflow {
         #[primary_span]
         span: Span,
@@ -144,22 +143,22 @@ impl InvalidIssueStringCause {
     }
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::missing_feature, code = "E0546")]
+#[derive(Diagnostic)]
+#[diag(attr_missing_feature, code = "E0546")]
 pub(crate) struct MissingFeature {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::non_ident_feature, code = "E0546")]
+#[derive(Diagnostic)]
+#[diag(attr_non_ident_feature, code = "E0546")]
 pub(crate) struct NonIdentFeature {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::missing_issue, code = "E0547")]
+#[derive(Diagnostic)]
+#[diag(attr_missing_issue, code = "E0547")]
 pub(crate) struct MissingIssue {
     #[primary_span]
     pub span: Span,
@@ -167,8 +166,8 @@ pub(crate) struct MissingIssue {
 
 // FIXME: This diagnostic is identical to `IncorrectMetaItem`, barring the error code. Consider
 // changing this to `IncorrectMetaItem`. See #51489.
-#[derive(SessionDiagnostic)]
-#[diag(attr::incorrect_meta_item, code = "E0551")]
+#[derive(Diagnostic)]
+#[diag(attr_incorrect_meta_item, code = "E0551")]
 pub(crate) struct IncorrectMetaItem2 {
     #[primary_span]
     pub span: Span,
@@ -176,15 +175,15 @@ pub(crate) struct IncorrectMetaItem2 {
 
 // FIXME: Why is this the same error code as `InvalidReprHintNoParen` and `InvalidReprHintNoValue`?
 // It is more similar to `IncorrectReprFormatGeneric`.
-#[derive(SessionDiagnostic)]
-#[diag(attr::incorrect_repr_format_packed_one_or_zero_arg, code = "E0552")]
+#[derive(Diagnostic)]
+#[diag(attr_incorrect_repr_format_packed_one_or_zero_arg, code = "E0552")]
 pub(crate) struct IncorrectReprFormatPackedOneOrZeroArg {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::invalid_repr_hint_no_paren, code = "E0552")]
+#[derive(Diagnostic)]
+#[diag(attr_invalid_repr_hint_no_paren, code = "E0552")]
 pub(crate) struct InvalidReprHintNoParen {
     #[primary_span]
     pub span: Span,
@@ -192,8 +191,8 @@ pub(crate) struct InvalidReprHintNoParen {
     pub name: String,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::invalid_repr_hint_no_value, code = "E0552")]
+#[derive(Diagnostic)]
+#[diag(attr_invalid_repr_hint_no_value, code = "E0552")]
 pub(crate) struct InvalidReprHintNoValue {
     #[primary_span]
     pub span: Span,
@@ -209,18 +208,18 @@ pub(crate) struct UnsupportedLiteral {
     pub start_point_span: Span,
 }
 
-impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral {
+impl<'a> IntoDiagnostic<'a> for UnsupportedLiteral {
     fn into_diagnostic(self, handler: &'a Handler) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
         let mut diag = handler.struct_span_err_with_code(
             self.span,
             match self.reason {
-                UnsupportedLiteralReason::Generic => fluent::attr::unsupported_literal_generic,
-                UnsupportedLiteralReason::CfgString => fluent::attr::unsupported_literal_cfg_string,
+                UnsupportedLiteralReason::Generic => fluent::attr_unsupported_literal_generic,
+                UnsupportedLiteralReason::CfgString => fluent::attr_unsupported_literal_cfg_string,
                 UnsupportedLiteralReason::DeprecatedString => {
-                    fluent::attr::unsupported_literal_deprecated_string
+                    fluent::attr_unsupported_literal_deprecated_string
                 }
                 UnsupportedLiteralReason::DeprecatedKvPair => {
-                    fluent::attr::unsupported_literal_deprecated_kv_pair
+                    fluent::attr_unsupported_literal_deprecated_kv_pair
                 }
             },
             error_code!(E0565),
@@ -228,7 +227,7 @@ impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral {
         if self.is_bytestr {
             diag.span_suggestion(
                 self.start_point_span,
-                fluent::attr::unsupported_literal_suggestion,
+                fluent::attr_unsupported_literal_suggestion,
                 "",
                 Applicability::MaybeIncorrect,
             );
@@ -237,16 +236,16 @@ impl<'a> SessionDiagnostic<'a> for UnsupportedLiteral {
     }
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::invalid_repr_align_need_arg, code = "E0589")]
+#[derive(Diagnostic)]
+#[diag(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)]
-#[diag(attr::invalid_repr_generic, code = "E0589")]
+#[derive(Diagnostic)]
+#[diag(attr_invalid_repr_generic, code = "E0589")]
 pub(crate) struct InvalidReprGeneric<'a> {
     #[primary_span]
     pub span: Span,
@@ -255,15 +254,15 @@ pub(crate) struct InvalidReprGeneric<'a> {
     pub error_part: &'a str,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::incorrect_repr_format_align_one_arg, code = "E0693")]
+#[derive(Diagnostic)]
+#[diag(attr_incorrect_repr_format_align_one_arg, code = "E0693")]
 pub(crate) struct IncorrectReprFormatAlignOneArg {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::incorrect_repr_format_generic, code = "E0693")]
+#[derive(Diagnostic)]
+#[diag(attr_incorrect_repr_format_generic, code = "E0693")]
 pub(crate) struct IncorrectReprFormatGeneric<'a> {
     #[primary_span]
     pub span: Span,
@@ -274,9 +273,9 @@ pub(crate) struct IncorrectReprFormatGeneric<'a> {
     pub cause: Option<IncorrectReprFormatGenericCause<'a>>,
 }
 
-#[derive(SessionSubdiagnostic)]
+#[derive(Subdiagnostic)]
 pub(crate) enum IncorrectReprFormatGenericCause<'a> {
-    #[suggestion(attr::suggestion, code = "{name}({int})", applicability = "machine-applicable")]
+    #[suggestion(suggestion, code = "{name}({int})", applicability = "machine-applicable")]
     Int {
         #[primary_span]
         span: Span,
@@ -288,11 +287,7 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
         int: u128,
     },
 
-    #[suggestion(
-        attr::suggestion,
-        code = "{name}({symbol})",
-        applicability = "machine-applicable"
-    )]
+    #[suggestion(suggestion, code = "{name}({symbol})", applicability = "machine-applicable")]
     Symbol {
         #[primary_span]
         span: Span,
@@ -317,29 +312,29 @@ impl<'a> IncorrectReprFormatGenericCause<'a> {
     }
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::rustc_promotable_pairing, code = "E0717")]
+#[derive(Diagnostic)]
+#[diag(attr_rustc_promotable_pairing, code = "E0717")]
 pub(crate) struct RustcPromotablePairing {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::rustc_allowed_unstable_pairing, code = "E0789")]
+#[derive(Diagnostic)]
+#[diag(attr_rustc_allowed_unstable_pairing, code = "E0789")]
 pub(crate) struct RustcAllowedUnstablePairing {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::cfg_predicate_identifier)]
+#[derive(Diagnostic)]
+#[diag(attr_cfg_predicate_identifier)]
 pub(crate) struct CfgPredicateIdentifier {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::deprecated_item_suggestion)]
+#[derive(Diagnostic)]
+#[diag(attr_deprecated_item_suggestion)]
 pub(crate) struct DeprecatedItemSuggestion {
     #[primary_span]
     pub span: Span,
@@ -351,22 +346,22 @@ pub(crate) struct DeprecatedItemSuggestion {
     pub details: (),
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::expected_single_version_literal)]
+#[derive(Diagnostic)]
+#[diag(attr_expected_single_version_literal)]
 pub(crate) struct ExpectedSingleVersionLiteral {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::expected_version_literal)]
+#[derive(Diagnostic)]
+#[diag(attr_expected_version_literal)]
 pub(crate) struct ExpectedVersionLiteral {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::expects_feature_list)]
+#[derive(Diagnostic)]
+#[diag(attr_expects_feature_list)]
 pub(crate) struct ExpectsFeatureList {
     #[primary_span]
     pub span: Span,
@@ -374,8 +369,8 @@ pub(crate) struct ExpectsFeatureList {
     pub name: String,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::expects_features)]
+#[derive(Diagnostic)]
+#[diag(attr_expects_features)]
 pub(crate) struct ExpectsFeatures {
     #[primary_span]
     pub span: Span,
@@ -383,15 +378,15 @@ pub(crate) struct ExpectsFeatures {
     pub name: String,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::soft_no_args)]
+#[derive(Diagnostic)]
+#[diag(attr_soft_no_args)]
 pub(crate) struct SoftNoArgs {
     #[primary_span]
     pub span: Span,
 }
 
-#[derive(SessionDiagnostic)]
-#[diag(attr::unknown_version_literal)]
+#[derive(Diagnostic)]
+#[diag(attr_unknown_version_literal)]
 pub(crate) struct UnknownVersionLiteral {
     #[primary_span]
     pub span: Span,