Fix most unimplemented interners

Author: yaahc

chalk-integration/src/program.rs

@@ -4,7 +4,7 @@ use chalk_ir::debug::Angle;
 use chalk_ir::interner::ChalkIr;
 use chalk_ir::tls;
 use chalk_ir::{
-    AliasTy, AssocTypeId, ImplId, Parameter, ProgramClause, StructId, TraitId, TyData, TypeName,
+    Ty, AliasTy, AssocTypeId, ImplId, Parameter, ProgramClause, StructId, TraitId, TyData, TypeName,
 };
 use chalk_rust_ir::{
     AssociatedTyDatum, AssociatedTyValue, AssociatedTyValueId, ImplDatum, ImplType, StructDatum,
@@ -120,6 +120,15 @@ impl tls::DebugContext for Program {
             Angle(&other_params)
         )
     }
+
+    fn debug_ty(
+        &self,
+        ty: &Ty<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        write!(fmt, "{:?}", ty.data(interner))
+    }
 }
 
 impl RustIrDatabase<ChalkIr> for Program {
@@ -162,6 +171,7 @@ impl RustIrDatabase<ChalkIr> for Program {
         trait_id: TraitId<ChalkIr>,
         parameters: &[Parameter<ChalkIr>],
     ) -> Vec<ImplId<ChalkIr>> {
+        let interner = self.interner();
         self.impl_data
             .iter()
             .filter(|(_, impl_datum)| {
@@ -170,6 +180,7 @@ impl RustIrDatabase<ChalkIr> for Program {
                     assert_eq!(trait_ref.substitution.len(), parameters.len());
                     <[_] as CouldMatch<[_]>>::could_match(
                         &parameters,
+                        interner,
                         &trait_ref.substitution.parameters(),
                     )
                 }

chalk-ir/src/could_match.rs

@@ -3,8 +3,8 @@ use crate::zip::{Zip, Zipper};
 use crate::*;
 
 /// A fast check to see whether two things could ever possibly match.
-pub trait CouldMatch<T: ?Sized> {
-    fn could_match(&self, other: &T) -> bool;
+pub trait CouldMatch<T: ?Sized + HasInterner> {
+    fn could_match(&self, interner: &T::Interner, other: &T) -> bool;
 }
 
 #[allow(unreachable_code, unused_variables)]
@@ -13,8 +13,7 @@ where
     T: Zip<I> + ?Sized + HasInterner<Interner = I>,
     I: Interner,
 {
-    fn could_match(&self, other: &T) -> bool {
-        let interner = unimplemented!();
+    fn could_match(&self, interner: &I, other: &T) -> bool {
         return Zip::zip_with(&mut MatchZipper{ interner }, self, other).is_ok();
 
         struct MatchZipper<'i, I> {
@@ -31,7 +30,7 @@ where
                             && a.substitution
                                 .iter()
                                 .zip(&b.substitution)
-                                .all(|(p_a, p_b)| p_a.could_match(&p_b))
+                                .all(|(p_a, p_b)| p_a.could_match(self.interner, &p_b))
                     }
 
                     _ => true,
@@ -59,11 +58,11 @@ where
 }
 
 impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClause<I> {
-    fn could_match(&self, other: &DomainGoal<I>) -> bool {
+    fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool {
         match self {
-            ProgramClause::Implies(implication) => implication.consequence.could_match(other),
+            ProgramClause::Implies(implication) => implication.consequence.could_match(interner, other),
 
-            ProgramClause::ForAll(clause) => clause.value.consequence.could_match(other),
+            ProgramClause::ForAll(clause) => clause.value.consequence.could_match(interner, other),
         }
     }
 }

chalk-ir/src/debug.rs

@@ -21,6 +21,13 @@ impl<I: Interner> Debug for AssocTypeId<I> {
     }
 }
 
+impl<I: Interner> Debug for Ty<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_ty(self, fmt).unwrap_or_else(|| unimplemented!())
+    }
+}
+
+
 impl Display for UniverseIndex {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         write!(fmt, "U{}", self.counter)
@@ -43,14 +50,6 @@ impl<I: Interner> Debug for TypeName<I> {
     }
 }
 
-#[allow(unreachable_code, unused_variables)]
-impl<I: Interner> Debug for Ty<I> {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        let interner = unimplemented!();
-        write!(fmt, "{:?}", self.data(interner))
-    }
-}
-
 impl<I: Interner> Debug for TyData<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {

chalk-ir/src/interner.rs

@@ -8,6 +8,7 @@ use crate::ParameterData;
 use crate::StructId;
 use crate::TraitId;
 use crate::TyData;
+use crate::Ty;
 use chalk_engine::context::Context;
 use chalk_engine::ExClause;
 use std::fmt::{self, Debug};
@@ -132,6 +133,18 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     /// if no info about current program is available from TLS).
     fn debug_alias(alias: &AliasTy<Self>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result>;
 
+    /// Prints the debug representation of an type. 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_ty(
+        ty: &Ty<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).
@@ -272,6 +285,13 @@ 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 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, StructId, TraitId};
+use crate::{AliasTy, AssocTypeId, Ty, StructId, TraitId};
 use std::cell::RefCell;
 use std::fmt;
 use std::sync::Arc;
@@ -32,6 +32,12 @@ pub trait DebugContext {
         alias: &AliasTy<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
+
+    fn debug_ty(
+        &self,
+        ty: &Ty<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/clauses.rs

@@ -116,12 +116,13 @@ pub(crate) fn program_clauses_for_goal<'db, I: Interner>(
         goal,
         environment
     );
+    let interner = db.interner();
 
     let mut vec = vec![];
     vec.extend(db.custom_clauses());
     program_clauses_that_could_match(db, environment, goal, &mut vec);
     program_clauses_for_env(db, environment, &mut vec);
-    vec.retain(|c| c.could_match(goal));
+    vec.retain(|c| c.could_match(interner, goal));
 
     debug!("vec = {:#?}", vec);
 

chalk-solve/src/solve/slg.rs

@@ -234,7 +234,7 @@ impl<'me, I: Interner> context::ContextOps<SlgContext<I>> for SlgContextOps<'me,
             environment
                 .clauses
                 .iter()
-                .filter(|&env_clause| env_clause.could_match(goal))
+                .filter(|&env_clause| env_clause.could_match(interner, goal))
                 .cloned(),
         );
 
@@ -495,22 +495,24 @@ fn into_ex_clause<I: Interner>(
 }
 
 trait SubstitutionExt<I: Interner> {
-    fn may_invalidate(&self, subst: &Canonical<Substitution<I>>) -> bool;
+    fn may_invalidate(&self, interner: &I, subst: &Canonical<Substitution<I>>) -> bool;
 }
 
 impl<I: Interner> SubstitutionExt<I> for Substitution<I> {
-    fn may_invalidate(&self, subst: &Canonical<Substitution<I>>) -> bool {
+    fn may_invalidate(&self, interner: &I, subst: &Canonical<Substitution<I>>) -> bool {
         self.iter()
             .zip(subst.value.iter())
-            .any(|(new, current)| MayInvalidate.aggregate_parameters(new, current))
+            .any(|(new, current)| MayInvalidate{ interner }.aggregate_parameters( new, current))
     }
 }
 
 // This is a struct in case we need to add state at any point like in AntiUnifier
-struct MayInvalidate;
+struct MayInvalidate<'i, I> {
+    interner: &'i I,
+}
 
-impl MayInvalidate {
-    fn aggregate_parameters<I: Interner>(
+impl<I: Interner> MayInvalidate<'_, I> {
+    fn aggregate_parameters(
         &mut self,
         new: &Parameter<I>,
         current: &Parameter<I>,
@@ -528,9 +530,8 @@ impl MayInvalidate {
     }
 
     // Returns true if the two types could be unequal.
-#[allow(unreachable_code, unused_variables)]
-    fn aggregate_tys<I: Interner>(&mut self, new: &Ty<I>, current: &Ty<I>) -> bool {
-        let interner = unimplemented!();
+    fn aggregate_tys(&mut self, new: &Ty<I>, current: &Ty<I>) -> bool {
+        let interner = self.interner;
         match (new.data(interner), current.data(interner)) {
             (_, TyData::BoundVar(_)) => {
                 // If the aggregate solution already has an inference
@@ -586,11 +587,11 @@ impl MayInvalidate {
         }
     }
 
-    fn aggregate_lifetimes<I: Interner>(&mut self, _: &Lifetime<I>, _: &Lifetime<I>) -> bool {
+    fn aggregate_lifetimes(&mut self, _: &Lifetime<I>, _: &Lifetime<I>) -> bool {
         true
     }
 
-    fn aggregate_application_tys<I: Interner>(
+    fn aggregate_application_tys(
         &mut self,
         new: &ApplicationTy<I>,
         current: &ApplicationTy<I>,
@@ -620,7 +621,7 @@ impl MayInvalidate {
         new != current
     }
 
-    fn aggregate_alias_tys<I: Interner>(&mut self, new: &AliasTy<I>, current: &AliasTy<I>) -> bool {
+    fn aggregate_alias_tys(&mut self, new: &AliasTy<I>, current: &AliasTy<I>) -> bool {
         let AliasTy {
             associated_ty_id: new_name,
             substitution: new_substitution,
@@ -638,7 +639,7 @@ impl MayInvalidate {
         )
     }
 
-    fn aggregate_name_and_substs<N, I>(
+    fn aggregate_name_and_substs<N>(
         &mut self,
         new_name: N,
         new_substitution: &Substitution<I>,
@@ -647,7 +648,6 @@ impl MayInvalidate {
     ) -> bool
     where
         N: Copy + Eq + Debug,
-        I: Interner,
     {
         if new_name != current_name {
             return true;
@@ -667,6 +667,6 @@ impl MayInvalidate {
         new_substitution
             .iter()
             .zip(current_substitution)
-            .any(|(new, current)| self.aggregate_parameters(new, current))
+            .any(|(new, current)| self.aggregate_parameters( new, current))
     }
 }

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

@@ -70,7 +70,7 @@ impl<I: Interner> context::AggregateOps<SlgContext<I>> for SlgContextOps<'_, I>
                 break Guidance::Unknown;
             }
 
-            if !answers.any_future_answer(|ref mut new_subst| new_subst.may_invalidate(&subst)) {
+            if !answers.any_future_answer(|ref mut new_subst| new_subst.may_invalidate(interner, &subst)) {
                 break Guidance::Definite(subst);
             }