the fix

Author: 2asoft

compiler/rustc_expand/src/expand.rs

@@ -29,7 +29,7 @@ use rustc_session::parse::feature_err;
 use rustc_session::{Limit, Session};
 use rustc_span::hygiene::SyntaxContext;
 use rustc_span::{ErrorGuaranteed, FileName, Ident, LocalExpnId, Span, Symbol, sym};
-use smallvec::SmallVec;
+use smallvec::{SmallVec, smallvec};
 
 use crate::base::*;
 use crate::config::{StripUnconfigured, attr_into_trace};
@@ -46,6 +46,22 @@ use crate::module::{
 use crate::placeholders::{PlaceholderExpander, placeholder};
 use crate::stats::*;
 
+/// Visitor to apply diagnostic attributes to expanded AST fragments
+struct DiagnosticAttrApplier {
+    attrs: Vec<ast::Attribute>,
+}
+
+impl MutVisitor for DiagnosticAttrApplier {
+    fn flat_map_item(&mut self, item: Box<ast::Item>) -> SmallVec<[Box<ast::Item>; 1]> {
+        let mut new_item = item;
+        // Prepend diagnostic attributes to preserve their position
+        let mut new_attrs = self.attrs.clone();
+        new_attrs.extend(new_item.attrs);
+        new_item.attrs = new_attrs.into();
+        smallvec![new_item]
+    }
+}
+
 macro_rules! ast_fragments {
     (
         $($Kind:ident($AstTy:ty) {
@@ -818,12 +834,43 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     let inner_tokens = attr_item.args.inner_tokens();
                     match expander.expand(self.cx, span, inner_tokens, tokens) {
                         Ok(tok_result) => {
-                            let fragment = self.parse_ast_fragment(
+                            // Extract diagnostic attributes from the original item before parsing
+                            let diagnostic_attrs = {
+                                match &item {
+                                    Annotatable::Item(item) => item
+                                        .attrs
+                                        .iter()
+                                        .filter(|attr| {
+                                            attr.name().map_or(false, |name| {
+                                                matches!(
+                                                    name,
+                                                    sym::expect
+                                                        | sym::allow
+                                                        | sym::warn
+                                                        | sym::deny
+                                                        | sym::forbid
+                                                )
+                                            })
+                                        })
+                                        .cloned()
+                                        .collect::<Vec<_>>(),
+                                    _ => Vec::new(),
+                                }
+                            };
+
+                            let mut fragment = self.parse_ast_fragment(
                                 tok_result,
                                 fragment_kind,
                                 &attr_item.path,
                                 span,
                             );
+
+                            // Apply diagnostic attributes to the expanded fragment
+                            if !diagnostic_attrs.is_empty() {
+                                fragment.mut_visit_with(&mut DiagnosticAttrApplier {
+                                    attrs: diagnostic_attrs,
+                                });
+                            }
                             if macro_stats {
                                 update_attr_macro_stats(
                                     self.cx,

compiler/rustc_expand/src/proc_macro.rs

@@ -4,6 +4,7 @@ use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_session::config::ProcMacroExecutionStrategy;
 use rustc_span::Span;
 use rustc_span::profiling::SpannedEventArgRecorder;
+use rustc_span::sym;
 use {rustc_ast as ast, rustc_proc_macro as pm};
 
 use crate::base::{self, *};
@@ -122,6 +123,27 @@ impl MultiItemModifier for DeriveProcMacro {
         // Eventually we might remove the special case hard error check
         // altogether. See #73345.
         crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess.psess);
+
+        // Extract diagnostic attributes from the original item before expansion
+        let diagnostic_attrs = {
+            match &item {
+                base::Annotatable::Item(item) => item
+                    .attrs
+                    .iter()
+                    .filter(|attr| {
+                        attr.name().map_or(false, |name| {
+                            matches!(
+                                name,
+                                sym::expect | sym::allow | sym::warn | sym::deny | sym::forbid
+                            )
+                        })
+                    })
+                    .cloned()
+                    .collect::<Vec<_>>(),
+                _ => Vec::new(), // Other annotatable types don't have attributes
+            }
+        };
+
         let input = item.to_tokens();
         let stream = {
             let _timer =
@@ -158,7 +180,15 @@ impl MultiItemModifier for DeriveProcMacro {
         loop {
             match parser.parse_item(ForceCollect::No) {
                 Ok(None) => break,
-                Ok(Some(item)) => {
+                Ok(Some(mut item)) => {
+                    // Apply diagnostic attributes from the original item to the expanded item
+                    if !diagnostic_attrs.is_empty() {
+                        // Prepend diagnostic attributes to preserve their position
+                        let mut new_attrs = diagnostic_attrs.clone();
+                        new_attrs.extend(item.attrs);
+                        item.attrs = new_attrs.into();
+                    }
+
                     if is_stmt {
                         items.push(Annotatable::Stmt(Box::new(ecx.stmt_item(span, item))));
                     } else {