[HACK] use Display instead of Debug in a few key places.

Author: eddyb

compiler/rustc_infer/src/traits/project.rs

@@ -179,10 +179,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
         key: ProjectionCacheKey<'tcx>,
         value: Normalized<'tcx, ty::Term<'tcx>>,
     ) {
-        debug!(
-            "ProjectionCacheEntry::insert_ty: adding cache entry: key={:?}, value={:?}",
-            key, value
-        );
+        debug!("ProjectionCacheEntry::insert: adding cache entry: {} => {}", key.ty, value);
         let mut map = self.map();
         if let Some(ProjectionCacheEntry::Recur) = map.get(&key) {
             debug!("Not overwriting Recur");
@@ -201,7 +198,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
         let mut map = self.map();
         match map.get(&key) {
             Some(&ProjectionCacheEntry::NormalizedTy { ref ty, complete: _ }) => {
-                info!("ProjectionCacheEntry::complete({:?}) - completing {:?}", key, ty);
+                info!("ProjectionCacheEntry::complete({}) - completing {}", key.ty, ty);
                 let mut ty = ty.clone();
                 if result.must_apply_considering_regions() {
                     ty.obligations = vec![];
@@ -211,7 +208,7 @@ impl<'tcx> ProjectionCache<'_, 'tcx> {
             ref value => {
                 // Type inference could "strand behind" old cache entries. Leave
                 // them alone for now.
-                info!("ProjectionCacheEntry::complete({:?}) - ignoring {:?}", key, value);
+                info!("ProjectionCacheEntry::complete({}) - ignoring {:?}", key.ty, value);
             }
         };
     }

compiler/rustc_infer/src/traits/structural_impls.rs

@@ -15,7 +15,17 @@ impl<'tcx, T: fmt::Debug> fmt::Debug for Normalized<'tcx, T> {
     }
 }
 
-impl<'tcx, O: fmt::Debug> fmt::Debug for traits::Obligation<'tcx, O> {
+impl<'tcx, T: fmt::Display> fmt::Display for Normalized<'tcx, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.value)?;
+        if !self.obligations.is_empty() {
+            write!(f, " @ obligations={:?}", self.obligations)?;
+        }
+        Ok(())
+    }
+}
+
+impl<'tcx, O: fmt::Debug + fmt::Display> fmt::Debug for traits::Obligation<'tcx, O> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if ty::tls::with(|tcx| tcx.sess.verbose()) {
             write!(
@@ -24,7 +34,11 @@ impl<'tcx, O: fmt::Debug> fmt::Debug for traits::Obligation<'tcx, O> {
                 self.predicate, self.cause, self.param_env, self.recursion_depth
             )
         } else {
-            write!(f, "Obligation(predicate={:?}, depth={})", self.predicate, self.recursion_depth)
+            write!(f, "{}", self.predicate)?;
+            if self.recursion_depth > 0 {
+                write!(f, " @ depth={}", self.recursion_depth)?;
+            }
+            Ok(())
         }
     }
 }
@@ -60,7 +74,9 @@ impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> {
 ///////////////////////////////////////////////////////////////////////////
 // TypeFoldable implementations.
 
-impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx, O> {
+impl<'tcx, O: TypeFoldable<'tcx> + fmt::Display> TypeFoldable<'tcx>
+    for traits::Obligation<'tcx, O>
+{
     fn try_fold_with<F: FallibleTypeFolder<'tcx>>(self, folder: &mut F) -> Result<Self, F::Error> {
         Ok(traits::Obligation {
             cause: self.cause,
@@ -71,7 +87,9 @@ impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx
     }
 }
 
-impl<'tcx, O: TypeVisitable<'tcx>> TypeVisitable<'tcx> for traits::Obligation<'tcx, O> {
+impl<'tcx, O: TypeVisitable<'tcx> + fmt::Display> TypeVisitable<'tcx>
+    for traits::Obligation<'tcx, O>
+{
     fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
         self.predicate.visit_with(visitor)?;
         self.param_env.visit_with(visitor)

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2457,6 +2457,7 @@ forward_display_to_print! {
     ty::Binder<'tcx, ty::ExistentialTraitRef<'tcx>>,
     ty::Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>>,
     ty::Binder<'tcx, TraitRefPrintOnlyTraitName<'tcx>>,
+    ty::Binder<'tcx, ty::ProjectionTy<'tcx>>,
     ty::Binder<'tcx, ty::FnSig<'tcx>>,
     ty::Binder<'tcx, ty::TraitPredicate<'tcx>>,
     ty::Binder<'tcx, TraitPredPrintModifiersAndPath<'tcx>>,