wip

Author: JonathanBrouwer

compiler/rustc_attr_parsing/messages.ftl

@@ -10,7 +10,7 @@ attr_parsing_empty_attribute =
     unused attribute
     .suggestion = remove this attribute
 
-attr_parsing_invalid_target = this attribute is not allowed on this target
+attr_parsing_invalid_target = `#[{$name}]` attribute cannot be used on {$article} {$target}
 
 attr_parsing_empty_confusables =
     expected at least one confusable name

compiler/rustc_attr_parsing/src/context.rs

@@ -61,7 +61,9 @@ use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
 use crate::context::MaybeWarn::{Allow, Error, Warn};
 use crate::parser::{ArgParser, MetaItemParser, PathParser};
-use crate::session_diagnostics::{AttributeParseError, AttributeParseErrorReason, UnknownMetaItem};
+use crate::session_diagnostics::{
+    AttributeParseError, AttributeParseErrorReason, InvalidTarget, UnknownMetaItem,
+};
 
 type GroupType<S> = LazyLock<GroupTypeInner<S>>;
 
@@ -905,16 +907,20 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                                     emit_lint(AttributeLint {
                                         id: target_id,
                                         span: n.item.span(),
-                                        kind: AttributeLintKind::InvalidTarget {},
+                                        kind: AttributeLintKind::InvalidTarget {
+                                            name: parts[0],
+                                            article: target.article(),
+                                            target: target.name(),
+                                        },
                                     });
                                 }
                                 AllowedResult::Error => {
-                                    self.dcx()
-                                        .struct_span_err(
-                                            n.item.span(),
-                                            "this attribute is not allowed on this target",
-                                        )
-                                        .emit();
+                                    self.dcx().emit_err(InvalidTarget {
+                                        span: n.item.span(),
+                                        name: parts[0],
+                                        article: target.article(),
+                                        target: target.name(),
+                                    });
                                 }
                             }
                         }

compiler/rustc_attr_parsing/src/lints.rs

@@ -34,11 +34,12 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<HirId>, lint_emi
             *first_span,
             session_diagnostics::EmptyAttributeList { attr_span: *first_span },
         ),
-        AttributeLintKind::InvalidTarget {} => lint_emitter.emit_node_span_lint(
-            rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            *id,
-            *span,
-            session_diagnostics::InvalidTarget {},
-        ),
+        &AttributeLintKind::InvalidTarget { name, article, target } => lint_emitter
+            .emit_node_span_lint(
+                rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
+                *id,
+                *span,
+                session_diagnostics::InvalidTargetLint { name, article, target },
+            ),
     }
 }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -482,7 +482,21 @@ pub(crate) struct EmptyAttributeList {
 
 #[derive(LintDiagnostic)]
 #[diag(attr_parsing_invalid_target)]
-pub(crate) struct InvalidTarget {}
+pub(crate) struct InvalidTargetLint {
+    pub name: Symbol,
+    pub article: &'static str,
+    pub target: &'static str,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_invalid_target)]
+pub(crate) struct InvalidTarget {
+    #[primary_span]
+    pub span: Span,
+    pub name: Symbol,
+    pub article: &'static str,
+    pub target: &'static str,
+}
 
 #[derive(Diagnostic)]
 #[diag(attr_parsing_invalid_alignment_value, code = E0589)]

compiler/rustc_hir/src/lints.rs

@@ -1,6 +1,6 @@
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_macros::HashStable_Generic;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 use crate::HirId;
 
@@ -34,5 +34,5 @@ pub enum AttributeLintKind {
     UnusedDuplicate { this: Span, other: Span, warning: bool },
     IllFormedAttributeInput { suggestions: Vec<String> },
     EmptyAttribute { first_span: Span },
-    InvalidTarget {},
+    InvalidTarget { name: Symbol, article: &'static str, target: &'static str },
 }

compiler/rustc_hir/src/target.rs

@@ -261,6 +261,19 @@ impl Target {
         }
     }
 
+    pub fn article(self) -> &'static str {
+        match self {
+            Target::ExternCrate
+            | Target::Enum
+            | Target::Impl { .. }
+            | Target::Expression
+            | Target::Arm
+            | Target::AssocConst
+            | Target::AssocTy => "an",
+            _ => "a",
+        }
+    }
+
     pub fn name(self) -> &'static str {
         match self {
             Target::ExternCrate => "extern crate",

compiler/rustc_passes/messages.ftl

@@ -379,7 +379,7 @@ passes_linkage =
     .label = not a function definition or static
 
 passes_loop_match_attr =
-    `#[loop_match]` this attribute is not allowed on this target
+    `#[loop_match]` attribute cannot be used on
     .label = not a loop
 
 passes_macro_export =

tests/ui/asm/naked-invalid-attr.rs

@@ -1,25 +1,25 @@
 // Checks that the #[unsafe(naked)] attribute can be placed on function definitions only.
 //
 //@ needs-asm-support
-#![unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+#![unsafe(naked)] //~ ERROR attribute cannot be used on
 
 use std::arch::naked_asm;
 
 extern "C" {
-    #[unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+    #[unsafe(naked)] //~ ERROR attribute cannot be used on
     fn f();
 }
 
-#[unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+#[unsafe(naked)] //~ ERROR attribute cannot be used on
 #[repr(C)]
 struct S {
-    #[unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+    #[unsafe(naked)] //~ ERROR attribute cannot be used on
     a: u32,
     b: u32,
 }
 
 trait Invoke {
-    #[unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+    #[unsafe(naked)] //~ ERROR attribute cannot be used on
     extern "C" fn invoke(&self);
 }
 
@@ -48,7 +48,7 @@ impl S {
 }
 
 fn main() {
-    #[unsafe(naked)] //~ ERROR this attribute is not allowed on this target
+    #[unsafe(naked)] //~ ERROR attribute cannot be used on
     || {};
 }
 

tests/ui/asm/naked-invalid-attr.stderr

@@ -4,37 +4,37 @@ error[E0433]: failed to resolve: use of unresolved module or unlinked crate `a`
 LL | #[::a]
    |     ^ use of unresolved module or unlinked crate `a`
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a crate
   --> $DIR/naked-invalid-attr.rs:4:11
    |
 LL | #![unsafe(naked)]
    |           ^^^^^
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a foreign function
   --> $DIR/naked-invalid-attr.rs:9:14
    |
 LL |     #[unsafe(naked)]
    |              ^^^^^
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a struct
   --> $DIR/naked-invalid-attr.rs:13:10
    |
 LL | #[unsafe(naked)]
    |          ^^^^^
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a struct field
   --> $DIR/naked-invalid-attr.rs:16:14
    |
 LL |     #[unsafe(naked)]
    |              ^^^^^
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a required trait method
   --> $DIR/naked-invalid-attr.rs:22:14
    |
 LL |     #[unsafe(naked)]
    |              ^^^^^
 
-error: this attribute is not allowed on this target
+error: `#[naked]` attribute cannot be used on a closure
   --> $DIR/naked-invalid-attr.rs:51:14
    |
 LL |     #[unsafe(naked)]

tests/ui/attributes/attrs-on-params.rs

@@ -1,7 +1,7 @@
 // This checks that incorrect params on function parameters are caught
 
 fn function(#[inline] param: u32) {
-    //~^ ERROR this attribute is not allowed on this target
+    //~^ ERROR attribute cannot be used on
     //~| ERROR allow, cfg, cfg_attr, deny, expect, forbid, and warn are the only allowed built-in attributes
 }