index stuff produced by macros

5 files changed, 86 insertions, 16 deletions

diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 55caae5c2..e2b1c88fe 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -28,11 +28,11 @@ use std::{
 use fst::{self, Streamer};
 use ra_syntax::{
     SyntaxNodeRef, SourceFileNode, SmolStr,
-    algo::visit::{visitor, Visitor},
+    algo::{visit::{visitor, Visitor}, find_covering_node},
     SyntaxKind::{self, *},
     ast::{self, NameOwner},
 };
-use ra_db::{SyntaxDatabase, SourceRootId, FilesDatabase, LocalSyntaxPtr};
+use ra_db::{SourceRootId, FilesDatabase, LocalSyntaxPtr};
 use salsa::ParallelDatabase;
 use rayon::prelude::*;
 
@@ -42,7 +42,7 @@ use crate::{
 };
 
 salsa::query_group! {
-    pub(crate) trait SymbolsDatabase: SyntaxDatabase {
+    pub(crate) trait SymbolsDatabase: hir::db::HirDatabase {
         fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
             type FileSymbolsQuery;
         }
@@ -53,10 +53,23 @@ salsa::query_group! {
     }
 }
 
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+fn file_symbols(db: &impl SymbolsDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
     db.check_canceled()?;
-    let syntax = db.source_file(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
+    let source_file = db.source_file(file_id);
+    let mut symbols = source_file
+        .syntax()
+        .descendants()
+        .filter_map(to_symbol)
+        .map(move |(name, ptr)| FileSymbol { name, ptr, file_id })
+        .collect::<Vec<_>>();
+
+    for (name, text_range) in hir::source_binder::macro_symbols(db, file_id)? {
+        let node = find_covering_node(source_file.syntax(), text_range);
+        let ptr = LocalSyntaxPtr::new(node);
+        symbols.push(FileSymbol { file_id, name, ptr })
+    }
+
+    Ok(Arc::new(SymbolIndex::new(symbols)))
 }
 
 pub(crate) fn world_symbols(db: &RootDatabase, query: Query) -> Cancelable<Vec<FileSymbol>> {
@@ -141,10 +154,6 @@ impl SymbolIndex {
             .collect::<Vec<_>>();
         SymbolIndex::new(symbols)
     }
-
-    fn for_file(file_id: FileId, file: SourceFileNode) -> SymbolIndex {
-        SymbolIndex::for_files(rayon::iter::once((file_id, file)))
-    }
 }
 
 impl Query {
diff --git a/crates/ra_analysis/tests/test/main.rs b/crates/ra_analysis/tests/test/main.rs
index 23a5799b9..bfdf8aef2 100644
--- a/crates/ra_analysis/tests/test/main.rs
+++ b/crates/ra_analysis/tests/test/main.rs
@@ -6,7 +6,7 @@ use test_utils::{assert_eq_dbg, assert_eq_text};
 
 use ra_analysis::{
     mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis},
-    AnalysisChange, CrateGraph, FileId, FnSignatureInfo,
+    AnalysisChange, CrateGraph, FileId, FnSignatureInfo, Query
 };
 
 fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
@@ -531,6 +531,7 @@ fn test_rename_for_mut_param() {
     }"#,
     );
 }
+
 fn test_rename(text: &str, new_name: &str, expected: &str) {
     let (analysis, position) = single_file_with_position(text);
     let edits = analysis.rename(position, new_name).unwrap();
@@ -547,3 +548,19 @@ fn test_rename(text: &str, new_name: &str, expected: &str) {
         .apply(&*analysis.file_text(file_id.unwrap()));
     assert_eq_text!(expected, &*result);
 }
+
+#[test]
+fn world_symbols_include_stuff_from_macros() {
+    let (analysis, _) = single_file(
+        "
+salsa::query_group! {
+pub trait HirDatabase: SyntaxDatabase {}
+}
+    ",
+    );
+
+    let mut symbols = analysis.symbol_search(Query::new("Hir".into())).unwrap();
+    let s = symbols.pop().unwrap();
+    assert_eq!(s.name(), "HirDatabase");
+    assert_eq!(s.range(), TextRange::from_to(33.into(), 44.into()));
+}
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index a09dee8b1..4c7ebe3ea 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -48,6 +48,13 @@ impl HirFileId {
         }
     }
 
+    pub(crate) fn as_macro_call_id(self) -> Option<MacroCallId> {
+        match self.0 {
+            HirFileIdRepr::Macro(it) => Some(it),
+            _ => None,
+        }
+    }
+
     pub(crate) fn hir_source_file(db: &impl HirDatabase, file_id: HirFileId) -> SourceFileNode {
         match file_id.0 {
             HirFileIdRepr::File(file_id) => db.source_file(file_id),
diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 40aa33ffa..8d1209626 100644
--- a/crates/ra_hir/src/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -64,14 +64,14 @@ impl ModuleScope {
 /// running name resolution.
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct InputModuleItems {
-    items: Vec<ModuleItem>,
+    pub(crate) items: Vec<ModuleItem>,
     imports: Vec<Import>,
 }
 
 #[derive(Debug, PartialEq, Eq)]
-struct ModuleItem {
-    id: SourceItemId,
-    name: Name,
+pub(crate) struct ModuleItem {
+    pub(crate) id: SourceItemId,
+    pub(crate) name: Name,
     kind: SyntaxKind,
     vis: Vis,
 }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 24490d119..85bd84469 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -8,8 +8,8 @@
 use ra_db::{FileId, FilePosition, Cancelable};
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
+    SmolStr, TextRange, SyntaxNodeRef,
     ast::{self, AstNode, NameOwner},
-    SyntaxNodeRef,
 };
 
 use crate::{
@@ -126,3 +126,40 @@ pub fn function_from_child_node(
     let fn_def = ctry!(node.ancestors().find_map(ast::FnDef::cast));
     function_from_source(db, file_id, fn_def)
 }
+
+pub fn macro_symbols(
+    db: &impl HirDatabase,
+    file_id: FileId,
+) -> Cancelable<Vec<(SmolStr, TextRange)>> {
+    let module = match module_from_file_id(db, file_id)? {
+        Some(it) => it,
+        None => return Ok(Vec::new()),
+    };
+    let items = db.input_module_items(module.source_root_id, module.module_id)?;
+    let mut res = Vec::new();
+
+    for macro_call_id in items
+        .items
+        .iter()
+        .filter_map(|it| it.id.file_id.as_macro_call_id())
+    {
+        if let Some(exp) = db.expand_macro_invocation(macro_call_id) {
+            let loc = macro_call_id.loc(db);
+            let syntax = db.file_item(loc.source_item_id);
+            let syntax = syntax.borrowed();
+            let macro_call = ast::MacroCall::cast(syntax).unwrap();
+            let off = macro_call.token_tree().unwrap().syntax().range().start();
+            let file = exp.file();
+            for trait_def in file.syntax().descendants().filter_map(ast::TraitDef::cast) {
+                if let Some(name) = trait_def.name() {
+                    let dst_range = name.syntax().range();
+                    if let Some(src_range) = exp.map_range_back(dst_range) {
+                        res.push((name.text(), src_range + off))
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(res)
+}