Some tracing for better debugging

Author: oli-obk

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -295,11 +295,12 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
     }
 
     /// Pushes the obligations required for `trait_ref` to be WF into `self.out`.
+    #[instrument(level = "debug", skip(self))]
     fn compute_trait_ref(&mut self, trait_ref: &ty::TraitRef<'tcx>, elaborate: Elaborate) {
         let tcx = self.infcx.tcx;
         let obligations = self.nominal_obligations(trait_ref.def_id, trait_ref.substs);
 
-        debug!("compute_trait_ref obligations {:?}", obligations);
+        debug!(?obligations);
         let param_env = self.param_env;
         let depth = self.recursion_depth;
 
@@ -699,12 +700,14 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         }
     }
 
+    #[instrument(level = "trace", skip(self))]
     fn nominal_obligations(
         &mut self,
         def_id: DefId,
         substs: SubstsRef<'tcx>,
     ) -> Vec<traits::PredicateObligation<'tcx>> {
         let predicates = self.infcx.tcx.predicates_of(def_id);
+        trace!(?predicates);
         let mut origins = vec![def_id; predicates.predicates.len()];
         let mut head = predicates;
         while let Some(parent) = head.parent {
@@ -713,6 +716,7 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         }
 
         let predicates = predicates.instantiate(self.infcx.tcx, substs);
+        trace!(?predicates, "instantiated");
         debug_assert_eq!(predicates.predicates.len(), origins.len());
 
         iter::zip(iter::zip(predicates.predicates, predicates.spans), origins.into_iter().rev())

compiler/rustc_typeck/src/astconv/mod.rs

@@ -709,6 +709,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
     ///
     /// If the `projections` argument is `None`, then assoc type bindings like `Foo<T = X>`
     /// are disallowed. Otherwise, they are pushed onto the vector given.
+    #[instrument(level = "debug", skip(self))]
     pub fn instantiate_mono_trait_ref(
         &self,
         trait_ref: &hir::TraitRef<'_>,

compiler/rustc_typeck/src/check/wfcheck.rs

@@ -1229,8 +1229,10 @@ fn check_impl<'tcx>(
                 // therefore don't need to be WF (the trait's `Self: Trait` predicate
                 // won't hold).
                 let trait_ref = tcx.impl_trait_ref(item.def_id).unwrap();
+                trace!(?trait_ref);
                 let trait_ref =
                     fcx.normalize_associated_types_in(ast_trait_ref.path.span, trait_ref);
+                trace!(?trait_ref, "normalized");
                 let obligations = traits::wf::trait_obligations(
                     fcx,
                     fcx.param_env,

compiler/rustc_typeck/src/collect.rs

@@ -1985,6 +1985,7 @@ fn infer_return_ty_for_fn_sig<'tcx>(
     }
 }
 
+#[instrument(level = "debug", skip(tcx))]
 fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::TraitRef<'_>> {
     let icx = ItemCtxt::new(tcx, def_id);
     match tcx.hir().expect_item(def_id.expect_local()).kind {