1 files changed, 196 insertions, 0 deletions

diff --git a/crates/libanalysis/src/db/mod.rs b/crates/libanalysis/src/db/mod.rs
new file mode 100644
index 000000000..f68aab61c
--- /dev/null
+++ b/crates/libanalysis/src/db/mod.rs
@@ -0,0 +1,196 @@
+mod queries;
+
+use std::{
+    hash::{Hash},
+    sync::Arc,
+    fmt::Debug,
+    any::Any,
+    iter,
+};
+use im;
+use salsa;
+use {
+    FileId,
+    imp::{FileResolverImp},
+};
+
+
+#[derive(Clone, Default)]
+pub(crate) struct State {
+    pub(crate) resolver: FileResolverImp,
+    pub(crate) file_map: im::HashMap<FileId, Arc<str>>,
+}
+
+type Data = Arc<Any + Send + Sync + 'static>;
+
+pub(crate) struct QueryCtx<'a> {
+    inner: &'a salsa::QueryCtx<State, Data>
+}
+
+pub(crate) struct Db {
+    inner: salsa::Db<State, Data>
+}
+
+struct GroundQuery<T, R> {
+    id: u16,
+    f: fn(&State, &T) -> R,
+    h: fn(&R) -> u64,
+}
+
+pub(crate) struct Query<T, R> {
+    pub(crate) id: u16,
+    pub(crate) f: fn(QueryCtx, &T) -> R,
+}
+
+impl Db {
+    pub(crate) fn new(state: State) -> Db {
+        Db { inner: salsa::Db::new(query_config(), state) }
+    }
+    pub(crate) fn state(&self) -> &State {
+        self.inner.ground_data()
+    }
+    pub(crate) fn with_state(
+        &self,
+        new_state: State,
+        updated_files: &[FileId],
+        file_set_changed: bool,
+    ) -> Db {
+        let mut inv = salsa::Invalidations::new();
+        if file_set_changed {
+            inv.invalidate(
+                salsa::QueryTypeId(queries::FILE_SET.id),
+                iter::once(salsa::InputFingerprint(hash(&()))),
+            );
+        } else {
+            inv.invalidate(
+                salsa::QueryTypeId(queries::FILE_SET.id),
+                iter::empty(),
+            );
+        }
+        inv.invalidate(
+            salsa::QueryTypeId(queries::FILE_TEXT.id),
+            updated_files.iter().map(hash).map(salsa::InputFingerprint),
+        );
+        Db { inner: self.inner.with_ground_data(new_state, inv) }
+    }
+    pub(crate) fn get<T, R>(&self, q: Query<T, R>, params: T) -> (Arc<R>, Vec<u16>)
+    where
+        T: Hash + Send + Sync + 'static,
+        R: Send + Sync + 'static,
+    {
+        let query_id = salsa::QueryId(
+            salsa::QueryTypeId(q.id),
+            salsa::InputFingerprint(hash(&params)),
+        );
+        let params = Arc::new(params);
+        let (res, events) = self.inner.get(query_id, params);
+        let res = res.downcast().unwrap();
+        let events = events.into_iter().map(|it| it.0).collect();
+        (res, events)
+    }
+
+}
+
+impl<'a> QueryCtx<'a> {
+    fn get_g<T, R>(&self, q: GroundQuery<T, R>, params: T) -> Arc<R>
+    where
+        T: Hash + Send + Sync + 'static,
+        R: Send + Sync + 'static,
+     {
+        let query_id = salsa::QueryId(
+            salsa::QueryTypeId(q.id),
+            salsa::InputFingerprint(hash(&params)),
+        );
+        let res = self.inner.get(query_id, Arc::new(params));
+        res.downcast().unwrap()
+    }
+    pub(crate) fn get<T, R>(&self, q: Query<T, R>, params: T) -> Arc<R>
+    where
+        T: Hash + Send + Sync + 'static,
+        R: Send + Sync + 'static,
+     {
+        let query_id = salsa::QueryId(
+            salsa::QueryTypeId(q.id),
+            salsa::InputFingerprint(hash(&params)),
+        );
+        let res = self.inner.get(query_id, Arc::new(params));
+        res.downcast().unwrap()
+    }
+}
+
+fn query_config() -> salsa::QueryConfig<State, Data> {
+    let mut res = salsa::QueryConfig::new();
+    let queries: Vec<SalsaGroundQuery> = vec![
+        queries::FILE_TEXT.into(),
+        queries::FILE_SET.into(),
+    ];
+    for q in queries {
+        res = res.with_ground_query(q.query_type, q.f)
+    }
+    let queries: Vec<SalsaQuery> = vec![
+        queries::FILE_SYNTAX.into(),
+        ::module_map_db::MODULE_DESCR.into(),
+        ::module_map_db::RESOLVE_SUBMODULE.into(),
+        ::module_map_db::PARENT_MODULE.into(),
+    ];
+    for q in queries {
+        res = res.with_query(q.query_type, q.f);
+    }
+    res
+}
+
+struct SalsaGroundQuery {
+    query_type: salsa::QueryTypeId,
+    f: Box<Fn(&State, &Data) -> (Data, salsa::OutputFingerprint) + Send + Sync + 'static>,
+}
+
+impl<T, R> From<GroundQuery<T, R>> for SalsaGroundQuery
+where
+    T: Send + Sync + 'static,
+    R: Send + Sync + 'static,
+{
+    fn from(q: GroundQuery<T, R>) -> SalsaGroundQuery
+    {
+        SalsaGroundQuery {
+            query_type: salsa::QueryTypeId(q.id),
+            f: Box::new(move |state, data| {
+                let data: &T = data.downcast_ref().unwrap();
+                let res = (q.f)(state, data);
+                let h = (q.h)(&res);
+                (Arc::new(res), salsa::OutputFingerprint(h))
+            })
+        }
+    }
+}
+
+struct SalsaQuery {
+    query_type: salsa::QueryTypeId,
+    f: Box<Fn(&salsa::QueryCtx<State, Data>, &Data) -> (Data, salsa::OutputFingerprint) + Send + Sync + 'static>,
+}
+
+impl<T, R> From<Query<T, R>> for SalsaQuery
+where
+    T: Hash + Send + Sync + 'static,
+    R: Hash + Send + Sync + 'static,
+{
+    fn from(q: Query<T, R>) -> SalsaQuery
+    {
+        SalsaQuery {
+            query_type: salsa::QueryTypeId(q.id),
+            f: Box::new(move |ctx, data| {
+                let ctx = QueryCtx { inner: ctx };
+                let data: &T = data.downcast_ref().unwrap();
+                let res = (q.f)(ctx, data);
+                let h = hash(&res);
+                (Arc::new(res), salsa::OutputFingerprint(h))
+            })
+        }
+    }
+}
+
+fn hash<T: ::std::hash::Hash>(x: &T) -> u64 {
+    use std::hash::Hasher;
+    let mut hasher = ::std::collections::hash_map::DefaultHasher::new();
+    ::std::hash::Hash::hash(x, &mut hasher);
+    hasher.finish()
+}