Addressing review comments

aerooneqq · aerooneqq · commit c5c8bbd6857f · 2025-12-11T16:15:40.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -43,13 +43,15 @@ use hir::def::{DefKind, PartialRes, Res};
 use hir::{BodyId, HirId};
 use rustc_abi::ExternAbi;
 use rustc_ast::*;
+use rustc_attr_parsing::{AttributeParser, ShouldEmit};
 use rustc_errors::ErrorGuaranteed;
+use rustc_hir::Target;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{Asyncness, DelegationFnSigAttrs, ResolverAstLowering};
 use rustc_span::symbol::kw;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{DUMMY_SP, Ident, Span, Symbol};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
@@ -69,7 +71,7 @@ struct AttributeAdditionInfo {
 
 enum AttributeAdditionKind {
     Default { factory: fn(Span) -> hir::Attribute },
-    Inherit { flag: DelegationFnSigAttrs, factory: fn(Span) -> hir::Attribute },
+    Inherit { flag: DelegationFnSigAttrs, factory: fn(Span, &hir::Attribute) -> hir::Attribute },
 }
 
 const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
@@ -78,7 +80,17 @@ static ATTRIBUTES_ADDITIONS: &[AttributeAdditionInfo] = &[
     AttributeAdditionInfo {
         equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
         kind: AttributeAdditionKind::Inherit {
-            factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
+            factory: |span, original_attribute| {
+                let reason = match original_attribute {
+                    hir::Attribute::Parsed(AttributeKind::MustUse {
+                        span: _,
+                        reason: Some(reason),
+                    }) => Some(reason.clone()),
+                    _ => None,
+                };
+
+                hir::Attribute::Parsed(AttributeKind::MustUse { span, reason })
+            },
             flag: DelegationFnSigAttrs::MUST_USE,
         },
     },
@@ -160,6 +172,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
         sig_id: DefId,
         existing_attrs: Option<&&[hir::Attribute]>,
     ) -> Vec<hir::Attribute> {
+        let local_original_attributes = self.parse_local_original_attributes(sig_id);
+
         candidate_additions
             .iter()
             .filter_map(|addition_info| {
@@ -174,33 +188,57 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 match addition_info.kind {
                     AttributeAdditionKind::Default { factory } => Some(factory(span)),
                     AttributeAdditionKind::Inherit { flag, factory } => {
-                        // Check if an attribute present on the target of delegation,
-                        // either in this crate or other
-                        let should_inherit = match sig_id.as_local() {
+                        let original_attribute = match sig_id.as_local() {
                             Some(local_id) => self
                                 .resolver
                                 .delegation_fn_sigs
                                 .get(&local_id)
-                                .is_some_and(|sig| sig.attrs_flags.contains(flag)),
-                            // We can not use `tcx.has_attr` and symbol here as attributes
-                            // from other crates have None in their identifiers
+                                .is_some_and(|sig| sig.attrs_flags.contains(flag))
+                                .then(|| {
+                                    local_original_attributes
+                                        .as_ref()
+                                        .map(|attrs| {
+                                            attrs
+                                                .iter()
+                                                .find(|base_attr| (addition_info.equals)(base_attr))
+                                        })
+                                        .flatten()
+                                })
+                                .flatten(),
                             None => self
                                 .tcx
                                 .get_all_attrs(sig_id)
                                 .iter()
-                                .any(|base_attr| (addition_info.equals)(base_attr)),
+                                .find(|base_attr| (addition_info.equals)(base_attr)),
                         };
 
-                        match should_inherit {
-                            true => Some(factory(span)),
-                            false => None,
-                        }
+                        original_attribute.map(|a| factory(span, a))
                     }
                 }
             })
             .collect::<Vec<_>>()
     }
 
+    fn parse_local_original_attributes(&self, sig_id: DefId) -> Option<Vec<hir::Attribute>> {
+        if let Some(local_id) = sig_id.as_local()
+            && let Some(info) = self.resolver.delegation_fn_sigs.get(&local_id)
+            && !info.to_inherit_attrs.is_empty()
+        {
+            Some(AttributeParser::parse_limited_all(
+                self.tcx.sess,
+                info.to_inherit_attrs.as_slice(),
+                None,
+                Target::Fn,
+                DUMMY_SP,
+                DUMMY_NODE_ID,
+                Some(self.tcx.features()),
+                ShouldEmit::Nothing,
+            ))
+        } else {
+            None
+        }
+    }
+
     fn get_delegation_sig_id(
         &self,
         item_id: NodeId,
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -25,6 +25,7 @@ pub use generic_args::{GenericArgKind, TermKind, *};
 pub use generics::*;
 pub use intrinsic::IntrinsicDef;
 use rustc_abi::{Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, VariantIdx};
+use rustc_ast::AttrVec;
 use rustc_ast::expand::typetree::{FncTree, Kind, Type, TypeTree};
 use rustc_ast::node_id::NodeMap;
 pub use rustc_ast_ir::{Movability, Mutability, try_visit};
@@ -229,13 +230,16 @@ bitflags::bitflags! {
     }
 }
 
+pub const DELEGATION_INHERIT_ATTRS_START: DelegationFnSigAttrs = DelegationFnSigAttrs::MUST_USE;
+
 #[derive(Debug)]
 pub struct DelegationFnSig {
     pub header: ast::FnHeader,
     pub param_count: usize,
     pub has_self: bool,
     pub c_variadic: bool,
     pub attrs_flags: DelegationFnSigAttrs,
+    pub to_inherit_attrs: AttrVec,
 }
 
 #[derive(Clone, Copy, Debug, HashStable)]
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -28,7 +28,9 @@ use rustc_hir::def::{self, CtorKind, DefKind, LifetimeRes, NonMacroAttrKind, Par
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{MissingLifetimeKind, PrimTy, TraitCandidate};
 use rustc_middle::middle::resolve_bound_vars::Set1;
-use rustc_middle::ty::{AssocTag, DelegationFnSig, DelegationFnSigAttrs, Visibility};
+use rustc_middle::ty::{
+    AssocTag, DELEGATION_INHERIT_ATTRS_START, DelegationFnSig, DelegationFnSigAttrs, Visibility,
+};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
@@ -5299,12 +5301,19 @@ impl ItemInfoCollector<'_, '_, '_> {
             (sym::must_use, DelegationFnSigAttrs::MUST_USE),
         ];
 
+        let mut to_inherit_attrs = AttrVec::new();
         let mut attrs_flags = DelegationFnSigAttrs::empty();
-        for attr in attrs {
+
+        'attrs_loop: for attr in attrs {
             for &(name, flag) in NAMES_TO_FLAGS {
                 if attr.has_name(name) {
                     attrs_flags.set(flag, true);
-                    continue;
+
+                    if flag.bits() >= DELEGATION_INHERIT_ATTRS_START.bits() {
+                        to_inherit_attrs.push(attr.clone());
+                    }
+
+                    continue 'attrs_loop;
                 }
             }
         }
@@ -5315,6 +5324,7 @@ impl ItemInfoCollector<'_, '_, '_> {
             has_self: decl.has_self(),
             c_variadic: decl.c_variadic(),
             attrs_flags,
+            to_inherit_attrs,
         };
 
         self.r.delegation_fn_sigs.insert(self.r.local_def_id(id), sig);
diff --git a/tests/pretty/auxiliary/to-reuse-functions.rs b/tests/pretty/auxiliary/to-reuse-functions.rs
@@ -4,7 +4,7 @@
 #[cold]
 pub unsafe fn unsafe_fn_extern() -> usize { 1 }
 
-#[must_use]
+#[must_use = "extern_fn_extern: some reason"]
 #[deprecated]
 pub extern "C" fn extern_fn_extern() -> usize { 1 }
 
diff --git a/tests/pretty/delegation-inherit-attributes.pp b/tests/pretty/delegation-inherit-attributes.pp
@@ -14,20 +14,28 @@
 extern crate to_reuse_functions;
 
 mod to_reuse {
-    #[attr = MustUse]
+    #[attr = MustUse {reason: "foo: some reason"}]
     #[attr = Cold]
     fn foo(x: usize) -> usize { x }
 
+    #[attr = MustUse]
+    #[attr = Cold]
+    fn foo_no_reason(x: usize) -> usize { x }
+
     #[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
     #[attr = Cold]
     fn bar(x: usize) -> usize { x }
 }
 
 #[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
-#[attr = MustUse]
+#[attr = MustUse {reason: "foo: some reason"}]
 #[attr = Inline(Hint)]
 fn foo1(arg0: _) -> _ { to_reuse::foo(self + 1) }
 
+#[attr = MustUse]
+#[attr = Inline(Hint)]
+fn foo_no_reason(arg0: _) -> _ { to_reuse::foo_no_reason(self + 1) }
+
 #[attr = Deprecation {deprecation: Deprecation {since: Unspecified}}]
 #[attr = MustUse {reason: "some reason"}]
 #[attr = Inline(Hint)]
@@ -39,7 +47,7 @@
 #[attr = MustUse]
 #[attr = Inline(Hint)]
 unsafe fn unsafe_fn_extern() -> _ { to_reuse_functions::unsafe_fn_extern() }
-#[attr = MustUse]
+#[attr = MustUse {reason: "extern_fn_extern: some reason"}]
 #[attr = Inline(Hint)]
 extern "C" fn extern_fn_extern()
     -> _ { to_reuse_functions::extern_fn_extern() }
diff --git a/tests/pretty/delegation-inherit-attributes.rs b/tests/pretty/delegation-inherit-attributes.rs
@@ -10,12 +10,18 @@
 extern crate to_reuse_functions;
 
 mod to_reuse {
-    #[must_use]
+    #[must_use = "foo: some reason"]
     #[cold]
     pub fn foo(x: usize) -> usize {
         x
     }
 
+    #[must_use]
+    #[cold]
+    pub fn foo_no_reason(x: usize) -> usize {
+        x
+    }
+
     #[cold]
     #[deprecated]
     pub fn bar(x: usize) -> usize {
@@ -28,6 +34,10 @@ reuse to_reuse::foo as foo1 {
     self + 1
 }
 
+reuse to_reuse::foo_no_reason {
+    self + 1
+}
+
 #[deprecated]
 #[must_use = "some reason"]
 reuse to_reuse::foo as foo2 {
