Rollup merge of #126686 - fmease:dump-preds-n-item-bounds, r=compiler-errors

Add `#[rustc_dump_{predicates,item_bounds}]`

Conflicts with #126668.

As discussed
r? compiler-errors CC ``@fee1-dead``

compiler/rustc_feature/src/builtin_attrs.rs

@@ -1088,6 +1088,14 @@ pub struct BuiltinAttribute {
         ErrorFollowing, EncodeCrossCrate::No,
         "the `#[custom_mir]` attribute is just used for the Rust test suite",
     ),
+    rustc_attr!(
+        TEST, rustc_dump_item_bounds, Normal, template!(Word),
+        WarnFollowing, EncodeCrossCrate::No
+    ),
+    rustc_attr!(
+        TEST, rustc_dump_predicates, Normal, template!(Word),
+        WarnFollowing, EncodeCrossCrate::No
+    ),
     rustc_attr!(
         TEST, rustc_object_lifetime_default, Normal, template!(Word),
         WarnFollowing, EncodeCrossCrate::No

compiler/rustc_hir_analysis/messages.ftl

@@ -510,7 +510,7 @@ hir_analysis_ty_param_some = type parameter `{$param}` must be used as the type
     .note = implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
     .only_note = only traits defined in the current crate can be implemented for a type parameter
 
-hir_analysis_type_of = {$type_of}
+hir_analysis_type_of = {$ty}
 
 hir_analysis_typeof_reserved_keyword_used =
     `typeof` is a reserved keyword but unimplemented
@@ -566,7 +566,7 @@ hir_analysis_value_of_associated_struct_already_specified =
 hir_analysis_variadic_function_compatible_convention = C-variadic function must have a compatible calling convention, like {$conventions}
     .label = C-variadic function must have a compatible calling convention
 
-hir_analysis_variances_of = {$variances_of}
+hir_analysis_variances_of = {$variances}
 
 hir_analysis_where_clause_on_main = `main` function is not allowed to have a `where` clause
     .label = `main` cannot have a `where` clause

compiler/rustc_hir_analysis/src/collect.rs

@@ -45,8 +45,8 @@
 use crate::check::intrinsic::intrinsic_operation_unsafety;
 use crate::errors;
 use crate::hir_ty_lowering::{HirTyLowerer, RegionInferReason};
-pub use type_of::test_opaque_hidden_types;
 
+pub(crate) mod dump;
 mod generics_of;
 mod item_bounds;
 mod predicates_of;

compiler/rustc_hir_analysis/src/collect/dump.rs

@@ -0,0 +1,43 @@
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::CRATE_DEF_ID;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::sym;
+
+pub(crate) fn opaque_hidden_types(tcx: TyCtxt<'_>) {
+    if !tcx.has_attr(CRATE_DEF_ID, sym::rustc_hidden_type_of_opaques) {
+        return;
+    }
+
+    for id in tcx.hir().items() {
+        let DefKind::OpaqueTy = tcx.def_kind(id.owner_id) else { continue };
+
+        let ty = tcx.type_of(id.owner_id).instantiate_identity();
+
+        tcx.dcx().emit_err(crate::errors::TypeOf { span: tcx.def_span(id.owner_id), ty });
+    }
+}
+
+pub(crate) fn predicates_and_item_bounds(tcx: TyCtxt<'_>) {
+    for id in tcx.hir_crate_items(()).owners() {
+        if tcx.has_attr(id, sym::rustc_dump_predicates) {
+            let preds = tcx.predicates_of(id).instantiate_identity(tcx).predicates;
+            let span = tcx.def_span(id);
+
+            let mut diag = tcx.dcx().struct_span_err(span, sym::rustc_dump_predicates.as_str());
+            for pred in preds {
+                diag.note(format!("{pred:?}"));
+            }
+            diag.emit();
+        }
+        if tcx.has_attr(id, sym::rustc_dump_item_bounds) {
+            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();
+        }
+    }
+}

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -15,7 +15,6 @@
 
 use super::bad_placeholder;
 use super::ItemCtxt;
-pub use opaque::test_opaque_hidden_types;
 
 mod opaque;
 

compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs

@@ -1,28 +1,14 @@
 use rustc_errors::StashKey;
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
+use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{self as hir, def, Expr, ImplItem, Item, Node, TraitItem};
 use rustc_middle::bug;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
-use rustc_span::{sym, ErrorGuaranteed, DUMMY_SP};
+use rustc_span::DUMMY_SP;
 
-use crate::errors::{TaitForwardCompat, TaitForwardCompat2, TypeOf, UnconstrainedOpaqueType};
-
-pub fn test_opaque_hidden_types(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
-    let mut res = Ok(());
-    if tcx.has_attr(CRATE_DEF_ID, sym::rustc_hidden_type_of_opaques) {
-        for id in tcx.hir().items() {
-            if matches!(tcx.def_kind(id.owner_id), DefKind::OpaqueTy) {
-                let type_of = tcx.type_of(id.owner_id).instantiate_identity();
-
-                res = Err(tcx.dcx().emit_err(TypeOf { span: tcx.def_span(id.owner_id), type_of }));
-            }
-        }
-    }
-    res
-}
+use crate::errors::{TaitForwardCompat, TaitForwardCompat2, UnconstrainedOpaqueType};
 
 /// Checks "defining uses" of opaque `impl Trait` in associated types.
 /// These can only be defined by associated items of the same trait.

compiler/rustc_hir_analysis/src/errors.rs

@@ -682,7 +682,7 @@ pub(crate) enum CannotCaptureLateBound {
 pub(crate) struct VariancesOf {
     #[primary_span]
     pub span: Span,
-    pub variances_of: String,
+    pub variances: String,
 }
 
 #[derive(Diagnostic)]
@@ -690,7 +690,7 @@ pub(crate) struct VariancesOf {
 pub(crate) struct TypeOf<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub type_of: Ty<'tcx>,
+    pub ty: Ty<'tcx>,
 }
 
 #[derive(Diagnostic)]

compiler/rustc_hir_analysis/src/lib.rs

@@ -151,10 +151,6 @@ pub fn provide(providers: &mut Providers) {
 pub fn check_crate(tcx: TyCtxt<'_>) {
     let _prof_timer = tcx.sess.timer("type_check_crate");
 
-    if tcx.features().rustc_attrs {
-        let _ = tcx.sess.time("outlives_testing", || outlives::test::test_inferred_outlives(tcx));
-    }
-
     tcx.sess.time("coherence_checking", || {
         tcx.hir().par_for_each_module(|module| {
             let _ = tcx.ensure().check_mod_type_wf(module);
@@ -169,11 +165,10 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
     });
 
     if tcx.features().rustc_attrs {
-        let _ = tcx.sess.time("variance_testing", || variance::test::test_variance(tcx));
-    }
-
-    if tcx.features().rustc_attrs {
-        let _ = collect::test_opaque_hidden_types(tcx);
+        tcx.sess.time("outlives_dumping", || outlives::dump::inferred_outlives(tcx));
+        tcx.sess.time("variance_dumping", || variance::dump::variances(tcx));
+        collect::dump::opaque_hidden_types(tcx);
+        collect::dump::predicates_and_item_bounds(tcx);
     }
 
     // Make sure we evaluate all static and (non-associated) const items, even if unused.

compiler/rustc_hir_analysis/src/outlives/dump.rs

@@ -0,0 +1,29 @@
+use rustc_middle::bug;
+use rustc_middle::ty::{self, TyCtxt};
+use rustc_span::sym;
+
+pub(crate) fn inferred_outlives(tcx: TyCtxt<'_>) {
+    for id in tcx.hir().items() {
+        if !tcx.has_attr(id.owner_id, sym::rustc_outlives) {
+            continue;
+        }
+
+        let preds = tcx.inferred_outlives_of(id.owner_id);
+        let mut preds: Vec<_> = preds
+            .iter()
+            .map(|(pred, _)| match pred.kind().skip_binder() {
+                ty::ClauseKind::RegionOutlives(p) => p.to_string(),
+                ty::ClauseKind::TypeOutlives(p) => p.to_string(),
+                err => bug!("unexpected clause {:?}", err),
+            })
+            .collect();
+        preds.sort();
+
+        let span = tcx.def_span(id.owner_id);
+        let mut err = tcx.dcx().struct_span_err(span, sym::rustc_outlives.as_str());
+        for pred in preds {
+            err.note(pred);
+        }
+        err.emit();
+    }
+}

compiler/rustc_hir_analysis/src/outlives/mod.rs

@@ -5,10 +5,9 @@
 use rustc_middle::ty::{self, CratePredicatesMap, TyCtxt, Upcast};
 use rustc_span::Span;
 
+pub(crate) mod dump;
 mod explicit;
 mod implicit_infer;
-/// Code to write unit test for outlives.
-pub mod test;
 mod utils;
 
 pub fn provide(providers: &mut Providers) {

compiler/rustc_hir_analysis/src/outlives/test.rs

@@ -1,31 +0,0 @@
-use rustc_middle::bug;
-use rustc_middle::ty::{self, TyCtxt};
-use rustc_span::{symbol::sym, ErrorGuaranteed};
-
-pub fn test_inferred_outlives(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
-    let mut res = Ok(());
-    for id in tcx.hir().items() {
-        // For unit testing: check for a special "rustc_outlives"
-        // attribute and report an error with various results if found.
-        if tcx.has_attr(id.owner_id, sym::rustc_outlives) {
-            let predicates = tcx.inferred_outlives_of(id.owner_id);
-            let mut pred: Vec<String> = predicates
-                .iter()
-                .map(|(out_pred, _)| match out_pred.kind().skip_binder() {
-                    ty::ClauseKind::RegionOutlives(p) => p.to_string(),
-                    ty::ClauseKind::TypeOutlives(p) => p.to_string(),
-                    err => bug!("unexpected clause {:?}", err),
-                })
-                .collect();
-            pred.sort();
-
-            let span = tcx.def_span(id.owner_id);
-            let mut err = tcx.dcx().struct_span_err(span, "rustc_outlives");
-            for p in pred {
-                err.note(p);
-            }
-            res = Err(err.emit());
-        }
-    }
-    res
-}

compiler/rustc_hir_analysis/src/variance/dump.rs

@@ -0,0 +1,32 @@
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::CRATE_DEF_ID;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::symbol::sym;
+
+pub(crate) fn variances(tcx: TyCtxt<'_>) {
+    if tcx.has_attr(CRATE_DEF_ID, sym::rustc_variance_of_opaques) {
+        for id in tcx.hir().items() {
+            let DefKind::OpaqueTy = tcx.def_kind(id.owner_id) else { continue };
+
+            let variances = tcx.variances_of(id.owner_id);
+
+            tcx.dcx().emit_err(crate::errors::VariancesOf {
+                span: tcx.def_span(id.owner_id),
+                variances: format!("{variances:?}"),
+            });
+        }
+    }
+
+    for id in tcx.hir().items() {
+        if !tcx.has_attr(id.owner_id, sym::rustc_variance) {
+            continue;
+        }
+
+        let variances = tcx.variances_of(id.owner_id);
+
+        tcx.dcx().emit_err(crate::errors::VariancesOf {
+            span: tcx.def_span(id.owner_id),
+            variances: format!("{variances:?}"),
+        });
+    }
+}

compiler/rustc_hir_analysis/src/variance/mod.rs

@@ -22,8 +22,7 @@
 /// Code to solve constraints and write out the results.
 mod solve;
 
-/// Code to write unit tests of variance.
-pub mod test;
+pub(crate) mod dump;
 
 /// Code for transforming variances.
 mod xform;

compiler/rustc_hir_analysis/src/variance/test.rs

@@ -1,37 +0,0 @@
-use rustc_hir::def::DefKind;
-use rustc_hir::def_id::CRATE_DEF_ID;
-use rustc_middle::ty::TyCtxt;
-use rustc_span::symbol::sym;
-use rustc_span::ErrorGuaranteed;
-
-use crate::errors;
-
-pub fn test_variance(tcx: TyCtxt<'_>) -> Result<(), ErrorGuaranteed> {
-    let mut res = Ok(());
-    if tcx.has_attr(CRATE_DEF_ID, sym::rustc_variance_of_opaques) {
-        for id in tcx.hir().items() {
-            if matches!(tcx.def_kind(id.owner_id), DefKind::OpaqueTy) {
-                let variances_of = tcx.variances_of(id.owner_id);
-
-                res = Err(tcx.dcx().emit_err(errors::VariancesOf {
-                    span: tcx.def_span(id.owner_id),
-                    variances_of: format!("{variances_of:?}"),
-                }));
-            }
-        }
-    }
-
-    // For unit testing: check for a special "rustc_variance"
-    // attribute and report an error with various results if found.
-    for id in tcx.hir().items() {
-        if tcx.has_attr(id.owner_id, sym::rustc_variance) {
-            let variances_of = tcx.variances_of(id.owner_id);
-
-            res = Err(tcx.dcx().emit_err(errors::VariancesOf {
-                span: tcx.def_span(id.owner_id),
-                variances_of: format!("{variances_of:?}"),
-            }));
-        }
-    }
-    res
-}

compiler/rustc_span/src/symbol.rs

@@ -1593,6 +1593,8 @@
         rustc_do_not_const_check,
         rustc_doc_primitive,
         rustc_dummy,
+        rustc_dump_item_bounds,
+        rustc_dump_predicates,
         rustc_dump_user_args,
         rustc_dump_vtable,
         rustc_effective_visibility,

tests/ui/attributes/dump-preds.rs

@@ -0,0 +1,20 @@
+//@ normalize-stderr-test "DefId\(.+?\)" -> "DefId(..)"
+
+#![feature(rustc_attrs)]
+
+#[rustc_dump_predicates]
+trait Trait<T>: Iterator<Item: Copy>
+//~^ ERROR rustc_dump_predicates
+where
+    String: From<T>
+{
+    #[rustc_dump_predicates]
+    #[rustc_dump_item_bounds]
+    type Assoc<P: Eq>: std::ops::Deref<Target = ()>
+    //~^ ERROR rustc_dump_predicates
+    //~| ERROR rustc_dump_item_bounds
+    where
+        Self::Assoc<()>: Copy;
+}
+
+fn main() {}

tests/ui/attributes/dump-preds.stderr

@@ -0,0 +1,39 @@
+error: rustc_dump_predicates
+  --> $DIR/dump-preds.rs:6:1
+   |
+LL | trait Trait<T>: Iterator<Item: Copy>
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: Binder { value: TraitPredicate(<Self as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<<Self as std::iter::Iterator>::Item as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<std::string::String as std::convert::From<T>>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<Self as Trait<T>>, polarity:Positive), bound_vars: [] }
+
+error: rustc_dump_predicates
+  --> $DIR/dump-preds.rs:13:5
+   |
+LL |     type Assoc<P: Eq>: std::ops::Deref<Target = ()>
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: Binder { value: TraitPredicate(<Self as std::iter::Iterator>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<<Self as std::iter::Iterator>::Item as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<T as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<std::string::String as std::convert::From<T>>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<Self as Trait<T>>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<P as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<P as std::cmp::Eq>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<()> as std::marker::Copy>, polarity:Positive), bound_vars: [] }
+
+error: rustc_dump_item_bounds
+  --> $DIR/dump-preds.rs:13:5
+   |
+LL |     type Assoc<P: Eq>: std::ops::Deref<Target = ()>
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: Binder { value: ProjectionPredicate(AliasTerm { args: [Alias(Projection, AliasTy { args: [Self/#0, T/#1, P/#2], def_id: DefId(..) })], def_id: DefId(..) }, Term::Ty(())), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::ops::Deref>, polarity:Positive), bound_vars: [] }
+   = note: Binder { value: TraitPredicate(<<Self as Trait<T>>::Assoc<P> as std::marker::Sized>, polarity:Positive), bound_vars: [] }
+
+error: aborting due to 3 previous errors
+