Merge pull request #202 from tmandry/finer-salsa

[WIP] Finer-grained salsa queries

Author: nikomatsakis

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

@@ -3,35 +3,38 @@
 extern crate test;
 use self::test::Bencher;
 
+use crate::db::ChalkDatabase;
+use crate::query::{ProgramSolverChoice, ProgramText};
+use chalk_solve::solve::SolverChoice;
 use ir;
 use ir::solve::SolverChoice;
 use std::sync::Arc;
 
-use super::{parse_and_lower_program,
-            parse_and_lower_goal,
-            assert_result};
+use super::{assert_result, parse_and_lower_goal, parse_and_lower_program};
 
 fn run_bench(
     program_text: &str,
     solver_choice: SolverChoice,
     goal_text: &str,
     bencher: &mut Bencher,
-    expected: &str
+    expected: &str,
 ) {
-    let program = Arc::new(parse_and_lower_program(program_text, solver_choice).unwrap());
-    let env = Arc::new(program.environment());
-    ir::tls::set_current_program(&program, || {
-        let goal = parse_and_lower_goal(&program, goal_text).unwrap();
-        let peeled_goal = goal.into_peeled_goal();
-
-        // Execute once to get an expected result.
-        let result = solver_choice.solve_root_goal(&env, &peeled_goal);
-
-        // Check expectation.
-        assert_result(&result, expected);
-
-        // Then do it many times to measure time.
-        bencher.iter(|| solver_choice.solve_root_goal(&env, &peeled_goal));
+    ChalkDatabase::with_program(Arc::new(program_text.to_string()), solver_choice, |db| {
+        let program = db.lowered_program().unwrap();
+        let env = db.environment().unwrap();
+        ir::tls::set_current_program(&program, || {
+            let goal = parse_and_lower_goal(&program, goal_text).unwrap();
+            let peeled_goal = goal.into_peeled_goal();
+
+            // Execute once to get an expected result.
+            let result = solver_choice.solve_root_goal(&env, &peeled_goal);
+
+            // Check expectation.
+            assert_result(&result, expected);
+
+            // Then do it many times to measure time.
+            bencher.iter(|| solver_choice.solve_root_goal(&env, &peeled_goal));
+        });
     });
 }
 
@@ -101,11 +104,9 @@ forall<T> {
 fn cycley_slg(b: &mut Bencher) {
     run_bench(
         CYCLEY,
-        SolverChoice::SLG {
-            max_size: 20,
-        },
+        SolverChoice::SLG { max_size: 20 },
         CYCLEY_GOAL,
         b,
-        "Unique"
+        "Unique",
     );
 }

chalk-solve/src/solve/test.rs

@@ -17,6 +17,8 @@ use std::io::Read;
 use std::process::exit;
 use std::sync::Arc;
 
+use chalk::db::ChalkDatabase;
+use chalk::query::LoweringDatabase;
 use chalk::rust_ir;
 use chalk::rust_ir::lowering::*;
 use chalk_engine::fallible::NoSolution;
@@ -74,9 +76,11 @@ impl Program {
     ///
     /// [`SolverChoice`]: struct.solve.SolverChoice.html
     fn new(text: String, solver_choice: SolverChoice) -> Result<Program> {
-        let ir = Arc::new(chalk_parse::parse_program(&text)?.lower(solver_choice)?);
-        let env = Arc::new(ir.environment());
-        Ok(Program { text, ir, env })
+        ChalkDatabase::with_program(Arc::new(text.clone()), solver_choice, |db| {
+            let ir = db.checked_program().unwrap();
+            let env = db.environment().unwrap();
+            Ok(Program { text, ir, env })
+        })
     }
 }
 

chalk-solve/src/solve/test/bench.rs

@@ -2,21 +2,23 @@ use petgraph::prelude::*;
 
 use crate::errors::Result;
 use crate::rust_ir::Program;
+use chalk_ir::ProgramEnvironment;
 use chalk_ir::{self, ItemId};
 use chalk_solve::solve::SolverChoice;
 use std::sync::Arc;
 
-mod orphan;
+crate mod orphan;
 mod solve;
 mod test;
 
 impl Program {
     crate fn record_specialization_priorities(
         &mut self,
+        env: Arc<ProgramEnvironment>,
         solver_choice: SolverChoice,
     ) -> Result<()> {
         chalk_ir::tls::set_current_program(&Arc::new(self.clone()), || {
-            let forest = self.build_specialization_forest(solver_choice)?;
+            let forest = self.build_specialization_forest(env, solver_choice)?;
 
             // Visit every root in the forest & set specialization
             // priority for the tree that is the root of.
@@ -31,6 +33,7 @@ impl Program {
     // Build the forest of specialization relationships.
     fn build_specialization_forest(
         &self,
+        env: Arc<ProgramEnvironment>,
         solver_choice: SolverChoice,
     ) -> Result<Graph<ItemId, ()>> {
         // The forest is returned as a graph but built as a GraphMap; this is
@@ -40,7 +43,7 @@ impl Program {
         // Find all specializations (implemented in coherence/solve)
         // Record them in the forest by adding an edge from the less special
         // to the more special.
-        self.visit_specializations(solver_choice, |less_special, more_special| {
+        self.visit_specializations(env, solver_choice, |less_special, more_special| {
             forest.add_edge(less_special, more_special, ());
         })?;
 

src/bin/chalki.rs

@@ -12,29 +12,28 @@ struct OrphanSolver {
     solver_choice: SolverChoice,
 }
 
-impl Program {
-    crate fn perform_orphan_check(&self, solver_choice: SolverChoice) -> Result<()> {
-        let solver = OrphanSolver {
-            env: Arc::new(self.environment()),
-            solver_choice,
-        };
+crate fn perform_orphan_check(
+    program: Arc<Program>,
+    env: Arc<ProgramEnvironment>,
+    solver_choice: SolverChoice,
+) -> Result<()> {
+    let solver = OrphanSolver { env, solver_choice };
 
-        let local_impls = self
-            .impl_data
-            .values()
-            // Only keep local impls (i.e. impls in the current crate)
-            .filter(|impl_datum| impl_datum.binders.value.impl_type == ImplType::Local);
+    let local_impls = program
+        .impl_data
+        .values()
+        // Only keep local impls (i.e. impls in the current crate)
+        .filter(|impl_datum| impl_datum.binders.value.impl_type == ImplType::Local);
 
-        for impl_datum in local_impls {
-            if !solver.orphan_check(impl_datum) {
-                let trait_id = impl_datum.binders.value.trait_ref.trait_ref().trait_id;
-                let trait_id = self.type_kinds.get(&trait_id).unwrap().name;
-                return Err(Error::from_kind(ErrorKind::FailedOrphanCheck(trait_id)));
-            }
+    for impl_datum in local_impls {
+        if !solver.orphan_check(impl_datum) {
+            let trait_id = impl_datum.binders.value.trait_ref.trait_ref().trait_id;
+            let trait_id = program.type_kinds.get(&trait_id).unwrap().name;
+            return Err(Error::from_kind(ErrorKind::FailedOrphanCheck(trait_id)));
         }
-
-        Ok(())
     }
+
+    Ok(())
 }
 
 impl OrphanSolver {

src/coherence.rs

@@ -17,16 +17,14 @@ struct DisjointSolver {
 impl Program {
     pub(super) fn visit_specializations<F>(
         &self,
+        env: Arc<ProgramEnvironment>,
         solver_choice: SolverChoice,
         mut record_specialization: F,
     ) -> Result<()>
     where
         F: FnMut(ItemId, ItemId),
     {
-        let mut solver = DisjointSolver {
-            env: Arc::new(self.environment()),
-            solver_choice,
-        };
+        let mut solver = DisjointSolver { env, solver_choice };
 
         // Create a vector of references to impl datums, sorted by trait ref.
         let impl_data = self

src/coherence/orphan.rs

@@ -1,21 +1,43 @@
-use crate::query;
+use crate::query::{self, ProgramSolverChoice, ProgramText};
+use chalk_solve::solve::SolverChoice;
+use salsa::Database;
+use std::sync::Arc;
 
 #[derive(Default)]
 pub struct ChalkDatabase {
     runtime: salsa::Runtime<ChalkDatabase>,
 }
 
-impl salsa::Database for ChalkDatabase {
+impl Database for ChalkDatabase {
     fn salsa_runtime(&self) -> &salsa::Runtime<ChalkDatabase> {
         &self.runtime
     }
 }
 
+impl ChalkDatabase {
+    pub fn with_program<F: FnOnce(&mut ChalkDatabase) -> R, R>(
+        program_text: Arc<String>,
+        solver_choice: SolverChoice,
+        f: F,
+    ) -> R {
+        let mut db = ChalkDatabase::default();
+
+        db.query_mut(ProgramText).set((), program_text);
+        db.query_mut(ProgramSolverChoice).set((), solver_choice);
+
+        f(&mut db)
+    }
+}
+
 salsa::database_storage! {
     pub struct DatabaseStorage for ChalkDatabase {
         impl query::LoweringDatabase {
             fn program_text() for query::ProgramText;
+            fn solver_choice() for query::ProgramSolverChoice;
+            fn program_ir() for query::ProgramIr;
             fn lowered_program() for query::LoweredProgram;
+            fn checked_program() for query::CheckedProgram;
+            fn environment() for query::Environment;
         }
     }
 }

src/coherence/solve.rs

@@ -30,7 +30,7 @@ crate mod coherence;
 pub mod errors;
 crate mod rules;
 
-mod db;
-mod query;
+pub mod db;
+pub mod query;
 
 mod test;

src/db.rs

@@ -1,8 +1,11 @@
 // https://crates.io/crates/salsa
 // hello world https://github.com/salsa-rs/salsa/blob/master/examples/hello_world/main.rs
 
+use crate::coherence::orphan;
+use crate::rules::wf;
 use crate::rust_ir;
 use crate::rust_ir::lowering::LowerProgram;
+use chalk_ir::ProgramEnvironment;
 use chalk_solve::solve::SolverChoice;
 use std::sync::Arc;
 
@@ -14,24 +17,71 @@ salsa::query_group! {
             storage input;
         }
 
-        // FIXME: Arc<Result<...>> is only needed because the error type is not clone
-        fn lowered_program(solver_choice: SolverChoice) -> Result<Arc<rust_ir::Program>, String> {
+        fn solver_choice() -> SolverChoice {
+            type ProgramSolverChoice;
+
+            storage input;
+        }
+
+        // FIXME: Result<..., String> is only needed because the error type is not clone
+
+        /// The program IR before recording specialization priorities.
+        /// Do not use this query directly.
+        fn program_ir() -> Result<Arc<rust_ir::Program>, String> {
+            type ProgramIr;
+        }
+
+        /// The lowered IR.
+        fn lowered_program() -> Result<Arc<rust_ir::Program>, String> {
             type LoweredProgram;
+        }
+
+        /// The lowered IR, with checks performed.
+        fn checked_program() -> Result<Arc<rust_ir::Program>, String> {
+            type CheckedProgram;
+        }
 
-            // FIXME: only volatile because the Error type does not implement Eq
-            storage volatile;
+        /// The program as logic.
+        fn environment() -> Result<Arc<ProgramEnvironment>, String> {
+            type Environment;
         }
     }
 }
 
-fn lowered_program(
-    db: &impl LoweringDatabase,
-    solver_choice: SolverChoice,
-) -> Result<Arc<rust_ir::Program>, String> {
+fn program_ir(db: &impl LoweringDatabase) -> Result<Arc<rust_ir::Program>, String> {
     let x: crate::errors::Result<_> = try {
         let text = db.program_text();
-        Arc::new(chalk_parse::parse_program(&text)?.lower(solver_choice)?)
+        Arc::new(chalk_parse::parse_program(&text)?.lower()?)
     };
 
     x.map_err(|err| err.to_string())
 }
+
+fn lowered_program(db: &impl LoweringDatabase) -> Result<Arc<rust_ir::Program>, String> {
+    let mut program = db.program_ir()?;
+    let env = db.environment()?;
+
+    let x: crate::errors::Result<_> = try {
+        Arc::make_mut(&mut program).record_specialization_priorities(env, db.solver_choice())?;
+        program
+    };
+
+    x.map_err(|err| err.to_string())
+}
+
+fn checked_program(db: &impl LoweringDatabase) -> Result<Arc<rust_ir::Program>, String> {
+    let program = db.lowered_program()?;
+    let env = db.environment()?;
+
+    let x: crate::errors::Result<_> = try {
+        orphan::perform_orphan_check(program.clone(), env.clone(), db.solver_choice())?;
+        wf::verify_well_formedness(program.clone(), env, db.solver_choice())?;
+        program
+    };
+    x.map_err(|err| err.to_string())
+}
+
+fn environment(db: &impl LoweringDatabase) -> Result<Arc<ProgramEnvironment>, String> {
+    let env = db.program_ir()?.environment();
+    Ok(Arc::new(env))
+}

src/lib.rs

@@ -6,7 +6,7 @@ use chalk_ir::*;
 use std::iter;
 
 mod default;
-mod wf;
+crate mod wf;
 
 impl Program {
     pub fn environment(&self) -> ProgramEnvironment {