Get interner into lifetime Debug impl

Author: yaahc

chalk-integration/src/program.rs

@@ -4,7 +4,8 @@ use chalk_ir::debug::Angle;
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::tls;
 use chalk_ir::{
-    AliasTy, AssocTypeId, ImplId, Parameter, ProgramClause, StructId, TraitId, Ty, TyData, TypeName,
+    AliasTy, AssocTypeId, ImplId, Lifetime, Parameter, ProgramClause, StructId, TraitId, Ty,
+    TyData, TypeName,
 };
 use chalk_rust_ir::{
     AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
@@ -125,6 +126,15 @@ impl tls::DebugContext for Program {
         let interner = self.interner();
         write!(fmt, "{:?}", ty.data(interner))
     }
+
+    fn debug_lifetime(
+        &self,
+        lifetime: &Lifetime<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        write!(fmt, "{:?}", lifetime.data(interner))
+    }
 }
 
 impl RustIrDatabase<ChalkIr> for Program {

chalk-ir/src/debug.rs

@@ -27,6 +27,12 @@ impl<I: Interner> Debug for Ty<I> {
     }
 }
 
+impl<I: Interner> Debug for Lifetime<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_lifetime(self, fmt).unwrap_or_else(|| unimplemented!())
+    }
+}
+
 impl Display for UniverseIndex {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "U{}", self.counter)
@@ -87,14 +93,6 @@ impl<I: Interner> Debug for Fn<I> {
     }
 }
 
-#[allow(unreachable_code, unused_variables)]
-impl<I: Interner> Debug for Lifetime<I> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        let interner = unimplemented!();
-        write!(fmt, "{:?}", self.data(interner))
-    }
-}
-
 impl<I: Interner> Debug for LifetimeData<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {

chalk-ir/src/interner.rs

@@ -2,6 +2,7 @@ use crate::AliasTy;
 use crate::AssocTypeId;
 use crate::Goal;
 use crate::GoalData;
+use crate::Lifetime;
 use crate::LifetimeData;
 use crate::Parameter;
 use crate::ParameterData;
@@ -142,6 +143,18 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     /// if no info about current program is available from TLS).
     fn debug_ty(ty: &Ty<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
 
+    /// Prints the debug representation of an lifetime. 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_lifetime(
+        lifetime: &Lifetime<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).
@@ -282,8 +295,15 @@ mod default {
             tls::with_current_program(|prog| Some(prog?.debug_alias(alias, fmt)))
         }
 
-        fn debug_ty(alias: &Ty<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
-            tls::with_current_program(|prog| Some(prog?.debug_ty(alias, fmt)))
+        fn debug_ty(ty: &Ty<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| Some(prog?.debug_ty(ty, fmt)))
+        }
+
+        fn debug_lifetime(
+            lifetime: &Lifetime<ChalkIr>,
+            fmt: &mut fmt::Formatter<'_>,
+        ) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| Some(prog?.debug_lifetime(lifetime, fmt)))
         }
 
         fn intern_ty(&self, ty: TyData<ChalkIr>) -> Arc<TyData<ChalkIr>> {
@@ -298,7 +318,10 @@ mod default {
             lifetime
         }
 
-        fn lifetime_data<'a>(&self, lifetime: &'a LifetimeData<ChalkIr>) -> &'a LifetimeData<ChalkIr> {
+        fn lifetime_data<'a>(
+            &self,
+            lifetime: &'a LifetimeData<ChalkIr>,
+        ) -> &'a LifetimeData<ChalkIr> {
             lifetime
         }
 

chalk-ir/src/tls.rs

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

chalk-solve/src/infer.rs

@@ -143,7 +143,11 @@ impl<I: Interner> InferenceTable<I> {
 
     /// If `leaf` represents an inference variable `X`, and `X` is bound,
     /// returns `Some(v)` where `v` is the value to which `X` is bound.
-    pub(crate) fn normalize_lifetime(&mut self, interner: &I, leaf: &Lifetime<I>) -> Option<Lifetime<I>> {
+    pub(crate) fn normalize_lifetime(
+        &mut self,
+        interner: &I,
+        leaf: &Lifetime<I>,
+    ) -> Option<Lifetime<I>> {
         let var = EnaVariable::from(leaf.inference_var(interner)?);
         let v1 = self.probe_lifetime_var(var)?;
         assert!(!v1.needs_shift(interner));

chalk-solve/src/infer/unify.rs

@@ -484,7 +484,6 @@ where
         var: InferenceVar,
         binders: usize,
     ) -> Fallible<Lifetime<I>> {
-        let interner = self.interner();
         // a free existentially bound region; find the
         // inference variable it corresponds to
         let interner = self.interner();

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

@@ -391,9 +391,7 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
 
     fn new_lifetime_variable(&mut self) -> Lifetime<I> {
         let interner = self.interner;
-        self.infer
-            .new_variable(self.universe)
-            .to_lifetime(interner)
+        self.infer.new_variable(self.universe).to_lifetime(interner)
     }
 }
 

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

@@ -365,11 +365,7 @@ impl<I: Interner> Zipper<I> for AnswerSubstitutor<'_, I> {
         // resulting answer that the subgoal found and unify it with
         // the value from our "pending subgoal".
         if let TyData::BoundVar(answer_depth) = answer.data(interner) {
-            if self.unify_free_answer_var(
-                interner,
-                *answer_depth,
-                ParameterKind::Ty(pending),
-            )? {
+            if self.unify_free_answer_var(interner, *answer_depth, ParameterKind::Ty(pending))? {
                 return Ok(());
             }
         }