Add ability to branch on whether DebugWithInfcx has an Infcx

Author: BoxyUwU

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -83,17 +83,17 @@ impl fmt::Debug for ty::LateParamRegion {
     }
 }
 
+impl<'tcx> fmt::Debug for Ty<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        with_no_trimmed_paths!(self.kind().fmt(f))
+    }
+}
 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))
+        this.map(|ty| ty.kind()).fmt(f)
     }
 }
 
@@ -264,9 +264,12 @@ impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for ty::RegionVid {
         this: WithInfcx<'_, Infcx, &Self>,
         f: &mut core::fmt::Formatter<'_>,
     ) -> core::fmt::Result {
-        match this.infcx.universe_of_lt(*this.data) {
-            Some(universe) => write!(f, "'?{}_{}", this.data.index(), universe.index()),
+        match this.infcx {
             None => write!(f, "{:?}", this.data),
+            Some(infcx) => match infcx.universe_of_lt(*this.data) {
+                Some(universe) => write!(f, "'?{}_{}", this.data.index(), universe.index()),
+                None => write!(f, "'?{}_..", this.data.index()),
+            },
         }
     }
 }

compiler/rustc_type_ir/src/const_kind.rs

@@ -180,15 +180,18 @@ impl<I: Interner> DebugWithInfcx<I> for InferConst {
         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()),
+        match this.infcx {
+            None => write!(f, "{:?}", this.data),
+            Some(infcx) => match *this.data {
+                InferConst::Var(vid) => match infcx.universe_of_ct(vid) {
+                    None => write!(f, "?{}_..c", vid.index()),
+                    Some(universe) => write!(f, "?{}_{}c", vid.index(), universe.index()),
+                },
+                InferConst::EffectVar(vid) => write!(f, "?{}e", vid.index()),
+                InferConst::Fresh(_) => {
+                    unreachable!()
+                }
             },
-            InferConst::EffectVar(vid) => write!(f, "?{}e", vid.index()),
-            InferConst::Fresh(_) => {
-                unreachable!()
-            }
         }
     }
 }

compiler/rustc_type_ir/src/debug.rs

@@ -1,51 +1,55 @@
 use crate::{ConstVid, InferCtxtLike, Interner, TyVid, UniverseIndex};
 
 use core::fmt;
-use std::marker::PhantomData;
-
-pub struct NoInfcx<I>(PhantomData<I>);
 
+pub struct NoInfcx<I>(core::convert::Infallible, core::marker::PhantomData<I>);
 impl<I: Interner> InferCtxtLike for NoInfcx<I> {
     type Interner = I;
 
     fn interner(&self) -> Self::Interner {
-        unreachable!()
+        match self.0 {}
     }
 
     fn universe_of_ty(&self, _ty: TyVid) -> Option<UniverseIndex> {
-        None
+        match self.0 {}
     }
 
-    fn universe_of_lt(&self, _lt: I::InferRegion) -> Option<UniverseIndex> {
-        None
+    fn root_ty_var(&self, _vid: TyVid) -> TyVid {
+        match self.0 {}
     }
 
-    fn universe_of_ct(&self, _ct: ConstVid) -> Option<UniverseIndex> {
-        None
+    fn probe_ty_var(&self, _vid: TyVid) -> Option<<Self::Interner as Interner>::Ty> {
+        match self.0 {}
     }
 
-    fn root_ty_var(&self, vid: TyVid) -> TyVid {
-        vid
+    fn universe_of_lt(
+        &self,
+        _lt: <Self::Interner as Interner>::InferRegion,
+    ) -> Option<UniverseIndex> {
+        match self.0 {}
     }
 
-    fn probe_ty_var(&self, _vid: TyVid) -> Option<I::Ty> {
-        None
+    fn opportunistic_resolve_lt_var(
+        &self,
+        _vid: <Self::Interner as Interner>::InferRegion,
+    ) -> Option<<Self::Interner as Interner>::Region> {
+        match self.0 {}
     }
 
-    fn opportunistic_resolve_lt_var(&self, _vid: I::InferRegion) -> Option<I::Region> {
-        None
+    fn universe_of_ct(&self, _ct: ConstVid) -> Option<UniverseIndex> {
+        match self.0 {}
     }
 
-    fn root_ct_var(&self, vid: ConstVid) -> ConstVid {
-        vid
+    fn root_ct_var(&self, _vid: ConstVid) -> ConstVid {
+        match self.0 {}
     }
 
-    fn probe_ct_var(&self, _vid: ConstVid) -> Option<I::Const> {
-        None
+    fn probe_ct_var(&self, _vid: ConstVid) -> Option<<Self::Interner as Interner>::Const> {
+        match self.0 {}
     }
 
     fn defining_opaque_types(&self) -> <Self::Interner as Interner>::DefiningOpaqueTypes {
-        Default::default()
+        match self.0 {}
     }
 }
 
@@ -96,7 +100,7 @@ impl<I: Interner, T: DebugWithInfcx<I>> DebugWithInfcx<I> for [T] {
 
 pub struct WithInfcx<'a, Infcx: InferCtxtLike, T> {
     pub data: T,
-    pub infcx: &'a Infcx,
+    pub infcx: Option<&'a Infcx>,
 }
 
 impl<Infcx: InferCtxtLike, T: Copy> Copy for WithInfcx<'_, Infcx, T> {}
@@ -109,13 +113,13 @@ impl<Infcx: InferCtxtLike, T: Clone> Clone for WithInfcx<'_, Infcx, T> {
 
 impl<'a, I: Interner, T> WithInfcx<'a, NoInfcx<I>, T> {
     pub fn with_no_infcx(data: T) -> Self {
-        Self { data, infcx: &NoInfcx(PhantomData) }
+        Self { data, infcx: None }
     }
 }
 
 impl<'a, Infcx: InferCtxtLike, T> WithInfcx<'a, Infcx, T> {
     pub fn new(data: T, infcx: &'a Infcx) -> Self {
-        Self { data, infcx }
+        Self { data, infcx: Some(infcx) }
     }
 
     pub fn wrap<U>(self, u: U) -> WithInfcx<'a, Infcx, U> {

compiler/rustc_type_ir/src/ty_kind.rs

@@ -415,7 +415,6 @@ impl<I: Interner> DebugWithInfcx<I> for TyKind<I> {
     }
 }
 
-// This is manually implemented because a derive would require `I: Debug`
 impl<I: Interner> fmt::Debug for TyKind<I> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         WithInfcx::with_no_infcx(self).fmt(f)
@@ -924,15 +923,18 @@ impl<I: Interner> DebugWithInfcx<I> for InferTy {
         this: WithInfcx<'_, Infcx, &Self>,
         f: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
-        match this.data {
-            InferTy::TyVar(vid) => {
-                if let Some(universe) = this.infcx.universe_of_ty(*vid) {
-                    write!(f, "?{}_{}t", vid.index(), universe.index())
-                } else {
-                    write!(f, "{:?}", this.data)
+        match this.infcx {
+            None => write!(f, "{:?}", this.data),
+            Some(infcx) => match this.data {
+                InferTy::TyVar(vid) => {
+                    if let Some(universe) = infcx.universe_of_ty(*vid) {
+                        write!(f, "?{}_{}t", vid.index(), universe.index())
+                    } else {
+                        write!(f, "{}_..t", vid.index())
+                    }
                 }
-            }
-            _ => write!(f, "{:?}", this.data),
+                _ => write!(f, "{:?}", this.data),
+            },
         }
     }
 }