Rollup merge of #153300 - fmease:test-attrs-tweaks, r=JonathanBrouwer

Tweak some of our internal `#[rustc_*]` TEST attributes

I think I might be the one who's used the internal TEST attrs `#[rustc_{dump_predicates,object_lifetime_default,outlives,variance}]` the most in recent times, I might even be the only one. As such I've noticed some recent-ish issues that haven't been fixed so far and which keep bothering me. Moreover I have a longstanding urge to rename several of these attributes which I couldn't contain anymore.

[`#[rustc_*]` TEST attributes](https://rustc-dev-guide.rust-lang.org/compiler-debugging.html#rustc_-test-attributes) are internal attributes that basically allow you to dump the output of specific queries for use in UI tests or for debugging purposes.

1. When some of these attributes were ported over to the new parsing API, their targets were unnecessarily restricted. I've kept encountering these incorrect "attribute cannot be used" errors all the while HIR analysis happily & correctly dumped the requested data below it. I've now relaxed their targets.
2. Since we now have target checking for the internal attributes I figured that it's unhelpful if we still intentionally crashed on invalid targets, so I've got rid of that.
3. I've always been annoyed that most of these (very old) attributes don't contain the word `dump` in their name (rendering their purpose non-obvious) and that some of their names diverge quite a bit from the corresponding query name. I've now rectified that. The new names take longer to type but it's still absolutely acceptable imo.

---

I haven't renamed all of the TEST attributes to follow the `rustc_dump_` scheme since that's quite tedious. If it's okay with you I'd like to postpone that (e.g., `rustc_{def_path,hidden_type…,layout,regions,symbol_name}`).

I've noticed that the parsers for TEST attrs are spread across `rustc_dump.rs`, `rustc_internal.rs` & `test_attrs.rs` which is a bit confusing. Since the new names are prefixed with `rustc_dump_` I've moved their parsers into `rustc_dump.rs` but of course they are still TEST attrs. IIRC, `test_attrs.rs` also contains non-`rustc_`-TEST attrs, so we can't just merge these two files. I guess that'll sort itself out in the future when I tackle the other internal TEST attrs.

r\? Jana || Jonathan

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs

@@ -1,5 +1,5 @@
-use rustc_hir::Target;
 use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{MethodKind, Target};
 use rustc_span::{Span, Symbol, sym};
 
 use crate::attributes::prelude::Allow;
@@ -25,6 +25,20 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpDefParentsParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpDefParents;
 }
 
+pub(crate) struct RustcDumpInferredOutlivesParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpInferredOutlivesParser {
+    const PATH: &[Symbol] = &[sym::rustc_dump_inferred_outlives];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Struct),
+        Allow(Target::Enum),
+        Allow(Target::Union),
+        Allow(Target::TyAlias),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpInferredOutlives;
+}
+
 pub(crate) struct RustcDumpItemBoundsParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpItemBoundsParser {
@@ -34,21 +48,88 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpItemBoundsParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpItemBounds;
 }
 
+pub(crate) struct RustcDumpObjectLifetimeDefaultsParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpObjectLifetimeDefaultsParser {
+    const PATH: &[Symbol] = &[sym::rustc_dump_object_lifetime_defaults];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::AssocConst),
+        Allow(Target::AssocTy),
+        Allow(Target::Const),
+        Allow(Target::Enum),
+        Allow(Target::Fn),
+        Allow(Target::ForeignFn),
+        Allow(Target::Impl { of_trait: false }),
+        Allow(Target::Impl { of_trait: true }),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Struct),
+        Allow(Target::Trait),
+        Allow(Target::TraitAlias),
+        Allow(Target::TyAlias),
+        Allow(Target::Union),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpObjectLifetimeDefaults;
+}
+
 pub(crate) struct RustcDumpPredicatesParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpPredicatesParser {
     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::AssocConst),
+        Allow(Target::AssocTy),
+        Allow(Target::Const),
+        Allow(Target::Delegation { mac: false }),
+        Allow(Target::Delegation { mac: true }),
         Allow(Target::Enum),
-        Allow(Target::Union),
+        Allow(Target::Fn),
+        Allow(Target::Impl { of_trait: false }),
+        Allow(Target::Impl { of_trait: true }),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Struct),
         Allow(Target::Trait),
-        Allow(Target::AssocTy),
+        Allow(Target::TraitAlias),
+        Allow(Target::TyAlias),
+        Allow(Target::Union),
     ]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpPredicates;
 }
 
+pub(crate) struct RustcDumpVariancesParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVariancesParser {
+    const PATH: &[Symbol] = &[sym::rustc_dump_variances];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Enum),
+        Allow(Target::Fn),
+        Allow(Target::Method(MethodKind::Inherent)),
+        Allow(Target::Method(MethodKind::Trait { body: false })),
+        Allow(Target::Method(MethodKind::Trait { body: true })),
+        Allow(Target::Method(MethodKind::TraitImpl)),
+        Allow(Target::Struct),
+        Allow(Target::Union),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpVariances;
+}
+
+pub(crate) struct RustcDumpVariancesOfOpaquesParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVariancesOfOpaquesParser {
+    const PATH: &[Symbol] = &[sym::rustc_dump_variances_of_opaques];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
+    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpVariancesOfOpaques;
+}
+
 pub(crate) struct RustcDumpVtableParser;
 
 impl<S: Stage> NoArgsAttributeParser<S> for RustcDumpVtableParser {

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -588,15 +588,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcLintUntrackedQueryInformationPa
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintUntrackedQueryInformation;
 }
 
-pub(crate) struct RustcObjectLifetimeDefaultParser;
-
-impl<S: Stage> NoArgsAttributeParser<S> for RustcObjectLifetimeDefaultParser {
-    const PATH: &[Symbol] = &[sym::rustc_object_lifetime_default];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcObjectLifetimeDefault;
-}
-
 pub(crate) struct RustcSimdMonomorphizeLaneLimitParser;
 
 impl<S: Stage> SingleAttributeParser<S> for RustcSimdMonomorphizeLaneLimitParser {

compiler/rustc_attr_parsing/src/attributes/test_attrs.rs

@@ -93,28 +93,6 @@ impl<S: Stage> SingleAttributeParser<S> for ShouldPanicParser {
     }
 }
 
-pub(crate) struct RustcVarianceParser;
-
-impl<S: Stage> NoArgsAttributeParser<S> for RustcVarianceParser {
-    const PATH: &[Symbol] = &[sym::rustc_variance];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
-        Allow(Target::Struct),
-        Allow(Target::Enum),
-        Allow(Target::Union),
-    ]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVariance;
-}
-
-pub(crate) struct RustcVarianceOfOpaquesParser;
-
-impl<S: Stage> NoArgsAttributeParser<S> for RustcVarianceOfOpaquesParser {
-    const PATH: &[Symbol] = &[sym::rustc_variance_of_opaques];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVarianceOfOpaques;
-}
-
 pub(crate) struct ReexportTestHarnessMainParser;
 
 impl<S: Stage> SingleAttributeParser<S> for ReexportTestHarnessMainParser {
@@ -215,20 +193,6 @@ impl<S: Stage> NoArgsAttributeParser<S> for RustcEvaluateWhereClausesParser {
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcEvaluateWhereClauses;
 }
 
-pub(crate) struct RustcOutlivesParser;
-
-impl<S: Stage> NoArgsAttributeParser<S> for RustcOutlivesParser {
-    const PATH: &[Symbol] = &[sym::rustc_outlives];
-    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
-        Allow(Target::Struct),
-        Allow(Target::Enum),
-        Allow(Target::Union),
-        Allow(Target::TyAlias),
-    ]);
-    const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcOutlives;
-}
-
 pub(crate) struct TestRunnerParser;
 
 impl<S: Stage> SingleAttributeParser<S> for TestRunnerParser {

compiler/rustc_attr_parsing/src/context.rs

@@ -281,9 +281,13 @@ attribute_parsers!(
         Single<WithoutArgs<RustcDenyExplicitImplParser>>,
         Single<WithoutArgs<RustcDoNotConstCheckParser>>,
         Single<WithoutArgs<RustcDumpDefParentsParser>>,
+        Single<WithoutArgs<RustcDumpInferredOutlivesParser>>,
         Single<WithoutArgs<RustcDumpItemBoundsParser>>,
+        Single<WithoutArgs<RustcDumpObjectLifetimeDefaultsParser>>,
         Single<WithoutArgs<RustcDumpPredicatesParser>>,
         Single<WithoutArgs<RustcDumpUserArgsParser>>,
+        Single<WithoutArgs<RustcDumpVariancesOfOpaquesParser>>,
+        Single<WithoutArgs<RustcDumpVariancesParser>>,
         Single<WithoutArgs<RustcDumpVtableParser>>,
         Single<WithoutArgs<RustcDynIncompatibleTraitParser>>,
         Single<WithoutArgs<RustcEffectiveVisibilityParser>>,
@@ -306,9 +310,7 @@ attribute_parsers!(
         Single<WithoutArgs<RustcNonConstTraitMethodParser>>,
         Single<WithoutArgs<RustcNonnullOptimizationGuaranteedParser>>,
         Single<WithoutArgs<RustcNounwindParser>>,
-        Single<WithoutArgs<RustcObjectLifetimeDefaultParser>>,
         Single<WithoutArgs<RustcOffloadKernelParser>>,
-        Single<WithoutArgs<RustcOutlivesParser>>,
         Single<WithoutArgs<RustcParenSugarParser>>,
         Single<WithoutArgs<RustcPassByValueParser>>,
         Single<WithoutArgs<RustcPassIndirectlyInNonRusticAbisParser>>,
@@ -323,8 +325,6 @@ attribute_parsers!(
         Single<WithoutArgs<RustcStrictCoherenceParser>>,
         Single<WithoutArgs<RustcTrivialFieldReadsParser>>,
         Single<WithoutArgs<RustcUnsafeSpecializationMarkerParser>>,
-        Single<WithoutArgs<RustcVarianceOfOpaquesParser>>,
-        Single<WithoutArgs<RustcVarianceParser>>,
         Single<WithoutArgs<ThreadLocalParser>>,
         Single<WithoutArgs<TrackCallerParser>>,
         // tidy-alphabetical-end

compiler/rustc_error_codes/src/error_codes/E0208.md

@@ -1,47 +1,2 @@
 #### This error code is internal to the compiler and will not be emitted with normal Rust code.
 #### Note: this error code is no longer emitted by the compiler.
-
-This error code shows the variance of a type's generic parameters.
-
-Erroneous code example:
-
-```compile_fail
-// NOTE: this feature is perma-unstable and should *only* be used for
-//       testing purposes.
-#![allow(internal_features)]
-#![feature(rustc_attrs)]
-
-#[rustc_variance]
-struct Foo<'a, T> { // error: deliberate error to display type's variance
-    t: &'a mut T,
-}
-```
-
-which produces the following error:
-
-```text
-error: [-, o]
- --> <anon>:4:1
-  |
-4 | struct Foo<'a, T> {
-  | ^^^^^^^^^^^^^^^^^
-```
-
-*Note that while `#[rustc_variance]` still exists and is used within the*
-*compiler, it no longer is marked as `E0208` and instead has no error code.*
-
-This error is deliberately triggered with the `#[rustc_variance]` attribute
-(`#![feature(rustc_attrs)]` must be enabled) and helps to show you the variance
-of the type's generic parameters. You can read more about variance and
-subtyping in [this section of the Rustonomicon]. For a more in depth look at
-variance (including a more complete list of common variances) see
-[this section of the Reference]. For information on how variance is implemented
-in the compiler, see [this section of `rustc-dev-guide`].
-
-This error can be easily fixed by removing the `#[rustc_variance]` attribute,
-the compiler's suggestion to comment it out can be applied automatically with
-`rustfix`.
-
-[this section of the Rustonomicon]: https://doc.rust-lang.org/nomicon/subtyping.html
-[this section of the Reference]: https://doc.rust-lang.org/reference/subtyping.html#variance
-[this section of `rustc-dev-guide`]: https://rustc-dev-guide.rust-lang.org/variance.html

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1419,7 +1419,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
 
     rustc_attr!(TEST, rustc_effective_visibility, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes),
     rustc_attr!(
-        TEST, rustc_outlives, Normal, template!(Word),
+        TEST, rustc_dump_inferred_outlives, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No
     ),
     rustc_attr!(
@@ -1439,11 +1439,11 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         WarnFollowing, EncodeCrossCrate::Yes
     ),
     rustc_attr!(
-        TEST, rustc_variance, Normal, template!(Word),
+        TEST, rustc_dump_variances, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No
     ),
     rustc_attr!(
-        TEST, rustc_variance_of_opaques, Normal, template!(Word),
+        TEST, rustc_dump_variances_of_opaques, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No
     ),
     rustc_attr!(
@@ -1531,7 +1531,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         WarnFollowing, EncodeCrossCrate::No
     ),
     rustc_attr!(
-        TEST, rustc_object_lifetime_default, Normal, template!(Word),
+        TEST, rustc_dump_object_lifetime_defaults, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No
     ),
     rustc_attr!(

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1366,15 +1366,27 @@ pub enum AttributeKind {
     /// Represents `#[rustc_dump_def_parents]`
     RustcDumpDefParents,
 
+    /// Represents `#[rustc_dump_inferred_outlives]`
+    RustcDumpInferredOutlives,
+
     /// Represents `#[rustc_dump_item_bounds]`
     RustcDumpItemBounds,
 
+    /// Represents `#[rustc_dump_object_lifetime_defaults]`.
+    RustcDumpObjectLifetimeDefaults,
+
     /// Represents `#[rustc_dump_predicates]`
     RustcDumpPredicates,
 
     /// Represents `#[rustc_dump_user_args]`
     RustcDumpUserArgs,
 
+    /// Represents `#[rustc_dump_variances]`
+    RustcDumpVariances,
+
+    /// Represents `#[rustc_dump_variances_of_opaques]`
+    RustcDumpVariancesOfOpaques,
+
     /// Represents `#[rustc_dump_vtable]`
     RustcDumpVtable(Span),
 
@@ -1493,15 +1505,9 @@ pub enum AttributeKind {
         span: Span,
     },
 
-    /// Represents `#[rustc_object_lifetime_default]`.
-    RustcObjectLifetimeDefault,
-
     /// Represents `#[rustc_offload_kernel]`
     RustcOffloadKernel,
 
-    /// Represents `#[rustc_outlives]`
-    RustcOutlives,
-
     /// Represents `#[rustc_paren_sugar]`.
     RustcParenSugar(Span),
 
@@ -1574,12 +1580,6 @@ pub enum AttributeKind {
     /// Represents `#[rustc_unsafe_specialization_marker]`.
     RustcUnsafeSpecializationMarker(Span),
 
-    /// Represents `#[rustc_variance]`
-    RustcVariance,
-
-    /// Represents `#[rustc_variance_of_opaques]`
-    RustcVarianceOfOpaques,
-
     /// Represents `#[sanitize]`
     ///
     /// the on set and off set are distjoint since there's a third option: unset.

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -124,9 +124,13 @@ impl AttributeKind {
             RustcDocPrimitive(..) => Yes,
             RustcDummy => No,
             RustcDumpDefParents => No,
+            RustcDumpInferredOutlives => No,
             RustcDumpItemBounds => No,
+            RustcDumpObjectLifetimeDefaults => No,
             RustcDumpPredicates => No,
             RustcDumpUserArgs => No,
+            RustcDumpVariances => No,
+            RustcDumpVariancesOfOpaques => No,
             RustcDumpVtable(..) => No,
             RustcDynIncompatibleTrait(..) => No,
             RustcEffectiveVisibility => Yes,
@@ -161,9 +165,7 @@ impl AttributeKind {
             RustcNounwind => No,
             RustcObjcClass { .. } => No,
             RustcObjcSelector { .. } => No,
-            RustcObjectLifetimeDefault => No,
             RustcOffloadKernel => Yes,
-            RustcOutlives => No,
             RustcParenSugar(..) => No,
             RustcPassByValue(..) => Yes,
             RustcPassIndirectlyInNonRusticAbis(..) => No,
@@ -185,8 +187,6 @@ impl AttributeKind {
             RustcThenThisWouldNeed(..) => No,
             RustcTrivialFieldReads => Yes,
             RustcUnsafeSpecializationMarker(..) => No,
-            RustcVariance => No,
-            RustcVarianceOfOpaques => No,
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,
             Stability { .. } => Yes,