Adressing review comments

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -63,33 +63,30 @@ pub(crate) struct DelegationResults<'hir> {
 }
 
 struct AttributeAdditionInfo {
-    pub factory: fn(Span) -> hir::Attribute,
     pub equals: fn(&hir::Attribute) -> bool,
     pub kind: AttributeAdditionKind,
 }
 
-struct AttributeAdditionState {
-    pub info: &'static AttributeAdditionInfo,
-    pub already_exists: bool,
-}
-
 enum AttributeAdditionKind {
-    Default,
-    Inherit { flag: DelegationFnSigAttrs },
+    Default { factory: fn(Span) -> hir::Attribute },
+    Inherit { flag: DelegationFnSigAttrs, factory: fn(Span) -> hir::Attribute },
 }
 
 const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
 
-static ATTRIBUTES_ADDITIONS: &'static [AttributeAdditionInfo] = &[
+static ATTRIBUTES_ADDITIONS: &[AttributeAdditionInfo] = &[
     AttributeAdditionInfo {
-        factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
         equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
-        kind: AttributeAdditionKind::Inherit { flag: DelegationFnSigAttrs::MUST_USE },
+        kind: AttributeAdditionKind::Inherit {
+            factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
+            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,
+        kind: AttributeAdditionKind::Default {
+            factory: |span| hir::Attribute::Parsed(AttributeKind::Inline(InlineAttr::Hint, span)),
+        },
     },
 ];
 
@@ -135,13 +132,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn add_attributes_if_needed(&mut self, span: Span, sig_id: DefId) {
-        let mut candidate_additions = ATTRIBUTES_ADDITIONS
-            .iter()
-            .map(|info| AttributeAdditionState { info, already_exists: false })
-            .collect::<Vec<_>>();
-
-        self.mark_existing_attributes(&mut candidate_additions);
-        let new_attributes = self.create_new_attributes(&candidate_additions, span, sig_id);
+        let new_attributes = self.create_new_attributes(
+            ATTRIBUTES_ADDITIONS,
+            span,
+            sig_id,
+            self.attrs.get(&PARENT_ID),
+        );
 
         if new_attributes.is_empty() {
             return;
@@ -157,35 +153,27 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.attrs.insert(PARENT_ID, new_arena_allocated_attributes);
     }
 
-    fn mark_existing_attributes(&mut self, candidate_additions: &mut Vec<AttributeAdditionState>) {
-        let Some(existing_attrs) = self.attrs.get(&PARENT_ID) else { return };
-
-        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<AttributeAdditionState>,
+        &self,
+        candidate_additions: &[AttributeAdditionInfo],
         span: Span,
         sig_id: DefId,
+        existing_attrs: Option<&&[hir::Attribute]>,
     ) -> Vec<hir::Attribute> {
         candidate_additions
             .iter()
-            .filter_map(|a| match a.already_exists {
-                true => None,
-                false => match a.info.kind {
-                    AttributeAdditionKind::Default => Some((a.info.factory)(span)),
-                    AttributeAdditionKind::Inherit { flag } => {
+            .filter_map(|addition_info| {
+                if let Some(existing_attrs) = existing_attrs
+                    && existing_attrs
+                        .iter()
+                        .any(|existing_attr| (addition_info.equals)(existing_attr))
+                {
+                    return None;
+                }
+
+                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() {
@@ -200,15 +188,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                 .tcx
                                 .get_all_attrs(sig_id)
                                 .iter()
-                                .any(|base_attr| (a.info.equals)(base_attr)),
+                                .any(|base_attr| (addition_info.equals)(base_attr)),
                         };
 
                         match should_inherit {
-                            true => Some((a.info.factory)(span)),
+                            true => Some(factory(span)),
                             false => None,
                         }
                     }
-                },
+                }
             })
             .collect::<Vec<_>>()
     }

compiler/rustc_resolve/src/late.rs

@@ -5294,15 +5294,15 @@ impl ItemInfoCollector<'_, '_, '_> {
         id: NodeId,
         attrs: &[Attribute],
     ) {
-        static NAMES_TO_FLAGS: &'static [(Symbol, DelegationFnSigAttrs)] = &[
+        static NAMES_TO_FLAGS: &[(Symbol, DelegationFnSigAttrs)] = &[
             (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.iter().map(|(s, f)| (*s, *f)) {
-                if !attrs_flags.contains(flag) && attr.has_name(name) {
+            for &(name, flag) in NAMES_TO_FLAGS {
+                if attr.has_name(name) {
                     attrs_flags.set(flag, true);
                     continue;
                 }