collect fixed-point iteration code into fixed-point module

Author: nikomatsakis

chalk-recursive/src/fixed_point.rs

@@ -1,13 +1,16 @@
-use crate::cache::Cache;
-use crate::search_graph::DepthFirstNumber;
-use crate::search_graph::SearchGraph;
-use crate::stack::{Stack, StackDepth};
-use crate::Minimums;
 use std::fmt::Debug;
 use std::hash::Hash;
 use tracing::debug;
 use tracing::{info, instrument};
 
+mod cache;
+mod search_graph;
+mod stack;
+
+pub use cache::Cache;
+use search_graph::{DepthFirstNumber, SearchGraph};
+use stack::{Stack, StackDepth};
+
 pub(super) struct RecursiveContext<K, V>
 where
     K: Hash + Eq + Debug + Clone,
@@ -45,6 +48,25 @@ where
     fn error_value(self) -> V;
 }
 
+/// The `minimums` struct is used while solving to track whether we encountered
+/// any cycles in the process.
+#[derive(Copy, Clone, Debug)]
+pub(super) struct Minimums {
+    positive: DepthFirstNumber,
+}
+
+impl Minimums {
+    pub fn new() -> Self {
+        Minimums {
+            positive: DepthFirstNumber::MAX,
+        }
+    }
+
+    pub fn update_from(&mut self, minimums: Minimums) {
+        self.positive = ::std::cmp::min(self.positive, minimums.positive);
+    }
+}
+
 impl<K, V> RecursiveContext<K, V>
 where
     K: Hash + Eq + Debug + Clone,

chalk-recursive/src/cache.rs renamed to chalk-recursive/src/fixed_point/cache.rs

@@ -1,5 +1,5 @@
 use super::stack::StackDepth;
-use crate::{Cache, Minimums};
+use super::{Cache, Minimums};
 use rustc_hash::FxHashMap;
 use std::fmt::Debug;
 use std::hash::Hash;

chalk-recursive/src/search_graph.rs renamed to chalk-recursive/src/fixed_point/search_graph.rs

@@ -3,19 +3,19 @@ use std::ops::Index;
 use std::ops::IndexMut;
 use std::usize;
 
-pub(crate) struct Stack {
+pub(super) struct Stack {
     // program: Arc<ProgramEnvironment>,
     entries: Vec<StackEntry>,
     overflow_depth: usize,
 }
 
 #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub(crate) struct StackDepth {
+pub(super) struct StackDepth {
     depth: usize,
 }
 
 /// The data we actively keep for each goal on the stack.
-pub(crate) struct StackEntry {
+pub(super) struct StackEntry {
     /// Was this a coinductive goal?
     coinductive_goal: bool,
 
@@ -24,7 +24,7 @@ pub(crate) struct StackEntry {
 }
 
 impl Stack {
-    pub(crate) fn new(
+    pub(super) fn new(
         // program: &Arc<ProgramEnvironment>,
         overflow_depth: usize,
     ) -> Self {
@@ -35,11 +35,11 @@ impl Stack {
         }
     }
 
-    pub(crate) fn is_empty(&self) -> bool {
+    pub(super) fn is_empty(&self) -> bool {
         self.entries.is_empty()
     }
 
-    pub(crate) fn push(&mut self, coinductive_goal: bool) -> StackDepth {
+    pub(super) fn push(&mut self, coinductive_goal: bool) -> StackDepth {
         let depth = StackDepth {
             depth: self.entries.len(),
         };
@@ -58,7 +58,7 @@ impl Stack {
         depth
     }
 
-    pub(crate) fn pop(&mut self, depth: StackDepth) {
+    pub(super) fn pop(&mut self, depth: StackDepth) {
         assert_eq!(
             depth.depth + 1,
             self.entries.len(),
@@ -70,7 +70,7 @@ impl Stack {
     /// True iff there exist at least one coinductive goal
     /// and one inductive goal each from the top of the stack
     /// down to (and including) the given depth.
-    pub(crate) fn mixed_inductive_coinductive_cycle_from(&self, depth: StackDepth) -> bool {
+    pub(super) fn mixed_inductive_coinductive_cycle_from(&self, depth: StackDepth) -> bool {
         let coinductive_count = self.entries[depth.depth..]
             .iter()
             .filter(|entry| entry.coinductive_goal)
@@ -83,11 +83,11 @@ impl Stack {
 }
 
 impl StackEntry {
-    pub(crate) fn flag_cycle(&mut self) {
+    pub(super) fn flag_cycle(&mut self) {
         self.cycle = true;
     }
 
-    pub(crate) fn read_and_reset_cycle_flag(&mut self) -> bool {
+    pub(super) fn read_and_reset_cycle_flag(&mut self) -> bool {
         mem::replace(&mut self.cycle, false)
     }
 }

chalk-recursive/src/stack.rs renamed to chalk-recursive/src/fixed_point/stack.rs

@@ -1,5 +1,5 @@
+use crate::fixed_point::Minimums;
 use crate::solve::SolveDatabase;
-use crate::Minimums;
 use chalk_ir::cast::Cast;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};

chalk-recursive/src/fulfill.rs

@@ -1,35 +1,12 @@
-use crate::search_graph::DepthFirstNumber;
 use chalk_ir::{Goal, InEnvironment, UCanonical};
 
 pub type UCanonicalGoal<I> = UCanonical<InEnvironment<Goal<I>>>;
 
-mod cache;
 mod combine;
 mod fixed_point;
 mod fulfill;
 mod recursive;
-mod search_graph;
 pub mod solve;
-mod stack;
 
-pub use cache::Cache;
+pub use fixed_point::Cache;
 pub use recursive::RecursiveSolver;
-
-/// The `minimums` struct is used while solving to track whether we encountered
-/// any cycles in the process.
-#[derive(Copy, Clone, Debug)]
-pub(crate) struct Minimums {
-    pub(crate) positive: DepthFirstNumber,
-}
-
-impl Minimums {
-    pub fn new() -> Self {
-        Minimums {
-            positive: DepthFirstNumber::MAX,
-        }
-    }
-
-    pub fn update_from(&mut self, minimums: Minimums) {
-        self.positive = ::std::cmp::min(self.positive, minimums.positive);
-    }
-}

chalk-recursive/src/lib.rs

@@ -1,7 +1,6 @@
-use super::fixed_point::{RecursiveContext, SolverStuff};
-use crate::cache::Cache;
+use crate::fixed_point::{Cache, Minimums, RecursiveContext, SolverStuff};
 use crate::solve::{SolveDatabase, SolveIteration};
-use crate::{Minimums, UCanonicalGoal};
+use crate::UCanonicalGoal;
 use chalk_ir::{interner::Interner, NoSolution};
 use chalk_ir::{Canonical, ConstrainedSubst, Goal, InEnvironment, UCanonical};
 use chalk_ir::{Constraints, Fallible};

chalk-recursive/src/recursive.rs

@@ -1,6 +1,7 @@
 use super::combine;
 use super::fulfill::Fulfill;
-use crate::{Minimums, UCanonicalGoal};
+use crate::fixed_point::Minimums;
+use crate::UCanonicalGoal;
 use chalk_ir::could_match::CouldMatch;
 use chalk_ir::fold::Fold;
 use chalk_ir::interner::{HasInterner, Interner};