Allow formatting TraitRef and TraitPredicate with an Infcx

Author: BoxyUwU

compiler/rustc_middle/src/ty/context.rs

@@ -4,6 +4,7 @@
 
 pub mod tls;
 
+use hir::def::Namespace;
 pub use rustc_type_ir::lift::Lift;
 
 use crate::arena::Arena;
@@ -27,6 +28,7 @@ use crate::traits::solve::{
     ExternalConstraints, ExternalConstraintsData, PredefinedOpaques, PredefinedOpaquesData,
 };
 use crate::ty::predicate::ExistentialPredicateStableCmpExt as _;
+use crate::ty::print::{with_no_trimmed_paths, FmtPrinter, Printer};
 use crate::ty::{
     self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, ConstData,
     GenericParamDefKind, ImplPolarity, List, ListWithCachedTypeInfo, ParamConst, ParamTy, Pattern,
@@ -89,6 +91,18 @@ use std::ops::{Bound, Deref};
 #[allow(rustc::usage_of_ty_tykind)]
 impl<'tcx> Interner for TyCtxt<'tcx> {
     type DefId = DefId;
+    fn print_def_path(defid: Self::DefId, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        ty::tls::with(|tcx| {
+            with_no_trimmed_paths!({
+                // this namespace is..... not strictly correct lol
+                let s = FmtPrinter::print_string(tcx, Namespace::TypeNS, |cx| {
+                    cx.print_def_path(defid, &[])
+                })?;
+                f.write_str(&s)
+            })
+        })
+    }
+
     type DefiningOpaqueTypes = &'tcx ty::List<LocalDefId>;
     type AdtDef = ty::AdtDef<'tcx>;
     type GenericArgs = ty::GenericArgsRef<'tcx>;

compiler/rustc_type_ir/src/interner.rs

@@ -28,6 +28,8 @@ pub trait Interner:
     + IrPrint<FnSig<Self>>
 {
     type DefId: Copy + Debug + Hash + Eq;
+    fn print_def_path(defid: Self::DefId, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result;
+
     type DefiningOpaqueTypes: Copy + Debug + Hash + Default + Eq + TypeVisitable<Self>;
     type AdtDef: Copy + Debug + Hash + Eq;
 

compiler/rustc_type_ir/src/ir_print.rs

@@ -48,4 +48,4 @@ define_display_via_print!(
     FnSig,
 );
 
-define_debug_via_print!(TraitRef, ExistentialTraitRef, ExistentialProjection);
+define_debug_via_print!(ExistentialTraitRef, ExistentialProjection);

compiler/rustc_type_ir/src/predicate.rs

@@ -73,6 +73,44 @@ pub struct TraitRef<I: Interner> {
     _use_trait_ref_new_instead: (),
 }
 
+impl<I: Interner> fmt::Debug for TraitRef<I> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        WithInfcx::with_no_infcx(self).fmt(f)
+    }
+}
+impl<I: Interner> DebugWithInfcx<I> for TraitRef<I> {
+    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
+        this: WithInfcx<'_, Infcx, &Self>,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
+        // If we ever wind up with a malformed `TraitRef` it might be good to not ICE in its Debug impl(?)
+        if this.data.args.len() == 0 {
+            return f
+                .debug_tuple("TraitRef")
+                .field(&this.data.def_id)
+                .field(&this.data.args)
+                .finish();
+        }
+
+        write!(f, "({:?} as ", this.map(|trait_ref| trait_ref.args[0]))?;
+        I::print_def_path(this.data.def_id, f)?;
+
+        match this.data.args.len() {
+            0 => unreachable!(),
+            1 => write!(f, ")"), // the first arg is the self type
+            2 => write!(f, "<{:?}>)", this.map(|trait_ref| trait_ref.args[1])),
+            3.. => {
+                write!(f, "<{:?}", this.map(|trait_ref| trait_ref.args[1]))?;
+                for arg in &this.data.args[2..] {
+                    let arg = this.wrap(arg);
+                    write!(f, ", {:?}", arg)?;
+                }
+                write!(f, ">)")
+            }
+        }
+    }
+}
+
 impl<I: Interner> TraitRef<I> {
     pub fn new(
         interner: I,
@@ -147,8 +185,46 @@ impl<I: Interner> TraitPredicate<I> {
 
 impl<I: Interner> fmt::Debug for TraitPredicate<I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        WithInfcx::with_no_infcx(self).fmt(f)
+    }
+}
+impl<I: Interner> DebugWithInfcx<I> for TraitPredicate<I> {
+    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
+        this: WithInfcx<'_, Infcx, &Self>,
+        f: &mut fmt::Formatter<'_>,
+    ) -> fmt::Result {
         // FIXME(effects) printing?
-        write!(f, "TraitPredicate({:?}, polarity:{:?})", self.trait_ref, self.polarity)
+
+        // If we ever wind up with a malformed `TraitRef` it might be good to not ICE in its Debug impl(?)
+        if this.data.trait_ref.args.len() == 0 {
+            return f
+                .debug_tuple("TraitPredicate")
+                .field(&this.data.trait_ref.def_id)
+                .field(&this.data.trait_ref.args)
+                .field(&this.data.polarity)
+                .finish();
+        }
+
+        write!(f, "({:?}: ", this.map(|pred| pred.trait_ref.args[0]))?;
+        match this.data.polarity {
+            PredicatePolarity::Positive => (),
+            PredicatePolarity::Negative => write!(f, "!")?,
+        };
+        I::print_def_path(this.data.trait_ref.def_id, f)?;
+
+        match this.data.trait_ref.args.len() {
+            0 => unreachable!(),
+            1 => write!(f, ")"), // the first arg is the self type
+            2 => write!(f, "<{:?}>)", this.map(|trait_ref| trait_ref.trait_ref.args[1])),
+            3.. => {
+                write!(f, "<{:?}", this.map(|trait_ref| trait_ref.trait_ref.args[1]))?;
+                for arg in &this.data.trait_ref.args[2..] {
+                    let arg = this.wrap(arg);
+                    write!(f, ", {:?}", arg)?;
+                }
+                write!(f, ">)")
+            }
+        }
     }
 }