Merge pull request #210 from nikomatsakis/salsa-0.10.0

move to salsa 0.10.0

Author: nikomatsakis

Cargo.lock

@@ -20,7 +20,7 @@ itertools = "0.7.8"
 lalrpop-intern = "0.15.1"
 petgraph = "0.4.13"
 rustyline = "1.0"
-salsa = "0.9.1"
+salsa = "0.10.0"
 serde = "1.0"
 serde_derive = "1.0"
 stacker = "0.1.5"

Cargo.toml

@@ -225,16 +225,45 @@ pub enum TypeSort {
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum Ty {
+    /// An "application" type is one that applies the set of type
+    /// arguments to some base type. For example, `Vec<u32>` would be
+    /// "applying" the parameters `[u32]` to the code type `Vec`.
+    /// This type is also used for base types like `u32` (which just apply
+    /// an empty list).
     Apply(ApplicationTy),
+
+    /// A "projection" type corresponds to an (unnormalized)
+    /// projection like `<P0 as Trait<P1..Pn>>::Foo`. Note that the
+    /// trait and all its parameters are fully known.
     Projection(ProjectionTy),
+
+    /// This is a variant of a projection in which the trait is
+    /// **not** known.  It corresponds to a case where people write
+    /// `T::Item` without specifying the trait. We would then try to
+    /// figure out the trait by looking at all the traits that are in
+    /// scope.
     UnselectedProjection(UnselectedProjectionTy),
+
+    /// A "higher-ranked" type. In the Rust surface syntax, this can
+    /// only be a funtion type (e.g., `for<'a> fn(&'a u32)`) or a dyn
+    /// type (e.g., `dyn for<'a> SomeTrait<&'a u32>`). However, in
+    /// Chalk's representation, we separate out the `for<'a>` part
+    /// from the underlying type, so technically we can represent
+    /// things like `for<'a> SomeStruct<'a>`, although that has no
+    /// meaning in Rust.
     ForAll(Box<QuantifiedTy>),
 
-    /// References the binding at the given depth (deBruijn index
-    /// style).
+    /// References the binding at the given depth. The index is a [de
+    /// Bruijn index], so it counts back through the in-scope biners,
+    /// with 0 being the innermost binder. This is used in impls and
+    /// the like. For example, if we had a rule like `for<T> { (T:
+    /// Clone) :- (T: Copy) }`, then `T` would be represented as a
+    /// `BoundVar(0)` (as the `for` is the innermost binder).
+    ///
+    /// [de Bruijn index]: https://en.wikipedia.org/wiki/De_Bruijn_index
     BoundVar(usize),
 
-    /// Inference variable.
+    /// Inference variable defined in the current inference context.
     InferenceVar(InferenceVar),
 }
 

chalk-ir/src/lib.rs

@@ -7,6 +7,7 @@ authors = ["Rust Compiler Team", "Chalk developers"]
 repository = "https://github.com/rust-lang/chalk"
 readme = "README.md"
 keywords = ["compiler", "traits", "prolog"]
+edition = "2018"
 
 [dependencies]
 lazy_static = "1.1.0"

chalk-macros/Cargo.toml

@@ -1,10 +1,11 @@
 #![allow(non_camel_case_types)]
 
-use crate::query::{self, ProgramSolverChoice, ProgramText};
+use crate::query::{Lowering, LoweringDatabase};
 use chalk_solve::solve::SolverChoice;
 use salsa::Database;
 use std::sync::Arc;
 
+#[salsa::database(Lowering)]
 #[derive(Default)]
 pub struct ChalkDatabase {
     runtime: salsa::Runtime<ChalkDatabase>,
@@ -24,22 +25,9 @@ impl ChalkDatabase {
     ) -> R {
         let mut db = ChalkDatabase::default();
 
-        db.query_mut(ProgramText).set((), program_text);
-        db.query_mut(ProgramSolverChoice).set((), solver_choice);
+        db.set_program_text(program_text);
+        db.set_solver_choice(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/db.rs

@@ -9,43 +9,28 @@ use chalk_ir::ProgramEnvironment;
 use chalk_solve::solve::SolverChoice;
 use std::sync::Arc;
 
-salsa::query_group! {
-    pub trait LoweringDatabase: salsa::Database {
-        fn program_text() -> Arc<String> {
-            type ProgramText;
-
-            storage input;
-        }
-
-        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;
-        }
-
-        /// The program as logic.
-        fn environment() -> Result<Arc<ProgramEnvironment>, String> {
-            type Environment;
-        }
-    }
+#[salsa::query_group(Lowering)]
+pub trait LoweringDatabase {
+    #[salsa::input]
+    fn program_text(&self) -> Arc<String>;
+
+    #[salsa::input]
+    fn solver_choice(&self) -> SolverChoice;
+
+    // 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(&self) -> Result<Arc<rust_ir::Program>, String>;
+
+    /// The lowered IR.
+    fn lowered_program(&self) -> Result<Arc<rust_ir::Program>, String>;
+
+    /// The lowered IR, with checks performed.
+    fn checked_program(&self) -> Result<Arc<rust_ir::Program>, String>;
+
+    /// The program as logic.
+    fn environment(&self) -> Result<Arc<ProgramEnvironment>, String>;
 }
 
 fn program_ir(db: &impl LoweringDatabase) -> Result<Arc<rust_ir::Program>, String> {