rust/crates/ra_hir/src/mock.rs

194 lines
6.0 KiB
Rust
Raw Normal View History

2019-01-10 04:04:04 -06:00
use std::{sync::Arc, panic};
2018-11-28 07:19:01 -06:00
use parking_lot::Mutex;
2019-01-17 05:11:00 -06:00
use ra_db::{
2019-01-25 14:27:16 -06:00
BaseDatabase, FilePosition, FileId, CrateGraph, SourceRoot, SourceRootId, FilesDatabase, salsa,
2019-01-17 05:11:00 -06:00
};
2018-11-28 07:19:01 -06:00
use relative_path::RelativePathBuf;
use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
2019-01-24 03:41:08 -06:00
use crate::{db, HirInterner};
2018-11-28 07:19:01 -06:00
2018-12-20 14:56:28 -06:00
pub const WORKSPACE: SourceRootId = SourceRootId(0);
2018-12-19 07:19:53 -06:00
2019-01-25 14:27:16 -06:00
#[salsa::database(
ra_db::FilesDatabaseStorage,
ra_db::SyntaxDatabaseStorage,
db::HirDatabaseStorage
)]
2018-11-28 07:19:01 -06:00
#[derive(Debug)]
pub(crate) struct MockDatabase {
events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
runtime: salsa::Runtime<MockDatabase>,
2019-01-24 03:41:08 -06:00
interner: Arc<HirInterner>,
file_counter: u32,
2018-11-28 07:19:01 -06:00
}
2019-01-10 04:04:04 -06:00
impl panic::RefUnwindSafe for MockDatabase {}
2018-11-28 07:19:01 -06:00
impl MockDatabase {
2018-12-19 03:40:41 -06:00
pub(crate) fn with_files(fixture: &str) -> (MockDatabase, SourceRoot) {
let (db, source_root, position) = MockDatabase::from_fixture(fixture);
2018-12-09 04:49:54 -06:00
assert!(position.is_none());
2018-12-19 03:40:41 -06:00
(db, source_root)
2018-12-09 04:49:54 -06:00
}
pub(crate) fn with_single_file(text: &str) -> (MockDatabase, SourceRoot, FileId) {
let mut db = MockDatabase::default();
let mut source_root = SourceRoot::default();
let file_id = db.add_file(WORKSPACE, &mut source_root, "/main.rs", text);
2019-01-25 06:25:01 -06:00
db.set_source_root(WORKSPACE, Arc::new(source_root.clone()));
(db, source_root, file_id)
}
2018-11-28 07:19:01 -06:00
pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
2018-12-09 04:49:54 -06:00
let (db, _, position) = MockDatabase::from_fixture(fixture);
let position = position.expect("expected a marker ( <|> )");
(db, position)
}
2018-12-19 03:40:41 -06:00
fn from_fixture(fixture: &str) -> (MockDatabase, SourceRoot, Option<FilePosition>) {
2018-11-28 07:19:01 -06:00
let mut db = MockDatabase::default();
let (source_root, pos) = db.add_fixture(WORKSPACE, fixture);
(db, source_root, pos)
}
pub fn add_fixture(
&mut self,
source_root_id: SourceRootId,
fixture: &str,
) -> (SourceRoot, Option<FilePosition>) {
2018-11-28 07:19:01 -06:00
let mut position = None;
2018-12-19 03:40:41 -06:00
let mut source_root = SourceRoot::default();
2018-11-28 07:19:01 -06:00
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(self.add_file_with_position(
source_root_id,
&mut source_root,
&entry.meta,
&entry.text,
));
2018-11-28 07:19:01 -06:00
} else {
self.add_file(source_root_id, &mut source_root, &entry.meta, &entry.text);
2018-11-28 07:19:01 -06:00
}
}
2019-01-25 06:25:01 -06:00
self.set_source_root(source_root_id, Arc::new(source_root.clone()));
(source_root, position)
2018-11-28 07:19:01 -06:00
}
fn add_file(
&mut self,
source_root_id: SourceRootId,
source_root: &mut SourceRoot,
path: &str,
text: &str,
) -> FileId {
2018-11-28 07:19:01 -06:00
assert!(path.starts_with('/'));
let is_crate_root = path == "/lib.rs" || path == "/main.rs";
2018-11-28 07:19:01 -06:00
let path = RelativePathBuf::from_path(&path[1..]).unwrap();
let file_id = FileId(self.file_counter);
self.file_counter += 1;
2018-11-28 07:19:01 -06:00
let text = Arc::new(text.to_string());
2019-01-25 06:25:01 -06:00
self.set_file_text(file_id, text);
self.set_file_relative_path(file_id, path.clone());
self.set_file_source_root(file_id, source_root_id);
2018-12-19 03:40:41 -06:00
source_root.files.insert(path, file_id);
if is_crate_root {
let mut crate_graph = CrateGraph::default();
crate_graph.add_crate_root(file_id);
2019-01-25 06:25:01 -06:00
self.set_crate_graph(Arc::new(crate_graph));
}
2018-11-28 07:19:01 -06:00
file_id
}
fn add_file_with_position(
&mut self,
source_root_id: SourceRootId,
2018-12-19 03:40:41 -06:00
source_root: &mut SourceRoot,
2018-11-28 07:19:01 -06:00
path: &str,
text: &str,
) -> FilePosition {
let (offset, text) = extract_offset(text);
let file_id = self.add_file(source_root_id, source_root, path, &text);
2018-11-28 07:19:01 -06:00
FilePosition { file_id, offset }
}
}
impl salsa::Database for MockDatabase {
fn salsa_runtime(&self) -> &salsa::Runtime<MockDatabase> {
&self.runtime
}
fn salsa_event(&self, event: impl Fn() -> salsa::Event<MockDatabase>) {
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(),
2019-01-24 03:41:08 -06:00
interner: Default::default(),
file_counter: 0,
2018-11-28 07:19:01 -06:00
};
2019-01-25 06:25:01 -06:00
db.set_crate_graph(Default::default());
db.set_local_roots(Default::default());
db.set_library_roots(Default::default());
2018-11-28 07:19:01 -06:00
db
}
}
impl salsa::ParallelDatabase for MockDatabase {
fn snapshot(&self) -> salsa::Snapshot<MockDatabase> {
salsa::Snapshot::new(MockDatabase {
events: Default::default(),
runtime: self.runtime.snapshot(self),
2019-01-24 03:41:08 -06:00
interner: Arc::clone(&self.interner),
file_counter: self.file_counter,
2018-11-28 07:19:01 -06:00
})
}
}
impl BaseDatabase for MockDatabase {}
2019-01-24 03:41:08 -06:00
impl AsRef<HirInterner> for MockDatabase {
fn as_ref(&self) -> &HirInterner {
&self.interner
2019-01-01 09:19:15 -06:00
}
}
2018-11-28 07:19:01 -06:00
impl MockDatabase {
pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<MockDatabase>> {
*self.events.lock() = Some(Vec::new());
f();
2019-01-25 06:16:50 -06:00
self.events.lock().take().unwrap()
2018-11-28 07:19:01 -06:00
}
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.
2019-01-25 06:16:50 -06:00
salsa::EventKind::WillExecute { database_key } => {
Some(format!("{:?}", database_key))
}
2018-11-28 07:19:01 -06:00
_ => None,
})
.collect()
}
}