1 files changed, 39 insertions, 90 deletions

diff --git a/crates/ra_hir_ty/src/test_db.rs b/crates/ra_hir_ty/src/test_db.rs
index 8498d3d96..a1714ff0f 100644
--- a/crates/ra_hir_ty/src/test_db.rs
+++ b/crates/ra_hir_ty/src/test_db.rs
@@ -1,18 +1,16 @@
 //! Database used for testing `hir`.
 
 use std::{
-    panic,
+    fmt, panic,
     sync::{Arc, Mutex},
 };
 
-use hir_def::{db::DefDatabase, AssocItemId, ModuleDefId, ModuleId};
-use hir_expand::{db::AstDatabase, diagnostics::DiagnosticSink};
-use ra_db::{
-    salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath, SourceDatabase, Upcast,
-};
-use stdx::format_to;
-
-use crate::{db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator};
+use hir_def::{db::DefDatabase, ModuleId};
+use hir_expand::db::AstDatabase;
+use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, SourceDatabase, Upcast};
+use ra_syntax::TextRange;
+use rustc_hash::{FxHashMap, FxHashSet};
+use test_utils::extract_annotations;
 
 #[salsa::database(
     ra_db::SourceDatabaseExtStorage,
@@ -22,10 +20,15 @@ use crate::{db::HirDatabase, diagnostics::Diagnostic, expr::ExprValidator};
     hir_def::db::DefDatabaseStorage,
     crate::db::HirDatabaseStorage
 )]
-#[derive(Debug, Default)]
+#[derive(Default)]
 pub struct TestDB {
-    events: Mutex<Option<Vec<salsa::Event<TestDB>>>>,
-    runtime: salsa::Runtime<TestDB>,
+    storage: salsa::Storage<TestDB>,
+    events: Mutex<Option<Vec<salsa::Event>>>,
+}
+impl fmt::Debug for TestDB {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("TestDB").finish()
+    }
 }
 
 impl Upcast<dyn AstDatabase> for TestDB {
@@ -41,18 +44,10 @@ impl Upcast<dyn DefDatabase> for TestDB {
 }
 
 impl salsa::Database for TestDB {
-    fn salsa_runtime(&self) -> &salsa::Runtime<TestDB> {
-        &self.runtime
-    }
-
-    fn salsa_runtime_mut(&mut self) -> &mut salsa::Runtime<Self> {
-        &mut self.runtime
-    }
-
-    fn salsa_event(&self, event: impl Fn() -> salsa::Event<TestDB>) {
+    fn salsa_event(&self, event: salsa::Event) {
         let mut events = self.events.lock().unwrap();
         if let Some(events) = &mut *events {
-            events.push(event());
+            events.push(event);
         }
     }
 }
@@ -60,8 +55,8 @@ impl salsa::Database for TestDB {
 impl salsa::ParallelDatabase for TestDB {
     fn snapshot(&self) -> salsa::Snapshot<TestDB> {
         salsa::Snapshot::new(TestDB {
+            storage: self.storage.snapshot(),
             events: Default::default(),
-            runtime: self.runtime.snapshot(self),
         })
     }
 }
@@ -72,27 +67,16 @@ impl FileLoader for TestDB {
     fn file_text(&self, file_id: FileId) -> Arc<String> {
         FileLoaderDelegate(self).file_text(file_id)
     }
-    fn resolve_relative_path(
-        &self,
-        anchor: FileId,
-        relative_path: &RelativePath,
-    ) -> Option<FileId> {
-        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    fn resolve_path(&self, anchor: FileId, path: &str) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_path(anchor, path)
     }
-    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+    fn relevant_crates(&self, file_id: FileId) -> Arc<FxHashSet<CrateId>> {
         FileLoaderDelegate(self).relevant_crates(file_id)
     }
-    fn resolve_extern_path(
-        &self,
-        extern_id: ra_db::ExternSourceId,
-        relative_path: &RelativePath,
-    ) -> Option<FileId> {
-        FileLoaderDelegate(self).resolve_extern_path(extern_id, relative_path)
-    }
 }
 
 impl TestDB {
-    pub fn module_for_file(&self, file_id: FileId) -> ModuleId {
+    pub(crate) fn module_for_file(&self, file_id: FileId) -> ModuleId {
         for &krate in self.relevant_crates(file_id).iter() {
             let crate_def_map = self.crate_def_map(krate);
             for (local_id, data) in crate_def_map.modules.iter() {
@@ -104,67 +88,32 @@ impl TestDB {
         panic!("Can't find module for file")
     }
 
-    fn diag<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
+    pub(crate) fn extract_annotations(&self) -> FxHashMap<FileId, Vec<(TextRange, String)>> {
+        let mut files = Vec::new();
         let crate_graph = self.crate_graph();
         for krate in crate_graph.iter() {
             let crate_def_map = self.crate_def_map(krate);
-
-            let mut fns = Vec::new();
             for (module_id, _) in crate_def_map.modules.iter() {
-                for decl in crate_def_map[module_id].scope.declarations() {
-                    if let ModuleDefId::FunctionId(f) = decl {
-                        fns.push(f)
-                    }
-                }
-
-                for impl_id in crate_def_map[module_id].scope.impls() {
-                    let impl_data = self.impl_data(impl_id);
-                    for item in impl_data.items.iter() {
-                        if let AssocItemId::FunctionId(f) = item {
-                            fns.push(*f)
-                        }
-                    }
-                }
-            }
-
-            for f in fns {
-                let infer = self.infer(f.into());
-                let mut sink = DiagnosticSink::new(&mut cb);
-                infer.add_diagnostics(self, f, &mut sink);
-                let mut validator = ExprValidator::new(f, infer, &mut sink);
-                validator.validate_body(self);
+                let file_id = crate_def_map[module_id].origin.file_id();
+                files.extend(file_id)
             }
         }
-    }
-
-    pub fn diagnostics(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-            count += 1;
-        });
-        (buf, count)
-    }
-
-    /// Like `diagnostics`, but filtered for a single diagnostic.
-    pub fn diagnostic<D: Diagnostic>(&self) -> (String, u32) {
-        let mut buf = String::new();
-        let mut count = 0;
-        self.diag(|d| {
-            // We want to filter diagnostics by the particular one we are testing for, to
-            // avoid surprising results in tests.
-            if d.downcast_ref::<D>().is_some() {
-                format_to!(buf, "{:?}: {}\n", d.syntax_node(self).text(), d.message());
-                count += 1;
-            };
-        });
-        (buf, count)
+        files
+            .into_iter()
+            .filter_map(|file_id| {
+                let text = self.file_text(file_id);
+                let annotations = extract_annotations(&text);
+                if annotations.is_empty() {
+                    return None;
+                }
+                Some((file_id, annotations))
+            })
+            .collect()
     }
 }
 
 impl TestDB {
-    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<TestDB>> {
+    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
         *self.events.lock().unwrap() = Some(Vec::new());
         f();
         self.events.lock().unwrap().take().unwrap()
@@ -178,7 +127,7 @@ impl TestDB {
                 // This pretty horrible, but `Debug` is the only way to inspect
                 // QueryDescriptor at the moment.
                 salsa::EventKind::WillExecute { database_key } => {
-                    Some(format!("{:?}", database_key))
+                    Some(format!("{:?}", database_key.debug(self)))
                 }
                 _ => None,
             })