internal: remove def-level diagnostics tests

matklad · matklad · commit 4af7a35197a1 · 2021-06-13T18:45:38.000+03:00
diff --git a/crates/hir_def/src/body/tests.rs b/crates/hir_def/src/body/tests.rs
@@ -3,7 +3,7 @@ mod block;
 use base_db::{fixture::WithFixture, SourceDatabase};
 use expect_test::Expect;
 
-use crate::{test_db::TestDB, ModuleDefId};
+use crate::ModuleDefId;
 
 use super::*;
 
@@ -28,11 +28,6 @@ fn lower(ra_fixture: &str) -> Arc<Body> {
     db.body(fn_def.unwrap().into())
 }
 
-fn check_diagnostics(ra_fixture: &str) {
-    let db: TestDB = TestDB::with_files(ra_fixture);
-    db.check_diagnostics();
-}
-
 fn block_def_map_at(ra_fixture: &str) -> String {
     let (db, position) = crate::test_db::TestDB::with_position(ra_fixture);
 
@@ -57,23 +52,23 @@ fn check_at(ra_fixture: &str, expect: Expect) {
 fn your_stack_belongs_to_me() {
     cov_mark::check!(your_stack_belongs_to_me);
     lower(
-        "
+        r#"
 macro_rules! n_nuple {
     ($e:tt) => ();
     ($($rest:tt)*) => {{
         (n_nuple!($($rest)*)None,)
     }};
 }
 fn main() { n_nuple!(1,2,3); }
-",
+"#,
     );
 }
 
 #[test]
 fn macro_resolve() {
     // Regression test for a path resolution bug introduced with inner item handling.
     lower(
-        r"
+        r#"
 macro_rules! vec {
     () => { () };
     ($elem:expr; $n:expr) => { () };
@@ -84,19 +79,6 @@ mod m {
         let _ = vec![FileSet::default(); self.len()];
     }
 }
-      ",
+"#,
     );
 }
-
-#[test]
-fn unresolved_macro_diag() {
-    check_diagnostics(
-        r#"
-fn f() {
-    m!();
-  //^^^^ UnresolvedMacroCall
-}
-      "#,
-    );
-}
-
diff --git a/crates/hir_def/src/test_db.rs b/crates/hir_def/src/test_db.rs
@@ -6,19 +6,16 @@ use std::{
 };
 
 use base_db::{
-    salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition, FileRange, Upcast,
+    salsa, AnchoredPath, CrateId, FileId, FileLoader, FileLoaderDelegate, FilePosition,
+    SourceDatabase, Upcast,
 };
-use base_db::{AnchoredPath, SourceDatabase};
 use hir_expand::{db::AstDatabase, InFile};
-use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
-use syntax::{algo, ast, AstNode, SyntaxNode, SyntaxNodePtr, TextRange, TextSize};
-use test_utils::extract_annotations;
+use syntax::{algo, ast, AstNode};
 
 use crate::{
-    body::BodyDiagnostic,
     db::DefDatabase,
-    nameres::{diagnostics::DefDiagnosticKind, DefMap, ModuleSource},
+    nameres::{DefMap, ModuleSource},
     src::HasSource,
     LocalModuleId, Lookup, ModuleDefId, ModuleId,
 };
@@ -245,145 +242,4 @@ impl TestDB {
             })
             .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(&self, cb: &mut dyn FnMut(FileRange, String)) {
-        let crate_graph = self.crate_graph();
-        for krate in crate_graph.iter() {
-            let crate_def_map = self.crate_def_map(krate);
-
-            for diag in crate_def_map.diagnostics() {
-                let (node, message): (InFile<SyntaxNode>, &str) = match &diag.kind {
-                    DefDiagnosticKind::UnresolvedModule { ast, .. } => {
-                        let node = ast.to_node(self.upcast());
-                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedModule")
-                    }
-                    DefDiagnosticKind::UnresolvedExternCrate { ast, .. } => {
-                        let node = ast.to_node(self.upcast());
-                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedExternCrate")
-                    }
-                    DefDiagnosticKind::UnresolvedImport { id, .. } => {
-                        let item_tree = id.item_tree(self.upcast());
-                        let import = &item_tree[id.value];
-                        let node = InFile::new(id.file_id(), import.ast_id).to_node(self.upcast());
-                        (InFile::new(id.file_id(), node.syntax().clone()), "UnresolvedImport")
-                    }
-                    DefDiagnosticKind::UnconfiguredCode { ast, .. } => {
-                        let node = ast.to_node(self.upcast());
-                        (InFile::new(ast.file_id, node.syntax().clone()), "UnconfiguredCode")
-                    }
-                    DefDiagnosticKind::UnresolvedProcMacro { ast, .. } => {
-                        (ast.to_node(self.upcast()), "UnresolvedProcMacro")
-                    }
-                    DefDiagnosticKind::UnresolvedMacroCall { ast, .. } => {
-                        let node = ast.to_node(self.upcast());
-                        (InFile::new(ast.file_id, node.syntax().clone()), "UnresolvedMacroCall")
-                    }
-                    DefDiagnosticKind::MacroError { ast, message } => {
-                        (ast.to_node(self.upcast()), message.as_str())
-                    }
-                    DefDiagnosticKind::UnimplementedBuiltinMacro { ast } => {
-                        let node = ast.to_node(self.upcast());
-                        (
-                            InFile::new(ast.file_id, node.syntax().clone()),
-                            "UnimplementedBuiltinMacro",
-                        )
-                    }
-                };
-
-                let frange = node.as_ref().original_file_range(self);
-                cb(frange, message.to_string())
-            }
-
-            for (_module_id, module) in crate_def_map.modules() {
-                for decl in module.scope.declarations() {
-                    if let ModuleDefId::FunctionId(it) = decl {
-                        let source_map = self.body_with_source_map(it.into()).1;
-                        for diag in source_map.diagnostics() {
-                            let (ptr, message): (InFile<SyntaxNodePtr>, &str) = match diag {
-                                BodyDiagnostic::InactiveCode { node, .. } => {
-                                    (node.clone().map(|it| it), "InactiveCode")
-                                }
-                                BodyDiagnostic::MacroError { node, message } => {
-                                    (node.clone().map(|it| it.into()), message.as_str())
-                                }
-                                BodyDiagnostic::UnresolvedProcMacro { node } => {
-                                    (node.clone().map(|it| it.into()), "UnresolvedProcMacro")
-                                }
-                                BodyDiagnostic::UnresolvedMacroCall { node, .. } => {
-                                    (node.clone().map(|it| it.into()), "UnresolvedMacroCall")
-                                }
-                            };
-
-                            let root = self.parse_or_expand(ptr.file_id).unwrap();
-                            let node = ptr.map(|ptr| ptr.to_node(&root));
-                            let frange = node.as_ref().original_file_range(self);
-                            cb(frange, message.to_string())
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    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(&mut |frange, 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);
-    }
-
-    pub(crate) fn check_no_diagnostics(&self) {
-        let db: &TestDB = self;
-        let annotations = db.extract_annotations();
-        assert!(annotations.is_empty());
-
-        let mut has_diagnostics = false;
-        db.diagnostics(&mut |_, _| {
-            has_diagnostics = true;
-        });
-
-        assert!(!has_diagnostics);
-    }
 }
diff --git a/crates/ide/src/diagnostics/unresolved_macro_call.rs b/crates/ide/src/diagnostics/unresolved_macro_call.rs
@@ -34,6 +34,18 @@ pub(super) fn unresolved_macro_call(
 mod tests {
     use crate::diagnostics::tests::check_diagnostics;
 
+    #[test]
+    fn unresolved_macro_diag() {
+        check_diagnostics(
+            r#"
+fn f() {
+    m!();
+} //^ unresolved macro `m!`
+
+"#,
+        );
+    }
+
     #[test]
     fn test_unresolved_macro_range() {
         check_diagnostics(
