Add cargo features to enable SLG or recursive solvers

Enabling one but not the other avoids compiling an unnecessary solver.

Author: AzureMarker

chalk-ir/Cargo.toml

@@ -12,4 +12,9 @@ edition = "2018"
 [dependencies]
 chalk-engine-base = { version = "0.10.1-dev", path = "../chalk-engine-base" }
 chalk-derive = { version = "0.10.1-dev", path = "../chalk-derive" }
-chalk-engine = { version = "0.10.1-dev", path = "../chalk-engine" }
+chalk-engine = { version = "0.10.1-dev", path = "../chalk-engine", optional = true }
+
+[features]
+default = ["slg-solver"]
+
+slg-solver = ["chalk-engine"]

chalk-ir/src/fold/boring_impls.rs

@@ -6,11 +6,12 @@
 
 use crate::interner::TargetInterner;
 use crate::*;
-use chalk_engine::context::Context;
-use chalk_engine::{ExClause, FlounderedSubgoal, Literal};
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+#[cfg(feature = "slg-solver")]
+use chalk_engine::{context::Context, ExClause, FlounderedSubgoal, Literal};
+
 impl<'a, T: Fold<I, TI>, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for &'a T {
     type Result = T::Result;
     fn fold_with<'i>(
@@ -240,8 +241,6 @@ copy_fold!(usize);
 copy_fold!(PlaceholderIndex);
 copy_fold!(QuantifierKind);
 copy_fold!(DebruijnIndex);
-copy_fold!(chalk_engine::TableIndex);
-copy_fold!(chalk_engine::TimeStamp);
 copy_fold!(());
 copy_fold!(UintTy);
 copy_fold!(IntTy);
@@ -250,6 +249,11 @@ copy_fold!(Scalar);
 copy_fold!(ClausePriority);
 copy_fold!(Mutability);
 
+#[cfg(feature = "slg-solver")]
+copy_fold!(chalk_engine::TableIndex);
+#[cfg(feature = "slg-solver")]
+copy_fold!(chalk_engine::TimeStamp);
+
 #[macro_export]
 macro_rules! id_fold {
     ($t:ident) => {
@@ -337,6 +341,7 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for ExClause<C>
 where
     C: Context,
@@ -377,6 +382,7 @@ where
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for FlounderedSubgoal<C>
 where
     C: Context,
@@ -407,6 +413,7 @@ where
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Literal<C>
 where
     C: Context,

chalk-ir/src/interner.rs

@@ -29,13 +29,14 @@ use crate::TyData;
 use crate::VariableKind;
 use crate::VariableKinds;
 use crate::{Const, ConstData};
-use chalk_engine::context::Context;
-use chalk_engine::ExClause;
 use std::fmt::{self, Debug};
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+#[cfg(feature = "slg-solver")]
+use chalk_engine::{context::Context, ExClause};
+
 /// A "interner" encapsulates the concrete representation of
 /// certain "core types" from chalk-ir. All the types in chalk-ir are
 /// parameterized by a `I: Interner`, and so (e.g.) if they want to
@@ -755,6 +756,7 @@ impl<'a, T: HasInterner> HasInterner for std::slice::Iter<'a, T> {
     type Interner = T::Interner;
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: HasInterner + Context> HasInterner for ExClause<C> {
     type Interner = <C as HasInterner>::Interner;
 }

chalk-ir/src/visit/boring_impls.rs

@@ -10,9 +10,11 @@ use crate::{
     ProgramClauses, QuantifiedWhereClauses, QuantifierKind, Scalar, Substitution, SuperVisit,
     TraitId, UintTy, UniverseIndex, Visit, VisitResult, Visitor,
 };
-use chalk_engine::{context::Context, ExClause, FlounderedSubgoal, Literal};
 use std::{marker::PhantomData, sync::Arc};
 
+#[cfg(feature = "slg-solver")]
+use chalk_engine::{context::Context, ExClause, FlounderedSubgoal, Literal};
+
 /// Convenience function to visit all the items in the iterator it.
 pub fn visit_iter<'i, T, I, R>(
     it: impl Iterator<Item = T>,
@@ -203,8 +205,6 @@ const_visit!(usize);
 const_visit!(PlaceholderIndex);
 const_visit!(QuantifierKind);
 const_visit!(DebruijnIndex);
-const_visit!(chalk_engine::TableIndex);
-const_visit!(chalk_engine::TimeStamp);
 const_visit!(ClausePriority);
 const_visit!(());
 const_visit!(Scalar);
@@ -213,6 +213,11 @@ const_visit!(IntTy);
 const_visit!(FloatTy);
 const_visit!(Mutability);
 
+#[cfg(feature = "slg-solver")]
+const_visit!(chalk_engine::TableIndex);
+#[cfg(feature = "slg-solver")]
+const_visit!(chalk_engine::TimeStamp);
+
 #[macro_export]
 macro_rules! id_visit {
     ($t:ident) => {
@@ -299,6 +304,7 @@ impl<I: Interner> Visit<I> for PhantomData<I> {
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner> Visit<I> for ExClause<C>
 where
     C: Context,
@@ -336,6 +342,7 @@ where
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner> Visit<I> for FlounderedSubgoal<C>
 where
     C: Context,
@@ -363,6 +370,7 @@ where
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl<C: Context, I: Interner> Visit<I> for Literal<C>
 where
     C: Context,

chalk-solve/Cargo.toml

@@ -17,8 +17,14 @@ rustc-hash = { version = "1.0.0" }
 
 chalk-engine-base = { version = "0.10.1-dev", path = "../chalk-engine-base" }
 chalk-derive = { version = "0.10.1-dev", path = "../chalk-derive" }
-chalk-engine = { version = "0.10.1-dev", path = "../chalk-engine" }
-chalk-ir = { version = "0.10.1-dev", path = "../chalk-ir" }
+chalk-engine = { version = "0.10.1-dev", path = "../chalk-engine", optional = true }
+chalk-ir = { version = "0.10.1-dev", path = "../chalk-ir", default-features = false }
 
 [dev-dependencies]
 chalk-integration = { version = "0.10.1-dev", path = "../chalk-integration" }
+
+[features]
+default = ["slg-solver", "recursive-solver"]
+
+slg-solver = ["chalk-engine", "chalk-ir/slg-solver"]
+recursive-solver = []

chalk-solve/src/lib.rs

@@ -19,6 +19,7 @@ mod coinductive_goal;
 pub mod ext;
 pub mod goal_builder;
 mod infer;
+#[cfg(feature = "recursive-solver")]
 pub mod recursive;
 pub mod rust_ir;
 mod solve;

chalk-solve/src/solve.rs

@@ -1,10 +1,18 @@
-use crate::solve::slg::SlgContext;
-use crate::{recursive::RecursiveContext, RustIrDatabase};
-use chalk_engine::forest::{Forest, SubstitutionResult};
+use crate::RustIrDatabase;
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use std::fmt;
 
+#[cfg(feature = "slg-solver")]
+use {
+    crate::solve::slg::SlgContext,
+    chalk_engine::forest::{Forest, SubstitutionResult},
+};
+
+#[cfg(feature = "recursive-solver")]
+use crate::recursive::RecursiveContext;
+
+#[cfg(feature = "slg-solver")]
 mod slg;
 pub(crate) mod truncate;
 
@@ -179,11 +187,13 @@ impl<'a, I: Interner> fmt::Display for SolutionDisplay<'a, I> {
 #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub enum SolverChoice {
     /// Run the SLG solver, producing a Solution.
+    #[cfg(feature = "slg-solver")]
     SLG {
         max_size: usize,
         expected_answers: Option<usize>,
     },
     /// Run the recursive solver.
+    #[cfg(feature = "recursive-solver")]
     Recursive {
         overflow_depth: usize,
         caching_enabled: bool,
@@ -192,6 +202,7 @@ pub enum SolverChoice {
 
 impl SolverChoice {
     /// Returns specific SLG parameters.
+    #[cfg(feature = "slg-solver")]
     pub fn slg(max_size: usize, expected_answers: Option<usize>) -> Self {
         SolverChoice::SLG {
             max_size,
@@ -200,11 +211,13 @@ impl SolverChoice {
     }
 
     /// Returns the default SLG parameters.
+    #[cfg(feature = "slg-solver")]
     pub fn slg_default() -> Self {
         SolverChoice::slg(10, None)
     }
 
     /// Returns the default recursive solver setup.
+    #[cfg(feature = "recursive-solver")]
     pub fn recursive() -> Self {
         SolverChoice::Recursive {
             overflow_depth: 100,
@@ -215,12 +228,14 @@ impl SolverChoice {
     /// Creates a solver state.
     pub fn into_solver<I: Interner>(self) -> Solver<I> {
         match self {
+            #[cfg(feature = "slg-solver")]
             SolverChoice::SLG {
                 max_size,
                 expected_answers,
             } => Solver(SolverImpl::Slg {
                 forest: Box::new(Forest::new(SlgContext::new(max_size, expected_answers))),
             }),
+            #[cfg(feature = "recursive-solver")]
             SolverChoice::Recursive {
                 overflow_depth,
                 caching_enabled,
@@ -232,10 +247,17 @@ impl SolverChoice {
     }
 }
 
+#[cfg(feature = "slg-solver")]
 impl Default for SolverChoice {
     fn default() -> Self {
-        // SolverChoice::recursive()
-        SolverChoice::slg(10, None)
+        SolverChoice::slg_default()
+    }
+}
+
+#[cfg(all(not(feature = "slg-solver"), feature = "recursive-solver"))]
+impl Default for SolverChoice {
+    fn default() -> Self {
+        SolverChoice::recursive()
     }
 }
 
@@ -246,7 +268,9 @@ impl Default for SolverChoice {
 pub struct Solver<I: Interner>(SolverImpl<I>);
 
 enum SolverImpl<I: Interner> {
+    #[cfg(feature = "slg-solver")]
     Slg { forest: Box<Forest<SlgContext<I>>> },
+    #[cfg(feature = "recursive-solver")]
     Recursive(Box<RecursiveContext<I>>),
 }
 
@@ -275,10 +299,12 @@ impl<I: Interner> Solver<I> {
         goal: &UCanonical<InEnvironment<Goal<I>>>,
     ) -> Option<Solution<I>> {
         match &mut self.0 {
+            #[cfg(feature = "slg-solver")]
             SolverImpl::Slg { forest } => {
                 let ops = forest.context().ops(program);
                 forest.solve(&ops, goal, || true)
             }
+            #[cfg(feature = "recursive-solver")]
             SolverImpl::Recursive(ctx) => ctx.solver(program).solve_root_goal(goal).ok(),
         }
     }
@@ -312,10 +338,12 @@ impl<I: Interner> Solver<I> {
         should_continue: impl std::ops::Fn() -> bool,
     ) -> Option<Solution<I>> {
         match &mut self.0 {
+            #[cfg(feature = "slg-solver")]
             SolverImpl::Slg { forest } => {
                 let ops = forest.context().ops(program);
                 forest.solve(&ops, goal, should_continue)
             }
+            #[cfg(feature = "recursive-solver")]
             SolverImpl::Recursive(ctx) => {
                 // TODO support should_continue in recursive solver
                 ctx.solver(program).solve_root_goal(goal).ok()
@@ -345,6 +373,7 @@ impl<I: Interner> Solver<I> {
     ///
     /// - `true` all solutions were processed with the function.
     /// - `false` the function returned `false` and solutions were interrupted.
+    #[cfg(feature = "slg-solver")]
     pub fn solve_multiple(
         &mut self,
         program: &dyn RustIrDatabase<I>,
@@ -356,6 +385,7 @@ impl<I: Interner> Solver<I> {
                 let ops = forest.context().ops(program);
                 forest.solve_multiple(&ops, goal, f)
             }
+            #[cfg(feature = "recursive-solver")]
             SolverImpl::Recursive(_ctx) => unimplemented!(),
         }
     }