make the search-graph and cache unaware of chalk types

Author: nikomatsakis

chalk-recursive/src/cache.rs

@@ -1,35 +1,45 @@
-use crate::UCanonicalGoal;
-use chalk_ir::interner::Interner;
-use chalk_ir::Fallible;
-use chalk_solve::Solution;
 use rustc_hash::FxHashMap;
+use std::fmt::Debug;
+use std::hash::Hash;
 use std::sync::{Arc, Mutex};
 use tracing::debug;
 use tracing::instrument;
 /// The "cache" stores results for goals that we have completely solved.
 /// Things are added to the cache when we have completely processed their
 /// result, and it can be shared amongst many solvers.
-pub struct Cache<I: Interner> {
-    data: Arc<Mutex<CacheData<I>>>,
+pub struct Cache<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
+    data: Arc<Mutex<CacheData<K, V>>>,
 }
-struct CacheData<I: Interner> {
-    cache: FxHashMap<UCanonicalGoal<I>, Fallible<Solution<I>>>,
+struct CacheData<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
+    cache: FxHashMap<K, V>,
 }
 
-impl<I: Interner> Cache<I> {
+impl<K, V> Cache<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
     pub fn new() -> Self {
         Self::default()
     }
 
     /// Record a cache result.
     #[instrument(skip(self))]
-    pub fn insert(&self, goal: UCanonicalGoal<I>, result: Fallible<Solution<I>>) {
+    pub fn insert(&self, goal: K, result: V) {
         let mut data = self.data.lock().unwrap();
         data.cache.insert(goal, result);
     }
 
     /// Record a cache result.
-    pub fn get(&self, goal: &UCanonicalGoal<I>) -> Option<Fallible<Solution<I>>> {
+    pub fn get(&self, goal: &K) -> Option<V> {
         let data = self.data.lock().unwrap();
         if let Some(result) = data.cache.get(&goal) {
             debug!(?goal, ?result, "Cache hit");
@@ -41,23 +51,35 @@ impl<I: Interner> Cache<I> {
     }
 }
 
-impl<I: Interner> Clone for Cache<I> {
+impl<K, V> Clone for Cache<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
     fn clone(&self) -> Self {
         Self {
             data: self.data.clone(),
         }
     }
 }
 
-impl<I: Interner> Default for Cache<I> {
+impl<K, V> Default for Cache<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
     fn default() -> Self {
         Self {
             data: Default::default(),
         }
     }
 }
 
-impl<I: Interner> Default for CacheData<I> {
+impl<K, V> Default for CacheData<K, V>
+where
+    K: Hash + Eq + Debug,
+    V: Debug + Clone,
+{
     fn default() -> Self {
         Self {
             cache: Default::default(),

chalk-recursive/src/recursive.rs

@@ -17,12 +17,12 @@ struct RecursiveContext<I: Interner> {
 
     /// The "search graph" stores "in-progress results" that are still being
     /// solved.
-    search_graph: SearchGraph<I>,
+    search_graph: SearchGraph<UCanonicalGoal<I>, Fallible<Solution<I>>>,
 
     /// The "cache" stores results for goals that we have completely solved.
     /// Things are added to the cache when we have completely processed their
     /// result.
-    cache: Option<Cache<I>>,
+    cache: Option<Cache<UCanonicalGoal<I>, Fallible<Solution<I>>>>,
 
     /// The maximum size for goals.
     max_size: usize,
@@ -43,7 +43,11 @@ pub struct RecursiveSolver<I: Interner> {
 }
 
 impl<I: Interner> RecursiveSolver<I> {
-    pub fn new(overflow_depth: usize, max_size: usize, cache: Option<Cache<I>>) -> Self {
+    pub fn new(
+        overflow_depth: usize,
+        max_size: usize,
+        cache: Option<Cache<UCanonicalGoal<I>, Fallible<Solution<I>>>>,
+    ) -> Self {
         Self {
             ctx: Box::new(RecursiveContext::new(overflow_depth, max_size, cache)),
         }
@@ -77,7 +81,11 @@ impl<T> MergeWith<T> for Fallible<T> {
 }
 
 impl<I: Interner> RecursiveContext<I> {
-    pub fn new(overflow_depth: usize, max_size: usize, cache: Option<Cache<I>>) -> Self {
+    pub fn new(
+        overflow_depth: usize,
+        max_size: usize,
+        cache: Option<Cache<UCanonicalGoal<I>, Fallible<Solution<I>>>>,
+    ) -> Self {
         RecursiveContext {
             stack: Stack::new(overflow_depth),
             search_graph: SearchGraph::new(),
@@ -245,10 +253,10 @@ impl<'me, I: Interner> SolveDatabase<I> for Solver<'me, I> {
             } else {
                 Err(NoSolution)
             };
-            let dfn =
-                self.context
-                    .search_graph
-                    .insert(&goal, depth, coinductive_goal, initial_solution);
+            let dfn = self
+                .context
+                .search_graph
+                .insert(&goal, depth, initial_solution);
             let subgoal_minimums = self.solve_new_subgoal(goal, depth, dfn);
             self.context.search_graph[dfn].links = subgoal_minimums;
             self.context.search_graph[dfn].stack_depth = None;

chalk-recursive/src/search_graph.rs

@@ -1,34 +1,35 @@
+use super::stack::StackDepth;
+use crate::{Cache, Minimums};
+use chalk_ir::ClausePriority;
+use rustc_hash::FxHashMap;
+use std::fmt::Debug;
+use std::hash::Hash;
 use std::ops::Add;
 use std::ops::Index;
 use std::ops::IndexMut;
 use std::usize;
-
-use super::stack::StackDepth;
-use crate::{Cache, Minimums, UCanonicalGoal};
-use chalk_ir::{
-    interner::Interner, Canonical, ClausePriority, ConstrainedSubst, Constraints, Fallible,
-    NoSolution,
-};
-use chalk_solve::Solution;
-use rustc_hash::FxHashMap;
 use tracing::{debug, instrument};
 
 /// The "search graph" stores in-progress goals that are still
 /// being solved.
-pub(super) struct SearchGraph<I: Interner> {
-    indices: FxHashMap<UCanonicalGoal<I>, DepthFirstNumber>,
-    nodes: Vec<Node<I>>,
+pub(super) struct SearchGraph<K, V>
+where
+    K: Hash + Eq + Debug + Clone,
+    V: Debug + Clone,
+{
+    indices: FxHashMap<K, DepthFirstNumber>,
+    nodes: Vec<Node<K, V>>,
 }
 
 #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub(super) struct DepthFirstNumber {
     index: usize,
 }
 
-pub(super) struct Node<I: Interner> {
-    pub(crate) goal: UCanonicalGoal<I>,
+pub(super) struct Node<K, V> {
+    pub(crate) goal: K,
 
-    pub(crate) solution: Fallible<Solution<I>>,
+    pub(crate) solution: V,
     pub(crate) solution_priority: ClausePriority,
 
     /// This is `Some(X)` if we are actively exploring this node, or
@@ -42,15 +43,19 @@ pub(super) struct Node<I: Interner> {
     pub(crate) links: Minimums,
 }
 
-impl<I: Interner> SearchGraph<I> {
+impl<K, V> SearchGraph<K, V>
+where
+    K: Hash + Eq + Debug + Clone,
+    V: Debug + Clone,
+{
     pub(crate) fn new() -> Self {
         SearchGraph {
             indices: FxHashMap::default(),
             nodes: vec![],
         }
     }
 
-    pub(crate) fn lookup(&self, goal: &UCanonicalGoal<I>) -> Option<DepthFirstNumber> {
+    pub(crate) fn lookup(&self, goal: &K) -> Option<DepthFirstNumber> {
         self.indices.get(goal).cloned()
     }
 
@@ -63,10 +68,9 @@ impl<I: Interner> SearchGraph<I> {
     ///   or `NoSolution` for other goals
     pub(crate) fn insert(
         &mut self,
-        goal: &UCanonicalGoal<I>,
+        goal: &K,
         stack_depth: StackDepth,
-        coinductive: bool,
-        solution: Fallible<Solution<I>>,
+        solution: V,
     ) -> DepthFirstNumber {
         let dfn = DepthFirstNumber {
             index: self.nodes.len(),
@@ -94,7 +98,7 @@ impl<I: Interner> SearchGraph<I> {
     /// Removes all nodes with a depth-first-number greater than or
     /// equal to `dfn`, adding their final solutions into the cache.
     #[instrument(level = "debug", skip(self, cache))]
-    pub(crate) fn move_to_cache(&mut self, dfn: DepthFirstNumber, cache: &Cache<I>) {
+    pub(crate) fn move_to_cache(&mut self, dfn: DepthFirstNumber, cache: &Cache<K, V>) {
         self.indices.retain(|_key, value| *value < dfn);
         for node in self.nodes.drain(dfn.index..) {
             assert!(node.stack_depth.is_none());
@@ -105,16 +109,24 @@ impl<I: Interner> SearchGraph<I> {
     }
 }
 
-impl<I: Interner> Index<DepthFirstNumber> for SearchGraph<I> {
-    type Output = Node<I>;
+impl<K, V> Index<DepthFirstNumber> for SearchGraph<K, V>
+where
+    K: Hash + Eq + Debug + Clone,
+    V: Debug + Clone,
+{
+    type Output = Node<K, V>;
 
-    fn index(&self, table_index: DepthFirstNumber) -> &Node<I> {
+    fn index(&self, table_index: DepthFirstNumber) -> &Node<K, V> {
         &self.nodes[table_index.index]
     }
 }
 
-impl<I: Interner> IndexMut<DepthFirstNumber> for SearchGraph<I> {
-    fn index_mut(&mut self, table_index: DepthFirstNumber) -> &mut Node<I> {
+impl<K, V> IndexMut<DepthFirstNumber> for SearchGraph<K, V>
+where
+    K: Hash + Eq + Debug + Clone,
+    V: Debug + Clone,
+{
+    fn index_mut(&mut self, table_index: DepthFirstNumber) -> &mut Node<K, V> {
         &mut self.nodes[table_index.index]
     }
 }