1 files changed, 44 insertions, 120 deletions

diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 6b56f99ac..df2ef293d 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,171 +1,95 @@
 use std::sync::Arc;
-#[cfg(test)]
-use parking_lot::Mutex;
-use ra_editor::LineIndex;
-use ra_syntax::{SourceFileNode, SyntaxNode};
 use salsa::{self, Database};
+use ra_db::{LocationIntener, BaseDatabase};
+use hir::{self, DefId, DefLoc, FnId, SourceItemId};
 
 use crate::{
-    db,
-    descriptors::{
-        DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleTreeQuery,
-        SubmodulesQuery, ItemMapQuery, InputModuleItemsQuery,
-    },
-    symbol_index::SymbolIndex,
-    syntax_ptr::SyntaxPtr,
-    loc2id::{IdMaps, IdDatabase},
-    Cancelable, Canceled, FileId,
+    symbol_index,
 };
 
 #[derive(Debug)]
 pub(crate) struct RootDatabase {
-    #[cfg(test)]
-    events: Mutex<Option<Vec<salsa::Event<RootDatabase>>>>,
-    #[cfg(not(test))]
-    events: (),
-
     runtime: salsa::Runtime<RootDatabase>,
-    id_maps: IdMaps,
+    id_maps: Arc<IdMaps>,
+}
+
+#[derive(Debug, Default)]
+struct IdMaps {
+    fns: LocationIntener<SourceItemId, FnId>,
+    defs: LocationIntener<DefLoc, DefId>,
 }
 
 impl salsa::Database for RootDatabase {
     fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> {
         &self.runtime
     }
-
-    #[allow(unused)]
-    fn salsa_event(&self, event: impl Fn() -> salsa::Event<RootDatabase>) {
-        #[cfg(test)]
-        {
-            let mut events = self.events.lock();
-            if let Some(events) = &mut *events {
-                events.push(event());
-            }
-        }
-    }
 }
 
 impl Default for RootDatabase {
     fn default() -> RootDatabase {
         let mut db = RootDatabase {
-            events: Default::default(),
             runtime: salsa::Runtime::default(),
-            id_maps: IdMaps::default(),
+            id_maps: Default::default(),
         };
-        db.query_mut(crate::input::SourceRootQuery)
-            .set(crate::input::WORKSPACE, Default::default());
-        db.query_mut(crate::input::CrateGraphQuery)
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(ra_db::WORKSPACE, Default::default());
+        db.query_mut(ra_db::CrateGraphQuery)
             .set((), Default::default());
-        db.query_mut(crate::input::LibrariesQuery)
+        db.query_mut(ra_db::LibrariesQuery)
             .set((), Default::default());
         db
     }
 }
 
-pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
-    if db.salsa_runtime().is_current_revision_canceled() {
-        Err(Canceled)
-    } else {
-        Ok(())
-    }
-}
-
 impl salsa::ParallelDatabase for RootDatabase {
     fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
         salsa::Snapshot::new(RootDatabase {
-            events: Default::default(),
             runtime: self.runtime.snapshot(self),
             id_maps: self.id_maps.clone(),
         })
     }
 }
 
-impl IdDatabase for RootDatabase {
-    fn id_maps(&self) -> &IdMaps {
-        &self.id_maps
-    }
-}
+impl BaseDatabase for RootDatabase {}
 
-#[cfg(test)]
-impl RootDatabase {
-    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<RootDatabase>> {
-        *self.events.lock() = Some(Vec::new());
-        f();
-        let events = self.events.lock().take().unwrap();
-        events
+impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
+    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
+        &self.id_maps.defs
     }
+}
 
-    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
-        let events = self.log(f);
-        events
-            .into_iter()
-            .filter_map(|e| match e.kind {
-                // This pretty horrible, but `Debug` is the only way to inspect
-                // QueryDescriptor at the moment.
-                salsa::EventKind::WillExecute { descriptor } => Some(format!("{:?}", descriptor)),
-                _ => None,
-            })
-            .collect()
+impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
+    fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
+        &self.id_maps.fns
     }
 }
 
 salsa::database_storage! {
     pub(crate) struct RootDatabaseStorage for RootDatabase {
-        impl crate::input::FilesDatabase {
-            fn file_text() for crate::input::FileTextQuery;
-            fn file_source_root() for crate::input::FileSourceRootQuery;
-            fn source_root() for crate::input::SourceRootQuery;
-            fn libraries() for crate::input::LibrariesQuery;
-            fn library_symbols() for crate::input::LibrarySymbolsQuery;
-            fn crate_graph() for crate::input::CrateGraphQuery;
-        }
-        impl SyntaxDatabase {
-            fn file_syntax() for FileSyntaxQuery;
-            fn file_lines() for FileLinesQuery;
-            fn file_symbols() for FileSymbolsQuery;
-            fn resolve_syntax_ptr() for ResolveSyntaxPtrQuery;
-        }
-        impl DescriptorDatabase {
-            fn module_tree() for ModuleTreeQuery;
-            fn fn_scopes() for FnScopesQuery;
-            fn _input_module_items() for InputModuleItemsQuery;
-            fn _item_map() for ItemMapQuery;
-            fn _fn_syntax() for FnSyntaxQuery;
-            fn _submodules() for SubmodulesQuery;
+        impl ra_db::FilesDatabase {
+            fn file_text() for ra_db::FileTextQuery;
+            fn file_source_root() for ra_db::FileSourceRootQuery;
+            fn source_root() for ra_db::SourceRootQuery;
+            fn libraries() for ra_db::LibrariesQuery;
+            fn crate_graph() for ra_db::CrateGraphQuery;
         }
-    }
-}
-
-salsa::query_group! {
-    pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase {
-        fn file_syntax(file_id: FileId) -> SourceFileNode {
-            type FileSyntaxQuery;
+        impl ra_db::SyntaxDatabase {
+            fn source_file() for ra_db::SourceFileQuery;
+            fn file_lines() for ra_db::FileLinesQuery;
         }
-        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
-            type FileLinesQuery;
+        impl symbol_index::SymbolsDatabase {
+            fn file_symbols() for symbol_index::FileSymbolsQuery;
+            fn library_symbols() for symbol_index::LibrarySymbolsQuery;
         }
-        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
-            type FileSymbolsQuery;
-        }
-        fn resolve_syntax_ptr(ptr: SyntaxPtr) -> SyntaxNode {
-            type ResolveSyntaxPtrQuery;
-            // Don't retain syntax trees in memory
-            storage volatile;
-            use fn crate::syntax_ptr::resolve_syntax_ptr;
+        impl hir::db::HirDatabase {
+            fn module_tree() for hir::db::ModuleTreeQuery;
+            fn fn_scopes() for hir::db::FnScopesQuery;
+            fn file_items() for hir::db::SourceFileItemsQuery;
+            fn file_item() for hir::db::FileItemQuery;
+            fn input_module_items() for hir::db::InputModuleItemsQuery;
+            fn item_map() for hir::db::ItemMapQuery;
+            fn fn_syntax() for hir::db::FnSyntaxQuery;
+            fn submodules() for hir::db::SubmodulesQuery;
         }
     }
 }
-
-fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
-    let text = db.file_text(file_id);
-    SourceFileNode::parse(&*text)
-}
-fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
-    let text = db.file_text(file_id);
-    Arc::new(LineIndex::new(&*text))
-}
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
-    db::check_canceled(db)?;
-    let syntax = db.file_syntax(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
-}