Port the rustc dump attributes to the attribute parser

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -57,6 +57,7 @@ pub(crate) mod pin_v2;
 pub(crate) mod proc_macro_attrs;
 pub(crate) mod prototype;
 pub(crate) mod repr;
+pub(crate) mod rustc_dump;
 pub(crate) mod rustc_internal;
 pub(crate) mod semantics;
 pub(crate) mod stability;

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -0,0 +1,62 @@
+use rustc_hir::Target;
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use crate::attributes::prelude::Allow;
+use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
+use crate::context::Stage;
+use crate::target_checking::AllowedTargets;
+
+pub(crate) struct RustcDumpUserArgs;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpUserArgs {
+    const PATH: &[Symbol] = &[sym::rustc_dump_user_args];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpUserArgs;
+}
+
+pub(crate) struct RustcDumpDefParents;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpDefParents {
+    const PATH: &[Symbol] = &[sym::rustc_dump_def_parents];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Fn)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpDefParents;
+}
+
+pub(crate) struct RustcDumpItemBounds;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpItemBounds {
+    const PATH: &[Symbol] = &[sym::rustc_dump_item_bounds];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::AssocTy)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpItemBounds;
+}
+
+pub(crate) struct RustcDumpPredicates;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpPredicates {
+    const PATH: &[Symbol] = &[sym::rustc_dump_predicates];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+        Allow(Target::Trait),
+        Allow(Target::AssocTy),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpPredicates;
+}
+
+pub(crate) struct RustcDumpVtable;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVtable {
+    const PATH: &[Symbol] = &[sym::rustc_dump_vtable];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Impl { of_trait: true }),
+        Allow(Target::TyAlias),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::RustcDumpVtable;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -63,6 +63,10 @@ use crate::attributes::proc_macro_attrs::{
 };
 use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
+use crate::attributes::rustc_dump::{
+    RustcDumpDefParents, RustcDumpItemBounds, RustcDumpPredicates, RustcDumpUserArgs,
+    RustcDumpVtable,
+};
 use crate::attributes::rustc_internal::{
     RustcHasIncoherentInherentImplsParser, RustcLayoutScalarValidRangeEndParser,
     RustcLayoutScalarValidRangeStartParser, RustcLegacyConstGenericsParser,
@@ -267,6 +271,11 @@ attribute_parsers!(
         Single<WithoutArgs<ProcMacroParser>>,
         Single<WithoutArgs<PubTransparentParser>>,
         Single<WithoutArgs<RustcCoherenceIsCoreParser>>,
+        Single<WithoutArgs<RustcDumpDefParents>>,
+        Single<WithoutArgs<RustcDumpItemBounds>>,
+        Single<WithoutArgs<RustcDumpPredicates>>,
+        Single<WithoutArgs<RustcDumpUserArgs>>,
+        Single<WithoutArgs<RustcDumpVtable>>,
         Single<WithoutArgs<RustcHasIncoherentInherentImplsParser>>,
         Single<WithoutArgs<RustcLintDiagnosticsParser>>,
         Single<WithoutArgs<RustcLintOptTyParser>>,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -906,6 +906,21 @@ pub enum AttributeKind {
     /// Represents `#[rustc_coherence_is_core]`
     RustcCoherenceIsCore(Span),
 
+    /// Represents `#[rustc_dump_def_parents]`
+    RustcDumpDefParents,
+
+    /// Represents `#[rustc_dump_item_bounds]`
+    RustcDumpItemBounds,
+
+    /// Represents `#[rustc_dump_predicates]`
+    RustcDumpPredicates,
+
+    /// Represents `#[rustc_dump_user_args]`
+    RustcDumpUserArgs,
+
+    /// Represents `#[rustc_dump_vtable]`
+    RustcDumpVtable(Span),
+
     /// Represents `#[rustc_has_incoherent_inherent_impls]`
     RustcHasIncoherentInherentImpls,
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -97,6 +97,11 @@ impl AttributeKind {
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcCoherenceIsCore(..) => No,
+            RustcDumpDefParents => No,
+            RustcDumpItemBounds => No,
+            RustcDumpPredicates => No,
+            RustcDumpUserArgs => No,
+            RustcDumpVtable(..) => No,
             RustcHasIncoherentInherentImpls => Yes,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,

compiler/rustc_hir_analysis/src/collect/dump.rs

@@ -1,6 +1,7 @@
 use rustc_hir as hir;
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
-use rustc_hir::intravisit;
+use rustc_hir::{find_attr, intravisit};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
 use rustc_span::sym;
@@ -28,7 +29,7 @@ pub(crate) fn opaque_hidden_types(tcx: TyCtxt<'_>) {
 
 pub(crate) fn predicates_and_item_bounds(tcx: TyCtxt<'_>) {
     for id in tcx.hir_crate_items(()).owners() {
-        if tcx.has_attr(id, sym::rustc_dump_predicates) {
+        if find_attr!(tcx.get_all_attrs(id), AttributeKind::RustcDumpPredicates) {
             let preds = tcx.predicates_of(id).instantiate_identity(tcx).predicates;
             let span = tcx.def_span(id);
 
@@ -38,7 +39,7 @@ pub(crate) fn predicates_and_item_bounds(tcx: TyCtxt<'_>) {
             }
             diag.emit();
         }
-        if tcx.has_attr(id, sym::rustc_dump_item_bounds) {
+        if find_attr!(tcx.get_all_attrs(id), AttributeKind::RustcDumpItemBounds) {
             let bounds = tcx.item_bounds(id).instantiate_identity();
             let span = tcx.def_span(id);
 
@@ -54,7 +55,7 @@ pub(crate) fn predicates_and_item_bounds(tcx: TyCtxt<'_>) {
 pub(crate) fn def_parents(tcx: TyCtxt<'_>) {
     for iid in tcx.hir_free_items() {
         let did = iid.owner_id.def_id;
-        if tcx.has_attr(did, sym::rustc_dump_def_parents) {
+        if find_attr!(tcx.get_all_attrs(did), AttributeKind::RustcDumpDefParents) {
             struct AnonConstFinder<'tcx> {
                 tcx: TyCtxt<'tcx>,
                 anon_consts: Vec<LocalDefId>,
@@ -102,7 +103,9 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
     for id in tcx.hir_free_items() {
         let def_id = id.owner_id.def_id;
 
-        let Some(attr) = tcx.get_attr(def_id, sym::rustc_dump_vtable) else {
+        let Some(&attr_span) =
+            find_attr!(tcx.get_all_attrs(def_id), AttributeKind::RustcDumpVtable(span) => span)
+        else {
             continue;
         };
 
@@ -111,14 +114,14 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                 let trait_ref = tcx.impl_trait_ref(def_id).instantiate_identity();
                 if trait_ref.has_non_region_param() {
                     tcx.dcx().span_err(
-                        attr.span(),
+                        attr_span,
                         "`rustc_dump_vtable` must be applied to non-generic impl",
                     );
                     continue;
                 }
                 if !tcx.is_dyn_compatible(trait_ref.def_id) {
                     tcx.dcx().span_err(
-                        attr.span(),
+                        attr_span,
                         "`rustc_dump_vtable` must be applied to dyn-compatible trait",
                     );
                     continue;
@@ -127,7 +130,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                     .try_normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), trait_ref)
                 else {
                     tcx.dcx().span_err(
-                        attr.span(),
+                        attr_span,
                         "`rustc_dump_vtable` applied to impl header that cannot be normalized",
                     );
                     continue;
@@ -138,7 +141,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                 let ty = tcx.type_of(def_id).instantiate_identity();
                 if ty.has_non_region_param() {
                     tcx.dcx().span_err(
-                        attr.span(),
+                        attr_span,
                         "`rustc_dump_vtable` must be applied to non-generic type",
                     );
                     continue;
@@ -147,14 +150,13 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                     tcx.try_normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 else {
                     tcx.dcx().span_err(
-                        attr.span(),
+                        attr_span,
                         "`rustc_dump_vtable` applied to type alias that cannot be normalized",
                     );
                     continue;
                 };
                 let ty::Dynamic(data, _) = *ty.kind() else {
-                    tcx.dcx()
-                        .span_err(attr.span(), "`rustc_dump_vtable` to type alias of dyn type");
+                    tcx.dcx().span_err(attr_span, "`rustc_dump_vtable` to type alias of dyn type");
                     continue;
                 };
                 if let Some(principal) = data.principal() {
@@ -167,7 +169,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
             }
             _ => {
                 tcx.dcx().span_err(
-                    attr.span(),
+                    attr_span,
                     "`rustc_dump_vtable` only applies to impl, or type alias of dyn type",
                 );
                 continue;

compiler/rustc_hir_typeck/src/writeback.rs

@@ -14,9 +14,10 @@ use std::ops::ControlFlow;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_data_structures::unord::ExtendUnord;
 use rustc_errors::{E0720, ErrorGuaranteed};
+use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{self, InferKind, Visitor};
-use rustc_hir::{self as hir, AmbigArg, HirId};
+use rustc_hir::{self as hir, AmbigArg, HirId, find_attr};
 use rustc_infer::traits::solve::Goal;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, PointerCoercion};
@@ -25,7 +26,7 @@ use rustc_middle::ty::{
     TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
     fold_regions,
 };
-use rustc_span::{Span, sym};
+use rustc_span::Span;
 use rustc_trait_selection::error_reporting::infer::need_type_info::TypeAnnotationNeeded;
 use rustc_trait_selection::opaque_types::opaque_type_has_defining_use_args;
 use rustc_trait_selection::solve;
@@ -45,8 +46,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // This attribute causes us to dump some writeback information
         // in the form of errors, which is used for unit tests.
-        let rustc_dump_user_args =
-            self.has_rustc_attrs && self.tcx.has_attr(item_def_id, sym::rustc_dump_user_args);
+        let rustc_dump_user_args = self.has_rustc_attrs
+            && find_attr!(self.tcx.get_all_attrs(item_def_id), AttributeKind::RustcDumpUserArgs);
 
         let mut wbcx = WritebackCx::new(self, body, rustc_dump_user_args);
         for param in body.params {

compiler/rustc_passes/src/check_attr.rs

@@ -309,6 +309,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::CfiEncoding { .. }
                     | AttributeKind::RustcHasIncoherentInherentImpls
                     | AttributeKind::MustNotSupend { .. }
+                    | AttributeKind::RustcDumpUserArgs
+                    | AttributeKind::RustcDumpItemBounds
+                    | AttributeKind::RustcDumpPredicates
+                    | AttributeKind::RustcDumpDefParents
+                    | AttributeKind::RustcDumpVtable(..)
                 ) => { /* do nothing  */ }
                 Attribute::Unparsed(attr_item) => {
                     style = Some(attr_item.style);
@@ -368,25 +373,20 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                             | sym::rustc_abi
                             | sym::rustc_layout
                             | sym::rustc_proc_macro_decls
-                            | sym::rustc_dump_def_parents
                             | sym::rustc_never_type_options
                             | sym::rustc_autodiff
                             | sym::rustc_capture_analysis
                             | sym::rustc_regions
                             | sym::rustc_strict_coherence
-                            | sym::rustc_dump_predicates
                             | sym::rustc_variance
                             | sym::rustc_variance_of_opaques
                             | sym::rustc_hidden_type_of_opaques
                             | sym::rustc_mir
-                            | sym::rustc_dump_user_args
                             | sym::rustc_effective_visibility
                             | sym::rustc_outlives
                             | sym::rustc_symbol_name
                             | sym::rustc_evaluate_where_clauses
-                            | sym::rustc_dump_vtable
                             | sym::rustc_delayed_bug_from_inside_query
-                            | sym::rustc_dump_item_bounds
                             | sym::rustc_def_path
                             | sym::rustc_partition_reused
                             | sym::rustc_partition_codegened