Remove actual SlgContext creation

Author: jackh726

chalk-engine/src/context.rs

@@ -148,7 +148,7 @@ pub trait AggregateOps<I: Interner, C: Context<I>> {
     fn make_solution(
         &self,
         root_goal: &UCanonical<InEnvironment<Goal<I>>>,
-        answers: impl AnswerStream<I, C>,
+        answers: impl AnswerStream<I>,
         should_continue: impl Fn() -> bool,
     ) -> Option<C::Solution>;
 }
@@ -330,7 +330,7 @@ impl<I: Interner> Debug for AnswerResult<I> {
     }
 }
 
-pub trait AnswerStream<I: Interner, C: Context<I>> {
+pub trait AnswerStream<I: Interner> {
     /// Gets the next answer for a given goal, but doesn't increment the answer index.
     /// Calling this or `next_answer` again will give the same answer.
     fn peek_answer(&mut self, should_continue: impl Fn() -> bool) -> AnswerResult<I>;

chalk-engine/src/forest.rs

@@ -9,35 +9,25 @@ use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, ConstrainedSubst, Goal, InEnvironment, Substitution, UCanonical};
 
 pub struct Forest<I: Interner, C: Context<I>> {
-    context: C,
     pub(crate) tables: Tables<I>,
 
     /// This is a clock which always increases. It is
     /// incremented every time a new subgoal is followed.
     /// This effectively gives us way to track what depth
     /// and loop a table or strand was last followed.
     pub(crate) clock: TimeStamp,
+    _context: std::marker::PhantomData<C>,
 }
 
 impl<I: Interner, C: Context<I>> Forest<I, C> {
-    pub fn new(context: C) -> Self {
+    pub fn new() -> Self {
         Forest {
-            context,
             tables: Tables::new(),
             clock: TimeStamp::default(),
+            _context: std::marker::PhantomData,
         }
     }
 
-    /// Gives access to `self.context`. In fact, the SLG solver
-    /// doesn't ever use `self.context` for anything, and only cares
-    /// about the associated types and methods defined on it.  But the
-    /// creator of the forest can use the context field to store
-    /// configuration info (e.g., in chalk, we store the max size of a
-    /// term in here).
-    pub fn context(&self) -> &C {
-        &self.context
-    }
-
     // Gets the next clock TimeStamp. This will never decrease.
     pub(crate) fn increment_clock(&mut self) -> TimeStamp {
         self.clock.increment();
@@ -52,14 +42,15 @@ impl<I: Interner, C: Context<I>> Forest<I, C> {
         &'f mut self,
         context: &'f impl ContextOps<I, C>,
         goal: &UCanonical<InEnvironment<Goal<I>>>,
-    ) -> impl AnswerStream<I, C> + 'f {
+    ) -> impl AnswerStream<I> + 'f {
         let table = self.get_or_create_table_for_ucanonical_goal(context, goal.clone());
         let answer = AnswerIndex::ZERO;
         ForestSolver {
             forest: self,
             context,
             table,
             answer,
+            _context: std::marker::PhantomData::<C>,
         }
     }
 
@@ -148,9 +139,10 @@ struct ForestSolver<'me, I: Interner, C: Context<I>, CO: ContextOps<I, C>> {
     context: &'me CO,
     table: TableIndex,
     answer: AnswerIndex,
+    _context: std::marker::PhantomData<C>,
 }
 
-impl<'me, I: Interner, C: Context<I>, CO: ContextOps<I, C>> AnswerStream<I, C>
+impl<'me, I: Interner, C: Context<I>, CO: ContextOps<I, C>> AnswerStream<I>
     for ForestSolver<'me, I, C, CO>
 {
     /// # Panics

chalk-solve/src/solve.rs

@@ -5,7 +5,7 @@ use std::fmt;
 
 #[cfg(feature = "slg-solver")]
 use {
-    crate::solve::slg::SlgContext,
+    crate::solve::slg::{SlgContext, SlgContextOps},
     chalk_engine::forest::{Forest, SubstitutionResult},
 };
 
@@ -233,7 +233,9 @@ impl SolverChoice {
                 max_size,
                 expected_answers,
             } => Solver(SolverImpl::Slg {
-                forest: Box::new(Forest::new(SlgContext::new(max_size, expected_answers))),
+                forest: Box::new(Forest::new()),
+                max_size,
+                expected_answers,
             }),
             #[cfg(feature = "recursive-solver")]
             SolverChoice::Recursive {
@@ -271,6 +273,12 @@ enum SolverImpl<I: Interner> {
     #[cfg(feature = "slg-solver")]
     Slg {
         forest: Box<Forest<I, SlgContext<I>>>,
+        max_size: usize,
+        /// The expected number of answers for a solution.
+        /// Only really sseful for tests, since `make_solution`
+        /// will panic if the number of cached answers does not
+        /// equal this when a solution is made.
+        expected_answers: Option<usize>,
     },
     #[cfg(feature = "recursive-solver")]
     Recursive(Box<RecursiveContext<I>>),
@@ -302,8 +310,12 @@ impl<I: Interner> Solver<I> {
     ) -> Option<Solution<I>> {
         match &mut self.0 {
             #[cfg(feature = "slg-solver")]
-            SolverImpl::Slg { forest } => {
-                let ops = forest.context().ops(program);
+            SolverImpl::Slg {
+                forest,
+                max_size,
+                expected_answers,
+            } => {
+                let ops = SlgContextOps::new(program, *max_size, *expected_answers);
                 forest.solve(&ops, goal, || true)
             }
             #[cfg(feature = "recursive-solver")]
@@ -341,8 +353,12 @@ impl<I: Interner> Solver<I> {
     ) -> Option<Solution<I>> {
         match &mut self.0 {
             #[cfg(feature = "slg-solver")]
-            SolverImpl::Slg { forest } => {
-                let ops = forest.context().ops(program);
+            SolverImpl::Slg {
+                forest,
+                max_size,
+                expected_answers,
+            } => {
+                let ops = SlgContextOps::new(program, *max_size, *expected_answers);
                 forest.solve(&ops, goal, should_continue)
             }
             #[cfg(feature = "recursive-solver")]
@@ -383,8 +399,12 @@ impl<I: Interner> Solver<I> {
         f: impl FnMut(SubstitutionResult<Canonical<ConstrainedSubst<I>>>, bool) -> bool,
     ) -> bool {
         match &mut self.0 {
-            SolverImpl::Slg { forest } => {
-                let ops = forest.context().ops(program);
+            SolverImpl::Slg {
+                forest,
+                max_size,
+                expected_answers,
+            } => {
+                let ops = SlgContextOps::new(program, *max_size, *expected_answers);
                 forest.solve_multiple(&ops, goal, f)
             }
             #[cfg(feature = "recursive-solver")]

chalk-solve/src/solve/slg.rs

@@ -23,40 +23,30 @@ mod resolvent;
 
 #[derive(Clone, Debug, HasInterner)]
 pub(crate) struct SlgContext<I: Interner> {
-    max_size: usize,
-    /// The expected number of answers for a solution.
-    /// Only really sseful for tests, since `make_solution`
-    /// will panic if the number of cached answers does not
-    /// equal this when a solution is made.
-    expected_answers: Option<usize>,
     phantom: PhantomData<I>,
 }
 
-impl<I: Interner> SlgContext<I> {
-    pub(crate) fn new(max_size: usize, expected_answers: Option<usize>) -> SlgContext<I> {
-        SlgContext {
-            max_size,
-            expected_answers,
-            phantom: PhantomData,
-        }
-    }
-
-    pub(crate) fn ops<'p>(&self, program: &'p dyn RustIrDatabase<I>) -> SlgContextOps<'p, I> {
-        SlgContextOps {
-            program,
-            max_size: self.max_size,
-            expected_answers: self.expected_answers,
-        }
-    }
-}
-
 #[derive(Clone, Debug)]
 pub(crate) struct SlgContextOps<'me, I: Interner> {
     program: &'me dyn RustIrDatabase<I>,
     max_size: usize,
     expected_answers: Option<usize>,
 }
 
+impl<I: Interner> SlgContextOps<'_, I> {
+    pub(crate) fn new<'p>(
+        program: &'p dyn RustIrDatabase<I>,
+        max_size: usize,
+        expected_answers: Option<usize>,
+    ) -> SlgContextOps<'p, I> {
+        SlgContextOps {
+            program,
+            max_size,
+            expected_answers,
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct TruncatingInferenceTable<I: Interner> {
     max_size: usize,

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

@@ -18,7 +18,7 @@ impl<I: Interner> context::AggregateOps<I, SlgContext<I>> for SlgContextOps<'_,
     fn make_solution(
         &self,
         root_goal: &UCanonical<InEnvironment<Goal<I>>>,
-        mut answers: impl context::AnswerStream<I, SlgContext<I>>,
+        mut answers: impl context::AnswerStream<I>,
         should_continue: impl std::ops::Fn() -> bool,
     ) -> Option<Solution<I>> {
         let interner = self.program.interner();