Merge pull request #152 from leodasvacas/a-bit-more-privacy

Give the chalk solver more privacy

Author: nikomatsakis

src/ir/lowering/test.rs

@@ -161,7 +161,7 @@ fn goal_quantifiers() {
     let program = Arc::new(
         parse_and_lower_program(
             "trait Foo<A, B> { }",
-            SolverChoice::slg()
+            SolverChoice::default()
         ).unwrap()
     );
     let goal = parse_and_lower_goal(
@@ -193,7 +193,7 @@ fn atc_accounting() {
 
             struct Iter<'a, T> { }
             ",
-            SolverChoice::slg()
+            SolverChoice::default()
         ).unwrap(),
     );
     tls::set_current_program(&program, || {

src/solve.rs

@@ -88,17 +88,17 @@ impl SolverChoice {
         env: &Arc<ProgramEnvironment>,
         canonical_goal: &UCanonical<InEnvironment<Goal>>,
     ) -> ::errors::Result<Option<Solution>> {
-        use self::slg::implementation::SlgContext;
+        use self::slg::implementation::solve_goal_in_program;
 
         match self {
             SolverChoice::SLG { max_size } => {
-                Ok(SlgContext::new(env, max_size).solve_root_goal(&canonical_goal))
+                Ok(solve_goal_in_program(canonical_goal, env, max_size))
             }
         }
     }
 
     /// Returns the default SLG parameters.
-    pub fn slg() -> Self {
+    fn slg() -> Self {
         SolverChoice::SLG { max_size: 10 }
     }
 }

src/solve/infer.rs

@@ -16,8 +16,7 @@ mod test;
 use self::var::*;
 
 #[derive(Clone)]
-pub struct InferenceTable {
-    // FIXME pub b/c of trait impl for SLG
+crate struct InferenceTable {
     unify: ena::UnificationTable<InferenceVariable>,
     vars: Vec<InferenceVariable>,
     max_universe: UniverseIndex,
@@ -29,7 +28,7 @@ crate struct InferenceSnapshot {
     vars: Vec<InferenceVariable>,
 }
 
-crate type ParameterInferenceVariable = ParameterKind<InferenceVariable>;
+pub(in solve) type ParameterInferenceVariable = ParameterKind<InferenceVariable>;
 
 impl InferenceTable {
     /// Create an empty inference table with no variables.
@@ -101,7 +100,7 @@ impl InferenceTable {
     /// Creates a new inference variable and returns its index. The
     /// kind of the variable should be known by the caller, but is not
     /// tracked directly by the inference table.
-    crate fn new_variable(&mut self, ui: UniverseIndex) -> InferenceVariable {
+    pub(in solve) fn new_variable(&mut self, ui: UniverseIndex) -> InferenceVariable {
         let var = self.unify.new_key(InferenceValue::Unbound(ui));
         self.vars.push(var);
         debug!("new_variable: var={:?} ui={:?}", var, ui);

src/solve/infer/canonicalize.rs

@@ -53,11 +53,11 @@ crate struct Canonicalized<T> {
     crate quantified: Canonical<T>,
 
     /// The free existential variables, along with the universes they inhabit.
-    crate free_vars: Vec<ParameterInferenceVariable>,
+    pub(in solve) free_vars: Vec<ParameterInferenceVariable>,
 
     /// The maximum universe of any universally quantified variables
     /// encountered.
-    crate max_universe: UniverseIndex,
+    max_universe: UniverseIndex,
 }
 
 struct Canonicalizer<'q> {

src/solve/infer/invert.rs

@@ -76,8 +76,8 @@ impl InferenceTable {
     {
         let Canonicalized {
             free_vars,
-            max_universe: _,
             quantified,
+            ..
         } = self.canonicalize(&value);
 
         // If the original contains free existential variables, give up.

src/solve/infer/ucanonicalize.rs

@@ -57,7 +57,7 @@ crate struct UCanonicalized<T> {
     crate quantified: UCanonical<T>,
 
     /// A map between the universes in `quantified` and the original universes
-    crate universes: UniverseMap,
+    pub(in solve) universes: UniverseMap,
 }
 
 /// Maps the universes found in the `u_canonicalize` result (the
@@ -66,7 +66,7 @@ crate struct UCanonicalized<T> {
 /// outside this module -- converts from "canonical" universes to the
 /// original (but see the `UMapToCanonical` folder).
 #[derive(Clone, Debug)]
-pub struct UniverseMap { // FIXME pub b/c of trait impl for SLG
+pub(in solve) struct UniverseMap {
     /// A reverse map -- for each universe Ux that appears in
     /// `quantified`, the corresponding universe in the original was
     /// `universes[x]`.

src/solve/infer/unify.rs

@@ -45,7 +45,7 @@ struct Unifier<'t> {
 }
 
 #[derive(Debug)]
-pub struct UnificationResult { // FIXME pub b/c of trait impl for SLG
+crate struct UnificationResult {
     crate goals: Vec<InEnvironment<DomainGoal>>,
     crate constraints: Vec<InEnvironment<Constraint>>,
 }

src/solve/infer/var.rs

@@ -31,7 +31,7 @@ use std::u32;
 ///     "downcast" the resulting variable using
 ///     e.g. `value.ty().unwrap()`.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct InferenceVariable { // FIXME pub b/c of trait impl for SLG
+pub(in solve) struct InferenceVariable {
     index: u32,
 }
 
@@ -85,7 +85,7 @@ impl UnifyKey for InferenceVariable {
 /// universe index; when the inference variable is assigned a value, it becomes
 /// bound and records that value. See `InferenceVariable` for more details.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum InferenceValue { // FIXME pub b/c of trait impl for SLG
+pub(in solve) enum InferenceValue {
     Unbound(UniverseIndex),
     Bound(Parameter),
 }

src/solve/slg/implementation.rs

@@ -19,13 +19,19 @@ use std::sync::Arc;
 mod aggregate;
 mod resolvent;
 
+/// Entry point for the chalk solver implementation.
+/// Solve a canonical goal `root_goal` in the given `program` environment.
+pub fn solve_goal_in_program(root_goal: &UCanonical<InEnvironment<Goal>>, program: &Arc<ProgramEnvironment>, max_size: usize) -> Option<Solution> {
+    Forest::new(SlgContext::new(program, max_size)).solve(root_goal)
+}
+
 #[derive(Clone, Debug)]
-pub struct SlgContext {
+pub(super) struct SlgContext {
     program: Arc<ProgramEnvironment>,
     max_size: usize,
 }
 
-pub struct TruncatingInferenceTable {
+pub(super) struct TruncatingInferenceTable {
     program: Arc<ProgramEnvironment>,
     max_size: usize,
     infer: InferenceTable,
@@ -38,15 +44,6 @@ impl SlgContext {
             max_size,
         }
     }
-
-    /// Convenience fn for solving a root goal.
-    crate fn solve_root_goal(
-        self,
-        root_goal: &UCanonical<InEnvironment<Goal>>,
-    ) -> Option<Solution> {
-        let mut forest = Forest::new(self);
-        forest.solve(root_goal)
-    }
 }
 
 impl context::Context for SlgContext {

src/solve/slg/test.rs

@@ -28,7 +28,7 @@ fn solve_goal(program_text: &str, goals: Vec<(usize, usize, &str, &str)>) {
    let program = &Arc::new(
         parse_and_lower_program(
             &program_text[1..program_text.len() - 1],
-            SolverChoice::slg()
+            SolverChoice::default()
         ).unwrap()
     );
     let env = &Arc::new(program.environment());
@@ -55,7 +55,7 @@ fn solve_goal_fixed_num_answers(program_text: &str, goals: Vec<(usize, usize, &s
     let program = &Arc::new(
         parse_and_lower_program(
             &program_text[1..program_text.len() - 1],
-            SolverChoice::slg()
+            SolverChoice::default()
         ).unwrap()
     );
     let env = &Arc::new(program.environment());

src/solve/test.rs

@@ -47,7 +47,7 @@ macro_rules! test {
         test!(@program[$program]
               @parsed_goals[
                   $($parsed_goals)*
-                      (stringify!($goal), SolverChoice::slg(), $expected)
+                      (stringify!($goal), SolverChoice::default(), $expected)
               ]
               @unparsed_goals[$($unparsed_goals)*])
     };

src/test_util.rs

@@ -24,7 +24,7 @@ macro_rules! lowering_success {
         assert!(program_text.ends_with("}"));
         let result = parse_and_lower_program(
             &program_text[1..program_text.len()-1],
-            $crate::solve::SolverChoice::slg()
+            $crate::solve::SolverChoice::default()
         );
         if let Err(ref e) = result {
             println!("lowering error: {}", e);
@@ -42,7 +42,7 @@ macro_rules! lowering_error {
         assert!(program_text.ends_with("}"));
         let error = parse_and_lower_program(
             &program_text[1..program_text.len()-1],
-            $crate::solve::SolverChoice::slg()
+            $crate::solve::SolverChoice::default()
         ).unwrap_err();
         let expected = $crate::errors::Error::from($expected);
         assert_eq!(