Rollup merge of rust-lang#157120 - JonathanBrouwer:repr-target-checking, r=mejrs

Cleanups around attribute target checking

This is in preparation for a new approach I'm trying for rust-lang#156569
So r? @mejrs

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/interface.rs

@@ -412,9 +412,7 @@ impl<'sess> AttributeParser<'sess> {
                         (accept.accept_fn)(&mut cx, &args);
                         finalizers.push(accept.finalizer);
 
-                        if !matches!(cx.should_emit, ShouldEmit::Nothing) {
-                            Self::check_target(&accept.allowed_targets, target, &mut cx);
-                        }
+                        Self::check_target(&accept.allowed_targets, &mut cx);
                     } else {
                         let attr = AttrItem {
                             path: attr_path.clone(),

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -7,14 +7,14 @@ use rustc_hir::attrs::AttributeKind;
 use rustc_hir::{AttrItem, Attribute, MethodKind, Target};
 use rustc_span::{BytePos, FileName, RemapPathScopeComponents, Span, Symbol, sym};
 
-use crate::AttributeParser;
 use crate::context::AcceptContext;
 use crate::errors::{
     InvalidAttrAtCrateLevel, InvalidTargetLint, ItemFollowingInnerAttr,
     UnsupportedAttributesInWhere,
 };
 use crate::session_diagnostics::InvalidTarget;
 use crate::target_checking::Policy::Allow;
+use crate::{AttributeParser, ShouldEmit};
 
 #[derive(Debug)]
 pub(crate) enum AllowedTargets {
@@ -90,17 +90,20 @@ pub(crate) enum Policy {
 impl<'sess> AttributeParser<'sess> {
     pub(crate) fn check_target(
         allowed_targets: &AllowedTargets,
-        target: Target,
         cx: &mut AcceptContext<'_, 'sess>,
     ) {
+        if matches!(cx.should_emit, ShouldEmit::Nothing) {
+            return;
+        }
+
         // For crate-level attributes we emit a specific set of lints to warn
         // people about accidentally not using them on the crate.
         if let &AllowedTargets::AllowList(&[Allow(Target::Crate)]) = allowed_targets {
-            Self::check_crate_level(target, cx);
+            Self::check_crate_level(cx);
             return;
         }
 
-        if matches!(cx.attr_path.segments.as_ref(), [sym::repr]) && target == Target::Crate {
+        if matches!(cx.attr_path.segments.as_ref(), [sym::repr]) && cx.target == Target::Crate {
             // The allowed targets of `repr` depend on its arguments. They can't be checked using
             // the `AttributeParser` code.
             let span = cx.attr_span;
@@ -119,11 +122,12 @@ impl<'sess> AttributeParser<'sess> {
                 .emit();
         }
 
-        match allowed_targets.is_allowed(target) {
+        match allowed_targets.is_allowed(cx.target) {
             AllowedResult::Allowed => {}
             AllowedResult::Warn => {
                 let allowed_targets = allowed_targets.allowed_targets();
-                let (applied, only) = allowed_targets_applied(allowed_targets, target, cx.features);
+                let (applied, only) =
+                    allowed_targets_applied(allowed_targets, cx.target, cx.features);
                 let name = cx.attr_path.clone();
 
                 let lint = if name.segments[0] == sym::deprecated
@@ -134,14 +138,15 @@ impl<'sess> AttributeParser<'sess> {
                         Target::Arm,
                         Target::MacroCall,
                     ]
-                    .contains(&target)
+                    .contains(&cx.target)
                 {
                     rustc_session::lint::builtin::USELESS_DEPRECATED
                 } else {
                     rustc_session::lint::builtin::UNUSED_ATTRIBUTES
                 };
 
                 let attr_span = cx.attr_span;
+                let target = cx.target;
                 cx.emit_lint_with_sess(
                     lint,
                     move |dcx, level, _| {
@@ -161,12 +166,13 @@ impl<'sess> AttributeParser<'sess> {
             }
             AllowedResult::Error => {
                 let allowed_targets = allowed_targets.allowed_targets();
-                let (applied, only) = allowed_targets_applied(allowed_targets, target, cx.features);
+                let (applied, only) =
+                    allowed_targets_applied(allowed_targets, cx.target, cx.features);
                 let name = cx.attr_path.clone();
                 cx.dcx().emit_err(InvalidTarget {
                     span: cx.attr_span.clone(),
                     name,
-                    target: target.plural_name(),
+                    target: cx.target.plural_name(),
                     only: if only { "only " } else { "" },
                     applied: DiagArgValue::StrListSepByAnd(
                         applied.into_iter().map(Cow::Owned).collect(),
@@ -176,8 +182,8 @@ impl<'sess> AttributeParser<'sess> {
         }
     }
 
-    pub(crate) fn check_crate_level(target: Target, cx: &mut AcceptContext<'_, 'sess>) {
-        if target == Target::Crate {
+    pub(crate) fn check_crate_level(cx: &mut AcceptContext<'_, 'sess>) {
+        if cx.target == Target::Crate {
             return;
         }
 
@@ -200,6 +206,7 @@ impl<'sess> AttributeParser<'sess> {
             })
             .unwrap_or_default();
 
+        let target = cx.target;
         cx.emit_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
             crate::errors::InvalidAttrStyle {