From 0ecb4371975c5a580a9b64e859542f86ca35bb07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 19:31:12 +0100 Subject: [PATCH 1/7] Relax target of `#[rustc_{dump_predicates,object_lifetime_default,variance}]` * `#[dump_predicates]` works on any definition for which query `predicates_of` returns a useful (!) result * `#[rustc_object_lifetime_default]` works on any definition for which query `object_lifetime_default` returns a useful (!) result for type parameters * `#[rustc_variance]` works on any definition for which query `variances_of` returns a useful (!) result When these attributes were ported to the new attribute parsing API, their targets were unnecessarily restricted. --- .../src/attributes/rustc_dump.rs | 21 +++++++++++++++---- .../src/attributes/rustc_internal.rs | 20 +++++++++++++++++- .../src/attributes/test_attrs.rs | 3 ++- 3 files changed, 38 insertions(+), 6 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index 71a8fb0dd47d9..3995d757b55bb 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -1,4 +1,4 @@ -use rustc_hir::Target; +use rustc_hir::{MethodKind, Target}; use rustc_hir::attrs::AttributeKind; use rustc_span::{Span, Symbol, sym}; @@ -40,11 +40,24 @@ impl NoArgsAttributeParser for RustcDumpPredicatesParser { const PATH: &[Symbol] = &[sym::rustc_dump_predicates]; const ON_DUPLICATE: OnDuplicate = 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; } diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs index 85e7112adbc21..5908b4f77f4d1 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs @@ -593,7 +593,25 @@ pub(crate) struct RustcObjectLifetimeDefaultParser; impl NoArgsAttributeParser for RustcObjectLifetimeDefaultParser { const PATH: &[Symbol] = &[sym::rustc_object_lifetime_default]; const ON_DUPLICATE: OnDuplicate = OnDuplicate::Error; - const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Struct)]); + 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::RustcObjectLifetimeDefault; } diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs index ac1d360c62809..8df473a09fd4f 100644 --- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs @@ -99,8 +99,9 @@ impl NoArgsAttributeParser for RustcVarianceParser { const PATH: &[Symbol] = &[sym::rustc_variance]; const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn; const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[ - Allow(Target::Struct), Allow(Target::Enum), + Allow(Target::Fn), + Allow(Target::Struct), Allow(Target::Union), ]); const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVariance; From 853967a62b2fca1372ae23f95a6f3a420d533660 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 16:00:32 +0100 Subject: [PATCH 2/7] Don't crash if `#[rustc_{dump_item_bounds,variance}]` was applied to the wrong item kind MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Attr parsing already reports an error for this, an subsequent ICE isn't really helpful. Side note: We certainly don't want convert the `bug!(…)`s in the respective queries to delayed bugs! It's imperative that these queries eagerly complain about misuse to prevent dormant bugs! --- .../src/attributes/rustc_dump.rs | 2 +- .../rustc_hir_analysis/src/collect/dump.rs | 33 ++++++++++++++----- .../rustc_hir_analysis/src/variance/dump.rs | 16 ++++++++- 3 files changed, 40 insertions(+), 11 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index 3995d757b55bb..3e1bd28bccc09 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -1,5 +1,5 @@ -use rustc_hir::{MethodKind, Target}; use rustc_hir::attrs::AttributeKind; +use rustc_hir::{MethodKind, Target}; use rustc_span::{Span, Symbol, sym}; use crate::attributes::prelude::Allow; diff --git a/compiler/rustc_hir_analysis/src/collect/dump.rs b/compiler/rustc_hir_analysis/src/collect/dump.rs index 8534cc26fd944..3e9c83b12df0a 100644 --- a/compiler/rustc_hir_analysis/src/collect/dump.rs +++ b/compiler/rustc_hir_analysis/src/collect/dump.rs @@ -1,4 +1,5 @@ use rustc_hir as hir; +use rustc_hir::def::DefKind; use rustc_hir::def_id::LocalDefId; use rustc_hir::{find_attr, intravisit}; use rustc_middle::hir::nested_filter; @@ -27,7 +28,10 @@ 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 find_attr!(tcx, id, RustcDumpPredicates) { + #[expect(deprecated)] // we don't want to unnecessarily retrieve the attrs twice in a row. + let attrs = tcx.get_all_attrs(id); + + if find_attr!(attrs, RustcDumpPredicates) { let preds = tcx.predicates_of(id).instantiate_identity(tcx).predicates; let span = tcx.def_span(id); @@ -37,15 +41,26 @@ pub(crate) fn predicates_and_item_bounds(tcx: TyCtxt<'_>) { } diag.emit(); } - if find_attr!(tcx, id, RustcDumpItemBounds) { - let bounds = tcx.item_bounds(id).instantiate_identity(); - let span = tcx.def_span(id); - let mut diag = tcx.dcx().struct_span_err(span, sym::rustc_dump_item_bounds.as_str()); - for bound in bounds { - diag.note(format!("{bound:?}")); - } - diag.emit(); + if find_attr!(attrs, RustcDumpItemBounds) { + let name = sym::rustc_dump_item_bounds.as_str(); + + match tcx.def_kind(id) { + DefKind::AssocTy => { + let bounds = tcx.item_bounds(id).instantiate_identity(); + let span = tcx.def_span(id); + + let mut diag = tcx.dcx().struct_span_err(span, name); + for bound in bounds { + diag.note(format!("{bound:?}")); + } + diag.emit() + } + kind => tcx.dcx().span_delayed_bug( + tcx.def_span(id), + format!("attr parsing didn't report an error for `#[{name}]` on {kind:?}"), + ), + }; } } } diff --git a/compiler/rustc_hir_analysis/src/variance/dump.rs b/compiler/rustc_hir_analysis/src/variance/dump.rs index db17aaf8de1f3..30e69418b1c74 100644 --- a/compiler/rustc_hir_analysis/src/variance/dump.rs +++ b/compiler/rustc_hir_analysis/src/variance/dump.rs @@ -1,5 +1,6 @@ use std::fmt::Write; +use rustc_hir::def::DefKind; use rustc_hir::def_id::LocalDefId; use rustc_hir::find_attr; use rustc_middle::ty::{GenericArgs, TyCtxt}; @@ -39,8 +40,21 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) { continue; } + match tcx.def_kind(id) { + DefKind::Fn | DefKind::Enum | DefKind::Struct | DefKind::Union => {} + DefKind::TyAlias if tcx.type_alias_is_lazy(id) => {} + kind => { + let message = format!( + "attr parsing didn't report an error for `#[{}]` on {kind:?}", + rustc_span::sym::rustc_variance, + ); + tcx.dcx().span_delayed_bug(tcx.def_span(id), message); + continue; + } + } + tcx.dcx().emit_err(crate::errors::VariancesOf { - span: tcx.def_span(id.owner_id), + span: tcx.def_span(id), variances: format_variances(tcx, id.owner_id.def_id), }); } From ec324dcc9cede332b3cd87426581e23b4d8bc5f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 16:28:43 +0100 Subject: [PATCH 3/7] Don't ignore `#[rustc_variance]` on associated functions --- compiler/rustc_attr_parsing/src/attributes/test_attrs.rs | 4 ++++ compiler/rustc_hir_analysis/src/variance/dump.rs | 8 ++++---- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs index 8df473a09fd4f..b8f1769e53c79 100644 --- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs @@ -101,6 +101,10 @@ impl NoArgsAttributeParser for RustcVarianceParser { 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), ]); diff --git a/compiler/rustc_hir_analysis/src/variance/dump.rs b/compiler/rustc_hir_analysis/src/variance/dump.rs index 30e69418b1c74..84d25bbbe9b96 100644 --- a/compiler/rustc_hir_analysis/src/variance/dump.rs +++ b/compiler/rustc_hir_analysis/src/variance/dump.rs @@ -35,13 +35,13 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) { } } - for id in crate_items.free_items() { - if !find_attr!(tcx, id.owner_id, RustcVariance) { + for id in crate_items.owners() { + if !find_attr!(tcx, id, RustcVariance) { continue; } match tcx.def_kind(id) { - DefKind::Fn | DefKind::Enum | DefKind::Struct | DefKind::Union => {} + DefKind::AssocFn | DefKind::Fn | DefKind::Enum | DefKind::Struct | DefKind::Union => {} DefKind::TyAlias if tcx.type_alias_is_lazy(id) => {} kind => { let message = format!( @@ -55,7 +55,7 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) { tcx.dcx().emit_err(crate::errors::VariancesOf { span: tcx.def_span(id), - variances: format_variances(tcx, id.owner_id.def_id), + variances: format_variances(tcx, id.def_id), }); } } From c3a40e26e4e59b85c76bb3ae621c5629076ecc14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 17:26:47 +0100 Subject: [PATCH 4/7] Rename `#[rustc_outlives]` to `#[rustc_dump_inferred_outlives]` --- .../src/attributes/rustc_dump.rs | 14 ++++++++++++++ .../src/attributes/test_attrs.rs | 16 +--------------- compiler/rustc_attr_parsing/src/context.rs | 2 +- compiler/rustc_feature/src/builtin_attrs.rs | 2 +- compiler/rustc_hir/src/attrs/data_structures.rs | 6 +++--- .../rustc_hir/src/attrs/encode_cross_crate.rs | 2 +- compiler/rustc_hir_analysis/src/outlives/dump.rs | 4 ++-- compiler/rustc_middle/src/queries.rs | 4 ++-- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_span/src/symbol.rs | 2 +- .../rustc-dev-guide/src/compiler-debugging.md | 2 +- .../rfcs/rfc-2093-infer-outlives/cross-crate.rs | 4 ++-- .../rfc-2093-infer-outlives/cross-crate.stderr | 2 +- tests/ui/rfcs/rfc-2093-infer-outlives/enum.rs | 12 ++++++------ .../ui/rfcs/rfc-2093-infer-outlives/enum.stderr | 6 +++--- .../rfcs/rfc-2093-infer-outlives/explicit-dyn.rs | 4 ++-- .../rfc-2093-infer-outlives/explicit-dyn.stderr | 2 +- .../rfc-2093-infer-outlives/explicit-enum.rs | 4 ++-- .../rfc-2093-infer-outlives/explicit-enum.stderr | 2 +- .../explicit-projection.rs | 4 ++-- .../explicit-projection.stderr | 2 +- .../rfc-2093-infer-outlives/explicit-struct.rs | 4 ++-- .../explicit-struct.stderr | 2 +- .../rfc-2093-infer-outlives/explicit-union.rs | 4 ++-- .../explicit-union.stderr | 2 +- .../rfcs/rfc-2093-infer-outlives/nested-enum.rs | 4 ++-- .../rfc-2093-infer-outlives/nested-enum.stderr | 2 +- .../rfc-2093-infer-outlives/nested-regions.rs | 4 ++-- .../nested-regions.stderr | 2 +- .../rfc-2093-infer-outlives/nested-structs.rs | 4 ++-- .../nested-structs.stderr | 2 +- .../rfcs/rfc-2093-infer-outlives/nested-union.rs | 4 ++-- .../rfc-2093-infer-outlives/nested-union.stderr | 2 +- .../rfcs/rfc-2093-infer-outlives/projection.rs | 4 ++-- .../rfc-2093-infer-outlives/projection.stderr | 2 +- .../ui/rfcs/rfc-2093-infer-outlives/reference.rs | 4 ++-- .../rfc-2093-infer-outlives/reference.stderr | 2 +- .../ui/rfcs/rfc-2093-infer-outlives/self-dyn.rs | 4 ++-- .../rfcs/rfc-2093-infer-outlives/self-dyn.stderr | 2 +- .../rfcs/rfc-2093-infer-outlives/self-structs.rs | 4 ++-- .../rfc-2093-infer-outlives/self-structs.stderr | 2 +- 41 files changed, 79 insertions(+), 79 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index 3e1bd28bccc09..0160a4b10ec06 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -25,6 +25,20 @@ impl NoArgsAttributeParser for RustcDumpDefParentsParser { const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpDefParents; } +pub(crate) struct RustcDumpInferredOutlivesParser; + +impl NoArgsAttributeParser for RustcDumpInferredOutlivesParser { + const PATH: &[Symbol] = &[sym::rustc_dump_inferred_outlives]; + const ON_DUPLICATE: OnDuplicate = 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 NoArgsAttributeParser for RustcDumpItemBoundsParser { diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs index b8f1769e53c79..ed1bb50da498b 100644 --- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs @@ -103,7 +103,7 @@ impl NoArgsAttributeParser for RustcVarianceParser { 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::Trait { body: true })), Allow(Target::Method(MethodKind::TraitImpl)), Allow(Target::Struct), Allow(Target::Union), @@ -220,20 +220,6 @@ impl NoArgsAttributeParser for RustcEvaluateWhereClausesParser { const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcEvaluateWhereClauses; } -pub(crate) struct RustcOutlivesParser; - -impl NoArgsAttributeParser for RustcOutlivesParser { - const PATH: &[Symbol] = &[sym::rustc_outlives]; - const ON_DUPLICATE: OnDuplicate = 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 SingleAttributeParser for TestRunnerParser { diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs index 802ee56f504b0..0f057f77d6107 100644 --- a/compiler/rustc_attr_parsing/src/context.rs +++ b/compiler/rustc_attr_parsing/src/context.rs @@ -281,6 +281,7 @@ attribute_parsers!( Single>, Single>, Single>, + Single>, Single>, Single>, Single>, @@ -308,7 +309,6 @@ attribute_parsers!( Single>, Single>, Single>, - Single>, Single>, Single>, Single>, diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index db8f459ef0451..526c7e912dca0 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/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!( diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs index 91409108a7533..23e76207810f7 100644 --- a/compiler/rustc_hir/src/attrs/data_structures.rs +++ b/compiler/rustc_hir/src/attrs/data_structures.rs @@ -1366,6 +1366,9 @@ pub enum AttributeKind { /// Represents `#[rustc_dump_def_parents]` RustcDumpDefParents, + /// Represents `#[rustc_dump_inferred_outlives]` + RustcDumpInferredOutlives, + /// Represents `#[rustc_dump_item_bounds]` RustcDumpItemBounds, @@ -1499,9 +1502,6 @@ pub enum AttributeKind { /// Represents `#[rustc_offload_kernel]` RustcOffloadKernel, - /// Represents `#[rustc_outlives]` - RustcOutlives, - /// Represents `#[rustc_paren_sugar]`. RustcParenSugar(Span), diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs index cd41a2b9b28c7..e61d102ef1f34 100644 --- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs +++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs @@ -124,6 +124,7 @@ impl AttributeKind { RustcDocPrimitive(..) => Yes, RustcDummy => No, RustcDumpDefParents => No, + RustcDumpInferredOutlives => No, RustcDumpItemBounds => No, RustcDumpPredicates => No, RustcDumpUserArgs => No, @@ -163,7 +164,6 @@ impl AttributeKind { RustcObjcSelector { .. } => No, RustcObjectLifetimeDefault => No, RustcOffloadKernel => Yes, - RustcOutlives => No, RustcParenSugar(..) => No, RustcPassByValue(..) => Yes, RustcPassIndirectlyInNonRusticAbis(..) => No, diff --git a/compiler/rustc_hir_analysis/src/outlives/dump.rs b/compiler/rustc_hir_analysis/src/outlives/dump.rs index 671846a35b266..fe8b2a30ab9ef 100644 --- a/compiler/rustc_hir_analysis/src/outlives/dump.rs +++ b/compiler/rustc_hir_analysis/src/outlives/dump.rs @@ -5,7 +5,7 @@ use rustc_span::sym; pub(crate) fn inferred_outlives(tcx: TyCtxt<'_>) { for id in tcx.hir_free_items() { - if !find_attr!(tcx, id.owner_id, RustcOutlives) { + if !find_attr!(tcx, id.owner_id, RustcDumpInferredOutlives) { continue; } @@ -21,7 +21,7 @@ pub(crate) fn inferred_outlives(tcx: TyCtxt<'_>) { preds.sort(); let span = tcx.def_span(id.owner_id); - let mut err = tcx.dcx().struct_span_err(span, sym::rustc_outlives.as_str()); + let mut err = tcx.dcx().struct_span_err(span, sym::rustc_dump_inferred_outlives.as_str()); for pred in preds { err.note(pred); } diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs index 0ff38a0f36041..5025510da1bde 100644 --- a/compiler/rustc_middle/src/queries.rs +++ b/compiler/rustc_middle/src/queries.rs @@ -838,8 +838,8 @@ rustc_queries! { /// /// E.g., for `struct Foo<'a, T> { x: &'a T }`, this would return `[T: 'a]`. /// - /// **Tip**: You can use `#[rustc_outlives]` on an item to basically print the - /// result of this query for use in UI tests or for debugging purposes. + /// **Tip**: You can use `#[rustc_dump_inferred_outlives]` on an item to basically + /// print the result of this query for use in UI tests or for debugging purposes. query inferred_outlives_of(key: DefId) -> &'tcx [(ty::Clause<'tcx>, Span)] { desc { "computing inferred outlives-predicates of `{}`", tcx.def_path_str(key) } cache_on_disk_if { key.is_local() } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index dacb02afe1612..46373adf4461a 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -319,6 +319,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcDocPrimitive(..) | AttributeKind::RustcDummy | AttributeKind::RustcDumpDefParents + | AttributeKind::RustcDumpInferredOutlives | AttributeKind::RustcDumpItemBounds | AttributeKind::RustcDumpPredicates | AttributeKind::RustcDumpUserArgs @@ -355,7 +356,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcObjcClass { .. } | AttributeKind::RustcObjcSelector { .. } | AttributeKind::RustcOffloadKernel - | AttributeKind::RustcOutlives | AttributeKind::RustcParenSugar(..) | AttributeKind::RustcPassByValue (..) | AttributeKind::RustcPassIndirectlyInNonRusticAbis(..) diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index 9a2d68fc6639f..df5ffe9ba740f 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1721,6 +1721,7 @@ symbols! { rustc_driver, rustc_dummy, rustc_dump_def_parents, + rustc_dump_inferred_outlives, rustc_dump_item_bounds, rustc_dump_predicates, rustc_dump_user_args, @@ -1763,7 +1764,6 @@ symbols! { rustc_object_lifetime_default, rustc_offload_kernel, rustc_on_unimplemented, - rustc_outlives, rustc_paren_sugar, rustc_partition_codegened, rustc_partition_reused, diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md index d4c599a6edf74..8bddb985556a7 100644 --- a/src/doc/rustc-dev-guide/src/compiler-debugging.md +++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md @@ -275,13 +275,13 @@ Here are some notable ones: |----------------|-------------| | `rustc_def_path` | Dumps the [`def_path_str`] of an item. | | `rustc_dump_def_parents` | Dumps the chain of `DefId` parents of certain definitions. | +| `rustc_dump_inferred_outlives` | Dumps implied bounds of an item. More precisely, the [`inferred_outlives_of`] an item. | | `rustc_dump_item_bounds` | Dumps the [`item_bounds`] of an item. | | `rustc_dump_predicates` | Dumps the [`predicates_of`] an item. | | `rustc_dump_vtable` | Dumps the vtable layout of an impl, or a type alias of a dyn type. | | `rustc_hidden_type_of_opaques` | Dumps the [hidden type of each opaque types][opaq] in the crate. | | `rustc_layout` | [See this section](#debugging-type-layouts). | | `rustc_object_lifetime_default` | Dumps the [object lifetime defaults] of an item. | -| `rustc_outlives` | Dumps implied bounds of an item. More precisely, the [`inferred_outlives_of`] an item. | | `rustc_regions` | Dumps NLL closure region requirements. | | `rustc_symbol_name` | Dumps the mangled & demangled [`symbol_name`] of an item. | | `rustc_variances` | Dumps the [variances] of an item. | diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.rs index a9bfeabf16e5e..c0625f734b6e7 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, T> { //~ ERROR rustc_dump_inferred_outlives bar: std::slice::IterMut<'a, T> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr index e2a92cf72d565..376bc647158a4 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/cross-crate.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/cross-crate.rs:4:1 | LL | struct Foo<'a, T> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/enum.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/enum.rs index 71d2d32226556..cfd0d52900ce0 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/enum.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/enum.rs @@ -3,20 +3,20 @@ // Needs an explicit where clause stating outlives condition. (RFC 2093) // Type T needs to outlive lifetime 'a. -#[rustc_outlives] -enum Foo<'a, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +enum Foo<'a, T> { //~ ERROR rustc_dump_inferred_outlives One(Bar<'a, T>) } // Type U needs to outlive lifetime 'b -#[rustc_outlives] -struct Bar<'b, U> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Bar<'b, U> { //~ ERROR rustc_dump_inferred_outlives field2: &'b U } // Type K needs to outlive lifetime 'c. -#[rustc_outlives] -enum Ying<'c, K> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +enum Ying<'c, K> { //~ ERROR rustc_dump_inferred_outlives One(&'c Yang) } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/enum.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/enum.stderr index b6ce2450e22aa..e17e8705a5388 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/enum.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/enum.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/enum.rs:7:1 | LL | enum Foo<'a, T> { @@ -6,7 +6,7 @@ LL | enum Foo<'a, T> { | = note: T: 'a -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/enum.rs:13:1 | LL | struct Bar<'b, U> { @@ -14,7 +14,7 @@ LL | struct Bar<'b, U> { | = note: U: 'b -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/enum.rs:19:1 | LL | enum Ying<'c, K> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.rs index 419fb0a0e4589..72a1d1042444c 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.rs @@ -3,8 +3,8 @@ trait Trait<'x, T> where T: 'x { } -#[rustc_outlives] -struct Foo<'a, A> //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, A> //~ ERROR rustc_dump_inferred_outlives { foo: Box> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr index 30d1b3e77b1ca..3631daf6af768 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-dyn.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/explicit-dyn.rs:7:1 | LL | struct Foo<'a, A> diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.rs index c330c27fea0a9..3c1cafba12079 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -enum Foo<'a, U> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +enum Foo<'a, U> { //~ ERROR rustc_dump_inferred_outlives One(Bar<'a, U>) } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr index afc044d88482a..58005cca476bf 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-enum.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/explicit-enum.rs:4:1 | LL | enum Foo<'a, U> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.rs index 00b89528865a9..b7f5e4a1aab60 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.rs @@ -4,8 +4,8 @@ trait Trait<'x, T> where T: 'x { type Type; } -#[rustc_outlives] -struct Foo<'a, A, B> where A: Trait<'a, B> //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, A, B> where A: Trait<'a, B> //~ ERROR rustc_dump_inferred_outlives { foo: >::Type } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr index 1c39c984a2a68..4d0844759c958 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-projection.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/explicit-projection.rs:8:1 | LL | struct Foo<'a, A, B> where A: Trait<'a, B> diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.rs index 3d5e610b934b3..e067f7469499e 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'b, U> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'b, U> { //~ ERROR rustc_dump_inferred_outlives bar: Bar<'b, U> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr index 4ec3087acffec..76824254c81d7 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-struct.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/explicit-struct.rs:4:1 | LL | struct Foo<'b, U> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.rs index 871208b5ba785..dbce3b8400a46 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -union Foo<'b, U: Copy> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +union Foo<'b, U: Copy> { //~ ERROR rustc_dump_inferred_outlives bar: Bar<'b, U> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr index bbb48ef1f2610..1f47fb4bf9779 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/explicit-union.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/explicit-union.rs:4:1 | LL | union Foo<'b, U: Copy> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.rs index 0cd706e7ab6d4..2eb6e7e45e1e1 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -enum Foo<'a, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +enum Foo<'a, T> { //~ ERROR rustc_dump_inferred_outlives One(Bar<'a, T>) } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr index b584d17ae8534..9fe22b7ca85b9 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-enum.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/nested-enum.rs:4:1 | LL | enum Foo<'a, T> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.rs index a01c5068171d1..b76443842919f 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, 'b, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, 'b, T> { //~ ERROR rustc_dump_inferred_outlives x: &'a &'b T } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr index 59df869c47a6b..f80173bbf0742 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-regions.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/nested-regions.rs:4:1 | LL | struct Foo<'a, 'b, T> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.rs index ac6817d22bdc0..f33b02b6fa3b7 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, T> { //~ ERROR rustc_dump_inferred_outlives field1: Bar<'a, T> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr index 7e5af7fe6ed54..06439e0e8a990 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-structs.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/nested-structs.rs:4:1 | LL | struct Foo<'a, T> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.rs index 27ebd0b54db5d..73332bf0ad651 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -union Foo<'a, T: Copy> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +union Foo<'a, T: Copy> { //~ ERROR rustc_dump_inferred_outlives field1: Bar<'a, T> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr index bb0eea027d5a9..b526934ab6d30 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/nested-union.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/nested-union.rs:4:1 | LL | union Foo<'a, T: Copy> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.rs index 411c86da1dec5..399bddd714db0 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, T: Iterator> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, T: Iterator> { //~ ERROR rustc_dump_inferred_outlives bar: &'a T::Item } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr index 47f3458e0867e..e93c2f88bf3e8 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/projection.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/projection.rs:4:1 | LL | struct Foo<'a, T: Iterator> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.rs index a48a3315aa955..84a5ae7133b4e 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, T> { //~ ERROR rustc_dump_inferred_outlives bar: &'a T, } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr index 329d5ff06abc4..7f8156ef6a3d1 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/reference.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/reference.rs:4:1 | LL | struct Foo<'a, T> { diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.rs index c53d6c18ff65a..c346eaaf2eafa 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.rs @@ -4,8 +4,8 @@ trait Trait<'x, 's, T> where T: 'x, 's: { } -#[rustc_outlives] -struct Foo<'a, 'b, A> //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, 'b, A> //~ ERROR rustc_dump_inferred_outlives { foo: Box> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr index 8f8ee92054718..707711434e0ba 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-dyn.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/self-dyn.rs:8:1 | LL | struct Foo<'a, 'b, A> diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.rs b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.rs index 8f2d29d6f17c2..1dfccda5c91fe 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.rs +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.rs @@ -1,7 +1,7 @@ #![feature(rustc_attrs)] -#[rustc_outlives] -struct Foo<'a, 'b, T> { //~ ERROR rustc_outlives +#[rustc_dump_inferred_outlives] +struct Foo<'a, 'b, T> { //~ ERROR rustc_dump_inferred_outlives field1: dyn Bar<'a, 'b, T> } diff --git a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr index 7fef81c261972..eed55b7377c44 100644 --- a/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr +++ b/tests/ui/rfcs/rfc-2093-infer-outlives/self-structs.stderr @@ -1,4 +1,4 @@ -error: rustc_outlives +error: rustc_dump_inferred_outlives --> $DIR/self-structs.rs:4:1 | LL | struct Foo<'a, 'b, T> { From 6bb6b11d9d54ad95a61d8157bf6090ef8a67f8b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 18:06:31 +0100 Subject: [PATCH 5/7] Rename `#[rustc_variance]` to `#[rustc_dump_variances]` --- .../src/attributes/rustc_dump.rs | 18 ++++++++ .../src/attributes/test_attrs.rs | 18 -------- compiler/rustc_attr_parsing/src/context.rs | 2 +- .../src/error_codes/E0208.md | 45 ------------------- compiler/rustc_feature/src/builtin_attrs.rs | 2 +- .../rustc_hir/src/attrs/data_structures.rs | 6 +-- .../rustc_hir/src/attrs/encode_cross_crate.rs | 2 +- compiler/rustc_hir_analysis/src/errors.rs | 8 ---- .../rustc_hir_analysis/src/variance/dump.rs | 14 ++---- compiler/rustc_middle/src/queries.rs | 4 +- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_span/src/symbol.rs | 2 +- .../rustc-dev-guide/src/compiler-debugging.md | 2 +- tests/ui/error-codes/E0208.rs | 8 ---- tests/ui/error-codes/E0208.stderr | 8 ---- .../feature-gate-rustc-attrs-1.rs | 6 +-- .../feature-gate-rustc-attrs-1.stderr | 8 ++-- .../ui/variance/variance-associated-consts.rs | 2 +- .../ui/variance/variance-associated-types.rs | 4 +- tests/ui/variance/variance-object-types.rs | 2 +- tests/ui/variance/variance-regions-direct.rs | 14 +++--- .../ui/variance/variance-regions-indirect.rs | 10 ++--- tests/ui/variance/variance-trait-bounds.rs | 8 ++-- .../variance/variance-trait-object-bound.rs | 2 +- tests/ui/variance/variance-types-bounds.rs | 10 ++--- tests/ui/variance/variance-types.rs | 12 ++--- 26 files changed, 72 insertions(+), 147 deletions(-) delete mode 100644 tests/ui/error-codes/E0208.rs delete mode 100644 tests/ui/error-codes/E0208.stderr diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index 0160a4b10ec06..dea66f3a74b98 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -76,6 +76,24 @@ impl NoArgsAttributeParser for RustcDumpPredicatesParser { const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpPredicates; } +pub(crate) struct RustcDumpVariancesParser; + +impl NoArgsAttributeParser for RustcDumpVariancesParser { + const PATH: &[Symbol] = &[sym::rustc_dump_variances]; + const ON_DUPLICATE: OnDuplicate = 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 RustcDumpVtableParser; impl NoArgsAttributeParser for RustcDumpVtableParser { diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs index ed1bb50da498b..b01666688f5eb 100644 --- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs @@ -93,24 +93,6 @@ impl SingleAttributeParser for ShouldPanicParser { } } -pub(crate) struct RustcVarianceParser; - -impl NoArgsAttributeParser for RustcVarianceParser { - const PATH: &[Symbol] = &[sym::rustc_variance]; - const ON_DUPLICATE: OnDuplicate = 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::RustcVariance; -} - pub(crate) struct RustcVarianceOfOpaquesParser; impl NoArgsAttributeParser for RustcVarianceOfOpaquesParser { diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs index 0f057f77d6107..915337b09d1dd 100644 --- a/compiler/rustc_attr_parsing/src/context.rs +++ b/compiler/rustc_attr_parsing/src/context.rs @@ -285,6 +285,7 @@ attribute_parsers!( Single>, Single>, Single>, + Single>, Single>, Single>, Single>, @@ -324,7 +325,6 @@ attribute_parsers!( Single>, Single>, Single>, - Single>, Single>, Single>, // tidy-alphabetical-end diff --git a/compiler/rustc_error_codes/src/error_codes/E0208.md b/compiler/rustc_error_codes/src/error_codes/E0208.md index 2b811b4b8500f..f7bbeb293caef 100644 --- a/compiler/rustc_error_codes/src/error_codes/E0208.md +++ b/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] - --> :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 diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index 526c7e912dca0..faf29dd467e1e 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -1439,7 +1439,7 @@ 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!( diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs index 23e76207810f7..d4fc0be8595ed 100644 --- a/compiler/rustc_hir/src/attrs/data_structures.rs +++ b/compiler/rustc_hir/src/attrs/data_structures.rs @@ -1378,6 +1378,9 @@ pub enum AttributeKind { /// Represents `#[rustc_dump_user_args]` RustcDumpUserArgs, + /// Represents `#[rustc_dump_variances]` + RustcDumpVariances, + /// Represents `#[rustc_dump_vtable]` RustcDumpVtable(Span), @@ -1574,9 +1577,6 @@ pub enum AttributeKind { /// Represents `#[rustc_unsafe_specialization_marker]`. RustcUnsafeSpecializationMarker(Span), - /// Represents `#[rustc_variance]` - RustcVariance, - /// Represents `#[rustc_variance_of_opaques]` RustcVarianceOfOpaques, diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs index e61d102ef1f34..c36282439a1cd 100644 --- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs +++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs @@ -128,6 +128,7 @@ impl AttributeKind { RustcDumpItemBounds => No, RustcDumpPredicates => No, RustcDumpUserArgs => No, + RustcDumpVariances => No, RustcDumpVtable(..) => No, RustcDynIncompatibleTrait(..) => No, RustcEffectiveVisibility => Yes, @@ -185,7 +186,6 @@ impl AttributeKind { RustcThenThisWouldNeed(..) => No, RustcTrivialFieldReads => Yes, RustcUnsafeSpecializationMarker(..) => No, - RustcVariance => No, RustcVarianceOfOpaques => No, Sanitize { .. } => No, ShouldPanic { .. } => No, diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs index 5cda2ac660fb1..1c999f1ffc93a 100644 --- a/compiler/rustc_hir_analysis/src/errors.rs +++ b/compiler/rustc_hir_analysis/src/errors.rs @@ -735,14 +735,6 @@ pub(crate) enum CannotCaptureLateBound { }, } -#[derive(Diagnostic)] -#[diag("{$variances}")] -pub(crate) struct VariancesOf { - #[primary_span] - pub span: Span, - pub variances: String, -} - #[derive(Diagnostic)] #[diag("{$ty}")] pub(crate) struct TypeOf<'tcx> { diff --git a/compiler/rustc_hir_analysis/src/variance/dump.rs b/compiler/rustc_hir_analysis/src/variance/dump.rs index 84d25bbbe9b96..1c12160619738 100644 --- a/compiler/rustc_hir_analysis/src/variance/dump.rs +++ b/compiler/rustc_hir_analysis/src/variance/dump.rs @@ -28,15 +28,12 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) { if find_attr!(tcx, crate, RustcVarianceOfOpaques) { for id in crate_items.opaques() { - tcx.dcx().emit_err(crate::errors::VariancesOf { - span: tcx.def_span(id), - variances: format_variances(tcx, id), - }); + tcx.dcx().span_err(tcx.def_span(id), format_variances(tcx, id)); } } for id in crate_items.owners() { - if !find_attr!(tcx, id, RustcVariance) { + if !find_attr!(tcx, id, RustcDumpVariances) { continue; } @@ -46,16 +43,13 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) { kind => { let message = format!( "attr parsing didn't report an error for `#[{}]` on {kind:?}", - rustc_span::sym::rustc_variance, + rustc_span::sym::rustc_dump_variances, ); tcx.dcx().span_delayed_bug(tcx.def_span(id), message); continue; } } - tcx.dcx().emit_err(crate::errors::VariancesOf { - span: tcx.def_span(id), - variances: format_variances(tcx, id.def_id), - }); + tcx.dcx().span_err(tcx.def_span(id), format_variances(tcx, id.def_id)); } } diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs index 5025510da1bde..42c4ff5e7afe3 100644 --- a/compiler/rustc_middle/src/queries.rs +++ b/compiler/rustc_middle/src/queries.rs @@ -1046,8 +1046,8 @@ rustc_queries! { /// The list of variances corresponds to the list of (early-bound) generic /// parameters of the item (including its parents). /// - /// **Tip**: You can use `#[rustc_variance]` on an item to basically print the - /// result of this query for use in UI tests or for debugging purposes. + /// **Tip**: You can use `#[rustc_dump_variances]` on an item to basically print + /// the result of this query for use in UI tests or for debugging purposes. query variances_of(def_id: DefId) -> &'tcx [ty::Variance] { desc { "computing the variances of `{}`", tcx.def_path_str(def_id) } cache_on_disk_if { def_id.is_local() } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 46373adf4461a..8a729a8f4b6a8 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -323,6 +323,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcDumpItemBounds | AttributeKind::RustcDumpPredicates | AttributeKind::RustcDumpUserArgs + | AttributeKind::RustcDumpVariances | AttributeKind::RustcDumpVtable(..) | AttributeKind::RustcDynIncompatibleTrait(..) | AttributeKind::RustcEffectiveVisibility @@ -376,7 +377,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcThenThisWouldNeed(..) | AttributeKind::RustcTrivialFieldReads | AttributeKind::RustcUnsafeSpecializationMarker(..) - | AttributeKind::RustcVariance | AttributeKind::RustcVarianceOfOpaques | AttributeKind::ShouldPanic { .. } | AttributeKind::TestRunner(..) diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index df5ffe9ba740f..ccbacea4c13e6 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1725,6 +1725,7 @@ symbols! { rustc_dump_item_bounds, rustc_dump_predicates, rustc_dump_user_args, + rustc_dump_variances, rustc_dump_vtable, rustc_dyn_incompatible_trait, rustc_effective_visibility, @@ -1793,7 +1794,6 @@ symbols! { rustc_then_this_would_need, rustc_trivial_field_reads, rustc_unsafe_specialization_marker, - rustc_variance, rustc_variance_of_opaques, rustdoc, rustdoc_internals, diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md index 8bddb985556a7..d4eb004a0eef8 100644 --- a/src/doc/rustc-dev-guide/src/compiler-debugging.md +++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md @@ -278,13 +278,13 @@ Here are some notable ones: | `rustc_dump_inferred_outlives` | Dumps implied bounds of an item. More precisely, the [`inferred_outlives_of`] an item. | | `rustc_dump_item_bounds` | Dumps the [`item_bounds`] of an item. | | `rustc_dump_predicates` | Dumps the [`predicates_of`] an item. | +| `rustc_dump_variances` | Dumps the [variances] of an item. | | `rustc_dump_vtable` | Dumps the vtable layout of an impl, or a type alias of a dyn type. | | `rustc_hidden_type_of_opaques` | Dumps the [hidden type of each opaque types][opaq] in the crate. | | `rustc_layout` | [See this section](#debugging-type-layouts). | | `rustc_object_lifetime_default` | Dumps the [object lifetime defaults] of an item. | | `rustc_regions` | Dumps NLL closure region requirements. | | `rustc_symbol_name` | Dumps the mangled & demangled [`symbol_name`] of an item. | -| `rustc_variances` | Dumps the [variances] of an item. | Right below you can find elaborate explainers on a selected few. diff --git a/tests/ui/error-codes/E0208.rs b/tests/ui/error-codes/E0208.rs deleted file mode 100644 index 2713ba6ed6cb5..0000000000000 --- a/tests/ui/error-codes/E0208.rs +++ /dev/null @@ -1,8 +0,0 @@ -#![feature(rustc_attrs)] - -#[rustc_variance] -struct Foo<'a, T> { //~ ERROR ['a: +, T: o] - t: &'a mut T, -} - -fn main() {} diff --git a/tests/ui/error-codes/E0208.stderr b/tests/ui/error-codes/E0208.stderr deleted file mode 100644 index a39e93afab3e1..0000000000000 --- a/tests/ui/error-codes/E0208.stderr +++ /dev/null @@ -1,8 +0,0 @@ -error: ['a: +, T: o] - --> $DIR/E0208.rs:4:1 - | -LL | struct Foo<'a, T> { - | ^^^^^^^^^^^^^^^^^ - -error: aborting due to 1 previous error - diff --git a/tests/ui/feature-gates/feature-gate-rustc-attrs-1.rs b/tests/ui/feature-gates/feature-gate-rustc-attrs-1.rs index beddfd87a5e7e..f9b097fdd2151 100644 --- a/tests/ui/feature-gates/feature-gate-rustc-attrs-1.rs +++ b/tests/ui/feature-gates/feature-gate-rustc-attrs-1.rs @@ -7,10 +7,10 @@ //~| NOTE the compiler does not even check whether the type indeed is being non-null-optimized; it is your responsibility to ensure that the attribute is only used on types that are optimized struct Foo {} -#[rustc_variance] +#[rustc_dump_variances] //~^ ERROR use of an internal attribute [E0658] -//~| NOTE the `#[rustc_variance]` attribute is an internal implementation detail that will never be stable -//~| NOTE the `#[rustc_variance]` attribute is used for rustc unit tests +//~| NOTE the `#[rustc_dump_variances]` attribute is an internal implementation detail that will never be stable +//~| NOTE the `#[rustc_dump_variances]` attribute is used for rustc unit tests enum E {} fn main() {} diff --git a/tests/ui/feature-gates/feature-gate-rustc-attrs-1.stderr b/tests/ui/feature-gates/feature-gate-rustc-attrs-1.stderr index 6588229b7d56e..81d8a750b897a 100644 --- a/tests/ui/feature-gates/feature-gate-rustc-attrs-1.stderr +++ b/tests/ui/feature-gates/feature-gate-rustc-attrs-1.stderr @@ -12,12 +12,12 @@ LL | #[rustc_nonnull_optimization_guaranteed] error[E0658]: use of an internal attribute --> $DIR/feature-gate-rustc-attrs-1.rs:10:1 | -LL | #[rustc_variance] - | ^^^^^^^^^^^^^^^^^ +LL | #[rustc_dump_variances] + | ^^^^^^^^^^^^^^^^^^^^^^^ | = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable - = note: the `#[rustc_variance]` attribute is an internal implementation detail that will never be stable - = note: the `#[rustc_variance]` attribute is used for rustc unit tests + = note: the `#[rustc_dump_variances]` attribute is an internal implementation detail that will never be stable + = note: the `#[rustc_dump_variances]` attribute is used for rustc unit tests error: aborting due to 2 previous errors diff --git a/tests/ui/variance/variance-associated-consts.rs b/tests/ui/variance/variance-associated-consts.rs index 97edb7e266ad0..e53533ae30d74 100644 --- a/tests/ui/variance/variance-associated-consts.rs +++ b/tests/ui/variance/variance-associated-consts.rs @@ -9,7 +9,7 @@ trait Trait { const Const: usize; } -#[rustc_variance] +#[rustc_dump_variances] struct Foo { //~ ERROR [T: o] field: [u8; ::Const] //~^ ERROR: unconstrained generic constant diff --git a/tests/ui/variance/variance-associated-types.rs b/tests/ui/variance/variance-associated-types.rs index 07ff41062e881..00e5338880a14 100644 --- a/tests/ui/variance/variance-associated-types.rs +++ b/tests/ui/variance/variance-associated-types.rs @@ -9,12 +9,12 @@ trait Trait<'a> { fn method(&'a self) { } } -#[rustc_variance] +#[rustc_dump_variances] struct Foo<'a, T : Trait<'a>> { //~ ERROR ['a: +, T: +] field: (T, &'a ()) } -#[rustc_variance] +#[rustc_dump_variances] struct Bar<'a, T : Trait<'a>> { //~ ERROR ['a: o, T: o] field: >::Type } diff --git a/tests/ui/variance/variance-object-types.rs b/tests/ui/variance/variance-object-types.rs index fd03dec982492..10e1e3ebd09a7 100644 --- a/tests/ui/variance/variance-object-types.rs +++ b/tests/ui/variance/variance-object-types.rs @@ -3,7 +3,7 @@ // For better or worse, associated types are invariant, and hence we // get an invariant result for `'a`. -#[rustc_variance] +#[rustc_dump_variances] struct Foo<'a> { //~ ERROR ['a: o] x: Box &'a i32 + 'static> } diff --git a/tests/ui/variance/variance-regions-direct.rs b/tests/ui/variance/variance-regions-direct.rs index 2bcacec33ea5a..1211db355baf3 100644 --- a/tests/ui/variance/variance-regions-direct.rs +++ b/tests/ui/variance/variance-regions-direct.rs @@ -5,7 +5,7 @@ // Regions that just appear in normal spots are contravariant: -#[rustc_variance] +#[rustc_dump_variances] struct Test2<'a, 'b, 'c> { //~ ERROR ['a: +, 'b: +, 'c: +] x: &'a isize, y: &'b [isize], @@ -14,7 +14,7 @@ struct Test2<'a, 'b, 'c> { //~ ERROR ['a: +, 'b: +, 'c: +] // Those same annotations in function arguments become covariant: -#[rustc_variance] +#[rustc_dump_variances] struct Test3<'a, 'b, 'c> { //~ ERROR ['a: -, 'b: -, 'c: -] x: extern "Rust" fn(&'a isize), y: extern "Rust" fn(&'b [isize]), @@ -23,7 +23,7 @@ struct Test3<'a, 'b, 'c> { //~ ERROR ['a: -, 'b: -, 'c: -] // Mutability induces invariance: -#[rustc_variance] +#[rustc_dump_variances] struct Test4<'a, 'b:'a> { //~ ERROR ['a: +, 'b: o] x: &'a mut &'b isize, } @@ -31,7 +31,7 @@ struct Test4<'a, 'b:'a> { //~ ERROR ['a: +, 'b: o] // Mutability induces invariance, even when in a // contravariant context: -#[rustc_variance] +#[rustc_dump_variances] struct Test5<'a, 'b:'a> { //~ ERROR ['a: -, 'b: o] x: extern "Rust" fn(&'a mut &'b isize), } @@ -41,14 +41,14 @@ struct Test5<'a, 'b:'a> { //~ ERROR ['a: -, 'b: o] // an argument list (which is contravariant), that // argument list occurs in an invariant context. -#[rustc_variance] +#[rustc_dump_variances] struct Test6<'a, 'b:'a> { //~ ERROR ['a: +, 'b: o] x: &'a mut extern "Rust" fn(&'b isize), } // No uses at all is bivariant: -#[rustc_variance] +#[rustc_dump_variances] struct Test7<'a> { //~ ERROR ['a: *] //~^ ERROR: `'a` is never used x: isize @@ -56,7 +56,7 @@ struct Test7<'a> { //~ ERROR ['a: *] // Try enums too. -#[rustc_variance] +#[rustc_dump_variances] enum Test8<'a, 'b, 'c:'b> { //~ ERROR ['a: -, 'b: +, 'c: o] Test8A(extern "Rust" fn(&'a isize)), Test8B(&'b [isize]), diff --git a/tests/ui/variance/variance-regions-indirect.rs b/tests/ui/variance/variance-regions-indirect.rs index aaa4d3f877995..0c5348ae0e40a 100644 --- a/tests/ui/variance/variance-regions-indirect.rs +++ b/tests/ui/variance/variance-regions-indirect.rs @@ -4,7 +4,7 @@ #![feature(rustc_attrs)] -#[rustc_variance] +#[rustc_dump_variances] enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR ['a: -, 'b: +, 'c: o, 'd: *] //~^ ERROR: `'d` is never used Test8A(extern "Rust" fn(&'a isize)), @@ -12,25 +12,25 @@ enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR ['a: -, 'b: +, 'c: o, 'd: *] Test8C(&'b mut &'c str), } -#[rustc_variance] +#[rustc_dump_variances] struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR ['w: *, 'x: o, 'y: +, 'z: -] //~^ ERROR: `'w` is never used f: Base<'z, 'y, 'x, 'w> } -#[rustc_variance] // Combine - and + to yield o +#[rustc_dump_variances] // Combine - and + to yield o struct Derived2<'a, 'b:'a, 'c> { //~ ERROR ['a: o, 'b: o, 'c: *] //~^ ERROR: `'c` is never used f: Base<'a, 'a, 'b, 'c> } -#[rustc_variance] // Combine + and o to yield o (just pay attention to 'a here) +#[rustc_dump_variances] // Combine + and o to yield o (just pay attention to 'a here) struct Derived3<'a:'b, 'b, 'c> { //~ ERROR ['a: o, 'b: +, 'c: *] //~^ ERROR: `'c` is never used f: Base<'a, 'b, 'a, 'c> } -#[rustc_variance] // Combine + and * to yield + (just pay attention to 'a here) +#[rustc_dump_variances] // Combine + and * to yield + (just pay attention to 'a here) struct Derived4<'a, 'b, 'c:'b> { //~ ERROR ['a: -, 'b: +, 'c: o] f: Base<'a, 'b, 'c, 'a> } diff --git a/tests/ui/variance/variance-trait-bounds.rs b/tests/ui/variance/variance-trait-bounds.rs index f86fa2bbef7a0..43f19378ee548 100644 --- a/tests/ui/variance/variance-trait-bounds.rs +++ b/tests/ui/variance/variance-trait-bounds.rs @@ -12,24 +12,24 @@ trait Setter { fn get(&self, _: T); } -#[rustc_variance] +#[rustc_dump_variances] struct TestStruct> { //~ ERROR [U: +, T: +] t: T, u: U } -#[rustc_variance] +#[rustc_dump_variances] enum TestEnum> { //~ ERROR [U: *, T: +] //~^ ERROR: `U` is never used Foo(T) } -#[rustc_variance] +#[rustc_dump_variances] struct TestContraStruct> { //~ ERROR [U: *, T: +] //~^ ERROR: `U` is never used t: T } -#[rustc_variance] +#[rustc_dump_variances] struct TestBox+Setter> { //~ ERROR [U: *, T: +] //~^ ERROR: `U` is never used t: T diff --git a/tests/ui/variance/variance-trait-object-bound.rs b/tests/ui/variance/variance-trait-object-bound.rs index ca80c6b6dce22..03dbdfb0bd376 100644 --- a/tests/ui/variance/variance-trait-object-bound.rs +++ b/tests/ui/variance/variance-trait-object-bound.rs @@ -10,7 +10,7 @@ use std::mem; trait T { fn foo(&self); } -#[rustc_variance] +#[rustc_dump_variances] struct TOption<'a> { //~ ERROR ['a: +] v: Option>, } diff --git a/tests/ui/variance/variance-types-bounds.rs b/tests/ui/variance/variance-types-bounds.rs index f4738a2dae1ab..b0c382560098a 100644 --- a/tests/ui/variance/variance-types-bounds.rs +++ b/tests/ui/variance/variance-types-bounds.rs @@ -3,24 +3,24 @@ #![feature(rustc_attrs)] -#[rustc_variance] +#[rustc_dump_variances] struct TestImm { //~ ERROR [A: +, B: +] x: A, y: B, } -#[rustc_variance] +#[rustc_dump_variances] struct TestMut { //~ ERROR [A: +, B: o] x: A, y: &'static mut B, } -#[rustc_variance] +#[rustc_dump_variances] struct TestIndirect { //~ ERROR [A: +, B: o] m: TestMut } -#[rustc_variance] +#[rustc_dump_variances] struct TestIndirect2 { //~ ERROR [A: o, B: o] n: TestMut, m: TestMut @@ -34,7 +34,7 @@ trait Setter { fn set(&mut self, a: A); } -#[rustc_variance] +#[rustc_dump_variances] struct TestObject { //~ ERROR [A: o, R: o] n: Box+Send>, m: Box+Send>, diff --git a/tests/ui/variance/variance-types.rs b/tests/ui/variance/variance-types.rs index aa336d1b424c1..3b3ac929a2633 100644 --- a/tests/ui/variance/variance-types.rs +++ b/tests/ui/variance/variance-types.rs @@ -6,32 +6,32 @@ use std::cell::Cell; // Check that a type parameter which is only used in a trait bound is // not considered bivariant. -#[rustc_variance] +#[rustc_dump_variances] struct InvariantMut<'a,A:'a,B:'a> { //~ ERROR ['a: +, A: o, B: o] t: &'a mut (A,B) } -#[rustc_variance] +#[rustc_dump_variances] struct InvariantCell { //~ ERROR [A: o] t: Cell } -#[rustc_variance] +#[rustc_dump_variances] struct InvariantIndirect { //~ ERROR [A: o] t: InvariantCell } -#[rustc_variance] +#[rustc_dump_variances] struct Covariant { //~ ERROR [A: +] t: A, u: fn() -> A } -#[rustc_variance] +#[rustc_dump_variances] struct Contravariant { //~ ERROR [A: -] t: fn(A) } -#[rustc_variance] +#[rustc_dump_variances] enum Enum { //~ ERROR [A: +, B: -, C: o] Foo(Covariant), Bar(Contravariant), From 6af78890bc23b160f3741cba0dd5210675c3b95e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 18:13:09 +0100 Subject: [PATCH 6/7] Rename `#![rustc_variance_of_opaques]` to `#![rustc_dump_variances_of_opaques]` --- compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs | 9 +++++++++ compiler/rustc_attr_parsing/src/attributes/test_attrs.rs | 9 --------- compiler/rustc_attr_parsing/src/context.rs | 2 +- compiler/rustc_feature/src/builtin_attrs.rs | 2 +- compiler/rustc_hir/src/attrs/data_structures.rs | 6 +++--- compiler/rustc_hir/src/attrs/encode_cross_crate.rs | 2 +- compiler/rustc_hir_analysis/src/variance/dump.rs | 2 +- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_span/src/symbol.rs | 2 +- tests/ui/impl-trait/capture-lifetime-not-in-hir.rs | 2 +- tests/ui/impl-trait/implicit-capture-late.rs | 2 +- tests/ui/impl-trait/in-trait/variance.rs | 2 +- .../impl-trait/precise-capturing/capturing-implicit.rs | 2 +- tests/ui/impl-trait/variance.rs | 2 +- tests/ui/traits/const-traits/variance.rs | 2 +- tests/ui/type-alias-impl-trait/variance.rs | 2 +- 16 files changed, 25 insertions(+), 25 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index dea66f3a74b98..06bf77771deb4 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -94,6 +94,15 @@ impl NoArgsAttributeParser for RustcDumpVariancesParser { const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpVariances; } +pub(crate) struct RustcDumpVariancesOfOpaquesParser; + +impl NoArgsAttributeParser for RustcDumpVariancesOfOpaquesParser { + const PATH: &[Symbol] = &[sym::rustc_dump_variances_of_opaques]; + const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn; + const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]); + const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpVariancesOfOpaques; +} + pub(crate) struct RustcDumpVtableParser; impl NoArgsAttributeParser for RustcDumpVtableParser { diff --git a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs index b01666688f5eb..2775eab1b5d97 100644 --- a/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs +++ b/compiler/rustc_attr_parsing/src/attributes/test_attrs.rs @@ -93,15 +93,6 @@ impl SingleAttributeParser for ShouldPanicParser { } } -pub(crate) struct RustcVarianceOfOpaquesParser; - -impl NoArgsAttributeParser for RustcVarianceOfOpaquesParser { - const PATH: &[Symbol] = &[sym::rustc_variance_of_opaques]; - const ON_DUPLICATE: OnDuplicate = OnDuplicate::Warn; - const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::Crate)]); - const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcVarianceOfOpaques; -} - pub(crate) struct ReexportTestHarnessMainParser; impl SingleAttributeParser for ReexportTestHarnessMainParser { diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs index 915337b09d1dd..8e871cd170033 100644 --- a/compiler/rustc_attr_parsing/src/context.rs +++ b/compiler/rustc_attr_parsing/src/context.rs @@ -285,6 +285,7 @@ attribute_parsers!( Single>, Single>, Single>, + Single>, Single>, Single>, Single>, @@ -324,7 +325,6 @@ attribute_parsers!( Single>, Single>, Single>, - Single>, Single>, Single>, // tidy-alphabetical-end diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index faf29dd467e1e..f18e7e3146a36 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -1443,7 +1443,7 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ 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!( diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs index d4fc0be8595ed..426eec68ca6fb 100644 --- a/compiler/rustc_hir/src/attrs/data_structures.rs +++ b/compiler/rustc_hir/src/attrs/data_structures.rs @@ -1381,6 +1381,9 @@ pub enum AttributeKind { /// Represents `#[rustc_dump_variances]` RustcDumpVariances, + /// Represents `#[rustc_dump_variances_of_opaques]` + RustcDumpVariancesOfOpaques, + /// Represents `#[rustc_dump_vtable]` RustcDumpVtable(Span), @@ -1577,9 +1580,6 @@ pub enum AttributeKind { /// Represents `#[rustc_unsafe_specialization_marker]`. RustcUnsafeSpecializationMarker(Span), - /// Represents `#[rustc_variance_of_opaques]` - RustcVarianceOfOpaques, - /// Represents `#[sanitize]` /// /// the on set and off set are distjoint since there's a third option: unset. diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs index c36282439a1cd..1237e8f0d1338 100644 --- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs +++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs @@ -129,6 +129,7 @@ impl AttributeKind { RustcDumpPredicates => No, RustcDumpUserArgs => No, RustcDumpVariances => No, + RustcDumpVariancesOfOpaques => No, RustcDumpVtable(..) => No, RustcDynIncompatibleTrait(..) => No, RustcEffectiveVisibility => Yes, @@ -186,7 +187,6 @@ impl AttributeKind { RustcThenThisWouldNeed(..) => No, RustcTrivialFieldReads => Yes, RustcUnsafeSpecializationMarker(..) => No, - RustcVarianceOfOpaques => No, Sanitize { .. } => No, ShouldPanic { .. } => No, Stability { .. } => Yes, diff --git a/compiler/rustc_hir_analysis/src/variance/dump.rs b/compiler/rustc_hir_analysis/src/variance/dump.rs index 1c12160619738..2e17464736959 100644 --- a/compiler/rustc_hir_analysis/src/variance/dump.rs +++ b/compiler/rustc_hir_analysis/src/variance/dump.rs @@ -26,7 +26,7 @@ fn format_variances(tcx: TyCtxt<'_>, def_id: LocalDefId) -> String { pub(crate) fn variances(tcx: TyCtxt<'_>) { let crate_items = tcx.hir_crate_items(()); - if find_attr!(tcx, crate, RustcVarianceOfOpaques) { + if find_attr!(tcx, crate, RustcDumpVariancesOfOpaques) { for id in crate_items.opaques() { tcx.dcx().span_err(tcx.def_span(id), format_variances(tcx, id)); } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 8a729a8f4b6a8..4d5c793bdd880 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -324,6 +324,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcDumpPredicates | AttributeKind::RustcDumpUserArgs | AttributeKind::RustcDumpVariances + | AttributeKind::RustcDumpVariancesOfOpaques | AttributeKind::RustcDumpVtable(..) | AttributeKind::RustcDynIncompatibleTrait(..) | AttributeKind::RustcEffectiveVisibility @@ -377,7 +378,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> { | AttributeKind::RustcThenThisWouldNeed(..) | AttributeKind::RustcTrivialFieldReads | AttributeKind::RustcUnsafeSpecializationMarker(..) - | AttributeKind::RustcVarianceOfOpaques | AttributeKind::ShouldPanic { .. } | AttributeKind::TestRunner(..) | AttributeKind::ThreadLocal diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index ccbacea4c13e6..de486138217d7 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1726,6 +1726,7 @@ symbols! { rustc_dump_predicates, rustc_dump_user_args, rustc_dump_variances, + rustc_dump_variances_of_opaques, rustc_dump_vtable, rustc_dyn_incompatible_trait, rustc_effective_visibility, @@ -1794,7 +1795,6 @@ symbols! { rustc_then_this_would_need, rustc_trivial_field_reads, rustc_unsafe_specialization_marker, - rustc_variance_of_opaques, rustdoc, rustdoc_internals, rustdoc_missing_doc_code_examples, diff --git a/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs b/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs index 2fde0f200c0e5..a5a6c310b7bf2 100644 --- a/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs +++ b/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs @@ -1,5 +1,5 @@ #![feature(rustc_attrs)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] trait Bar<'a> { type Assoc: From<()>; diff --git a/tests/ui/impl-trait/implicit-capture-late.rs b/tests/ui/impl-trait/implicit-capture-late.rs index 57a00357c711d..d7ef8fb888064 100644 --- a/tests/ui/impl-trait/implicit-capture-late.rs +++ b/tests/ui/impl-trait/implicit-capture-late.rs @@ -2,7 +2,7 @@ #![feature(rustc_attrs)] #![allow(internal_features)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] use std::ops::Deref; diff --git a/tests/ui/impl-trait/in-trait/variance.rs b/tests/ui/impl-trait/in-trait/variance.rs index f0b8c05b2d710..b1e7d91fc6ad1 100644 --- a/tests/ui/impl-trait/in-trait/variance.rs +++ b/tests/ui/impl-trait/in-trait/variance.rs @@ -1,6 +1,6 @@ #![feature(rustc_attrs)] #![allow(internal_features)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] trait Foo<'i> { fn implicit_capture_early<'a: 'a>() -> impl Sized {} diff --git a/tests/ui/impl-trait/precise-capturing/capturing-implicit.rs b/tests/ui/impl-trait/precise-capturing/capturing-implicit.rs index 7b53b20ceffad..255f093b3cca1 100644 --- a/tests/ui/impl-trait/precise-capturing/capturing-implicit.rs +++ b/tests/ui/impl-trait/precise-capturing/capturing-implicit.rs @@ -2,7 +2,7 @@ #![feature(rustc_attrs)] #![feature(type_alias_impl_trait)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] fn foo(x: &()) -> impl IntoIterator + use<> { //~^ ERROR ['_: o] diff --git a/tests/ui/impl-trait/variance.rs b/tests/ui/impl-trait/variance.rs index e73e0c623aa40..d08e2297932e9 100644 --- a/tests/ui/impl-trait/variance.rs +++ b/tests/ui/impl-trait/variance.rs @@ -3,7 +3,7 @@ #![feature(rustc_attrs)] #![allow(internal_features)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] trait Captures<'a> {} impl Captures<'_> for T {} diff --git a/tests/ui/traits/const-traits/variance.rs b/tests/ui/traits/const-traits/variance.rs index 73014703adc03..711b810e3716c 100644 --- a/tests/ui/traits/const-traits/variance.rs +++ b/tests/ui/traits/const-traits/variance.rs @@ -1,6 +1,6 @@ #![feature(rustc_attrs, const_trait_impl)] #![allow(internal_features)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] const trait Foo {} diff --git a/tests/ui/type-alias-impl-trait/variance.rs b/tests/ui/type-alias-impl-trait/variance.rs index d9140695dae28..5b2d23d631b45 100644 --- a/tests/ui/type-alias-impl-trait/variance.rs +++ b/tests/ui/type-alias-impl-trait/variance.rs @@ -1,6 +1,6 @@ #![feature(rustc_attrs, type_alias_impl_trait, impl_trait_in_assoc_type)] #![allow(internal_features)] -#![rustc_variance_of_opaques] +#![rustc_dump_variances_of_opaques] trait Captures<'a> {} impl Captures<'_> for T {} From 722fcbb72e3e312153dcc142108fac6efef40538 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= Date: Mon, 2 Mar 2026 18:33:02 +0100 Subject: [PATCH 7/7] Rename `#[rustc_object_lifetime_default]` to `#[rustc_dump_object_lifetime_defaults]` --- .../src/attributes/rustc_dump.rs | 27 +++++++++++++++++++ .../src/attributes/rustc_internal.rs | 27 ------------------- compiler/rustc_attr_parsing/src/context.rs | 2 +- compiler/rustc_feature/src/builtin_attrs.rs | 2 +- .../rustc_hir/src/attrs/data_structures.rs | 6 ++--- .../rustc_hir/src/attrs/encode_cross_crate.rs | 2 +- compiler/rustc_middle/src/queries.rs | 2 +- compiler/rustc_passes/src/check_attr.rs | 10 +++---- compiler/rustc_passes/src/errors.rs | 8 ------ compiler/rustc_span/src/symbol.rs | 2 +- .../rustc-dev-guide/src/compiler-debugging.md | 2 +- .../object-lifetime-default.rs | 14 +++++----- 12 files changed, 48 insertions(+), 56 deletions(-) diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs index 06bf77771deb4..7c771a71bf638 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_dump.rs @@ -48,6 +48,33 @@ impl NoArgsAttributeParser for RustcDumpItemBoundsParser { const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcDumpItemBounds; } +pub(crate) struct RustcDumpObjectLifetimeDefaultsParser; + +impl NoArgsAttributeParser for RustcDumpObjectLifetimeDefaultsParser { + const PATH: &[Symbol] = &[sym::rustc_dump_object_lifetime_defaults]; + const ON_DUPLICATE: OnDuplicate = 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 NoArgsAttributeParser for RustcDumpPredicatesParser { diff --git a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs index 5908b4f77f4d1..e8b4cb343794c 100644 --- a/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs +++ b/compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs @@ -588,33 +588,6 @@ impl NoArgsAttributeParser for RustcLintUntrackedQueryInformationPa const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcLintUntrackedQueryInformation; } -pub(crate) struct RustcObjectLifetimeDefaultParser; - -impl NoArgsAttributeParser for RustcObjectLifetimeDefaultParser { - const PATH: &[Symbol] = &[sym::rustc_object_lifetime_default]; - const ON_DUPLICATE: OnDuplicate = 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::RustcObjectLifetimeDefault; -} - pub(crate) struct RustcSimdMonomorphizeLaneLimitParser; impl SingleAttributeParser for RustcSimdMonomorphizeLaneLimitParser { diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs index 8e871cd170033..190568bed508d 100644 --- a/compiler/rustc_attr_parsing/src/context.rs +++ b/compiler/rustc_attr_parsing/src/context.rs @@ -283,6 +283,7 @@ attribute_parsers!( Single>, Single>, Single>, + Single>, Single>, Single>, Single>, @@ -309,7 +310,6 @@ attribute_parsers!( Single>, Single>, Single>, - Single>, Single>, Single>, Single>, diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs index f18e7e3146a36..f586cbb1d7154 100644 --- a/compiler/rustc_feature/src/builtin_attrs.rs +++ b/compiler/rustc_feature/src/builtin_attrs.rs @@ -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!( diff --git a/compiler/rustc_hir/src/attrs/data_structures.rs b/compiler/rustc_hir/src/attrs/data_structures.rs index 426eec68ca6fb..e8476c3d8c73b 100644 --- a/compiler/rustc_hir/src/attrs/data_structures.rs +++ b/compiler/rustc_hir/src/attrs/data_structures.rs @@ -1372,6 +1372,9 @@ pub enum AttributeKind { /// Represents `#[rustc_dump_item_bounds]` RustcDumpItemBounds, + /// Represents `#[rustc_dump_object_lifetime_defaults]`. + RustcDumpObjectLifetimeDefaults, + /// Represents `#[rustc_dump_predicates]` RustcDumpPredicates, @@ -1502,9 +1505,6 @@ pub enum AttributeKind { span: Span, }, - /// Represents `#[rustc_object_lifetime_default]`. - RustcObjectLifetimeDefault, - /// Represents `#[rustc_offload_kernel]` RustcOffloadKernel, diff --git a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs index 1237e8f0d1338..27128f6996370 100644 --- a/compiler/rustc_hir/src/attrs/encode_cross_crate.rs +++ b/compiler/rustc_hir/src/attrs/encode_cross_crate.rs @@ -126,6 +126,7 @@ impl AttributeKind { RustcDumpDefParents => No, RustcDumpInferredOutlives => No, RustcDumpItemBounds => No, + RustcDumpObjectLifetimeDefaults => No, RustcDumpPredicates => No, RustcDumpUserArgs => No, RustcDumpVariances => No, @@ -164,7 +165,6 @@ impl AttributeKind { RustcNounwind => No, RustcObjcClass { .. } => No, RustcObjcSelector { .. } => No, - RustcObjectLifetimeDefault => No, RustcOffloadKernel => Yes, RustcParenSugar(..) => No, RustcPassByValue(..) => Yes, diff --git a/compiler/rustc_middle/src/queries.rs b/compiler/rustc_middle/src/queries.rs index 42c4ff5e7afe3..d8e2a8fc18c12 100644 --- a/compiler/rustc_middle/src/queries.rs +++ b/compiler/rustc_middle/src/queries.rs @@ -2119,7 +2119,7 @@ rustc_queries! { /// Returns the *default lifetime* to be used if a trait object type were to be passed for /// the type parameter given by `DefId`. /// - /// **Tip**: You can use `#[rustc_object_lifetime_default]` on an item to basically + /// **Tip**: You can use `#[rustc_dump_object_lifetime_defaults]` on an item to basically /// print the result of this query for use in UI tests or for debugging purposes. /// /// # Examples diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 4d5c793bdd880..3e2f10df20b8f 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -184,8 +184,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> { Attribute::Parsed(AttributeKind::TargetFeature{ attr_span, ..}) => { self.check_target_feature(hir_id, *attr_span, target, attrs) } - Attribute::Parsed(AttributeKind::RustcObjectLifetimeDefault) => { - self.check_object_lifetime_default(hir_id); + Attribute::Parsed(AttributeKind::RustcDumpObjectLifetimeDefaults) => { + self.check_dump_object_lifetime_defaults(hir_id); } &Attribute::Parsed(AttributeKind::RustcPubTransparent(attr_span)) => { self.check_rustc_pub_transparent(attr_span, span, attrs) @@ -781,8 +781,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> { } } - /// Debugging aid for `object_lifetime_default` query. - fn check_object_lifetime_default(&self, hir_id: HirId) { + /// Debugging aid for the `object_lifetime_default` query. + fn check_dump_object_lifetime_defaults(&self, hir_id: HirId) { let tcx = self.tcx; if let Some(owner_id) = hir_id.as_owner() && let Some(generics) = tcx.hir_get_generics(owner_id.def_id) @@ -796,7 +796,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> { ObjectLifetimeDefault::Param(def_id) => tcx.item_name(def_id).to_string(), ObjectLifetimeDefault::Ambiguous => "Ambiguous".to_owned(), }; - tcx.dcx().emit_err(errors::ObjectLifetimeErr { span: p.span, repr }); + tcx.dcx().span_err(p.span, repr); } } } diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs index 0cf0d1a5c80ff..8073cb257b032 100644 --- a/compiler/rustc_passes/src/errors.rs +++ b/compiler/rustc_passes/src/errors.rs @@ -814,14 +814,6 @@ pub(crate) struct UselessAssignment<'a> { )] pub(crate) struct InlineIgnoredForExported; -#[derive(Diagnostic)] -#[diag("{$repr}")] -pub(crate) struct ObjectLifetimeErr { - #[primary_span] - pub span: Span, - pub repr: String, -} - #[derive(Diagnostic)] pub(crate) enum AttrApplication { #[diag("attribute should be applied to an enum", code = E0517)] diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index de486138217d7..478a73f86b5f2 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -1723,6 +1723,7 @@ symbols! { rustc_dump_def_parents, rustc_dump_inferred_outlives, rustc_dump_item_bounds, + rustc_dump_object_lifetime_defaults, rustc_dump_predicates, rustc_dump_user_args, rustc_dump_variances, @@ -1763,7 +1764,6 @@ symbols! { rustc_nounwind, rustc_objc_class, rustc_objc_selector, - rustc_object_lifetime_default, rustc_offload_kernel, rustc_on_unimplemented, rustc_paren_sugar, diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md index d4eb004a0eef8..25f7eb27eeea3 100644 --- a/src/doc/rustc-dev-guide/src/compiler-debugging.md +++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md @@ -277,12 +277,12 @@ Here are some notable ones: | `rustc_dump_def_parents` | Dumps the chain of `DefId` parents of certain definitions. | | `rustc_dump_inferred_outlives` | Dumps implied bounds of an item. More precisely, the [`inferred_outlives_of`] an item. | | `rustc_dump_item_bounds` | Dumps the [`item_bounds`] of an item. | +| `rustc_dump_object_lifetime_defaults` | Dumps the [object lifetime defaults] of an item. | | `rustc_dump_predicates` | Dumps the [`predicates_of`] an item. | | `rustc_dump_variances` | Dumps the [variances] of an item. | | `rustc_dump_vtable` | Dumps the vtable layout of an impl, or a type alias of a dyn type. | | `rustc_hidden_type_of_opaques` | Dumps the [hidden type of each opaque types][opaq] in the crate. | | `rustc_layout` | [See this section](#debugging-type-layouts). | -| `rustc_object_lifetime_default` | Dumps the [object lifetime defaults] of an item. | | `rustc_regions` | Dumps NLL closure region requirements. | | `rustc_symbol_name` | Dumps the mangled & demangled [`symbol_name`] of an item. | diff --git a/tests/ui/object-lifetime/object-lifetime-default.rs b/tests/ui/object-lifetime/object-lifetime-default.rs index 74f5bb7ddb0ec..bb1ca509bf67d 100644 --- a/tests/ui/object-lifetime/object-lifetime-default.rs +++ b/tests/ui/object-lifetime/object-lifetime-default.rs @@ -1,37 +1,37 @@ #![feature(rustc_attrs)] -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct A< T, //~ ERROR BaseDefault >(T); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct B< 'a, T, //~ ERROR BaseDefault >(&'a (), T); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct C< 'a, T: 'a, //~ ERROR 'a >(&'a T); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct D< 'a, 'b, T: 'a + 'b, //~ ERROR Ambiguous >(&'a T, &'b T); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct E< 'a, 'b: 'a, T: 'b, //~ ERROR 'b >(&'a T, &'b T); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct F< 'a, 'b, @@ -39,7 +39,7 @@ struct F< U: 'b, //~ ERROR 'b >(&'a T, &'b U); -#[rustc_object_lifetime_default] +#[rustc_dump_object_lifetime_defaults] struct G< 'a, 'b,