Auto merge of #146420 - jdonszelmann:crate-level-into-allowed-targets, r=scrabsha

Crate level into allowed targets
r? `@scrabsha`
`@rustbot` blocked on #146389

Author: bors

compiler/rustc_attr_parsing/src/attributes/crate_level.rs

@@ -43,11 +43,7 @@ impl<S: Stage> SingleAttributeParser<S> for CrateNameParser {
 constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::WarnButFutureError;
 constTEMPLATE:AttributeTemplate = template!(NameValueStr:"name");
-constTYPE:AttributeType = AttributeType::CrateLevel;
-
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 letArgParser::NameValue(n) = args else{
@@ -76,11 +72,7 @@ impl<S: Stage> SingleAttributeParser<S> for RecursionLimitParser {
 constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::WarnButFutureError;
 constTEMPLATE:AttributeTemplate = template!(NameValueStr:"N","https://doc.rust-lang.org/reference/attributes/limits.html#the-recursion_limit-attribute");
-constTYPE:AttributeType = AttributeType::CrateLevel;
-
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 letArgParser::NameValue(nv) = args else{
@@ -103,11 +95,7 @@ impl<S: Stage> SingleAttributeParser<S> for MoveSizeLimitParser {
 constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
 constTEMPLATE:AttributeTemplate = template!(NameValueStr:"N");
-constTYPE:AttributeType = AttributeType::CrateLevel;
-
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 letArgParser::NameValue(nv) = args else{
@@ -130,11 +118,7 @@ impl<S: Stage> SingleAttributeParser<S> for TypeLengthLimitParser {
 constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::WarnButFutureError;
 constTEMPLATE:AttributeTemplate = template!(NameValueStr:"N");
-constTYPE:AttributeType = AttributeType::CrateLevel;
-
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 letArgParser::NameValue(nv) = args else{
@@ -157,11 +141,7 @@ impl<S: Stage> SingleAttributeParser<S> for PatternComplexityLimitParser {
 constATTRIBUTE_ORDER:AttributeOrder = AttributeOrder::KeepOutermost;
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
 constTEMPLATE:AttributeTemplate = template!(NameValueStr:"N");
-constTYPE:AttributeType = AttributeType::CrateLevel;
-
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 letArgParser::NameValue(nv) = args else{
@@ -182,21 +162,15 @@ pub(crate) struct NoCoreParser;
 impl<S:Stage>NoArgsAttributeParser<S>forNoCoreParser{
 constPATH:&[Symbol] = &[sym::no_core];
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Warn;
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 constCREATE:fn(Span) -> AttributeKind = AttributeKind::NoCore;
-constTYPE:AttributeType = AttributeType::CrateLevel;
 }
 
 pub(crate)structNoStdParser;
 
 impl<S:Stage>NoArgsAttributeParser<S>forNoStdParser{
 constPATH:&[Symbol] = &[sym::no_std];
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Warn;
-// because it's a crate-level attribute, we already warn about it.
-// Putting target limitations here would give duplicate warnings
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(ALL_TARGETS);
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 constCREATE:fn(Span) -> AttributeKind = AttributeKind::NoStd;
-constTYPE:AttributeType = AttributeType::CrateLevel;
 }

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -12,15 +12,11 @@
 //! - [`CombineAttributeParser`](crate::attributes::CombineAttributeParser): makes it easy to implement an attribute which should combine the
 //! contents of attributes, if an attribute appear multiple times in a list
 //!
-//! By default, attributes are allowed anywhere. When adding an attribute that should only be used
-//! at the crate root, consider setting the `TYPE` in the parser trait to
-//! [`AttributeType::CrateLevel`](rustc_feature::AttributeType::CrateLevel).
-//!
 //! Attributes should be added to `crate::context::ATTRIBUTE_PARSERS` to be parsed.
 
 use std::marker::PhantomData;
 
-use rustc_feature::{AttributeTemplate,AttributeType,template};
+use rustc_feature::{AttributeTemplate, template};
 use rustc_hir::attrs::AttributeKind;
 use rustc_span::{Span,Symbol};
 use thin_vec::ThinVec;
@@ -89,11 +85,8 @@ pub(crate) trait AttributeParser<S: Stage>: Default + 'static {
 ///
 /// If an attribute has this symbol, the `accept` function will be called on it.
 constATTRIBUTES:AcceptMapping<Self,S>;
-
 constALLOWED_TARGETS:AllowedTargets;
 
-constTYPE:AttributeType = AttributeType::Normal;
-
 /// The parser has gotten a chance to accept the attributes on an item,
 /// here it can produce an attribute.
 ///
@@ -135,8 +128,6 @@ pub(crate) trait SingleAttributeParser<S: Stage>: 'static {
 /// The template this attribute parser should implement. Used for diagnostics.
 constTEMPLATE:AttributeTemplate;
 
-constTYPE:AttributeType = AttributeType::Normal;
-
 /// Converts a single syntactical attribute to a single semantic attribute, or [`AttributeKind`]
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>;
 }
@@ -183,8 +174,6 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
 )];
 constALLOWED_TARGETS:AllowedTargets = T::ALLOWED_TARGETS;
 
-constTYPE:AttributeType = T::TYPE;
-
 fnfinalize(self,_cx:&FinalizeContext<'_,'_,S>) -> Option<AttributeKind>{
 Some(self.1?.0)
 }
@@ -269,7 +258,6 @@ pub(crate) trait NoArgsAttributeParser<S: Stage>: 'static {
 constPATH:&[Symbol];
 constON_DUPLICATE:OnDuplicate<S>;
 constALLOWED_TARGETS:AllowedTargets;
-constTYPE:AttributeType = AttributeType::Normal;
 
 /// Create the [`AttributeKind`] given attribute's [`Span`].
 constCREATE:fn(Span) -> AttributeKind;
@@ -289,7 +277,6 @@ impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for Without
 constON_DUPLICATE:OnDuplicate<S> = T::ON_DUPLICATE;
 constALLOWED_TARGETS:AllowedTargets = T::ALLOWED_TARGETS;
 constTEMPLATE:AttributeTemplate = template!(Word);
-constTYPE:AttributeType = T::TYPE;
 
 fnconvert(cx:&mutAcceptContext<'_,'_,S>,args:&ArgParser<'_>) -> Option<AttributeKind>{
 ifletErr(span) = args.no_args(){
@@ -323,8 +310,6 @@ pub(crate) trait CombineAttributeParser<S: Stage>: 'static {
 /// The template this attribute parser should implement. Used for diagnostics.
 constTEMPLATE:AttributeTemplate;
 
-constTYPE:AttributeType = AttributeType::Normal;
-
 /// Converts a single syntactical attribute to a number of elements of the semantic attribute, or [`AttributeKind`]
 fnextend<'c>(
 cx:&'cmutAcceptContext<'_,'_,S>,
@@ -360,7 +345,6 @@ impl<T: CombineAttributeParser<S>, S: Stage> AttributeParser<S> for Combine<T, S
  group.items.extend(T::extend(cx, args))
 })];
 constALLOWED_TARGETS:AllowedTargets = T::ALLOWED_TARGETS;
-constTYPE:AttributeType = T::TYPE;
 
 fnfinalize(self,_cx:&FinalizeContext<'_,'_,S>) -> Option<AttributeKind>{
 ifletSome(first_span) = self.first_span{

compiler/rustc_attr_parsing/src/attributes/prelude.rs

@@ -1,6 +1,6 @@
 // data structures
 #[doc(hidden)]
-pub(super)use rustc_feature::{AttributeTemplate,AttributeType,template};
+pub(super)use rustc_feature::{AttributeTemplate, template};
 #[doc(hidden)]
 pub(super)use rustc_hir::attrs::AttributeKind;
 #[doc(hidden)]

compiler/rustc_attr_parsing/src/attributes/traits.rs

@@ -1,7 +1,5 @@
 use std::mem;
 
-use rustc_feature::AttributeType;
-
 usesuper::prelude::*;
 usecrate::attributes::{
 AttributeOrder,NoArgsAttributeParser,OnDuplicate,SingleAttributeParser,
@@ -155,8 +153,7 @@ pub(crate) struct CoherenceIsCoreParser;
 impl<S:Stage>NoArgsAttributeParser<S>forCoherenceIsCoreParser{
 constPATH:&[Symbol] = &[sym::rustc_coherence_is_core];
 constON_DUPLICATE:OnDuplicate<S> = OnDuplicate::Error;
-constALLOWED_TARGETS:AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
-constTYPE:AttributeType = AttributeType::CrateLevel;
+constALLOWED_TARGETS:AllowedTargets = AllowedTargets::CrateLevel;
 constCREATE:fn(Span) -> AttributeKind = |_| AttributeKind::CoherenceIsCore;
 }
 

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,7 @@ use std::sync::LazyLock;
 use private::Sealed;
 use rustc_ast::{AttrStyle,CRATE_NODE_ID,MetaItemLit,NodeId};
 use rustc_errors::{Diag,Diagnostic,Level};
-use rustc_feature::{AttributeTemplate,AttributeType};
+use rustc_feature::AttributeTemplate;
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::{AttributeLint,AttributeLintKind};
 use rustc_hir::{AttrPath,CRATE_HIR_ID,HirId};
@@ -83,7 +83,6 @@ pub(super) struct GroupTypeInnerAccept<S: Stage> {
 pub(super)template:AttributeTemplate,
 pub(super)accept_fn:AcceptFn<S>,
 pub(super)allowed_targets:AllowedTargets,
-pub(super)attribute_type:AttributeType,
 }
 
 typeAcceptFn<S> =
@@ -133,7 +132,6 @@ macro_rules! attribute_parsers {
 })
 }),
  allowed_targets: <$names ascrate::attributes::AttributeParser<$stage>>::ALLOWED_TARGETS,
- attribute_type: <$names ascrate::attributes::AttributeParser<$stage>>::TYPE,
 });
 }
 

compiler/rustc_attr_parsing/src/interface.rs

@@ -272,7 +272,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 
 (accept.accept_fn)(&mut cx, args);
 if !matches!(cx.stage.should_emit(),ShouldEmit::Nothing){
-Self::check_type(accept.attribute_type, target,&mut cx);
 Self::check_target(&accept.allowed_targets, target,&mut cx);
 }
 }

compiler/rustc_attr_parsing/src/target_checking.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use rustc_ast::AttrStyle;
 use rustc_errors::DiagArgValue;
-use rustc_feature::{AttributeType,Features};
+use rustc_feature::Features;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{MethodKind,Target};
 
@@ -14,6 +14,11 @@ use crate::session_diagnostics::InvalidTarget;
 pub(crate)enumAllowedTargets{
 AllowList(&'static[Policy]),
 AllowListWarnRest(&'static[Policy]),
+/// Special, and not the same as `AllowList(&[Allow(Target::Crate)])`.
+/// For crate-level attributes we emit a specific set of lints to warn
+/// people about accidentally not using them on the crate.
+/// Only use this for attributes that are *exclusively* valid at the crate level.
+CrateLevel,
 }
 
 pub(crate)enumAllowedResult{
@@ -43,13 +48,15 @@ impl AllowedTargets {
 AllowedResult::Warn
 }
 }
+AllowedTargets::CrateLevel => AllowedResult::Allowed,
 }
 }
 
 pub(crate)fnallowed_targets(&self) -> Vec<Target>{
 matchself{
 AllowedTargets::AllowList(list) => list,
 AllowedTargets::AllowListWarnRest(list) => list,
+AllowedTargets::CrateLevel => ALL_TARGETS,
 }
 .iter()
 .filter_map(|target| match target {
@@ -74,6 +81,8 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 target:Target,
 cx:&mutAcceptContext<'_,'sess,S>,
 ){
+Self::check_type(matches!(allowed_targets,AllowedTargets::CrateLevel), target, cx);
+
 match allowed_targets.is_allowed(target){
 AllowedResult::Allowed => {}
 AllowedResult::Warn => {
@@ -109,7 +118,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 }
 
 pub(crate)fncheck_type(
-attribute_type:AttributeType,
+crate_level:bool,
 target:Target,
 cx:&mutAcceptContext<'_,'sess,S>,
 ){
@@ -119,7 +128,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
 return;
 }
 
-ifattribute_type != AttributeType::CrateLevel{
+if!crate_level{
 return;
 }