From e89700f9678d3797c09f0a397b7b67fe9c6f5e9f Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 28 Nov 2018 16:19:01 +0300 Subject: Move hir tests to hit --- crates/ra_hir/src/lib.rs | 2 + crates/ra_hir/src/mock.rs | 172 ++++++++++++++++++++++++++++++++++++ crates/ra_hir/src/module/nameres.rs | 97 ++++++++++++++++++++ 3 files changed, 271 insertions(+) create mode 100644 crates/ra_hir/src/mock.rs (limited to 'crates/ra_hir/src') diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index f13f0107e..e7b6a81f4 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -15,6 +15,8 @@ macro_rules! ctry { } pub mod db; +#[cfg(test)] +mod mock; mod query_definitions; mod function; mod module; diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs new file mode 100644 index 000000000..8e256b89f --- /dev/null +++ b/crates/ra_hir/src/mock.rs @@ -0,0 +1,172 @@ +use std::sync::Arc; + +use parking_lot::Mutex; +use salsa::{self, Database}; +use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE}; +use relative_path::RelativePathBuf; +use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset}; + +use crate::{db, DefId, DefLoc, FnId, SourceItemId}; + +#[derive(Debug)] +pub(crate) struct MockDatabase { + events: Mutex>>>, + runtime: salsa::Runtime, + id_maps: Arc, +} + +impl MockDatabase { + pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) { + let mut db = MockDatabase::default(); + + let mut position = None; + let mut file_map = FileMap::default(); + for entry in parse_fixture(fixture) { + if entry.text.contains(CURSOR_MARKER) { + assert!( + position.is_none(), + "only one marker (<|>) per fixture is allowed" + ); + position = Some(db.add_file_with_position(&mut file_map, &entry.meta, &entry.text)); + } else { + db.add_file(&mut file_map, &entry.meta, &entry.text); + } + } + let position = position.expect("expected a marker (<|>)"); + let source_root = file_map.into_source_root(); + db.query_mut(ra_db::SourceRootQuery) + .set(WORKSPACE, Arc::new(source_root)); + (db, position) + } + + fn add_file(&mut self, file_map: &mut FileMap, path: &str, text: &str) -> FileId { + assert!(path.starts_with('/')); + let path = RelativePathBuf::from_path(&path[1..]).unwrap(); + + let file_id = file_map.add(path); + let text = Arc::new(text.to_string()); + self.query_mut(ra_db::FileTextQuery).set(file_id, text); + self.query_mut(ra_db::FileSourceRootQuery) + .set(file_id, WORKSPACE); + file_id + } + + fn add_file_with_position( + &mut self, + file_map: &mut FileMap, + path: &str, + text: &str, + ) -> FilePosition { + let (offset, text) = extract_offset(text); + let file_id = self.add_file(file_map, path, &text); + FilePosition { file_id, offset } + } +} + +#[derive(Debug, Default)] +struct IdMaps { + fns: LocationIntener, + defs: LocationIntener, +} + +impl salsa::Database for MockDatabase { + fn salsa_runtime(&self) -> &salsa::Runtime { + &self.runtime + } + + fn salsa_event(&self, event: impl Fn() -> salsa::Event) { + let mut events = self.events.lock(); + if let Some(events) = &mut *events { + events.push(event()); + } + } +} + +impl Default for MockDatabase { + fn default() -> MockDatabase { + let mut db = MockDatabase { + events: Default::default(), + runtime: salsa::Runtime::default(), + id_maps: Default::default(), + }; + db.query_mut(ra_db::SourceRootQuery) + .set(ra_db::WORKSPACE, Default::default()); + db.query_mut(ra_db::CrateGraphQuery) + .set((), Default::default()); + db.query_mut(ra_db::LibrariesQuery) + .set((), Default::default()); + db + } +} + +impl salsa::ParallelDatabase for MockDatabase { + fn snapshot(&self) -> salsa::Snapshot { + salsa::Snapshot::new(MockDatabase { + events: Default::default(), + runtime: self.runtime.snapshot(self), + id_maps: self.id_maps.clone(), + }) + } +} + +impl BaseDatabase for MockDatabase {} + +impl AsRef> for MockDatabase { + fn as_ref(&self) -> &LocationIntener { + &self.id_maps.defs + } +} + +impl AsRef> for MockDatabase { + fn as_ref(&self) -> &LocationIntener { + &self.id_maps.fns + } +} + +impl MockDatabase { + pub(crate) fn log(&self, f: impl FnOnce()) -> Vec> { + *self.events.lock() = Some(Vec::new()); + f(); + let events = self.events.lock().take().unwrap(); + events + } + + pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec { + 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() + } +} + +salsa::database_storage! { + pub(crate) struct MockDatabaseStorage for MockDatabase { + 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; + } + impl ra_db::SyntaxDatabase { + fn source_file() for ra_db::SourceFileQuery; + fn file_lines() for ra_db::FileLinesQuery; + } + impl db::HirDatabase { + fn module_tree() for db::ModuleTreeQuery; + fn fn_scopes() for db::FnScopesQuery; + fn file_items() for db::SourceFileItemsQuery; + fn file_item() for db::FileItemQuery; + fn input_module_items() for db::InputModuleItemsQuery; + fn item_map() for db::ItemMapQuery; + fn fn_syntax() for db::FnSyntaxQuery; + fn submodules() for db::SubmodulesQuery; + } + } +} diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs index 837a8d5ae..de13835b2 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/module/nameres.rs @@ -336,3 +336,100 @@ where f(module_items) } } + +//TODO: move to hir +#[cfg(test)] +mod tests { + use std::sync::Arc; + + use salsa::Database; + use ra_db::FilesDatabase; + use ra_syntax::SmolStr; + + use crate::{ + self as hir, + db::HirDatabase, + mock::MockDatabase, +}; + + fn item_map(fixture: &str) -> (Arc, hir::ModuleId) { + let (db, pos) = MockDatabase::with_position(fixture); + let source_root = db.file_source_root(pos.file_id); + let module = hir::Module::guess_from_position(&db, pos).unwrap().unwrap(); + let module_id = module.module_id; + (db.item_map(source_root).unwrap(), module_id) + } + + #[test] + fn test_item_map() { + let (item_map, module_id) = item_map( + " + //- /lib.rs + mod foo; + + use crate::foo::bar::Baz; + <|> + + //- /foo/mod.rs + pub mod bar; + + //- /foo/bar.rs + pub struct Baz; + ", + ); + let name = SmolStr::from("Baz"); + let resolution = &item_map.per_module[&module_id].items[&name]; + assert!(resolution.def_id.is_some()); + } + + #[test] + fn typing_inside_a_function_should_not_invalidate_item_map() { + let (mut db, pos) = MockDatabase::with_position( + " + //- /lib.rs + mod foo;<|> + + use crate::foo::bar::Baz; + + fn foo() -> i32 { + 1 + 1 + } + //- /foo/mod.rs + pub mod bar; + + //- /foo/bar.rs + pub struct Baz; + ", + ); + let source_root = db.file_source_root(pos.file_id); + { + let events = db.log_executed(|| { + db.item_map(source_root).unwrap(); + }); + assert!(format!("{:?}", events).contains("item_map")) + } + + let new_text = " + mod foo; + + use crate::foo::bar::Baz; + + fn foo() -> i32 { 92 } + " + .to_string(); + + db.query_mut(ra_db::FileTextQuery) + .set(pos.file_id, Arc::new(new_text)); + + { + let events = db.log_executed(|| { + db.item_map(source_root).unwrap(); + }); + assert!( + !format!("{:?}", events).contains("_item_map"), + "{:#?}", + events + ) + } + } +} -- cgit v1.2.3