Rollup merge of rust-lang#126075 - compiler-errors:remove-debugwithinfcx, r=lcnr

Remove `DebugWithInfcx` machinery

This PR removes `DebugWithInfcx` after having a lot of second thoughts about it due to recent type system uplifting work. We could add it back later if we want, but I don't think the amount of boilerplate in the complier and the existence of (kindof) hacks like `NoInfcx` currently justify the existence of `DebugWithInfcx`, especially since it's not even being used anywhere in the compiler currently.

The motivation for `DebugWithInfcx` is that we want to be able to print infcx-aware information, such as universe information[^1] (though if there are other usages that I'm overlooking, please let me know). I think there are probably more tailored solutions that can specifically be employed in places where this infcx-aware printing is necessary. For example, one way of achieving this is by implementing a custom `FmtPrinter` which overloads `ty_infer_name` (perhaps also extending it to have overrideable stubs for printing placeholders too) to print the `?u.i` name for an infer var. This will necessitate uplifting `Print` from `rustc_middle::ty::print`, but this seems a bit more extensible and reusable than `DebugWithInfcx`.

One of the problems w/ `DebugWithInfcx` is its opt-in-ness. Even if a compiler dev adds a new `debug!(ty)` in a context where there is an `infcx` we can access, they have to *opt-in* to using `DebugWithInfcx` with something like `debug!(infcx.with(ty))`. This feels to me like it risks a lot of boilerplate, and very easy to just forget adding it at all, especially in cases like `#[instrument]`.

A second problem is the `NoInfcx` type itself. It's necessary to have this dummy infcx implementation since we often want to print types outside of the scope of a valid `Infcx`. Right now, `NoInfcx` is only *partially* a valid implementation of `InferCtxtLike`, except for the methods that we specifically need for `DebugWithInfcx`. As I work on uplifting the trait solver, I actually want to add a lot more methods to `InferCtxtLike` and having to add `unreachable!("this should never be called")` stubs for uplifted methods like `next_ty_var` is quite annoying.

In reality, I actually only *really* care about the second problem -- we could, perhaps, instead just try to get rid of `NoInfcx` and just just duplicate `Debug` and `DebugWithInfcx` for most types. If we're okay with duplicating all these implementations (though most of them would just be trivial `#[derive(Debug, DebugWithInfcx)]`), I'd be okay with that too 🤔

r? `@BoxyUwU` `@lcnr` would like to know your thoughts -- happy to discuss this further, mainly trying to bring this problem up

[^1]: Which in my experience is only really necessary when we're debugging things like generalizer bugs.

Author: GuillaumeGomez

Diff for: compiler/rustc_middle/src/ty/list.rs

@@ -1,5 +1,5 @@
 use super::flags::FlagComputation;
-use super::{DebruijnIndex, DebugWithInfcx, InferCtxtLike, TyCtxt, TypeFlags, WithInfcx};
+use super::{DebruijnIndex, TypeFlags};
 use crate::arena::Arena;
 use rustc_data_structures::aligned::{align_of, Aligned};
 use rustc_serialize::{Encodable, Encoder};
@@ -162,14 +162,6 @@ impl<H, T: fmt::Debug> fmt::Debug for RawList<H, T> {
         (**self).fmt(f)
     }
 }
-impl<'tcx, H, T: DebugWithInfcx<TyCtxt<'tcx>>> DebugWithInfcx<TyCtxt<'tcx>> for RawList<H, T> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        fmt::Debug::fmt(&this.map(|this| this.as_slice()), f)
-    }
-}
 
 impl<H, S: Encoder, T: Encodable<S>> Encodable<S> for RawList<H, T> {
     #[inline]

Diff for: compiler/rustc_middle/src/ty/mod.rs

@@ -61,7 +61,6 @@ use rustc_span::{ExpnId, ExpnKind, Span};
 use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
 pub use rustc_target::abi::{ReprFlags, ReprOptions};
 pub use rustc_type_ir::relate::VarianceDiagInfo;
-pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
 use tracing::{debug, instrument};
 pub use vtable::*;
 

Diff for: compiler/rustc_middle/src/ty/structural_impls.rs

@@ -13,7 +13,7 @@ use rustc_ast_ir::visit::VisitorResult;
 use rustc_hir::def::Namespace;
 use rustc_span::source_map::Spanned;
 use rustc_target::abi::TyAndLayout;
-use rustc_type_ir::{ConstKind, DebugWithInfcx, InferCtxtLike, WithInfcx};
+use rustc_type_ir::ConstKind;
 
 use std::fmt::{self, Debug};
 
@@ -83,14 +83,6 @@ impl fmt::Debug for ty::LateParamRegion {
     }
 }
 
-impl<'tcx> ty::DebugWithInfcx<TyCtxt<'tcx>> for Ty<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        this.data.fmt(f)
-    }
-}
 impl<'tcx> fmt::Debug for Ty<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         with_no_trimmed_paths!(fmt::Debug::fmt(self.kind(), f))
@@ -121,91 +113,46 @@ impl<'tcx> fmt::Debug for ty::Clause<'tcx> {
     }
 }
 
-impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for Pattern<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        match &**this.data {
-            ty::PatternKind::Range { start, end, include_end } => f
-                .debug_struct("Pattern::Range")
-                .field("start", start)
-                .field("end", end)
-                .field("include_end", include_end)
-                .finish(),
-        }
-    }
-}
-
 impl<'tcx> fmt::Debug for ty::consts::Expr<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        WithInfcx::with_no_infcx(self).fmt(f)
-    }
-}
-impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::consts::Expr<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        match this.data.kind {
+        match self.kind {
             ty::ExprKind::Binop(op) => {
-                let (lhs_ty, rhs_ty, lhs, rhs) = this.data.binop_args();
-                write!(
-                    f,
-                    "({op:?}: ({:?}: {:?}), ({:?}: {:?}))",
-                    &this.wrap(lhs),
-                    &this.wrap(lhs_ty),
-                    &this.wrap(rhs),
-                    &this.wrap(rhs_ty),
-                )
+                let (lhs_ty, rhs_ty, lhs, rhs) = self.binop_args();
+                write!(f, "({op:?}: ({:?}: {:?}), ({:?}: {:?}))", lhs, lhs_ty, rhs, rhs_ty,)
             }
             ty::ExprKind::UnOp(op) => {
-                let (rhs_ty, rhs) = this.data.unop_args();
-                write!(f, "({op:?}: ({:?}: {:?}))", &this.wrap(rhs), &this.wrap(rhs_ty))
+                let (rhs_ty, rhs) = self.unop_args();
+                write!(f, "({op:?}: ({:?}: {:?}))", rhs, rhs_ty)
             }
             ty::ExprKind::FunctionCall => {
-                let (func_ty, func, args) = this.data.call_args();
+                let (func_ty, func, args) = self.call_args();
                 let args = args.collect::<Vec<_>>();
-                write!(f, "({:?}: {:?})(", &this.wrap(func), &this.wrap(func_ty))?;
+                write!(f, "({:?}: {:?})(", func, func_ty)?;
                 for arg in args.iter().rev().skip(1).rev() {
-                    write!(f, "{:?}, ", &this.wrap(arg))?;
+                    write!(f, "{:?}, ", arg)?;
                 }
                 if let Some(arg) = args.last() {
-                    write!(f, "{:?}", &this.wrap(arg))?;
+                    write!(f, "{:?}", arg)?;
                 }
 
                 write!(f, ")")
             }
             ty::ExprKind::Cast(kind) => {
-                let (value_ty, value, to_ty) = this.data.cast_args();
-                write!(
-                    f,
-                    "({kind:?}: ({:?}: {:?}), {:?})",
-                    &this.wrap(value),
-                    &this.wrap(value_ty),
-                    &this.wrap(to_ty)
-                )
+                let (value_ty, value, to_ty) = self.cast_args();
+                write!(f, "({kind:?}: ({:?}: {:?}), {:?})", value, value_ty, to_ty)
             }
         }
     }
 }
 
 impl<'tcx> fmt::Debug for ty::Const<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        WithInfcx::with_no_infcx(self).fmt(f)
-    }
-}
-impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::Const<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
         // If this is a value, we spend some effort to make it look nice.
-        if let ConstKind::Value(_, _) = this.data.kind() {
+        if let ConstKind::Value(_, _) = self.kind() {
             return ty::tls::with(move |tcx| {
                 // Somehow trying to lift the valtree results in lifetime errors, so we lift the
                 // entire constant.
-                let lifted = tcx.lift(*this.data).unwrap();
+                let lifted = tcx.lift(*self).unwrap();
                 let ConstKind::Value(ty, valtree) = lifted.kind() else {
                     bug!("we checked that this is a valtree")
                 };
@@ -215,7 +162,7 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::Const<'tcx> {
             });
         }
         // Fall back to something verbose.
-        write!(f, "{kind:?}", kind = &this.map(|data| data.kind()))
+        write!(f, "{:?}", self.kind())
     }
 }
 
@@ -247,32 +194,12 @@ impl<'tcx> fmt::Debug for GenericArg<'tcx> {
         }
     }
 }
-impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for GenericArg<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        match this.data.unpack() {
-            GenericArgKind::Lifetime(lt) => write!(f, "{:?}", &this.wrap(lt)),
-            GenericArgKind::Const(ct) => write!(f, "{:?}", &this.wrap(ct)),
-            GenericArgKind::Type(ty) => write!(f, "{:?}", &this.wrap(ty)),
-        }
-    }
-}
 
 impl<'tcx> fmt::Debug for Region<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{:?}", self.kind())
     }
 }
-impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for Region<'tcx> {
-    fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        write!(f, "{:?}", &this.map(|data| data.kind()))
-    }
-}
 
 ///////////////////////////////////////////////////////////////////////////
 // Atomic structs

Diff for: compiler/rustc_type_ir/src/binder.rs

@@ -8,12 +8,11 @@ use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_serialize::Decodable;
 use tracing::debug;
 
-use crate::debug::{DebugWithInfcx, WithInfcx};
 use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldable};
 use crate::inherent::*;
 use crate::lift::Lift;
 use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
-use crate::{self as ty, InferCtxtLike, Interner, SsoHashSet};
+use crate::{self as ty, Interner, SsoHashSet};
 
 /// Binder is a binder for higher-ranked lifetimes or types. It is part of the
 /// compiler's representation for things like `for<'a> Fn(&'a isize)`
@@ -56,18 +55,6 @@ where
     }
 }
 
-impl<I: Interner, T: DebugWithInfcx<I>> DebugWithInfcx<I> for ty::Binder<I, T> {
-    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        f.debug_tuple("Binder")
-            .field(&this.map(|data| data.as_ref().skip_binder()))
-            .field(&this.data.bound_vars())
-            .finish()
-    }
-}
-
 macro_rules! impl_binder_encode_decode {
     ($($t:ty),+ $(,)?) => {
         $(

Diff for: compiler/rustc_type_ir/src/const_kind.rs

@@ -5,7 +5,7 @@ use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
 use std::fmt;
 
-use crate::{self as ty, DebruijnIndex, DebugWithInfcx, InferCtxtLike, Interner, WithInfcx};
+use crate::{self as ty, DebruijnIndex, Interner};
 
 use self::ConstKind::*;
 
@@ -61,28 +61,19 @@ impl<I: Interner> PartialEq for ConstKind<I> {
 
 impl<I: Interner> fmt::Debug for ConstKind<I> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        WithInfcx::with_no_infcx(self).fmt(f)
-    }
-}
-
-impl<I: Interner> DebugWithInfcx<I> for ConstKind<I> {
-    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
         use ConstKind::*;
 
-        match this.data {
+        match self {
             Param(param) => write!(f, "{param:?}"),
-            Infer(var) => write!(f, "{:?}", &this.wrap(var)),
+            Infer(var) => write!(f, "{:?}", &var),
             Bound(debruijn, var) => crate::debug_bound_var(f, *debruijn, var),
             Placeholder(placeholder) => write!(f, "{placeholder:?}"),
             Unevaluated(uv) => {
-                write!(f, "{:?}", &this.wrap(uv))
+                write!(f, "{:?}", &uv)
             }
-            Value(ty, valtree) => write!(f, "({valtree:?}: {:?})", &this.wrap(ty)),
+            Value(ty, valtree) => write!(f, "({valtree:?}: {:?})", &ty),
             Error(_) => write!(f, "{{const error}}"),
-            Expr(expr) => write!(f, "{:?}", &this.wrap(expr)),
+            Expr(expr) => write!(f, "{:?}", &expr),
         }
     }
 }
@@ -112,17 +103,9 @@ impl<I: Interner> UnevaluatedConst<I> {
 
 impl<I: Interner> fmt::Debug for UnevaluatedConst<I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        WithInfcx::with_no_infcx(self).fmt(f)
-    }
-}
-impl<I: Interner> DebugWithInfcx<I> for UnevaluatedConst<I> {
-    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
         f.debug_struct("UnevaluatedConst")
-            .field("def", &this.data.def)
-            .field("args", &this.wrap(this.data.args))
+            .field("def", &self.def)
+            .field("args", &self.args)
             .finish()
     }
 }
@@ -175,23 +158,6 @@ impl fmt::Debug for InferConst {
         }
     }
 }
-impl<I: Interner> DebugWithInfcx<I> for InferConst {
-    fn fmt<Infcx: InferCtxtLike<Interner = I>>(
-        this: WithInfcx<'_, Infcx, &Self>,
-        f: &mut core::fmt::Formatter<'_>,
-    ) -> core::fmt::Result {
-        match *this.data {
-            InferConst::Var(vid) => match this.infcx.universe_of_ct(vid) {
-                None => write!(f, "{:?}", this.data),
-                Some(universe) => write!(f, "?{}_{}c", vid.index(), universe.index()),
-            },
-            InferConst::EffectVar(vid) => write!(f, "?{}e", vid.index()),
-            InferConst::Fresh(_) => {
-                unreachable!()
-            }
-        }
-    }
-}
 
 #[cfg(feature = "nightly")]
 impl<CTX> HashStable<CTX> for InferConst {