add lint preventing attr target regression

Author: Bryntet

compiler/rustc_ast_lowering/src/lib.rs

@@ -209,6 +209,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 tcx.features(),
                 registered_tools,
                 Late,
+                tcx.dcx(),
             ),
             delayed_lints: Vec::new(),
         }

compiler/rustc_attr_parsing/messages.ftl

@@ -211,6 +211,10 @@ attr_parsing_stability_outside_std = stability attributes may not be used outsid
 attr_parsing_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes
     .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.)
 
+attr_parsing_target_regression = attribute parser for `#[{$attribute_symbol}]` uses `AllowedTargets::AllowListWarnRest` but does not specify `Allow` or `Error` for target: `{$target}`
+    .help = this target is already emitting errs for all unparsed attrs so omitting it in `AllowListWarnRest` would mean a regression from emitting an error, to emitting a warn
+    .note = this is an internal rustc lint
+
 attr_parsing_unknown_version_literal =
     unknown version literal format, assuming it refers to a future version
 

compiler/rustc_attr_parsing/src/context.rs

@@ -90,7 +90,7 @@ use crate::session_diagnostics::{
 };
 use crate::target_checking::AllowedTargets;
 
-type GroupType<S> = LazyLock<GroupTypeInner<S>>;
+pub(crate) type GroupType<S> = LazyLock<GroupTypeInner<S>>;
 
 pub(super) struct GroupTypeInner<S: Stage> {
     pub(super) accepters: BTreeMap<&'static [Symbol], Vec<GroupTypeInnerAccept<S>>>,

compiler/rustc_attr_parsing/src/interface.rs

@@ -12,10 +12,11 @@ use rustc_session::Session;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
-use crate::context::{AcceptContext, FinalizeContext, SharedContext, Stage};
+use crate::context::{AcceptContext, FinalizeContext, GroupType, SharedContext, Stage};
 use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
 use crate::parser::{ArgParser, PathParser, RefPathParser};
-use crate::session_diagnostics::ParsedDescription;
+use crate::session_diagnostics::{AttributeTargetRegression, ParsedDescription};
+use crate::target_checking::AllowedTargets;
 use crate::{Early, Late, OmitDoc, ShouldEmit};
 
 /// Context created once, for example as part of the ast lowering
@@ -237,7 +238,9 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         features: &'sess Features,
         tools: Vec<Symbol>,
         stage: S,
+        dcx: DiagCtxtHandle<'_>,
     ) -> Self {
+        Self::check_allowed_attrs(S::parsers(), dcx);
         Self { features: Some(features), tools, parse_only: None, sess, stage }
     }
 
@@ -486,4 +489,31 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
             }
         }
     }
+
+    fn check_allowed_attrs(parsers: &'static GroupType<S>, dcx: DiagCtxtHandle<'_>) {
+        use crate::target_checking::Policy::{Allow, Error, Warn};
+        let targets = [Target::Param];
+        for (syms, accepters) in &parsers.accepters {
+            for accept in accepters {
+                let AllowedTargets::AllowListWarnRest(allow_list) = accept.allowed_targets else {
+                    continue;
+                };
+
+                let missing_targets = targets.into_iter().flat_map(|target| {
+                    (!allow_list.iter().any(|policy| {
+                        [Allow(target), Warn(target), Error(target)].contains(policy)
+                    }))
+                    .then_some(target)
+                });
+                for target in missing_targets {
+                    for sym in *syms {
+                        dcx.emit_warn(AttributeTargetRegression {
+                            attribute_symbol: *sym,
+                            target: target.name(),
+                        });
+                    }
+                }
+            }
+        }
+    }
 }

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -946,3 +946,12 @@ pub(crate) struct UnsupportedInstructionSet<'a> {
     pub instruction_set: Symbol,
     pub current_target: &'a TargetTuple,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_target_regression)]
+#[help]
+#[note]
+pub(crate) struct AttributeTargetRegression {
+    pub attribute_symbol: Symbol,
+    pub target: &'static str,
+}

compiler/rustc_resolve/src/def_collector.rs

@@ -144,6 +144,7 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
                     self.resolver.tcx.features(),
                     Vec::new(),
                     Early { emit_errors: ShouldEmit::Nothing },
+                    self.resolver.dcx(),
                 );
                 let attrs = parser.parse_attribute_list(
                     &i.attrs,