WIP on attributes inheritance

aerooneqq · aerooneqq · commit 226f00a9dd27 · 2025-12-11T12:42:46.000+03:00
diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -47,9 +47,9 @@ use rustc_errors::ErrorGuaranteed;
 use rustc_hir::attrs::{AttributeKind, InlineAttr};
 use rustc_hir::def_id::DefId;
 use rustc_middle::span_bug;
-use rustc_middle::ty::{Asyncness, ResolverAstLowering};
+use rustc_middle::ty::{Asyncness, DelegationFnSigAttrs, ResolverAstLowering};
 use rustc_span::symbol::kw;
-use rustc_span::{Ident, Span, Symbol};
+use rustc_span::{Ident, Span, Symbol, sym};
 use {rustc_ast as ast, rustc_hir as hir};
 
 use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
@@ -62,6 +62,40 @@ pub(crate) struct DelegationResults<'hir> {
     pub generics: &'hir hir::Generics<'hir>,
 }
 
+struct AttributeAdditionInfo {
+    pub factory: fn(Span) -> hir::Attribute,
+    pub equals: fn(&hir::Attribute) -> bool,
+    pub kind: AttributeAdditionKind,
+}
+
+struct AttributeAdditionStatus {
+    pub info: &'static AttributeAdditionInfo,
+    pub already_exists: bool,
+}
+
+enum AttributeAdditionKind {
+    Default,
+    Inherit { symbol: Symbol, flag: DelegationFnSigAttrs },
+}
+
+const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
+
+static ATTRS_ADDITIONS: &'static [AttributeAdditionInfo; 2] = &[
+    AttributeAdditionInfo {
+        factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
+        equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
+        kind: AttributeAdditionKind::Inherit {
+            symbol: sym::must_use,
+            flag: DelegationFnSigAttrs::MUST_USE,
+        },
+    },
+    AttributeAdditionInfo {
+        factory: |span| hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span)),
+        equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::Inline(..))),
+        kind: AttributeAdditionKind::Default,
+    },
+];
+
 impl<'hir> LoweringContext<'_, 'hir> {
     fn is_method(&self, def_id: DefId, span: Span) -> bool {
         match self.tcx.def_kind(def_id) {
@@ -88,7 +122,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let sig_id = self.get_delegation_sig_id(item_id, delegation.id, span, is_in_trait_impl);
         match sig_id {
             Ok(sig_id) => {
-                self.add_inline_attribute_if_needed(span);
+                self.add_attributes_if_needed(span, sig_id);
 
                 let is_method = self.is_method(sig_id, span);
                 let (param_count, c_variadic) = self.param_count(sig_id);
@@ -103,29 +137,80 @@ impl<'hir> LoweringContext<'_, 'hir> {
         }
     }
 
-    fn add_inline_attribute_if_needed(&mut self, span: Span) {
-        const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
-        let create_inline_attr_slice =
-            || [hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span))];
-
-        let new_attributes = match self.attrs.get(&PARENT_ID) {
-            Some(attrs) => {
-                // Check if reuse already specifies any inline attribute, if so, do nothing
-                if attrs
-                    .iter()
-                    .any(|a| matches!(a, hir::Attribute::Parsed(AttributeKind::Inline(..))))
-                {
-                    return;
-                }
+    fn add_attributes_if_needed(&mut self, span: Span, sig_id: DefId) {
+        let mut candidate_additions = ATTRS_ADDITIONS
+            .iter()
+            .map(|a| AttributeAdditionStatus { info: a, already_exists: false })
+            .collect::<Vec<_>>();
 
-                self.arena.alloc_from_iter(
-                    attrs.into_iter().map(|a| a.clone()).chain(create_inline_attr_slice()),
-                )
-            }
-            None => self.arena.alloc_from_iter(create_inline_attr_slice()),
+        self.check_if_attributes_already_exist(&mut candidate_additions);
+        let new_attributes = self.create_new_attributes(&candidate_additions, span, sig_id);
+
+        if new_attributes.is_empty() {
+            return;
+        }
+
+        let new_arena_allocated_attributes = match self.attrs.get(&PARENT_ID) {
+            Some(existing_attrs) => self.arena.alloc_from_iter(
+                existing_attrs.iter().map(|a| a.clone()).chain(new_attributes.into_iter()),
+            ),
+            None => self.arena.alloc_from_iter(new_attributes.into_iter()),
         };
 
-        self.attrs.insert(PARENT_ID, new_attributes);
+        self.attrs.insert(PARENT_ID, new_arena_allocated_attributes);
+    }
+
+    fn check_if_attributes_already_exist(
+        &mut self,
+        candidate_additions: &mut Vec<AttributeAdditionStatus>,
+    ) {
+        if let Some(existing_attrs) = self.attrs.get(&PARENT_ID) {
+            for attr in existing_attrs.iter() {
+                for addition in candidate_additions.iter_mut() {
+                    if addition.already_exists {
+                        continue;
+                    }
+
+                    if (addition.info.equals)(attr) {
+                        addition.already_exists = true;
+                    }
+                }
+            }
+        }
+    }
+
+    fn create_new_attributes(
+        &mut self,
+        candidate_additions: &Vec<AttributeAdditionStatus>,
+        span: Span,
+        sig_id: DefId,
+    ) -> Vec<hir::Attribute> {
+        candidate_additions
+            .into_iter()
+            .filter_map(|a| match a.already_exists {
+                true => None,
+                false => match a.info.kind {
+                    AttributeAdditionKind::Default => Some((a.info.factory)(span)),
+                    AttributeAdditionKind::Inherit { symbol, flag } => {
+                        // Check if an anttribute present on the target of delegation,
+                        // either in this crate or others
+                        let should_inherit = match sig_id.as_local() {
+                            None => self.tcx.get_attr(sig_id, symbol).is_some(),
+                            Some(local_id) => self
+                                .resolver
+                                .delegation_fn_sigs
+                                .get(&local_id)
+                                .is_some_and(|sig| sig.attrs_flags.contains(flag)),
+                        };
+
+                        match should_inherit {
+                            true => Some((a.info.factory)(span)),
+                            false => None,
+                        }
+                    }
+                },
+            })
+            .collect::<Vec<_>>()
     }
 
     fn get_delegation_sig_id(
@@ -220,7 +305,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     // We are not forwarding the attributes, as the delegation fn sigs are collected on the ast,
                     // and here we need the hir attributes.
                     let default_safety =
-                        if sig.target_feature || self.tcx.def_kind(parent) == DefKind::ForeignMod {
+                        if sig.attrs_flags.contains(DelegationFnSigAttrs::TARGET_FEATURE)
+                            || self.tcx.def_kind(parent) == DefKind::ForeignMod
+                        {
                             hir::Safety::Unsafe
                         } else {
                             hir::Safety::Safe
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
@@ -221,13 +221,21 @@ pub struct ResolverAstLowering {
     pub delegation_fn_sigs: LocalDefIdMap<DelegationFnSig>,
 }
 
+bitflags::bitflags! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    pub struct DelegationFnSigAttrs: u8 {
+        const TARGET_FEATURE = 1 << 0;
+        const MUST_USE = 1 << 1;
+    }
+}
+
 #[derive(Debug)]
 pub struct DelegationFnSig {
     pub header: ast::FnHeader,
     pub param_count: usize,
     pub has_self: bool,
     pub c_variadic: bool,
-    pub target_feature: bool,
+    pub attrs_flags: DelegationFnSigAttrs,
 }
 
 #[derive(Clone, Copy, Debug, HashStable)]
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -28,7 +28,7 @@ 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, Visibility};
+use rustc_middle::ty::{AssocTag, DelegationFnSig, DelegationFnSigAttrs, Visibility};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
@@ -5294,13 +5294,29 @@ impl ItemInfoCollector<'_, '_, '_> {
         id: NodeId,
         attrs: &[Attribute],
     ) {
+        static NAMES_TO_FLAGS: [(Symbol, DelegationFnSigAttrs); 2] = [
+            (sym::target_feature, DelegationFnSigAttrs::TARGET_FEATURE),
+            (sym::must_use, DelegationFnSigAttrs::MUST_USE),
+        ];
+
+        let mut attrs_flags = DelegationFnSigAttrs::empty();
+        for attr in attrs {
+            for (name, flag) in NAMES_TO_FLAGS {
+                if !attrs_flags.contains(flag) && attr.has_name(name) {
+                    attrs_flags.set(flag, true);
+                    continue;
+                }
+            }
+        }
+
         let sig = DelegationFnSig {
             header,
             param_count: decl.inputs.len(),
             has_self: decl.has_self(),
             c_variadic: decl.c_variadic(),
-            target_feature: attrs.iter().any(|attr| attr.has_name(sym::target_feature)),
+            attrs_flags,
         };
+
         self.r.delegation_fn_sigs.insert(self.r.local_def_id(id), sig);
     }
 }
