10 files changed, 462 insertions, 393 deletions

diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs
index b4ee092b5..739ca6ae8 100644
--- a/crates/ra_analysis/src/completion.rs
+++ b/crates/ra_analysis/src/completion.rs
@@ -58,6 +58,6 @@ fn check_completion(code: &str, expected_completions: &str, kind: CompletionKind
     } else {
         single_file_with_position(code)
     };
-    let completions = completions(&analysis.imp.db, position).unwrap().unwrap();
+    let completions = completions(&analysis.db, position).unwrap().unwrap();
     completions.assert_match(expected_completions, kind);
 }
diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs
index daf666505..4dead3689 100644
--- a/crates/ra_analysis/src/completion/complete_scope.rs
+++ b/crates/ra_analysis/src/completion/complete_scope.rs
@@ -27,7 +27,7 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) ->
             match res.import {
                 None => true,
                 Some(import) => {
-                    let range = import.range(ctx.db, module.source().file_id());
+                    let range = import.range(ctx.db, module.file_id());
                     !range.is_subrange(&ctx.leaf.range())
                 }
             }
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index b072a5eba..d7740f0c4 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,7 +1,6 @@
 use std::{fmt, sync::Arc};
 use salsa::{self, Database};
 use ra_db::{LocationIntener, BaseDatabase};
-use hir::{self, DefId, DefLoc};
 
 use crate::{
     symbol_index,
@@ -15,7 +14,8 @@ pub(crate) struct RootDatabase {
 
 #[derive(Default)]
 struct IdMaps {
-    defs: LocationIntener<DefLoc, DefId>,
+    defs: LocationIntener<hir::DefLoc, hir::DefId>,
+    macros: LocationIntener<hir::MacroCallLoc, hir::MacroCallId>,
 }
 
 impl fmt::Debug for IdMaps {
@@ -59,12 +59,18 @@ impl salsa::ParallelDatabase for RootDatabase {
 
 impl BaseDatabase for RootDatabase {}
 
-impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
-    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
+impl AsRef<LocationIntener<hir::DefLoc, hir::DefId>> for RootDatabase {
+    fn as_ref(&self) -> &LocationIntener<hir::DefLoc, hir::DefId> {
         &self.id_maps.defs
     }
 }
 
+impl AsRef<LocationIntener<hir::MacroCallLoc, hir::MacroCallId>> for RootDatabase {
+    fn as_ref(&self) -> &LocationIntener<hir::MacroCallLoc, hir::MacroCallId> {
+        &self.id_maps.macros
+    }
+}
+
 salsa::database_storage! {
     pub(crate) struct RootDatabaseStorage for RootDatabase {
         impl ra_db::FilesDatabase {
@@ -85,6 +91,8 @@ salsa::database_storage! {
             fn library_symbols() for symbol_index::LibrarySymbolsQuery;
         }
         impl hir::db::HirDatabase {
+            fn hir_source_file() for hir::db::HirSourceFileQuery;
+            fn expand_macro_invocation() for hir::db::ExpandMacroCallQuery;
             fn module_tree() for hir::db::ModuleTreeQuery;
             fn fn_scopes() for hir::db::FnScopesQuery;
             fn file_items() for hir::db::SourceFileItemsQuery;
diff --git a/crates/ra_analysis/src/extend_selection.rs b/crates/ra_analysis/src/extend_selection.rs
index 805e9059e..f1b77f981 100644
--- a/crates/ra_analysis/src/extend_selection.rs
+++ b/crates/ra_analysis/src/extend_selection.rs
@@ -18,15 +18,15 @@ pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRang
 }
 
 fn extend_selection_in_macro(
-    db: &RootDatabase,
+    _db: &RootDatabase,
     source_file: &SourceFileNode,
     frange: FileRange,
 ) -> Option<TextRange> {
     let macro_call = find_macro_call(source_file.syntax(), frange.range)?;
-    let exp = crate::macros::expand(db, frange.file_id, macro_call)?;
-    let dst_range = exp.map_range_forward(frange.range)?;
-    let dst_range = ra_editor::extend_selection(exp.source_file().syntax(), dst_range)?;
-    let src_range = exp.map_range_back(dst_range)?;
+    let (off, exp) = hir::MacroDef::ast_expand(macro_call)?;
+    let dst_range = exp.map_range_forward(frange.range - off)?;
+    let dst_range = ra_editor::extend_selection(exp.syntax().borrowed(), dst_range)?;
+    let src_range = exp.map_range_back(dst_range)? + off;
     Some(src_range)
 }
 
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 5669aa94d..ff13247de 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,16 +1,12 @@
-use std::{
-    fmt,
-    sync::Arc,
-};
+use std::sync::Arc;
 
-use rayon::prelude::*;
-use salsa::{Database, ParallelDatabase};
+use salsa::Database;
 
 use hir::{
     self, FnSignatureInfo, Problem, source_binder,
 };
 use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
-use ra_editor::{self, FileSymbol, find_node_at_offset, LineIndex, LocalEdit, Severity};
+use ra_editor::{self, find_node_at_offset, LocalEdit, Severity};
 use ra_syntax::{
     algo::find_covering_node,
     ast::{self, ArgListOwner, Expr, FnDef, NameOwner},
@@ -21,39 +17,26 @@ use ra_syntax::{
 
 use crate::{
     AnalysisChange,
-    Cancelable,
-    completion::{CompletionItem, completions},
+    Cancelable, NavigationTarget,
     CrateId, db, Diagnostic, FileId, FilePosition, FileRange, FileSystemEdit,
     Query, ReferenceResolution, RootChange, SourceChange, SourceFileEdit,
-    symbol_index::{LibrarySymbolsQuery, SymbolIndex, SymbolsDatabase},
+    symbol_index::{LibrarySymbolsQuery, FileSymbol},
 };
 
-#[derive(Debug, Default)]
-pub(crate) struct AnalysisHostImpl {
-    db: db::RootDatabase,
-}
-
-impl AnalysisHostImpl {
-    pub fn analysis(&self) -> AnalysisImpl {
-        AnalysisImpl {
-            db: self.db.snapshot(),
-        }
-    }
-    pub fn apply_change(&mut self, change: AnalysisChange) {
+impl db::RootDatabase {
+    pub(crate) fn apply_change(&mut self, change: AnalysisChange) {
         log::info!("apply_change {:?}", change);
         // self.gc_syntax_trees();
         if !change.new_roots.is_empty() {
-            let mut local_roots = Vec::clone(&self.db.local_roots());
+            let mut local_roots = Vec::clone(&self.local_roots());
             for (root_id, is_local) in change.new_roots {
-                self.db
-                    .query_mut(ra_db::SourceRootQuery)
+                self.query_mut(ra_db::SourceRootQuery)
                     .set(root_id, Default::default());
                 if is_local {
                     local_roots.push(root_id);
                 }
             }
-            self.db
-                .query_mut(ra_db::LocalRootsQuery)
+            self.query_mut(ra_db::LocalRootsQuery)
                 .set((), Arc::new(local_roots));
         }
 
@@ -61,53 +44,44 @@ impl AnalysisHostImpl {
             self.apply_root_change(root_id, root_change);
         }
         for (file_id, text) in change.files_changed {
-            self.db.query_mut(ra_db::FileTextQuery).set(file_id, text)
+            self.query_mut(ra_db::FileTextQuery).set(file_id, text)
         }
         if !change.libraries_added.is_empty() {
-            let mut libraries = Vec::clone(&self.db.library_roots());
+            let mut libraries = Vec::clone(&self.library_roots());
             for library in change.libraries_added {
                 libraries.push(library.root_id);
-                self.db
-                    .query_mut(ra_db::SourceRootQuery)
+                self.query_mut(ra_db::SourceRootQuery)
                     .set(library.root_id, Default::default());
-                self.db
-                    .query_mut(LibrarySymbolsQuery)
+                self.query_mut(LibrarySymbolsQuery)
                     .set_constant(library.root_id, Arc::new(library.symbol_index));
                 self.apply_root_change(library.root_id, library.root_change);
             }
-            self.db
-                .query_mut(ra_db::LibraryRootsQuery)
+            self.query_mut(ra_db::LibraryRootsQuery)
                 .set((), Arc::new(libraries));
         }
         if let Some(crate_graph) = change.crate_graph {
-            self.db
-                .query_mut(ra_db::CrateGraphQuery)
+            self.query_mut(ra_db::CrateGraphQuery)
                 .set((), Arc::new(crate_graph))
         }
     }
 
     fn apply_root_change(&mut self, root_id: SourceRootId, root_change: RootChange) {
-        let mut source_root = SourceRoot::clone(&self.db.source_root(root_id));
+        let mut source_root = SourceRoot::clone(&self.source_root(root_id));
         for add_file in root_change.added {
-            self.db
-                .query_mut(ra_db::FileTextQuery)
+            self.query_mut(ra_db::FileTextQuery)
                 .set(add_file.file_id, add_file.text);
-            self.db
-                .query_mut(ra_db::FileRelativePathQuery)
+            self.query_mut(ra_db::FileRelativePathQuery)
                 .set(add_file.file_id, add_file.path.clone());
-            self.db
-                .query_mut(ra_db::FileSourceRootQuery)
+            self.query_mut(ra_db::FileSourceRootQuery)
                 .set(add_file.file_id, root_id);
             source_root.files.insert(add_file.path, add_file.file_id);
         }
         for remove_file in root_change.removed {
-            self.db
-                .query_mut(ra_db::FileTextQuery)
+            self.query_mut(ra_db::FileTextQuery)
                 .set(remove_file.file_id, Default::default());
             source_root.files.remove(&remove_file.path);
         }
-        self.db
-            .query_mut(ra_db::SourceRootQuery)
+        self.query_mut(ra_db::SourceRootQuery)
             .set(root_id, Arc::new(source_root));
     }
 
@@ -116,147 +90,67 @@ impl AnalysisHostImpl {
     /// syntax trees. However, if we actually do that, everything is recomputed
     /// for some reason. Needs investigation.
     fn gc_syntax_trees(&mut self) {
-        self.db
-            .query(ra_db::SourceFileQuery)
+        self.query(ra_db::SourceFileQuery)
             .sweep(salsa::SweepStrategy::default().discard_values());
-        self.db
-            .query(hir::db::SourceFileItemsQuery)
+        self.query(hir::db::SourceFileItemsQuery)
             .sweep(salsa::SweepStrategy::default().discard_values());
-        self.db
-            .query(hir::db::FileItemQuery)
+        self.query(hir::db::FileItemQuery)
             .sweep(salsa::SweepStrategy::default().discard_values());
     }
 }
 
-pub(crate) struct AnalysisImpl {
-    pub(crate) db: salsa::Snapshot<db::RootDatabase>,
-}
-
-impl fmt::Debug for AnalysisImpl {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let db: &db::RootDatabase = &self.db;
-        fmt.debug_struct("AnalysisImpl").field("db", db).finish()
-    }
-}
-
-impl AnalysisImpl {
-    pub fn file_text(&self, file_id: FileId) -> Arc<String> {
-        self.db.file_text(file_id)
-    }
-    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
-        self.db.source_file(file_id)
-    }
-    pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
-        self.db.file_lines(file_id)
-    }
-    pub fn world_symbols(&self, query: Query) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
-        struct Snap(salsa::Snapshot<db::RootDatabase>);
-        impl Clone for Snap {
-            fn clone(&self) -> Snap {
-                Snap(self.0.snapshot())
-            }
-        }
-
-        let buf: Vec<Arc<SymbolIndex>> = if query.libs {
-            let snap = Snap(self.db.snapshot());
-            self.db
-                .library_roots()
-                .par_iter()
-                .map_with(snap, |db, &lib_id| db.0.library_symbols(lib_id))
-                .collect()
-        } else {
-            let mut files = Vec::new();
-            for &root in self.db.local_roots().iter() {
-                let sr = self.db.source_root(root);
-                files.extend(sr.files.values().map(|&it| it))
-            }
-
-            let snap = Snap(self.db.snapshot());
-            files
-                .par_iter()
-                .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
-                .filter_map(|it| it.ok())
-                .collect()
-        };
-        Ok(query.search(&buf))
-    }
-
-    pub(crate) fn module_path(&self, position: FilePosition) -> Cancelable<Option<String>> {
-        let descr = match source_binder::module_from_position(&*self.db, position)? {
-            None => return Ok(None),
-            Some(it) => it,
-        };
-        let name = match descr.name() {
-            None => return Ok(None),
-            Some(it) => it.to_string(),
-        };
-
-        let modules = descr.path_to_root();
-
-        let path = modules
-            .iter()
-            .filter_map(|s| s.name())
-            .skip(1) // name is already part of the string.
-            .fold(name, |path, it| format!("{}::{}", it, path));
-
-        Ok(Some(path.to_string()))
-    }
-
+impl db::RootDatabase {
     /// This returns `Vec` because a module may be included from several places. We
     /// don't handle this case yet though, so the Vec has length at most one.
-    pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        let descr = match source_binder::module_from_position(&*self.db, position)? {
+    pub(crate) fn parent_module(
+        &self,
+        position: FilePosition,
+    ) -> Cancelable<Vec<NavigationTarget>> {
+        let descr = match source_binder::module_from_position(self, position)? {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
-        let (file_id, decl) = match descr.parent_link_source(&*self.db) {
+        let (file_id, decl) = match descr.parent_link_source(self) {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
         let decl = decl.borrowed();
         let decl_name = decl.name().unwrap();
-        let sym = FileSymbol {
+        let symbol = FileSymbol {
             name: decl_name.text(),
             node_range: decl_name.syntax().range(),
             kind: MODULE,
         };
-        Ok(vec![(file_id, sym)])
+        Ok(vec![NavigationTarget { file_id, symbol }])
     }
     /// Returns `Vec` for the same reason as `parent_module`
-    pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        let descr = match source_binder::module_from_file_id(&*self.db, file_id)? {
+    pub(crate) fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
+        let descr = match source_binder::module_from_file_id(self, file_id)? {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
         let root = descr.crate_root();
-        let file_id = root.source().file_id();
+        let file_id = root.file_id();
 
-        let crate_graph = self.db.crate_graph();
+        let crate_graph = self.crate_graph();
         let crate_id = crate_graph.crate_id_for_crate_root(file_id);
         Ok(crate_id.into_iter().collect())
     }
-    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.db.crate_graph().crate_root(crate_id)
-    }
-    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        let completions = completions(&self.db, position)?;
-        Ok(completions.map(|it| it.into()))
+    pub(crate) fn crate_root(&self, crate_id: CrateId) -> FileId {
+        self.crate_graph().crate_root(crate_id)
     }
-    pub fn approximately_resolve_symbol(
+    pub(crate) fn approximately_resolve_symbol(
         &self,
         position: FilePosition,
     ) -> Cancelable<Option<ReferenceResolution>> {
-        let file = self.db.source_file(position.file_id);
+        let file = self.source_file(position.file_id);
         let syntax = file.syntax();
         if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
             let mut rr = ReferenceResolution::new(name_ref.syntax().range());
-            if let Some(fn_descr) = source_binder::function_from_child_node(
-                &*self.db,
-                position.file_id,
-                name_ref.syntax(),
-            )? {
-                let scope = fn_descr.scopes(&*self.db);
+            if let Some(fn_descr) =
+                source_binder::function_from_child_node(self, position.file_id, name_ref.syntax())?
+            {
+                let scope = fn_descr.scopes(self);
                 // First try to resolve the symbol locally
                 if let Some(entry) = scope.resolve_local_name(name_ref) {
                     rr.add_resolution(
@@ -281,9 +175,9 @@ impl AnalysisImpl {
             if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                 if module.has_semi() {
                     if let Some(child_module) =
-                        source_binder::module_from_declaration(&*self.db, position.file_id, module)?
+                        source_binder::module_from_declaration(self, position.file_id, module)?
                     {
-                        let file_id = child_module.source().file_id();
+                        let file_id = child_module.file_id();
                         let name = match child_module.name() {
                             Some(name) => name.to_string().into(),
                             None => "".into(),
@@ -302,10 +196,13 @@ impl AnalysisImpl {
         Ok(None)
     }
 
-    pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
-        let file = self.db.source_file(position.file_id);
+    pub(crate) fn find_all_refs(
+        &self,
+        position: FilePosition,
+    ) -> Cancelable<Vec<(FileId, TextRange)>> {
+        let file = self.source_file(position.file_id);
         // Find the binding associated with the offset
-        let (binding, descr) = match find_binding(&self.db, &file, position)? {
+        let (binding, descr) = match find_binding(self, &file, position)? {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
@@ -317,7 +214,7 @@ impl AnalysisImpl {
             .collect::<Vec<_>>();
         ret.extend(
             descr
-                .scopes(&*self.db)
+                .scopes(self)
                 .find_all_refs(binding)
                 .into_iter()
                 .map(|ref_desc| (position.file_id, ref_desc.range)),
@@ -355,9 +252,9 @@ impl AnalysisImpl {
             Ok(Some((binding, descr)))
         }
     }
-    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
-        let file = self.db.source_file(file_id);
-        let result = match (symbol.description(&file), symbol.docs(&file)) {
+    pub(crate) fn doc_text_for(&self, nav: NavigationTarget) -> Cancelable<Option<String>> {
+        let file = self.source_file(nav.file_id);
+        let result = match (nav.symbol.description(&file), nav.symbol.docs(&file)) {
             (Some(desc), Some(docs)) => {
                 Some("```rust\n".to_string() + &*desc + "\n```\n\n" + &*docs)
             }
@@ -369,8 +266,8 @@ impl AnalysisImpl {
         Ok(result)
     }
 
-    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
-        let syntax = self.db.source_file(file_id);
+    pub(crate) fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
+        let syntax = self.source_file(file_id);
 
         let mut res = ra_editor::diagnostics(&syntax)
             .into_iter()
@@ -381,9 +278,9 @@ impl AnalysisImpl {
                 fix: d.fix.map(|fix| SourceChange::from_local_edit(file_id, fix)),
             })
             .collect::<Vec<_>>();
-        if let Some(m) = source_binder::module_from_file_id(&*self.db, file_id)? {
-            for (name_node, problem) in m.problems(&*self.db) {
-                let source_root = self.db.file_source_root(file_id);
+        if let Some(m) = source_binder::module_from_file_id(self, file_id)? {
+            for (name_node, problem) in m.problems(self) {
+                let source_root = self.file_source_root(file_id);
                 let diag = match problem {
                     Problem::UnresolvedModule { candidate } => {
                         let create_file = FileSystemEdit::CreateFile {
@@ -433,8 +330,8 @@ impl AnalysisImpl {
         Ok(res)
     }
 
-    pub fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
-        let file = self.file_syntax(frange.file_id);
+    pub(crate) fn assists(&self, frange: FileRange) -> Vec<SourceChange> {
+        let file = self.source_file(frange.file_id);
         let offset = frange.range.start();
         let actions = vec![
             ra_editor::flip_comma(&file, offset).map(|f| f()),
@@ -451,11 +348,11 @@ impl AnalysisImpl {
             .collect()
     }
 
-    pub fn resolve_callable(
+    pub(crate) fn resolve_callable(
         &self,
         position: FilePosition,
     ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
-        let file = self.db.source_file(position.file_id);
+        let file = self.source_file(position.file_id);
         let syntax = file.syntax();
 
         // Find the calling expression and it's NameRef
@@ -466,12 +363,12 @@ impl AnalysisImpl {
         let file_symbols = self.index_resolve(name_ref)?;
         for (fn_file_id, fs) in file_symbols {
             if fs.kind == FN_DEF {
-                let fn_file = self.db.source_file(fn_file_id);
+                let fn_file = self.source_file(fn_file_id);
                 if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) {
                     let descr = ctry!(source_binder::function_from_source(
-                        &*self.db, fn_file_id, fn_def
+                        self, fn_file_id, fn_def
                     )?);
-                    if let Some(descriptor) = descr.signature_info(&*self.db) {
+                    if let Some(descriptor) = descr.signature_info(self) {
                         // If we have a calling expression let's find which argument we are on
                         let mut current_parameter = None;
 
@@ -518,20 +415,20 @@ impl AnalysisImpl {
         Ok(None)
     }
 
-    pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
-        let file = self.db.source_file(frange.file_id);
+    pub(crate) fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
+        let file = self.source_file(frange.file_id);
         let syntax = file.syntax();
         let node = find_covering_node(syntax, frange.range);
         let parent_fn = ctry!(node.ancestors().find_map(FnDef::cast));
         let function = ctry!(source_binder::function_from_source(
-            &*self.db,
+            self,
             frange.file_id,
             parent_fn
         )?);
-        let infer = function.infer(&*self.db)?;
+        let infer = function.infer(self)?;
         Ok(infer.type_of_node(node).map(|t| t.to_string()))
     }
-    pub fn rename(
+    pub(crate) fn rename(
         &self,
         position: FilePosition,
         new_name: &str,
@@ -555,7 +452,7 @@ impl AnalysisImpl {
         let mut query = Query::new(name.to_string());
         query.exact();
         query.limit(4);
-        self.world_symbols(query)
+        crate::symbol_index::world_symbols(self, query)
     }
 }
 
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index e6cfaecc3..a01febf4e 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -19,33 +19,30 @@ mod runnables;
 
 mod extend_selection;
 mod syntax_highlighting;
-mod macros;
 
 use std::{fmt, sync::Arc};
 
 use rustc_hash::FxHashMap;
-use ra_syntax::{SourceFileNode, TextRange, TextUnit};
+use ra_syntax::{SourceFileNode, TextRange, TextUnit, SmolStr, SyntaxKind};
 use ra_text_edit::TextEdit;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
+use salsa::ParallelDatabase;
 
-use crate::{
-    imp::{AnalysisHostImpl, AnalysisImpl},
-    symbol_index::SymbolIndex,
-};
+use crate::symbol_index::{SymbolIndex, FileSymbol};
 
 pub use crate::{
     completion::{CompletionItem, CompletionItemKind, InsertText},
-    runnables::{Runnable, RunnableKind}
+    runnables::{Runnable, RunnableKind},
 };
 pub use ra_editor::{
-    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, StructureNode, Severity
+    Fold, FoldKind, HighlightedRange, LineIndex, StructureNode, Severity
 };
 pub use hir::FnSignatureInfo;
 
 pub use ra_db::{
     Canceled, Cancelable, FilePosition, FileRange,
-    CrateGraph, CrateId, SourceRootId, FileId
+    CrateGraph, CrateId, SourceRootId, FileId, SyntaxDatabase, FilesDatabase
 };
 
 #[derive(Default)]
@@ -151,27 +148,6 @@ impl AnalysisChange {
     }
 }
 
-/// `AnalysisHost` stores the current state of the world.
-#[derive(Debug, Default)]
-pub struct AnalysisHost {
-    imp: AnalysisHostImpl,
-}
-
-impl AnalysisHost {
-    /// Returns a snapshot of the current state, which you can query for
-    /// semantic information.
-    pub fn analysis(&self) -> Analysis {
-        Analysis {
-            imp: self.imp.analysis(),
-        }
-    }
-    /// Applies changes to the current state of the world. If there are
-    /// outstanding snapshots, they will be canceled.
-    pub fn apply_change(&mut self, change: AnalysisChange) {
-        self.imp.apply_change(change)
-    }
-}
-
 #[derive(Debug)]
 pub struct SourceChange {
     pub label: String,
@@ -243,6 +219,27 @@ impl Query {
     }
 }
 
+#[derive(Debug)]
+pub struct NavigationTarget {
+    file_id: FileId,
+    symbol: FileSymbol,
+}
+
+impl NavigationTarget {
+    pub fn name(&self) -> SmolStr {
+        self.symbol.name.clone()
+    }
+    pub fn kind(&self) -> SyntaxKind {
+        self.symbol.kind
+    }
+    pub fn file_id(&self) -> FileId {
+        self.file_id
+    }
+    pub fn range(&self) -> TextRange {
+        self.symbol.node_range
+    }
+}
+
 /// Result of "goto def" query.
 #[derive(Debug)]
 pub struct ReferenceResolution {
@@ -251,7 +248,7 @@ pub struct ReferenceResolution {
     /// client where the reference was.
     pub reference_range: TextRange,
     /// What this reference resolves to.
-    pub resolves_to: Vec<(FileId, FileSymbol)>,
+    pub resolves_to: Vec<NavigationTarget>,
 }
 
 impl ReferenceResolution {
@@ -263,7 +260,28 @@ impl ReferenceResolution {
     }
 
     fn add_resolution(&mut self, file_id: FileId, symbol: FileSymbol) {
-        self.resolves_to.push((file_id, symbol))
+        self.resolves_to.push(NavigationTarget { file_id, symbol })
+    }
+}
+
+/// `AnalysisHost` stores the current state of the world.
+#[derive(Debug, Default)]
+pub struct AnalysisHost {
+    db: db::RootDatabase,
+}
+
+impl AnalysisHost {
+    /// Returns a snapshot of the current state, which you can query for
+    /// semantic information.
+    pub fn analysis(&self) -> Analysis {
+        Analysis {
+            db: self.db.snapshot(),
+        }
+    }
+    /// Applies changes to the current state of the world. If there are
+    /// outstanding snapshots, they will be canceled.
+    pub fn apply_change(&mut self, change: AnalysisChange) {
+        self.db.apply_change(change)
     }
 }
 
@@ -273,112 +291,146 @@ impl ReferenceResolution {
 /// `Analysis` are canceled (most method return `Err(Canceled)`).
 #[derive(Debug)]
 pub struct Analysis {
-    pub(crate) imp: AnalysisImpl,
+    db: salsa::Snapshot<db::RootDatabase>,
 }
 
 impl Analysis {
+    /// Gets the text of the source file.
     pub fn file_text(&self, file_id: FileId) -> Arc<String> {
-        self.imp.file_text(file_id)
+        self.db.file_text(file_id)
     }
+    /// Gets the syntax tree of the file.
     pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
-        self.imp.file_syntax(file_id).clone()
+        self.db.source_file(file_id).clone()
     }
+    /// Gets the file's `LineIndex`: data structure to convert between absolute
+    /// offsets and line/column representation.
     pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
-        self.imp.file_line_index(file_id)
+        self.db.file_lines(file_id)
     }
+    /// Selects the next syntactic nodes encopasing the range.
     pub fn extend_selection(&self, frange: FileRange) -> TextRange {
-        extend_selection::extend_selection(&self.imp.db, frange)
+        extend_selection::extend_selection(&self.db, frange)
     }
+    /// Returns position of the mathcing brace (all types of braces are
+    /// supported).
     pub fn matching_brace(&self, file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
         ra_editor::matching_brace(file, offset)
     }
+    /// Returns a syntax tree represented as `String`, for debug purposes.
+    // FIXME: use a better name here.
     pub fn syntax_tree(&self, file_id: FileId) -> String {
-        let file = self.imp.file_syntax(file_id);
+        let file = self.db.source_file(file_id);
         ra_editor::syntax_tree(&file)
     }
+    /// Returns an edit to remove all newlines in the range, cleaning up minor
+    /// stuff like trailing commas.
     pub fn join_lines(&self, frange: FileRange) -> SourceChange {
-        let file = self.imp.file_syntax(frange.file_id);
+        let file = self.db.source_file(frange.file_id);
         SourceChange::from_local_edit(frange.file_id, ra_editor::join_lines(&file, frange.range))
     }
+    /// Returns an edit which should be applied when opening a new line, fixing
+    /// up minor stuff like continuing the comment.
     pub fn on_enter(&self, position: FilePosition) -> Option<SourceChange> {
-        let file = self.imp.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
         let edit = ra_editor::on_enter(&file, position.offset)?;
-        let res = SourceChange::from_local_edit(position.file_id, edit);
-        Some(res)
+        Some(SourceChange::from_local_edit(position.file_id, edit))
     }
+    /// Returns an edit which should be applied after `=` was typed. Primaraly,
+    /// this works when adding `let =`.
+    // FIXME: use a snippet completion instead of this hack here.
     pub fn on_eq_typed(&self, position: FilePosition) -> Option<SourceChange> {
-        let file = self.imp.file_syntax(position.file_id);
-        Some(SourceChange::from_local_edit(
-            position.file_id,
-            ra_editor::on_eq_typed(&file, position.offset)?,
-        ))
+        let file = self.db.source_file(position.file_id);
+        let edit = ra_editor::on_eq_typed(&file, position.offset)?;
+        Some(SourceChange::from_local_edit(position.file_id, edit))
     }
+    /// Returns a tree representation of symbols in the file. Useful to draw a
+    /// file outline.
     pub fn file_structure(&self, file_id: FileId) -> Vec<StructureNode> {
-        let file = self.imp.file_syntax(file_id);
+        let file = self.db.source_file(file_id);
         ra_editor::file_structure(&file)
     }
+    /// Returns the set of folding ranges.
     pub fn folding_ranges(&self, file_id: FileId) -> Vec<Fold> {
-        let file = self.imp.file_syntax(file_id);
+        let file = self.db.source_file(file_id);
         ra_editor::folding_ranges(&file)
     }
-    pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        self.imp.world_symbols(query)
+    /// Fuzzy searches for a symbol.
+    pub fn symbol_search(&self, query: Query) -> Cancelable<Vec<NavigationTarget>> {
+        let res = symbol_index::world_symbols(&*self.db, query)?
+            .into_iter()
+            .map(|(file_id, symbol)| NavigationTarget { file_id, symbol })
+            .collect();
+        Ok(res)
     }
+    /// Resolves reference to definition, but does not gurantee correctness.
     pub fn approximately_resolve_symbol(
         &self,
         position: FilePosition,
     ) -> Cancelable<Option<ReferenceResolution>> {
-        self.imp.approximately_resolve_symbol(position)
+        self.db.approximately_resolve_symbol(position)
     }
+    /// Finds all usages of the reference at point.
     pub fn find_all_refs(&self, position: FilePosition) -> Cancelable<Vec<(FileId, TextRange)>> {
-        self.imp.find_all_refs(position)
-    }
-    pub fn doc_text_for(&self, file_id: FileId, symbol: FileSymbol) -> Cancelable<Option<String>> {
-        self.imp.doc_text_for(file_id, symbol)
+        self.db.find_all_refs(position)
     }
-    pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        self.imp.parent_module(position)
+    /// Returns documentation string for a given target.
+    pub fn doc_text_for(&self, nav: NavigationTarget) -> Cancelable<Option<String>> {
+        self.db.doc_text_for(nav)
     }
-    pub fn module_path(&self, position: FilePosition) -> Cancelable<Option<String>> {
-        self.imp.module_path(position)
+    /// Returns a `mod name;` declaration whihc created the current module.
+    pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<NavigationTarget>> {
+        self.db.parent_module(position)
     }
+    /// Returns crates this file belongs too.
     pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        self.imp.crate_for(file_id)
+        self.db.crate_for(file_id)
     }
+    /// Returns the root file of the given crate.
     pub fn crate_root(&self, crate_id: CrateId) -> Cancelable<FileId> {
-        Ok(self.imp.crate_root(crate_id))
+        Ok(self.db.crate_root(crate_id))
     }
+    /// Returns the set of possible targets to run for the current file.
     pub fn runnables(&self, file_id: FileId) -> Cancelable<Vec<Runnable>> {
-        let file = self.imp.file_syntax(file_id);
-        Ok(runnables::runnables(self, &file, file_id))
+        runnables::runnables(&*self.db, file_id)
     }
+    /// Computes syntax highlighting for the given file.
     pub fn highlight(&self, file_id: FileId) -> Cancelable<Vec<HighlightedRange>> {
-        syntax_highlighting::highlight(&*self.imp.db, file_id)
+        syntax_highlighting::highlight(&*self.db, file_id)
     }
+    /// Computes completions at the given position.
     pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
-        self.imp.completions(position)
+        let completions = completion::completions(&self.db, position)?;
+        Ok(completions.map(|it| it.into()))
     }
+    /// Computes assists (aks code actons aka intentions) for the given
+    /// position.
     pub fn assists(&self, frange: FileRange) -> Cancelable<Vec<SourceChange>> {
-        Ok(self.imp.assists(frange))
+        Ok(self.db.assists(frange))
     }
+    /// Computes the set of diagnostics for the given file.
     pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
-        self.imp.diagnostics(file_id)
+        self.db.diagnostics(file_id)
     }
+    /// Computes parameter information for the given call expression.
     pub fn resolve_callable(
         &self,
         position: FilePosition,
     ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
-        self.imp.resolve_callable(position)
+        self.db.resolve_callable(position)
     }
+    /// Computes the type of the expression at the given position.
     pub fn type_of(&self, frange: FileRange) -> Cancelable<Option<String>> {
-        self.imp.type_of(frange)
+        self.db.type_of(frange)
     }
+    /// Returns the edit required to rename reference at the position to the new
+    /// name.
     pub fn rename(
         &self,
         position: FilePosition,
         new_name: &str,
     ) -> Cancelable<Vec<SourceFileEdit>> {
-        self.imp.rename(position, new_name)
+        self.db.rename(position, new_name)
     }
 }
 
diff --git a/crates/ra_analysis/src/macros.rs b/crates/ra_analysis/src/macros.rs
deleted file mode 100644
index b9feb7fad..000000000
--- a/crates/ra_analysis/src/macros.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-/// Begining of macro expansion.
-///
-/// This code should be moved out of ra_analysis into hir (?) ideally.
-use ra_syntax::{ast, AstNode, SourceFileNode, TextRange};
-
-use crate::{db::RootDatabase, FileId};
-
-pub(crate) fn expand(
-    _db: &RootDatabase,
-    _file_id: FileId,
-    macro_call: ast::MacroCall,
-) -> Option<MacroExpansion> {
-    let path = macro_call.path()?;
-    if path.qualifier().is_some() {
-        return None;
-    }
-    let name_ref = path.segment()?.name_ref()?;
-    if name_ref.text() != "ctry" {
-        return None;
-    }
-
-    let arg = macro_call.token_tree()?;
-    let text = format!(
-        r"
-        fn dummy() {{
-            match {} {{
-                None => return Ok(None),
-                Some(it) => it,
-            }}
-        }}",
-        arg.syntax().text()
-    );
-    let file = SourceFileNode::parse(&text);
-    let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
-    let match_arg = match_expr.expr()?;
-    let ranges_map = vec![(arg.syntax().range(), match_arg.syntax().range())];
-    let res = MacroExpansion {
-        source_file: file,
-        ranges_map,
-    };
-    Some(res)
-}
-
-pub(crate) struct MacroExpansion {
-    pub(crate) source_file: SourceFileNode,
-    pub(crate) ranges_map: Vec<(TextRange, TextRange)>,
-}
-
-impl MacroExpansion {
-    pub(crate) fn source_file(&self) -> &SourceFileNode {
-        &self.source_file
-    }
-    pub(crate) fn map_range_back(&self, tgt_range: TextRange) -> Option<TextRange> {
-        for (s_range, t_range) in self.ranges_map.iter() {
-            if tgt_range.is_subrange(&t_range) {
-                let tgt_at_zero_range = tgt_range - tgt_range.start();
-                let tgt_range_offset = tgt_range.start() - t_range.start();
-                let src_range = tgt_at_zero_range + tgt_range_offset + s_range.start();
-                return Some(src_range);
-            }
-        }
-        None
-    }
-    pub(crate) fn map_range_forward(&self, src_range: TextRange) -> Option<TextRange> {
-        for (s_range, t_range) in self.ranges_map.iter() {
-            if src_range.is_subrange(&s_range) {
-                let src_at_zero_range = src_range - src_range.start();
-                let src_range_offset = src_range.start() - s_range.start();
-                let src_range = src_at_zero_range + src_range_offset + t_range.start();
-                return Some(src_range);
-            }
-        }
-        None
-    }
-}
diff --git a/crates/ra_analysis/src/runnables.rs b/crates/ra_analysis/src/runnables.rs
index 61ca0930a..474267605 100644
--- a/crates/ra_analysis/src/runnables.rs
+++ b/crates/ra_analysis/src/runnables.rs
@@ -1,11 +1,11 @@
+use itertools::Itertools;
 use ra_syntax::{
     ast::{self, AstNode, NameOwner, ModuleItemOwner},
-    SourceFileNode, TextRange, SyntaxNodeRef,
-    TextUnit,
-};
-use crate::{
-    Analysis, FileId, FilePosition
+    TextRange, SyntaxNodeRef,
 };
+use ra_db::{Cancelable, SyntaxDatabase};
+
+use crate::{db::RootDatabase, FileId};
 
 #[derive(Debug)]
 pub struct Runnable {
@@ -20,53 +20,67 @@ pub enum RunnableKind {
     Bin,
 }
 
-pub fn runnables(
-    analysis: &Analysis,
-    file_node: &SourceFileNode,
-    file_id: FileId,
-) -> Vec<Runnable> {
-    file_node
+pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Runnable>> {
+    let source_file = db.source_file(file_id);
+    let res = source_file
         .syntax()
         .descendants()
-        .filter_map(|i| runnable(analysis, i, file_id))
-        .collect()
+        .filter_map(|i| runnable(db, file_id, i))
+        .collect();
+    Ok(res)
 }
 
-fn runnable<'a>(analysis: &Analysis, item: SyntaxNodeRef<'a>, file_id: FileId) -> Option<Runnable> {
-    if let Some(f) = ast::FnDef::cast(item) {
-        let name = f.name()?.text();
-        let kind = if name == "main" {
-            RunnableKind::Bin
-        } else if f.has_atom_attr("test") {
-            RunnableKind::Test {
-                name: name.to_string(),
-            }
-        } else {
-            return None;
-        };
-        Some(Runnable {
-            range: f.syntax().range(),
-            kind,
-        })
+fn runnable(db: &RootDatabase, file_id: FileId, item: SyntaxNodeRef) -> Option<Runnable> {
+    if let Some(fn_def) = ast::FnDef::cast(item) {
+        runnable_fn(fn_def)
     } else if let Some(m) = ast::Module::cast(item) {
-        if m.item_list()?
-            .items()
-            .map(ast::ModuleItem::syntax)
-            .filter_map(ast::FnDef::cast)
-            .any(|f| f.has_atom_attr("test"))
-        {
-            let postition = FilePosition {
-                file_id,
-                offset: m.syntax().range().start() + TextUnit::from_usize(1),
-            };
-            analysis.module_path(postition).ok()?.map(|path| Runnable {
-                range: m.syntax().range(),
-                kind: RunnableKind::TestMod { path },
-            })
-        } else {
-            None
-        }
+        runnable_mod(db, file_id, m)
     } else {
         None
     }
 }
+
+fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
+    let name = fn_def.name()?.text();
+    let kind = if name == "main" {
+        RunnableKind::Bin
+    } else if fn_def.has_atom_attr("test") {
+        RunnableKind::Test {
+            name: name.to_string(),
+        }
+    } else {
+        return None;
+    };
+    Some(Runnable {
+        range: fn_def.syntax().range(),
+        kind,
+    })
+}
+
+fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Option<Runnable> {
+    let has_test_function = module
+        .item_list()?
+        .items()
+        .filter_map(|it| match it {
+            ast::ModuleItem::FnDef(it) => Some(it),
+            _ => None,
+        })
+        .any(|f| f.has_atom_attr("test"));
+    if !has_test_function {
+        return None;
+    }
+    let range = module.syntax().range();
+    let module =
+        hir::source_binder::module_from_child_node(db, file_id, module.syntax()).ok()??;
+    let path = module
+        .path_to_root()
+        .into_iter()
+        .rev()
+        .into_iter()
+        .filter_map(|it| it.name().map(Clone::clone))
+        .join("::");
+    Some(Runnable {
+        range,
+        kind: RunnableKind::TestMod { path },
+    })
+}
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index e5bdf0aa1..ddcf3d052 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -4,17 +4,19 @@ use std::{
 };
 
 use fst::{self, Streamer};
-use ra_editor::{self, FileSymbol};
 use ra_syntax::{
-    SourceFileNode,
+    AstNode, SyntaxNodeRef, SourceFileNode, SmolStr, TextRange,
+    algo::visit::{visitor, Visitor},
     SyntaxKind::{self, *},
+    ast::{self, NameOwner, DocCommentsOwner},
 };
-use ra_db::{SyntaxDatabase, SourceRootId};
+use ra_db::{SyntaxDatabase, SourceRootId, FilesDatabase};
+use salsa::ParallelDatabase;
 use rayon::prelude::*;
 
 use crate::{
-    Cancelable,
-    FileId, Query,
+    Cancelable, FileId, Query,
+    db::RootDatabase,
 };
 
 salsa::query_group! {
@@ -35,6 +37,41 @@ fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<Sym
     Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
 }
 
+pub(crate) fn world_symbols(
+    db: &RootDatabase,
+    query: Query,
+) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+    /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
+    struct Snap(salsa::Snapshot<RootDatabase>);
+    impl Clone for Snap {
+        fn clone(&self) -> Snap {
+            Snap(self.0.snapshot())
+        }
+    }
+
+    let buf: Vec<Arc<SymbolIndex>> = if query.libs {
+        let snap = Snap(db.snapshot());
+        db.library_roots()
+            .par_iter()
+            .map_with(snap, |db, &lib_id| db.0.library_symbols(lib_id))
+            .collect()
+    } else {
+        let mut files = Vec::new();
+        for &root in db.local_roots().iter() {
+            let sr = db.source_root(root);
+            files.extend(sr.files.values().map(|&it| it))
+        }
+
+        let snap = Snap(db.snapshot());
+        files
+            .par_iter()
+            .map_with(snap, |db, &file_id| db.0.file_symbols(file_id))
+            .filter_map(|it| it.ok())
+            .collect()
+    };
+    Ok(query.search(&buf))
+}
+
 #[derive(Default, Debug)]
 pub(crate) struct SymbolIndex {
     symbols: Vec<(FileId, FileSymbol)>,
@@ -65,8 +102,9 @@ impl SymbolIndex {
     ) -> SymbolIndex {
         let mut symbols = files
             .flat_map(|(file_id, file)| {
-                ra_editor::file_symbols(&file)
-                    .into_iter()
+                file.syntax()
+                    .descendants()
+                    .filter_map(to_symbol)
                     .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
                     .collect::<Vec<_>>()
             })
@@ -121,3 +159,116 @@ fn is_type(kind: SyntaxKind) -> bool {
         _ => false,
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct FileSymbol {
+    pub(crate) name: SmolStr,
+    pub(crate) node_range: TextRange,
+    pub(crate) kind: SyntaxKind,
+}
+
+impl FileSymbol {
+    pub(crate) fn docs(&self, file: &SourceFileNode) -> Option<String> {
+        file.syntax()
+            .descendants()
+            .filter(|node| node.kind() == self.kind && node.range() == self.node_range)
+            .filter_map(|node: SyntaxNodeRef| {
+                fn doc_comments<'a, N: DocCommentsOwner<'a>>(node: N) -> Option<String> {
+                    let comments = node.doc_comment_text();
+                    if comments.is_empty() {
+                        None
+                    } else {
+                        Some(comments)
+                    }
+                }
+
+                visitor()
+                    .visit(doc_comments::<ast::FnDef>)
+                    .visit(doc_comments::<ast::StructDef>)
+                    .visit(doc_comments::<ast::EnumDef>)
+                    .visit(doc_comments::<ast::TraitDef>)
+                    .visit(doc_comments::<ast::Module>)
+                    .visit(doc_comments::<ast::TypeDef>)
+                    .visit(doc_comments::<ast::ConstDef>)
+                    .visit(doc_comments::<ast::StaticDef>)
+                    .accept(node)?
+            })
+            .nth(0)
+    }
+    /// Get a description of this node.
+    ///
+    /// e.g. `struct Name`, `enum Name`, `fn Name`
+    pub(crate) fn description(&self, file: &SourceFileNode) -> Option<String> {
+        // TODO: After type inference is done, add type information to improve the output
+        file.syntax()
+            .descendants()
+            .filter(|node| node.kind() == self.kind && node.range() == self.node_range)
+            .filter_map(|node: SyntaxNodeRef| {
+                // TODO: Refactor to be have less repetition
+                visitor()
+                    .visit(|node: ast::FnDef| {
+                        let mut string = "fn ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::StructDef| {
+                        let mut string = "struct ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::EnumDef| {
+                        let mut string = "enum ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::TraitDef| {
+                        let mut string = "trait ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::Module| {
+                        let mut string = "mod ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::TypeDef| {
+                        let mut string = "type ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::ConstDef| {
+                        let mut string = "const ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .visit(|node: ast::StaticDef| {
+                        let mut string = "static ".to_string();
+                        node.name()?.syntax().text().push_to(&mut string);
+                        Some(string)
+                    })
+                    .accept(node)?
+            })
+            .nth(0)
+    }
+}
+
+fn to_symbol(node: SyntaxNodeRef) -> Option<FileSymbol> {
+    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<FileSymbol> {
+        let name = node.name()?;
+        Some(FileSymbol {
+            name: name.text(),
+            node_range: node.syntax().range(),
+            kind: node.syntax().kind(),
+        })
+    }
+    visitor()
+        .visit(decl::<ast::FnDef>)
+        .visit(decl::<ast::StructDef>)
+        .visit(decl::<ast::EnumDef>)
+        .visit(decl::<ast::TraitDef>)
+        .visit(decl::<ast::Module>)
+        .visit(decl::<ast::TypeDef>)
+        .visit(decl::<ast::ConstDef>)
+        .visit(decl::<ast::StaticDef>)
+        .accept(node)?
+}
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
index 7e9139a74..ccea4aee3 100644
--- a/crates/ra_analysis/src/syntax_highlighting.rs
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -15,13 +15,13 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Hi
         .descendants()
         .filter_map(ast::MacroCall::cast)
     {
-        if let Some(exp) = crate::macros::expand(db, file_id, macro_call) {
-            let mapped_ranges = ra_editor::highlight(exp.source_file().syntax())
+        if let Some((off, exp)) = hir::MacroDef::ast_expand(macro_call) {
+            let mapped_ranges = ra_editor::highlight(exp.syntax().borrowed())
                 .into_iter()
                 .filter_map(|r| {
                     let mapped_range = exp.map_range_back(r.range)?;
                     let res = HighlightedRange {
-                        range: mapped_range,
+                        range: mapped_range + off,
                         tag: r.tag,
                     };
                     Some(res)
@@ -44,7 +44,7 @@ mod tests {
             fn main() {
                 ctry!({ let x = 92; x});
             }
-        ",
+            ",
         );
         let highlights = analysis.highlight(file_id).unwrap();
         assert_eq_dbg(
@@ -60,4 +60,26 @@ mod tests {
             &highlights,
         )
     }
+
+    // FIXME: this test is not really necessary: artifact of the inital hacky
+    // macros implementation.
+    #[test]
+    fn highlight_query_group_macro() {
+        let (analysis, file_id) = single_file(
+            "
+            salsa::query_group! {
+                pub trait HirDatabase: SyntaxDatabase {}
+            }
+            ",
+        );
+        let highlights = analysis.highlight(file_id).unwrap();
+        assert_eq_dbg(
+            r#"[HighlightedRange { range: [20; 32), tag: "macro" },
+                HighlightedRange { range: [13; 18), tag: "text" },
+                HighlightedRange { range: [51; 54), tag: "keyword" },
+                HighlightedRange { range: [55; 60), tag: "keyword" },
+                HighlightedRange { range: [61; 72), tag: "function" }]"#,
+            &highlights,
+        )
+    }
 }