Get close but probably died trying

Author: yaahc

chalk-integration/src/lowering.rs

@@ -1392,7 +1392,7 @@ impl<T, L> Kinded for chalk_ir::ParameterKind<T, L> {
 #[allow(unreachable_code, unused_variables)]
 impl Kinded for chalk_ir::Parameter<ChalkIr> {
     fn kind(&self) -> Kind {
-        let interner = unimplemented!();
+        let interner = &ChalkIr;
         self.data(interner).kind()
     }
 }

chalk-integration/src/program.rs

@@ -5,7 +5,7 @@ use chalk_ir::interner::ChalkIr;
 use chalk_ir::tls;
 use chalk_ir::{
     AliasTy, AssocTypeId, ImplId, Lifetime, Parameter, ProgramClause, StructId, TraitId, Ty,
-    TyData, TypeName,
+    TyData, TypeName, ParameterKind,
 };
 use chalk_rust_ir::{
     AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
@@ -135,6 +135,18 @@ impl tls::DebugContext for Program {
         let interner = self.interner();
         write!(fmt, "{:?}", lifetime.data(interner))
     }
+
+    fn debug_parameter(
+        &self,
+        parameter: &Parameter<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        match parameter.data(interner) {
+            ParameterKind::Ty(n) => write!(fmt, "{:?}", n),
+            ParameterKind::Lifetime(n) => write!(fmt, "{:?}", n),
+        }
+    }
 }
 
 impl RustIrDatabase<ChalkIr> for Program {

chalk-ir/src/could_match.rs

@@ -53,6 +53,10 @@ where
             {
                 Zip::zip_with(self, &a.value, &b.value)
             }
+
+            fn interner(&self) -> &I {
+                self.interner
+            }
         }
     }
 }

chalk-ir/src/debug.rs

@@ -33,6 +33,13 @@ impl<I: Interner> Debug for Lifetime<I> {
     }
 }
 
+#[allow(unreachable_code, unused_variables)]
+impl<I: Interner> Debug for Parameter<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_parameter(self, fmt).unwrap_or_else(|| unimplemented!())
+    }
+}
+
 impl Display for UniverseIndex {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "U{}", self.counter)
@@ -386,17 +393,6 @@ impl<T: Debug, L: Debug> Debug for ParameterKind<T, L> {
     }
 }
 
-#[allow(unreachable_code, unused_variables)]
-impl<I: Interner> Debug for Parameter<I> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        let interner = unimplemented!();
-        match self.data(interner) {
-            ParameterKind::Ty(n) => write!(fmt, "{:?}", n),
-            ParameterKind::Lifetime(n) => write!(fmt, "{:?}", n),
-        }
-    }
-}
-
 impl<I: Interner> Debug for Constraint<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {

chalk-ir/src/interner.rs

@@ -155,6 +155,18 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result>;
 
+    /// Prints the debug representation of an parameter. To get good
+    /// results, this requires inspecting TLS, and is difficult to
+    /// code without reference to a specific interner (and hence
+    /// fully known types).
+    ///
+    /// Returns `None` to fallback to the default debug output (e.g.,
+    /// if no info about current program is available from TLS).
+    fn debug_parameter(
+        parameter: &Parameter<Self>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result>;
+
     /// Create an "interned" type from `ty`. This is not normally
     /// invoked directly; instead, you invoke `TyData::intern` (which
     /// will ultimately call this method).
@@ -307,6 +319,13 @@ mod default {
                 .or_else(|| Some(write!(fmt, "{:?}", lifetime.interned)))
         }
 
+        fn debug_parameter(
+            parameter: &Parameter<ChalkIr>,
+            fmt: &mut fmt::Formatter<'_>,
+        ) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| Some(prog?.debug_parameter(parameter, fmt)))
+        }
+
         fn intern_ty(&self, ty: TyData<ChalkIr>) -> Arc<TyData<ChalkIr>> {
             Arc::new(ty)
         }

chalk-ir/src/tls.rs

@@ -1,5 +1,5 @@
 use crate::interner::ChalkIr;
-use crate::{AliasTy, AssocTypeId, Lifetime, StructId, TraitId, Ty};
+use crate::{AliasTy, AssocTypeId, Lifetime, StructId, TraitId, Ty, Parameter};
 use std::cell::RefCell;
 use std::fmt;
 use std::sync::Arc;
@@ -40,6 +40,12 @@ pub trait DebugContext {
         lifetime: &Lifetime<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
+
+    fn debug_parameter(
+        &self,
+        parameter: &Parameter<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error>;
 }
 
 pub fn with_current_program<R>(op: impl FnOnce(Option<&Arc<dyn DebugContext>>) -> R) -> R {

chalk-ir/src/zip.rs

@@ -32,6 +32,9 @@ pub trait Zipper<I: Interner> {
     fn zip_binders<T>(&mut self, a: &Binders<T>, b: &Binders<T>) -> Fallible<()>
     where
         T: Zip<I> + Fold<I, I, Result = T>;
+
+    /// Retreives the interner from the underlying zipper object
+    fn interner(&self) -> &I;
 }
 
 impl<'f, Z, I> Zipper<I> for &'f mut Z
@@ -53,6 +56,10 @@ where
     {
         (**self).zip_binders(a, b)
     }
+
+    fn interner(&self) -> &I {
+        Z::interner(*self)
+    }
 }
 
 /// The `Zip` trait walks two values, invoking the `Zipper` methods where
@@ -323,7 +330,7 @@ impl<T: Zip<I>, L: Zip<I>, I: Interner> Zip<I> for ParameterKind<T, L> {
 #[allow(unreachable_code, unused_variables)]
 impl<I: Interner> Zip<I> for Parameter<I> {
     fn zip_with<Z: Zipper<I>>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()> {
-        let interner = unimplemented!();
+        let interner = zipper.interner();
         Zip::zip_with(zipper, a.data(interner), b.data(interner))
     }
 }

chalk-solve/src/infer/unify.rs

@@ -364,6 +364,10 @@ impl<I: Interner> Zipper<I> for Unifier<'_, I> {
 
         self.unify_binders(a, b)
     }
+
+    fn interner(&self) -> &I {
+        self.interner
+    }
 }
 
 struct OccursCheck<'u, 't, I: Interner> {

chalk-solve/src/solve/slg/resolvent.rs

@@ -464,4 +464,8 @@ impl<I: Interner> Zipper<I> for AnswerSubstitutor<'_, I> {
         self.pending_binders -= pending.binders.len();
         Ok(())
     }
+
+    fn interner(&self) -> &I {
+        self.interner
+    }
 }