sync::{Arc, Mutex},
};
-use base_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition, Upcast};
-use base_db::{AnchoredPath, SourceDatabase};
-use hir_expand::diagnostics::Diagnostic;
-use hir_expand::diagnostics::DiagnosticSinkBuilder;
+use base_db::{
+ salsa, AnchoredPath, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition,
+ SourceDatabase, Upcast,
+};
use hir_expand::{db::AstDatabase, InFile};
-use rustc_hash::FxHashMap;
use rustc_hash::FxHashSet;
-use syntax::{algo, ast, AstNode, TextRange, TextSize};
-use test_utils::extract_annotations;
+use syntax::{algo, ast, AstNode};
-use crate::{db::DefDatabase, nameres::DefMap, src::HasSource, Lookup, ModuleDefId, ModuleId};
+use crate::{
+ db::DefDatabase,
+ nameres::{DefMap, ModuleSource},
+ src::HasSource,
+ LocalModuleId, Lookup, ModuleDefId, ModuleId,
+};
#[salsa::database(
base_db::SourceDatabaseExtStorage,
crate::db::InternDatabaseStorage,
crate::db::DefDatabaseStorage
)]
-#[derive(Default)]
pub(crate) struct TestDB {
storage: salsa::Storage<TestDB>,
events: Mutex<Option<Vec<salsa::Event>>>,
}
+impl Default for TestDB {
+ fn default() -> Self {
+ let mut this = Self { storage: Default::default(), events: Default::default() };
+ this.set_enable_proc_attr_macros(true);
+ this
+ }
+}
+
impl Upcast<dyn AstDatabase> for TestDB {
fn upcast(&self) -> &(dyn AstDatabase + 'static) {
&*self
pub(crate) fn module_at_position(&self, position: FilePosition) -> ModuleId {
let file_module = self.module_for_file(position.file_id);
let mut def_map = file_module.def_map(self);
+ let module = self.mod_at_position(&def_map, position);
def_map = match self.block_at_position(&def_map, position) {
Some(it) => it,
- None => return file_module,
+ None => return def_map.module_id(module),
};
loop {
let new_map = self.block_at_position(&def_map, position);
}
}
+ /// Finds the smallest/innermost module in `def_map` containing `position`.
+ fn mod_at_position(&self, def_map: &DefMap, position: FilePosition) -> LocalModuleId {
+ let mut size = None;
+ let mut res = def_map.root();
+ for (module, data) in def_map.modules() {
+ let src = data.definition_source(self);
+ if src.file_id != position.file_id.into() {
+ continue;
+ }
+
+ let range = match src.value {
+ ModuleSource::SourceFile(it) => it.syntax().text_range(),
+ ModuleSource::Module(it) => it.syntax().text_range(),
+ ModuleSource::BlockExpr(it) => it.syntax().text_range(),
+ };
+
+ if !range.contains(position.offset) {
+ continue;
+ }
+
+ let new_size = match size {
+ None => range.len(),
+ Some(size) => {
+ if range.len() < size {
+ range.len()
+ } else {
+ size
+ }
+ }
+ };
+
+ if size != Some(new_size) {
+ cov_mark::hit!(submodule_in_testdb);
+ size = Some(new_size);
+ res = module;
+ }
+ }
+
+ res
+ }
+
fn block_at_position(&self, def_map: &DefMap, position: FilePosition) -> Option<Arc<DefMap>> {
// Find the smallest (innermost) function in `def_map` containing the cursor.
let mut size = None;
events
.into_iter()
.filter_map(|e| match e.kind {
- // This pretty horrible, but `Debug` is the only way to inspect
+ // This is pretty horrible, but `Debug` is the only way to inspect
// QueryDescriptor at the moment.
salsa::EventKind::WillExecute { database_key } => {
Some(format!("{:?}", database_key.debug(self)))
})
.collect()
}
-
- 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);
- for (module_id, _) in crate_def_map.modules() {
- let file_id = crate_def_map[module_id].origin.file_id();
- files.extend(file_id)
- }
- }
- assert!(!files.is_empty());
- 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()
- }
-
- pub(crate) fn diagnostics<F: FnMut(&dyn Diagnostic)>(&self, mut cb: F) {
- let crate_graph = self.crate_graph();
- for krate in crate_graph.iter() {
- let crate_def_map = self.crate_def_map(krate);
-
- let mut sink = DiagnosticSinkBuilder::new().build(&mut cb);
- for (module_id, module) in crate_def_map.modules() {
- crate_def_map.add_diagnostics(self, module_id, &mut sink);
-
- for decl in module.scope.declarations() {
- if let ModuleDefId::FunctionId(it) = decl {
- let source_map = self.body_with_source_map(it.into()).1;
- source_map.add_diagnostics(self, &mut sink);
- }
- }
- }
- }
- }
-
- pub(crate) fn check_diagnostics(&self) {
- let db: &TestDB = self;
- let annotations = db.extract_annotations();
- assert!(!annotations.is_empty());
-
- let mut actual: FxHashMap<FileId, Vec<(TextRange, String)>> = FxHashMap::default();
- db.diagnostics(|d| {
- let src = d.display_source();
- let root = db.parse_or_expand(src.file_id).unwrap();
-
- let node = src.map(|ptr| ptr.to_node(&root));
- let frange = node.as_ref().original_file_range(db);
-
- let message = d.message();
- actual.entry(frange.file_id).or_default().push((frange.range, message));
- });
-
- for (file_id, diags) in actual.iter_mut() {
- diags.sort_by_key(|it| it.0.start());
- let text = db.file_text(*file_id);
- // For multiline spans, place them on line start
- for (range, content) in diags {
- if text[*range].contains('\n') {
- *range = TextRange::new(range.start(), range.start() + TextSize::from(1));
- *content = format!("... {}", content);
- }
- }
- }
-
- assert_eq!(annotations, actual);
- }
}
projects / rust.git / blobdiff