Wip

JonathanBrouwer · JonathanBrouwer · commit 1cffc481325a · 2025-08-09T18:59:23.000+02:00
Signed-off-by: Jonathan Brouwer &lt;jonathantbrouwer@gmail.com&gt;
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -16,7 +16,10 @@ impl<S: Stage> CombineAttributeParser<S> for AllowInternalUnstableParser {
     type Item = (Symbol, Span);
     const CONVERT: ConvertFn<Self::Item> =
         |items, span| AttributeKind::AllowInternalUnstable(items, span);
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::MacroDef];
+    const ALLOWED_TARGETS: &'static [Target] = &[
+        Target::MacroDef,
+        Target::Fn, //TODO if proc macro
+    ];
     const TEMPLATE: AttributeTemplate = template!(Word, List: "feat1, feat2, ...");
 
     fn extend<'c>(
diff --git a/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs
@@ -62,7 +62,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for ColdParser {
         Target::Method(MethodKind::Trait { body: false }),
         Target::Method(MethodKind::Inherent),
         Target::ForeignFn,
-        Target::Closure
+        Target::Closure,
     ];
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Cold;
 }
@@ -164,7 +164,11 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
                 this.span = Some(cx.attr_span);
             }
         })];
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn];
+    const ALLOWED_TARGETS: &'static [Target] = &[
+        Target::Fn,
+        Target::Method(MethodKind::Inherent),
+        Target::Method(MethodKind::Trait { body: true }),
+    ];
 
     fn finalize(self, cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         // FIXME(jdonszelmann): upgrade this list to *parsed* attributes
@@ -261,6 +265,9 @@ impl<S: Stage> NoArgsAttributeParser<S> for TrackCallerParser {
         Target::Fn,
         Target::Method(MethodKind::Inherent),
         Target::Method(MethodKind::Trait { body: true }),
+        Target::Method(MethodKind::Trait { body: false }),
+        Target::ForeignFn,
+        Target::Closure,
     ];
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::TrackCaller;
 }
@@ -269,7 +276,7 @@ pub(crate) struct NoMangleParser;
 impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
     const PATH: &[Symbol] = &[sym::no_mangle];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn, Target::Static];
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::NoMangle;
 }
 
@@ -408,5 +415,5 @@ impl<S: Stage> CombineAttributeParser<S> for TargetFeatureParser {
         features
     }
 
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn, Target::Method(MethodKind::Inherent)];
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/confusables.rs b/compiler/rustc_attr_parsing/src/attributes/confusables.rs
@@ -42,11 +42,7 @@ impl<S: Stage> AttributeParser<S> for ConfusablesParser {
             this.first_span.get_or_insert(cx.attr_span);
         },
     )];
-    const ALLOWED_TARGETS: &'static [Target] = &[
-        Target::Method(MethodKind::Inherent),
-        Target::Method(MethodKind::Trait { body: false }),
-        Target::Method(MethodKind::Trait { body: true }),
-    ];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Method(MethodKind::Inherent)];
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if self.confusables.is_empty() {
diff --git a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
@@ -51,6 +51,9 @@ impl<S: Stage> SingleAttributeParser<S> for DeprecationParser {
         Target::Method(MethodKind::Inherent),
         Target::TyAlias,
         Target::Use,
+        Target::ForeignFn,
+        Target::Field,
+        Target::Trait,
     ];
     const TEMPLATE: AttributeTemplate = template!(
         Word,
diff --git a/compiler/rustc_attr_parsing/src/attributes/dummy.rs b/compiler/rustc_attr_parsing/src/attributes/dummy.rs
@@ -1,6 +1,6 @@
 use rustc_feature::{AttributeTemplate, template};
-use rustc_hir::Target;
 use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{MethodKind, Target};
 use rustc_span::{Symbol, sym};
 
 use crate::attributes::{AttributeOrder, OnDuplicate, SingleAttributeParser};
@@ -12,7 +12,46 @@ impl<S: Stage> SingleAttributeParser<S> for DummyParser {
     const PATH: &[Symbol] = &[sym::rustc_dummy];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
-    const ALLOWED_TARGETS: &'static [Target] = &[];
+    const ALLOWED_TARGETS: &'static [Target] = &[
+        //TODO better solution than listing everything here?
+        Target::ExternCrate,
+        Target::Use,
+        Target::Static,
+        Target::Const,
+        Target::Fn,
+        Target::Closure,
+        Target::Mod,
+        Target::ForeignMod,
+        Target::GlobalAsm,
+        Target::TyAlias,
+        Target::Enum,
+        Target::Variant,
+        Target::Struct,
+        Target::Field,
+        Target::Union,
+        Target::Trait,
+        Target::TraitAlias,
+        Target::Impl { of_trait: false },
+        Target::Impl { of_trait: true },
+        Target::Expression,
+        Target::Statement,
+        Target::Arm,
+        Target::AssocConst,
+        Target::Method(MethodKind::Inherent),
+        Target::Method(MethodKind::Trait { body: false }),
+        Target::Method(MethodKind::Trait { body: true }),
+        Target::AssocTy,
+        Target::ForeignFn,
+        Target::ForeignStatic,
+        Target::ForeignTy,
+        Target::MacroDef,
+        Target::Param,
+        Target::PatField,
+        Target::ExprField,
+        Target::WherePredicate,
+        Target::MacroCall,
+        Target::Crate,
+    ];
     const TEMPLATE: AttributeTemplate = template!(Word); // Anything, really
 
     fn convert(_: &mut AcceptContext<'_, '_, S>, _: &ArgParser<'_>) -> Option<AttributeKind> {
diff --git a/compiler/rustc_attr_parsing/src/attributes/inline.rs b/compiler/rustc_attr_parsing/src/attributes/inline.rs
@@ -24,6 +24,7 @@ impl<S: Stage> SingleAttributeParser<S> for InlineParser {
         Target::Method(MethodKind::Inherent),
         Target::Method(MethodKind::Trait { body: false }),
         Target::Method(MethodKind::Trait { body: true }),
+        Target::Closure,
     ];
     const TEMPLATE: AttributeTemplate = template!(Word, List: "always|never");
 
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -40,7 +40,7 @@ impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
     const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::ForeignMod];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Static, Target::Fn];
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: "name");
 
     fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser<'_>) -> Option<AttributeKind> {
diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -46,7 +46,8 @@ const ALLOWED_TARGETS: &[Target] = &[
     Target::TyAlias,
     Target::Variant,
     Target::Field,
-    Target::Param
+    Target::Param,
+    Target::Static,
 ];
 
 #[derive(Default)]
@@ -179,7 +180,7 @@ pub(crate) struct ConstStabilityIndirectParser;
 impl<S: Stage> NoArgsAttributeParser<S> for ConstStabilityIndirectParser {
     const PATH: &[Symbol] = &[sym::rustc_const_stable_indirect];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Ignore;
-    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn];
+    const ALLOWED_TARGETS: &'static [Target] = &[Target::Fn, Target::Method(MethodKind::Inherent)];
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::ConstStabilityIndirect;
 }
 
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
@@ -854,11 +854,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                         if self.stage.should_emit().should_emit()
                             && !accept.allowed_targets.contains(&target)
                         {
-                            if parts == &[sym::cold] && target == (Target::Expression) {
-                                panic!();
-                            }
-
-                            self.dcx().span_bug(
+                            self.dcx().span_delayed_bug(
                                 n.item.span(),
                                 format!(
                                     "{:?} target {target:?} not allowed {:?}",
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
@@ -7,6 +7,7 @@
 use std::fmt::{self, Display};
 
 use rustc_ast::{AssocItemKind, ForeignItemKind, ast};
+
 use crate::def::DefKind;
 use crate::{Item, ItemKind, TraitItem, TraitItemKind, hir};
 
@@ -237,11 +238,7 @@ impl Target {
     }
 
     pub fn from_expr(expr: &ast::Expr) -> Self {
-        if let ast::ExprKind::Closure(..) = expr.kind {
-            Self::Closure
-        } else {
-            Self::Expression
-        }
+        if let ast::ExprKind::Closure(..) = expr.kind { Self::Closure } else { Self::Expression }
     }
 
     pub fn name(self) -> &'static str {
