Move is_coinductive call to recursive

Author: jackh726

chalk-solve/src/recursive.rs

@@ -10,7 +10,7 @@ use self::stack::{Stack, StackDepth};
 use crate::clauses::program_clauses_for_goal;
 use crate::infer::{InferenceTable, ParameterEnaVariableExt};
 use crate::solve::truncate;
-use crate::RustIrDatabase;
+use crate::{coinductive_goal::IsCoinductive, RustIrDatabase};
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::visit::Visit;
@@ -516,7 +516,8 @@ impl<'me, I: Interner> RecursiveSolver<I> for Solver<'me, I> {
         } else {
             // Otherwise, push the goal onto the stack and create a table.
             // The initial result for this table is error.
-            let depth = self.context.stack.push(self.program, &goal);
+            let coinductive_goal = goal.is_coinductive(self.program);
+            let depth = self.context.stack.push(coinductive_goal);
             let dfn = self.context.search_graph.insert(&goal, depth);
             let subgoal_minimums = self.solve_new_subgoal(goal, depth, dfn);
             self.context.search_graph[dfn].links = subgoal_minimums;

chalk-solve/src/recursive/fulfill.rs

@@ -1,5 +1,4 @@
-use super::lib::{Guidance, Solution};
-use crate::recursive::Minimums;
+use super::lib::{Guidance, Minimums, Solution};
 use chalk_ir::cast::Cast;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};

chalk-solve/src/recursive/search_graph.rs

@@ -3,8 +3,8 @@ use std::ops::Index;
 use std::ops::IndexMut;
 use std::usize;
 
+use super::lib::{Minimums, Solution, UCanonicalGoal};
 use super::stack::StackDepth;
-use super::{Minimums, UCanonicalGoal, Solution};
 use chalk_ir::debug;
 use chalk_ir::{interner::Interner, ClausePriority, Fallible, NoSolution};
 use rustc_hash::FxHashMap;

chalk-solve/src/recursive/stack.rs

@@ -1,6 +1,3 @@
-use super::UCanonicalGoal;
-use crate::{coinductive_goal::IsCoinductive, RustIrDatabase};
-use chalk_ir::interner::Interner;
 use std::mem;
 use std::ops::Index;
 use std::ops::IndexMut;
@@ -42,11 +39,7 @@ impl Stack {
         self.entries.is_empty()
     }
 
-    pub(crate) fn push<I: Interner>(
-        &mut self,
-        program: &dyn RustIrDatabase<I>,
-        goal: &UCanonicalGoal<I>,
-    ) -> StackDepth {
+    pub(crate) fn push(&mut self, coinductive_goal: bool) -> StackDepth {
         let depth = StackDepth {
             depth: self.entries.len(),
         };
@@ -58,7 +51,6 @@ impl Stack {
             panic!("overflow depth reached")
         }
 
-        let coinductive_goal = goal.is_coinductive(program);
         self.entries.push(StackEntry {
             coinductive_goal,
             cycle: false,