Wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/deprecation.rs

@@ -47,6 +47,7 @@ impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
         Target::Union,
         Target::Const,
         Target::Static,
+        Target::MacroDef,
     ];
     const TEMPLATE: AttributeTemplate = template!(
         Word,

compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs

@@ -110,7 +110,7 @@ impl<S: Stage> AttributeParser<S> for MacroUseParser {
             }
         },
     )];
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Mod, Target::ExternCrate];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Mod, Target::ExternCrate, Target::Crate]; //TODO crate?
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         Some(AttributeKind::MacroUse { span: self.first_span?, arguments: self.state })

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -26,6 +26,12 @@ macro_rules! reject_outside_std {
     };
 }
 
+const ALLOWED_TARGETS: &[Target] = &[Target::Fn,
+    Target::Struct,
+    Target::Method(MethodKind::Inherent),
+    Target::Impl { of_trait: true },
+    Target::MacroDef];
+
 #[derive(Default)]
 pub(crate) struct StabilityParser {
     allowed_through_unstable_modules: Option<Symbol>,
@@ -87,12 +93,7 @@ impl<S: Stage> AttributeParser<S> for StabilityParser {
             },
         ),
     ];
-    const ALLOWED_TARGETS: &'static [Target] = &[
-        Target::Fn,
-        Target::Struct,
-        Target::Method(MethodKind::Inherent),
-        Target::Impl { of_trait: true },
-    ];
+    const ALLOWED_TARGETS: &'static [Target] = ALLOWED_TARGETS;
 
     fn finalize(mut self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if let Some(atum) = self.allowed_through_unstable_modules {
@@ -148,7 +149,7 @@ impl<S: Stage> AttributeParser<S> for BodyStabilityParser {
             }
         },
     )];
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::AssocConst, Target::Fn];
+    const ALLOWED_TARGETS: &'static [Target] = ALLOWED_TARGETS;
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         let (stability, span) = self.stability?;
@@ -213,7 +214,7 @@ impl<S: Stage> AttributeParser<S> for ConstStabilityParser {
             this.promotable = true;
         }),
     ];
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn, Target::ForeignFn];
+    const ALLOWED_TARGETS: &'static [Target] = ALLOWED_TARGETS;
 
     fn finalize(mut self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if self.promotable {

compiler/rustc_attr_parsing/src/context.rs

@@ -72,6 +72,7 @@ struct GroupTypeInner<S: Stage> {
 struct GroupTypeInnerAccept<S: Stage> {
     template: AttributeTemplate,
     accept_fn: AcceptFn<S>,
+    allowed_targets: &'static [Target],
 }
 
 type AcceptFn<S> =
@@ -119,7 +120,8 @@ macro_rules! attribute_parsers {
                                 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:?}");
                         }
@@ -847,7 +849,11 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                             attr_path: path.get_attribute_path(),
                         };
 
-                        (accept.accept_fn)(&mut cx, args)
+                        (accept.accept_fn)(&mut cx, args);
+
+                        if !accept.allowed_targets.contains(&target) {
+                            self.dcx().span_bug(n.item.span(), format!("{:?} target {target:?} not allowed {:?}", parts, accept.allowed_targets));
+                        }
                     } else {
                         // If we're here, we must be compiling a tool attribute... Or someone
                         // forgot to parse their fancy new attribute. Let's warn them in any case.