Update tracing calls

Author: fmease

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -371,7 +371,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'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() {
@@ -643,17 +643,15 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         assoc_bindings
     }
 
+    #[instrument(level = "debug", skip_all)]
     pub fn lower_args_for_assoc_item(
         &self,
         span: Span,
         item_def_id: DefId,
         item_segment: &hir::PathSegment<'tcx>,
         parent_args: GenericArgsRef<'tcx>,
     ) -> GenericArgsRef<'tcx> {
-        debug!(
-            "create_args_for_associated_item(span: {:?}, item_def_id: {:?}, item_segment: {:?}",
-            span, item_def_id, item_segment
-        );
+        debug!(?span, ?item_def_id, ?item_segment);
         let (args, _) = self.lower_args_for_path(
             span,
             item_def_id,
@@ -984,24 +982,19 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
     ///
     /// `ty_param_def_id` is the `DefId` of the type parameter.
     /// This function will fail if there are no suitable bounds or there is any ambiguity.
-    #[instrument(level = "debug", skip(self), ret)]
+    #[instrument(level = "debug", skip_all, ret)]
     fn find_bound_for_assoc_item(
         &self,
         ty_param_def_id: LocalDefId,
         assoc_name: Ident,
         span: Span,
     ) -> Result<ty::PolyTraitRef<'tcx>, ErrorGuaranteed> {
+        debug!(?ty_param_def_id, ?assoc_name, ?span);
         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={:#?}", predicates);
 
         let param_name = tcx.hir().ty_param_name(ty_param_def_id);
         self.one_bound_for_assoc_item(
@@ -1151,7 +1144,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
     /// parameter or `Self`.
     // NOTE: When this function starts resolving `Trait::AssocTy` successfully
     // it should also start reporting the `BARE_TRAIT_OBJECTS` lint.
-    #[instrument(level = "debug", skip(self, hir_ref_id, span, qself, assoc_segment), fields(assoc_ident=?assoc_segment.ident), ret)]
+    #[instrument(level = "debug", skip_all, ret)]
     pub fn lower_assoc_path_to_ty(
         &self,
         hir_ref_id: hir::HirId,
@@ -1161,7 +1154,9 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         assoc_segment: &hir::PathSegment<'tcx>,
         permit_variants: bool,
     ) -> Result<(Ty<'tcx>, DefKind, DefId), ErrorGuaranteed> {
+        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
@@ -1704,6 +1699,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
             .collect()
     }
 
+    #[instrument(level = "debug", skip_all)]
     fn lower_qpath_to_ty(
         &self,
         span: Span,
@@ -1716,22 +1712,19 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         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.
@@ -1766,8 +1759,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
             );
             return Ty::new_error(tcx, reported);
         };
-
-        debug!("qpath_to_ty: self_type={:?}", self_ty);
+        debug!(?self_ty);
 
         let trait_ref = self.lower_path_to_mono_trait_ref(
             span,
@@ -1777,12 +1769,11 @@ impl<'o, 'tcx> dyn HirTyLowerer<'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);
 
-        debug!("qpath_to_ty: trait_ref={:?}", trait_ref);
-
         Ty::new_projection(tcx, item_def_id, item_args)
     }
 
@@ -2025,20 +2016,17 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
     }
 
     /// Check a type `Path` and lower it to a `Ty`.
+    #[instrument(level = "debug", skip_all)]
     pub fn lower_res_to_ty(
         &self,
         opt_self_ty: Option<Ty<'tcx>>,
         path: &hir::Path<'tcx>,
         hir_id: hir::HirId,
         permit_variants: bool,
     ) -> Ty<'tcx> {
+        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) => {
@@ -2572,19 +2560,19 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         result_ty
     }
 
-    #[instrument(level = "debug", skip(self), ret)]
+    #[instrument(level = "debug", skip_all, ret)]
     fn lower_impl_trait_ty(
         &self,
         def_id: DefId,
         lifetimes: &[hir::GenericArg<'_>],
         in_trait: bool,
     ) -> Ty<'tcx> {
-        debug!("impl_trait_ty_to_ty(def_id={:?}, lifetimes={:?})", def_id, lifetimes);
+        debug!(?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
@@ -2610,7 +2598,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'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_hir_analysis/src/astconv/object_safety.rs

@@ -18,6 +18,7 @@ use smallvec::{smallvec, SmallVec};
 use super::HirTyLowerer;
 
 impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
+    #[instrument(level = "debug", skip_all, ret)]
     pub(super) fn lower_object_ty_to_poly_trait_ref(
         &self,
         span: Span,
@@ -159,7 +160,7 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         for (base_trait_ref, span) in regular_traits_refs_spans {
             let base_pred: ty::Predicate<'tcx> = base_trait_ref.to_predicate(tcx);
             for pred in traits::elaborate(tcx, [base_pred]) {
-                debug!("conv_object_ty_poly_trait_ref: observing object predicate `{:?}`", pred);
+                debug!("observing object predicate `{pred:?}`");
 
                 let bound_predicate = pred.kind();
                 match bound_predicate.skip_binder() {
@@ -246,8 +247,8 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
         // the bounds
         let mut duplicates = FxHashSet::default();
         auto_traits.retain(|i| duplicates.insert(i.trait_ref().def_id()));
-        debug!("regular_traits: {:?}", regular_traits);
-        debug!("auto_traits: {:?}", auto_traits);
+        debug!(?regular_traits);
+        debug!(?auto_traits);
 
         // Erase the `dummy_self` (`trait_object_dummy_self`) used above.
         let existential_trait_refs = regular_traits.iter().map(|i| {
@@ -398,10 +399,8 @@ impl<'o, 'tcx> dyn HirTyLowerer<'tcx> + 'o {
                 }
             })
         };
-        debug!("region_bound: {:?}", region_bound);
+        debug!(?region_bound);
 
-        let ty = Ty::new_dynamic(tcx, existential_predicates, region_bound, representation);
-        debug!("trait_object_type: {:?}", ty);
-        ty
+        Ty::new_dynamic(tcx, existential_predicates, region_bound, representation)
     }
 }

compiler/rustc_hir_analysis/src/collect.rs

@@ -549,9 +549,10 @@ fn get_new_lifetime_name<'tcx>(
     (1..).flat_map(a_to_z_repeat_n).find(|lt| !existing_lifetimes.contains(lt.as_str())).unwrap()
 }
 
+#[instrument(level = "debug", skip_all)]
 fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
     let it = tcx.hir().item(item_id);
-    debug!("convert: item {} with id {}", it.ident, it.hir_id());
+    debug!(item = %it.ident, id = %it.hir_id());
     let def_id = item_id.owner_id.def_id;
 
     match &it.kind {

compiler/rustc_trait_selection/src/traits/object_safety.rs

@@ -37,6 +37,7 @@ pub use crate::traits::{MethodViolationCode, ObjectSafetyViolation};
 /// Currently that is `Self` in supertraits. This is needed
 /// because `object_safety_violations` can't be used during
 /// type collection.
+#[instrument(level = "debug", skip(tcx))]
 pub fn hir_ty_lowering_object_safety_violations(
     tcx: TyCtxt<'_>,
     trait_def_id: DefId,
@@ -47,9 +48,7 @@ pub fn hir_ty_lowering_object_safety_violations(
         .filter(|spans| !spans.is_empty())
         .map(ObjectSafetyViolation::SupertraitSelf)
         .collect();
-
-    debug!("astconv_object_safety_violations(trait_def_id={:?}) = {:?}", trait_def_id, violations);
-
+    debug!(?violations);
     violations
 }