Update logging statements

Author: fmease

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -369,7 +369,7 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
 
         let tcx = self.tcx();
         let generics = tcx.generics_of(def_id);
-        debug!("generics: {:?}", generics);
+        debug!(?generics);
 
         if generics.has_self {
             if generics.parent.is_some() {
@@ -989,15 +989,9 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
     ) -> Result<ty::PolyTraitRef<'tcx>, ErrorGuaranteed> {
         let tcx = self.tcx();
 
-        debug!(
-            "find_bound_for_assoc_item(ty_param_def_id={:?}, assoc_name={:?}, span={:?})",
-            ty_param_def_id, assoc_name, span,
-        );
-
         let predicates =
             &self.get_type_parameter_bounds(span, ty_param_def_id, assoc_name).predicates;
-
-        debug!("find_bound_for_assoc_item: predicates={:#?}", predicates);
+        debug!(?predicates);
 
         let param_name = tcx.hir().ty_param_name(ty_param_def_id);
         self.one_bound_for_assoc_item(
@@ -1156,7 +1150,10 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
         assoc_segment: &hir::PathSegment<'tcx>,
         permit_variants: bool,
     ) -> Result<(Ty<'tcx>, DefKind, DefId), ErrorGuaranteed> {
+        let _guard = tracing::debug_span!("lower_assoc_path_to_ty").entered();
+        debug!(%qself_ty, ?assoc_segment.ident);
         let tcx = self.tcx();
+
         let assoc_ident = assoc_segment.ident;
         let qself_res = if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = &qself.kind {
             path.res
@@ -1709,25 +1706,23 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
         item_segment: &hir::PathSegment<'tcx>,
         constness: ty::BoundConstness,
     ) -> Ty<'tcx> {
+        let _guard = tracing::debug_span!("lower_qpath_to_ty").entered();
         let tcx = self.tcx();
 
         let trait_def_id = tcx.parent(item_def_id);
-
-        debug!("qpath_to_ty: trait_def_id={:?}", trait_def_id);
+        debug!(?trait_def_id);
 
         let Some(self_ty) = opt_self_ty else {
             let path_str = tcx.def_path_str(trait_def_id);
 
             let def_id = self.item_def_id();
-
-            debug!("qpath_to_ty: self.item_def_id()={:?}", def_id);
+            debug!(item_def_id = ?def_id);
 
             let parent_def_id = def_id
                 .as_local()
                 .map(|def_id| tcx.local_def_id_to_hir_id(def_id))
                 .map(|hir_id| tcx.hir().get_parent_item(hir_id).to_def_id());
-
-            debug!("qpath_to_ty: parent_def_id={:?}", parent_def_id);
+            debug!(?parent_def_id);
 
             // If the trait in segment is the same as the trait defining the item,
             // use the `<Self as ..>` syntax in the error.
@@ -1762,6 +1757,7 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
             );
             return Ty::new_error(tcx, reported);
         };
+        debug!(?self_ty);
 
         let trait_ref = self.lower_path_to_mono_trait_ref(
             span,
@@ -1771,6 +1767,7 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
             false,
             constness,
         );
+        debug!(?trait_ref);
 
         let item_args =
             self.lower_args_for_assoc_item(span, item_def_id, item_segment, trait_ref.args);
@@ -2024,13 +2021,10 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
         hir_id: hir::HirId,
         permit_variants: bool,
     ) -> Ty<'tcx> {
+        let _guard = tracing::debug_span!("lower_res_to_ty").entered();
+        debug!(?path.res, ?opt_self_ty, ?path.segments);
         let tcx = self.tcx();
 
-        debug!(
-            "res_to_ty(res={:?}, opt_self_ty={:?}, path_segments={:?})",
-            path.res, opt_self_ty, path.segments
-        );
-
         let span = path.span;
         match path.res {
             Res::Def(DefKind::OpaqueTy, did) => {
@@ -2555,12 +2549,11 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
         lifetimes: &[hir::GenericArg<'_>],
         in_trait: bool,
     ) -> Ty<'tcx> {
-        debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes);
         let tcx = self.tcx();
 
         let generics = tcx.generics_of(def_id);
+        debug!(?generics);
 
-        debug!("impl_trait_ty_to_ty: generics={:?}", generics);
         let args = ty::GenericArgs::for_item(tcx, def_id, |param, _| {
             // We use `generics.count() - lifetimes.len()` here instead of `generics.parent_count`
             // since return-position impl trait in trait squashes all of the generics from its source fn
@@ -2586,7 +2579,7 @@ impl<'o, 'tcx> dyn HirLowerer<'tcx> + 'o {
                 tcx.mk_param_from_def(param)
             }
         });
-        debug!("impl_trait_ty_to_ty: args={:?}", args);
+        debug!(?args);
 
         if in_trait {
             Ty::new_projection(tcx, def_id, args)

compiler/rustc_trait_selection/src/traits/object_safety.rs

@@ -48,7 +48,10 @@ pub fn hir_lowering_object_safety_violations(
         .map(ObjectSafetyViolation::SupertraitSelf)
         .collect();
 
-    debug!("astconv_object_safety_violations(trait_def_id={:?}) = {:?}", trait_def_id, violations);
+    debug!(
+        "hir_lowering_object_safety_violations(trait_def_id={:?}) = {:?}",
+        trait_def_id, violations
+    );
 
     violations
 }