Some improvements

Author: aerooneqq

compiler/rustc_ast_lowering/src/delegation.rs

@@ -68,7 +68,7 @@ struct AttributeAdditionInfo {
     pub kind: AttributeAdditionKind,
 }
 
-struct AttributeAdditionStatus {
+struct AttributeAdditionState {
     pub info: &'static AttributeAdditionInfo,
     pub already_exists: bool,
 }
@@ -80,7 +80,7 @@ enum AttributeAdditionKind {
 
 const PARENT_ID: hir::ItemLocalId = hir::ItemLocalId::ZERO;
 
-static ATTRS_ADDITIONS: &'static [AttributeAdditionInfo; 2] = &[
+static ATTRIBUTES_ADDITIONS: &'static [AttributeAdditionInfo] = &[
     AttributeAdditionInfo {
         factory: |span| hir::Attribute::Parsed(AttributeKind::MustUse { span, reason: None }),
         equals: |a| matches!(a, hir::Attribute::Parsed(AttributeKind::MustUse { .. })),
@@ -135,12 +135,12 @@ impl<'hir> LoweringContext<'_, 'hir> {
     }
 
     fn add_attributes_if_needed(&mut self, span: Span, sig_id: DefId) {
-        let mut candidate_additions = ATTRS_ADDITIONS
+        let mut candidate_additions = ATTRIBUTES_ADDITIONS
             .iter()
-            .map(|a| AttributeAdditionStatus { info: a, already_exists: false })
+            .map(|info| AttributeAdditionState { info, already_exists: false })
             .collect::<Vec<_>>();
 
-        self.check_if_attributes_already_exist(&mut candidate_additions);
+        self.mark_existing_attributes(&mut candidate_additions);
         let new_attributes = self.create_new_attributes(&candidate_additions, span, sig_id);
 
         if new_attributes.is_empty() {
@@ -157,51 +157,50 @@ impl<'hir> LoweringContext<'_, 'hir> {
         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;
-                    }
+    fn mark_existing_attributes(&mut self, candidate_additions: &mut Vec<AttributeAdditionState>) {
+        let Some(existing_attrs) = self.attrs.get(&PARENT_ID) else { return };
 
-                    if (addition.info.equals)(attr) {
-                        addition.already_exists = true;
-                    }
+        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>,
+        candidate_additions: &Vec<AttributeAdditionState>,
         span: Span,
         sig_id: DefId,
     ) -> Vec<hir::Attribute> {
         candidate_additions
-            .into_iter()
+            .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 } => {
                         // Check if an attribute present on the target of delegation,
-                        // either in this crate or others
+                        // either in this crate or other
                         let should_inherit = match sig_id.as_local() {
-                            None => self
-                                .tcx
-                                .get_all_attrs(sig_id)
-                                .iter()
-                                .any(|base_attr| (a.info.equals)(base_attr)),
                             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
+                            None => self
+                                .tcx
+                                .get_all_attrs(sig_id)
+                                .iter()
+                                .any(|base_attr| (a.info.equals)(base_attr)),
                         };
 
                         match should_inherit {

compiler/rustc_resolve/src/late.rs

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