wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/context.rs

@@ -71,7 +71,7 @@ use crate::session_diagnostics::{
 type GroupType<S> = LazyLock<GroupTypeInner<S>>;
 
 struct GroupTypeInner<S: Stage> {
-    accepters: BTreeMap<&'static [Symbol], GroupTypeInnerAccept<S>>,
+    accepters: BTreeMap<&'static [Symbol], Vec<GroupTypeInnerAccept<S>>>,
     finalizers: Vec<FinalizeFn<S>>,
 }
 
@@ -111,7 +111,7 @@ macro_rules! attribute_parsers {
         @[$stage: ty] pub(crate) static $name: ident = [$($names: ty),* $(,)?];
     ) => {
         pub(crate) static $name: GroupType<$stage> = LazyLock::new(|| {
-            let mut accepts = BTreeMap::<_, GroupTypeInnerAccept<$stage>>::new();
+            let mut accepts = BTreeMap::<_, Vec<GroupTypeInnerAccept<$stage>>>::new();
             let mut finalizes = Vec::<FinalizeFn<$stage>>::new();
             $(
                 {
@@ -120,17 +120,15 @@ macro_rules! attribute_parsers {
                     };
 
                     for (path, template, accept_fn) in <$names>::ATTRIBUTES {
-                        if accepts.insert(*path, GroupTypeInnerAccept {
+                        accepts.entry(*path).or_default().push(GroupTypeInnerAccept {
                             template: *template,
                             accept_fn: Box::new(|cx, args| {
                                 STATE_OBJECT.with_borrow_mut(|s| {
                                     accept_fn(s, cx, args)
                                 })
                             }),
                             allowed_targets: <$names as crate::attributes::AttributeParser<$stage>>::ALLOWED_TARGETS,
-                        }).is_some() {
-                            panic!("Found two attribute parsers for attribute {path:?}");
-                        }
+                        });
                     }
 
                     finalizes.push(Box::new(|cx| {
@@ -903,53 +901,55 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                     let args = parser.args();
                     let parts = path.segments().map(|i| i.name).collect::<Vec<_>>();
 
-                    if let Some(accept) = S::parsers().accepters.get(parts.as_slice()) {
-                        let mut cx: AcceptContext<'_, 'sess, S> = AcceptContext {
-                            shared: SharedContext {
-                                cx: self,
-                                target_span,
-                                target_id,
-                                emit_lint: &mut emit_lint,
-                            },
-                            attr_span: lower_span(attr.span),
-                            template: &accept.template,
-                            attr_path: path.get_attribute_path(),
-                        };
-
-                        (accept.accept_fn)(&mut cx, args);
-
-                        if self.stage.should_emit().should_emit() {
-                            match accept.allowed_targets.is_allowed(target) {
-                                AllowedResult::Allowed => {}
-                                AllowedResult::Warn => {
-                                    let allowed_targets = accept.allowed_targets.allowed_targets();
-                                    emit_lint(AttributeLint {
-                                        id: target_id,
-                                        span: attr.span,
-                                        kind: AttributeLintKind::InvalidTarget {
+                    if let Some(accepts) = S::parsers().accepters.get(parts.as_slice()) {
+                        for accept in accepts {
+                            let mut cx: AcceptContext<'_, 'sess, S> = AcceptContext {
+                                shared: SharedContext {
+                                    cx: self,
+                                    target_span,
+                                    target_id,
+                                    emit_lint: &mut emit_lint,
+                                },
+                                attr_span: lower_span(attr.span),
+                                template: &accept.template,
+                                attr_path: path.get_attribute_path(),
+                            };
+
+                            (accept.accept_fn)(&mut cx, args);
+
+                            if self.stage.should_emit().should_emit() {
+                                match accept.allowed_targets.is_allowed(target) {
+                                    AllowedResult::Allowed => {}
+                                    AllowedResult::Warn => {
+                                        let allowed_targets = accept.allowed_targets.allowed_targets();
+                                        emit_lint(AttributeLint {
+                                            id: target_id,
+                                            span: attr.span,
+                                            kind: AttributeLintKind::InvalidTarget {
+                                                name: parts[0],
+                                                target: target.plural_name(),
+                                                only: if allowed_targets.len() == 1 {
+                                                    "only "
+                                                } else {
+                                                    ""
+                                                },
+                                                applied: allowed_targets_applied(
+                                                    allowed_targets,
+                                                    target,
+                                                ),
+                                            },
+                                        });
+                                    }
+                                    AllowedResult::Error => {
+                                        let allowed_targets = accept.allowed_targets.allowed_targets();
+                                        self.dcx().emit_err(InvalidTarget {
+                                            span: attr.span,
                                             name: parts[0],
                                             target: target.plural_name(),
-                                            only: if allowed_targets.len() == 1 {
-                                                "only "
-                                            } else {
-                                                ""
-                                            },
-                                            applied: allowed_targets_applied(
-                                                allowed_targets,
-                                                target,
-                                            ),
-                                        },
-                                    });
-                                }
-                                AllowedResult::Error => {
-                                    let allowed_targets = accept.allowed_targets.allowed_targets();
-                                    self.dcx().emit_err(InvalidTarget {
-                                        span: attr.span,
-                                        name: parts[0],
-                                        target: target.plural_name(),
-                                        only: if allowed_targets.len() == 1 { "only " } else { "" },
-                                        applied: allowed_targets_applied(allowed_targets, target),
-                                    });
+                                            only: if allowed_targets.len() == 1 { "only " } else { "" },
+                                            applied: allowed_targets_applied(allowed_targets, target),
+                                        });
+                                    }
                                 }
                             }
                         }