Start working on intern goal_data

Author: yaahc

chalk-engine/src/context.rs

@@ -154,16 +154,6 @@ pub trait Context: Clone + Debug {
 
     fn goal_from_goal_in_environment(goal: &Self::GoalInEnvironment) -> &Self::Goal;
 
-    /// Convert the context's goal type into the `HhGoal` type that
-    /// the SLG solver understands. The expectation is that the
-    /// context's goal type has the same set of variants, but with
-    /// different names and a different setup. If you inspect
-    /// `HhGoal`, you will see that this is a "shallow" or "lazy"
-    /// conversion -- that is, we convert the outermost goal into an
-    /// `HhGoal`, but the goals contained within are left as context
-    /// goals.
-    fn into_hh_goal(goal: Self::Goal) -> HhGoal<Self>;
-
     // Used by: simplify
     fn add_clauses(env: &Self::Environment, clauses: Self::ProgramClauses) -> Self::Environment;
 
@@ -266,6 +256,16 @@ pub trait ContextOps<C: Context>: Sized + Clone + Debug + AggregateOps<C> {
         u_canon: &C::UCanonicalGoalInEnvironment,
         canonical_subst: &C::CanonicalAnswerSubst,
     ) -> bool;
+
+    /// Convert the context's goal type into the `HhGoal` type that
+    /// the SLG solver understands. The expectation is that the
+    /// context's goal type has the same set of variants, but with
+    /// different names and a different setup. If you inspect
+    /// `HhGoal`, you will see that this is a "shallow" or "lazy"
+    /// conversion -- that is, we convert the outermost goal into an
+    /// `HhGoal`, but the goals contained within are left as context
+    /// goals.
+    fn into_hh_goal(&self, goal: C::Goal) -> HhGoal<C>;
 }
 
 /// Methods for combining solutions to yield an aggregate solution.

chalk-engine/src/logic.rs

@@ -255,7 +255,7 @@ impl<C: Context> Forest<C> {
         goal: C::Goal,
     ) {
         let table_ref = &mut self.tables[table];
-        match C::into_hh_goal(goal) {
+        match context.into_hh_goal(goal) {
             HhGoal::DomainGoal(domain_goal) => {
                 match context.program_clauses(&environment, &domain_goal, &mut infer) {
                     Ok(clauses) => {

chalk-engine/src/simplify.rs

@@ -33,20 +33,20 @@ impl<C: Context> Forest<C> {
                 HhGoal::ForAll(subgoal) => {
                     let subgoal =
                         infer.instantiate_binders_universally(context.interner(), &subgoal);
-                    pending_goals.push((environment, C::into_hh_goal(subgoal)));
+                    pending_goals.push((environment, context.into_hh_goal(subgoal)));
                 }
                 HhGoal::Exists(subgoal) => {
                     let subgoal =
                         infer.instantiate_binders_existentially(context.interner(), &subgoal);
-                    pending_goals.push((environment, C::into_hh_goal(subgoal)))
+                    pending_goals.push((environment, context.into_hh_goal(subgoal)))
                 }
                 HhGoal::Implies(wc, subgoal) => {
                     let new_environment = C::add_clauses(&environment, wc);
-                    pending_goals.push((new_environment, C::into_hh_goal(subgoal)));
+                    pending_goals.push((new_environment, context.into_hh_goal(subgoal)));
                 }
                 HhGoal::All(subgoals) => {
                     for subgoal in subgoals {
-                        pending_goals.push((environment.clone(), C::into_hh_goal(subgoal)));
+                        pending_goals.push((environment.clone(), context.into_hh_goal(subgoal)));
                     }
                 }
                 HhGoal::Not(subgoal) => {

chalk-integration/src/program.rs

@@ -4,8 +4,8 @@ use chalk_ir::debug::Angle;
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::tls;
 use chalk_ir::{
-    AliasTy, AssocTypeId, ImplId, Lifetime, Parameter, ParameterKind, ProgramClause, StructId,
-    TraitId, Ty, TyData, TypeName,
+    AliasTy, AssocTypeId, Goal, GoalData, ImplId, Lifetime, Parameter, ParameterKind,
+    ProgramClause, StructId, TraitId, Ty, TyData, TypeName,
 };
 use chalk_rust_ir::{
     AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
@@ -147,6 +147,35 @@ impl tls::DebugContext for Program {
             ParameterKind::Lifetime(n) => write!(fmt, "{:?}", n),
         }
     }
+
+    fn debug_goal(
+        &self,
+        goal: &Goal<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        match goal.data(interner) {
+            GoalData::Quantified(qkind, ref subgoal) => {
+                write!(fmt, "{:?}<", qkind)?;
+                for (index, binder) in subgoal.binders.iter().enumerate() {
+                    if index > 0 {
+                        write!(fmt, ", ")?;
+                    }
+                    match *binder {
+                        ParameterKind::Ty(()) => write!(fmt, "type")?,
+                        ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
+                    }
+                }
+                write!(fmt, "> {{ {:?} }}", subgoal.value)
+            }
+            GoalData::Implies(ref wc, ref g) => write!(fmt, "if ({:?}) {{ {:?} }}", wc, g),
+            GoalData::All(ref goals) => write!(fmt, "all{:?}", goals),
+            GoalData::Not(ref g) => write!(fmt, "not {{ {:?} }}", g),
+            GoalData::EqGoal(ref wc) => write!(fmt, "{:?}", wc),
+            GoalData::DomainGoal(ref wc) => write!(fmt, "{:?}", wc),
+            GoalData::CannotProve(()) => write!(fmt, r"¯\_(ツ)_/¯"),
+        }
+    }
 }
 
 impl RustIrDatabase<ChalkIr> for Program {

chalk-ir/src/debug.rs

@@ -33,13 +33,18 @@ 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<I: Interner> Debug for Goal<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_goal(self, fmt).unwrap_or_else(|| unimplemented!())
+    }
+}
+
 impl Display for UniverseIndex {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "U{}", self.counter)
@@ -264,32 +269,6 @@ impl<I: Interner> Debug for EqGoal<I> {
     }
 }
 
-impl<I: Interner> Debug for Goal<I> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        match self.data() {
-            GoalData::Quantified(qkind, ref subgoal) => {
-                write!(fmt, "{:?}<", qkind)?;
-                for (index, binder) in subgoal.binders.iter().enumerate() {
-                    if index > 0 {
-                        write!(fmt, ", ")?;
-                    }
-                    match *binder {
-                        ParameterKind::Ty(()) => write!(fmt, "type")?,
-                        ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
-                    }
-                }
-                write!(fmt, "> {{ {:?} }}", subgoal.value)
-            }
-            GoalData::Implies(ref wc, ref g) => write!(fmt, "if ({:?}) {{ {:?} }}", wc, g),
-            GoalData::All(ref goals) => write!(fmt, "all{:?}", goals),
-            GoalData::Not(ref g) => write!(fmt, "not {{ {:?} }}", g),
-            GoalData::EqGoal(ref wc) => write!(fmt, "{:?}", wc),
-            GoalData::DomainGoal(ref wc) => write!(fmt, "{:?}", wc),
-            GoalData::CannotProve(()) => write!(fmt, r"¯\_(ツ)_/¯"),
-        }
-    }
-}
-
 impl<I: Interner> Debug for Goals<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "(")?;

chalk-ir/src/fold.rs

@@ -413,8 +413,12 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for Goal<I> {
         I: 'i,
         TI: 'i,
     {
-        let interner = folder.target_interner();
-        Ok(Goal::new(interner, self.data().fold_with(folder, binders)?))
+        let interner = folder.interner();
+        let target_interner = folder.target_interner();
+        Ok(Goal::new(
+            target_interner,
+            self.data(interner).fold_with(folder, binders)?,
+        ))
     }
 }
 

chalk-ir/src/interner.rs

@@ -167,6 +167,15 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result>;
 
+    /// Prints the debug representation of an goal. 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_goal(goal: &Goal<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).
@@ -200,7 +209,7 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     fn intern_goal(&self, data: GoalData<Self>) -> Self::InternedGoal;
 
     /// Lookup the `GoalData` that was interned to create a `InternedGoal`.
-    fn goal_data(goal: &Self::InternedGoal) -> &GoalData<Self>;
+    fn goal_data<'a>(&self, goal: &'a Self::InternedGoal) -> &'a GoalData<Self>;
 
     /// Create an "interned" goals from `data`. This is not
     /// normally invoked directly; instead, you invoke
@@ -326,6 +335,10 @@ mod default {
             tls::with_current_program(|prog| Some(prog?.debug_parameter(parameter, fmt)))
         }
 
+        fn debug_goal(goal: &Goal<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| Some(prog?.debug_goal(goal, fmt)))
+        }
+
         fn intern_ty(&self, ty: TyData<ChalkIr>) -> Arc<TyData<ChalkIr>> {
             Arc::new(ty)
         }
@@ -360,7 +373,7 @@ mod default {
             Arc::new(goal)
         }
 
-        fn goal_data(goal: &Arc<GoalData<ChalkIr>>) -> &GoalData<ChalkIr> {
+        fn goal_data<'a>(&self, goal: &'a Arc<GoalData<ChalkIr>>) -> &'a GoalData<ChalkIr> {
             goal
         }
 

chalk-ir/src/lib.rs

@@ -1083,8 +1083,8 @@ impl<I: Interner> Goal<I> {
         Self { interned }
     }
 
-    pub fn data(&self) -> &GoalData<I> {
-        I::goal_data(&self.interned)
+    pub fn data(&self, interner: &I) -> &GoalData<I> {
+        interner.goal_data(&self.interned)
     }
 
     pub fn quantify(
@@ -1138,8 +1138,8 @@ impl<I: Interner> Goal<I> {
 
     /// True if this goal is "trivially true" -- i.e., no work is
     /// required to prove it.
-    pub fn is_trivially_true(&self) -> bool {
-        match self.data() {
+    pub fn is_trivially_true(&self, interner: &I) -> bool {
+        match self.data(interner) {
             GoalData::All(goals) => goals.is_empty(),
             _ => false,
         }

chalk-ir/src/tls.rs

@@ -1,5 +1,5 @@
 use crate::interner::ChalkIr;
-use crate::{AliasTy, AssocTypeId, Lifetime, Parameter, StructId, TraitId, Ty};
+use crate::{AliasTy, AssocTypeId, Goal, Lifetime, Parameter, StructId, TraitId, Ty};
 use std::cell::RefCell;
 use std::fmt;
 use std::sync::Arc;
@@ -46,6 +46,12 @@ pub trait DebugContext {
         parameter: &Parameter<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
+
+    fn debug_goal(
+        &self,
+        goal: &Goal<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

@@ -327,7 +327,8 @@ impl<I: Interner> Zip<I> for Goal<I> {
     where
         I: 'i,
     {
-        Zip::zip_with(zipper, a.data(), b.data())
+        let interner = zipper.interner();
+        Zip::zip_with(zipper, a.data(interner), b.data(interner))
     }
 }