41 files changed, 1680 insertions, 1223 deletions
diff --git a/crates/gen_lsp_server/src/msg.rs b/crates/gen_lsp_server/src/msg.rs
index e0d0aeab5..e1b27c808 100644
--- a/crates/gen_lsp_server/src/msg.rs
+++ b/crates/gen_lsp_server/src/msg.rs
@@ -94,7 +94,7 @@ impl RawRequest {
        R::Params: Serialize,
    {
        RawRequest {
-            id: id,
+            id,
            method: R::METHOD.to_string(),
            params: to_value(params).unwrap(),
        }
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index b4a1a09b5..fe9765a66 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -14,4 +14,6 @@ rustc-hash = "1.0"
 parking_lot = "0.6.4"
 ra_syntax = { path = "../ra_syntax" }
 ra_editor = { path = "../ra_editor" }
+ra_db = { path = "../ra_db" }
+hir = { path = "../ra_hir", package = "ra_hir" }
 test_utils = { path = "../test_utils" }
diff --git a/crates/ra_analysis/src/arena.rs b/crates/ra_analysis/src/arena.rs
deleted file mode 100644
index 98ed89274..000000000
--- a/crates/ra_analysis/src/arena.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-//! A simple id-based arena, similar to https://github.com/fitzgen/id-arena.
-//! We use our own version for more compact id's and to allow inherent impls
-//! on Ids.
-use std::{
-    fmt,
-    ops::{Index, IndexMut},
-    hash::{Hash, Hasher},
-    marker::PhantomData,
-};
-pub(crate) struct Id<T> {
-    idx: u32,
-    _ty: PhantomData<fn() -> T>,
-}
-impl<T> fmt::Debug for Id<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Id").field(&self.idx).finish()
-    }
-}
-impl<T> Copy for Id<T> {}
-impl<T> Clone for Id<T> {
-    fn clone(&self) -> Id<T> {
-        *self
-    }
-}
-impl<T> PartialEq for Id<T> {
-    fn eq(&self, other: &Id<T>) -> bool {
-        self.idx == other.idx
-    }
-}
-impl<T> Eq for Id<T> {}
-impl<T> Hash for Id<T> {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.idx.hash(h);
-    }
-}
-#[derive(Debug, PartialEq, Eq)]
-pub(crate) struct Arena<T> {
-    data: Vec<T>,
-}
-impl<T> Default for Arena<T> {
-    fn default() -> Arena<T> {
-        Arena { data: Vec::new() }
-    }
-}
-impl<T> Arena<T> {
-    pub(crate) fn push(&mut self, value: T) -> Id<T> {
-        let id = self.data.len() as u32;
-        self.data.push(value);
-        Id {
-            idx: id as u32,
-            _ty: PhantomData,
-        }
-    }
-    pub(crate) fn keys<'a>(&'a self) -> impl Iterator<Item = Id<T>> + 'a {
-        (0..(self.data.len() as u32)).into_iter().map(|idx| Id {
-            idx,
-            _ty: PhantomData,
-        })
-    }
-    pub(crate) fn items<'a>(&'a self) -> impl Iterator<Item = (Id<T>, &T)> + 'a {
-        self.data.iter().enumerate().map(|(idx, item)| {
-            let idx = idx as u32;
-            (
-                Id {
-                    idx,
-                    _ty: PhantomData,
-                },
-                item,
-            )
-        })
-    }
-}
-impl<T> Index<Id<T>> for Arena<T> {
-    type Output = T;
-    fn index(&self, id: Id<T>) -> &T {
-        &self.data[id.idx as usize]
-    }
-}
-impl<T> IndexMut<Id<T>> for Arena<T> {
-    fn index_mut(&mut self, id: Id<T>) -> &mut T {
-        &mut self.data[id.idx as usize]
-    }
-}
diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index d7acca044..124da486a 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -7,13 +7,11 @@ use ra_syntax::{
    AstNode, AtomEdit,
    SyntaxNodeRef,
 };
+use ra_db::SyntaxDatabase;
 use rustc_hash::{FxHashMap};
 use crate::{
-    db::{self, SyntaxDatabase},
+    db,
-    descriptors::{
-        module::{ModuleDescriptor}
-    },
    Cancelable, FilePosition
 };
@@ -31,17 +29,14 @@ pub(crate) fn completions(
    db: &db::RootDatabase,
    position: FilePosition,
 ) -> Cancelable<Option<Vec<CompletionItem>>> {
-    let original_file = db.file_syntax(position.file_id);
+    let original_file = db.source_file(position.file_id);
    // Insert a fake ident to get a valid parse tree
    let file = {
        let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
        original_file.reparse(&edit)
    };
-    let module = match ModuleDescriptor::guess_from_position(db, position)? {
+    let module = ctry!(hir::Module::guess_from_position(db, position)?);
-        None => return Ok(None),
-        Some(it) => it,
-    };
    let mut res = Vec::new();
    let mut has_completions = false;
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
index e52062107..8ea7478a8 100644
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -6,22 +6,23 @@ use ra_syntax::{
    ast::{self, LoopBodyOwner},
    SyntaxKind::*,
 };
+use     hir::{
+        self,
+        FnScopes,
+        Def,
+        Path,
+};
 use crate::{
    db::RootDatabase,
    completion::CompletionItem,
-    descriptors::{
-        module::{ModuleDescriptor},
-        function::FnScopes,
-        Path,
-    },
    Cancelable
 };
 pub(super) fn completions(
    acc: &mut Vec<CompletionItem>,
    db: &RootDatabase,
-    module: &ModuleDescriptor,
+    module: &hir::Module,
    file: &SourceFileNode,
    name_ref: ast::NameRef,
 ) -> Cancelable<()> {
@@ -42,13 +43,15 @@ pub(super) fn completions(
            let module_scope = module.scope(db)?;
            acc.extend(
                module_scope
-                    .items
+                    .entries()
-                    .iter()
                    .filter(|(_name, res)| {
                        // Don't expose this item
-                        match res.import_name {
+                        match res.import {
                            None => true,
-                            Some(ptr) => !ptr.range().is_subrange(&name_ref.syntax().range()),
+                            Some(import) => {
+                                let range = import.range(db, module.source().file_id());
+                                !range.is_subrange(&name_ref.syntax().range())
+                            }
                        }
                    })
                    .map(|(name, _res)| CompletionItem {
@@ -147,26 +150,27 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
 fn complete_path(
    acc: &mut Vec<CompletionItem>,
    db: &RootDatabase,
-    module: &ModuleDescriptor,
+    module: &hir::Module,
    mut path: Path,
 ) -> Cancelable<()> {
    if path.segments.is_empty() {
        return Ok(());
    }
    path.segments.pop();
-    let target_module = match module.resolve_path(path) {
+    let def_id = match module.resolve_path(db, path)? {
        None => return Ok(()),
        Some(it) => it,
    };
+    let target_module = match def_id.resolve(db)? {
+        Def::Module(it) => it,
+        Def::Item => return Ok(()),
+    };
    let module_scope = target_module.scope(db)?;
-    let completions = module_scope
+    let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
-        .items
+        label: name.to_string(),
-        .iter()
+        lookup: None,
-        .map(|(name, _res)| CompletionItem {
+        snippet: None,
-            label: name.to_string(),
+    });
-            lookup: None,
-            snippet: None,
-        });
    acc.extend(completions);
    Ok(())
 }
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 6b56f99ac..df2ef293d 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,171 +1,95 @@
 use std::sync::Arc;
-#[cfg(test)]
-use parking_lot::Mutex;
-use ra_editor::LineIndex;
-use ra_syntax::{SourceFileNode, SyntaxNode};
 use salsa::{self, Database};
+use ra_db::{LocationIntener, BaseDatabase};
+use hir::{self, DefId, DefLoc, FnId, SourceItemId};
 use crate::{
-    db,
+    symbol_index,
-    descriptors::{
-        DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleTreeQuery,
-        SubmodulesQuery, ItemMapQuery, InputModuleItemsQuery,
-    },
-    symbol_index::SymbolIndex,
-    syntax_ptr::SyntaxPtr,
-    loc2id::{IdMaps, IdDatabase},
-    Cancelable, Canceled, FileId,
 };
 #[derive(Debug)]
 pub(crate) struct RootDatabase {
-    #[cfg(test)]
-    events: Mutex<Option<Vec<salsa::Event<RootDatabase>>>>,
-    #[cfg(not(test))]
-    events: (),
    runtime: salsa::Runtime<RootDatabase>,
-    id_maps: IdMaps,
+    id_maps: Arc<IdMaps>,
+}
+#[derive(Debug, Default)]
+struct IdMaps {
+    fns: LocationIntener<SourceItemId, FnId>,
+    defs: LocationIntener<DefLoc, DefId>,
 }
 impl salsa::Database for RootDatabase {
    fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> {
        &self.runtime
    }
-    #[allow(unused)]
-    fn salsa_event(&self, event: impl Fn() -> salsa::Event<RootDatabase>) {
-        #[cfg(test)]
-        {
-            let mut events = self.events.lock();
-            if let Some(events) = &mut *events {
-                events.push(event());
-            }
-        }
-    }
 }
 impl Default for RootDatabase {
    fn default() -> RootDatabase {
        let mut db = RootDatabase {
-            events: Default::default(),
            runtime: salsa::Runtime::default(),
-            id_maps: IdMaps::default(),
+            id_maps: Default::default(),
        };
-        db.query_mut(crate::input::SourceRootQuery)
+        db.query_mut(ra_db::SourceRootQuery)
-            .set(crate::input::WORKSPACE, Default::default());
+            .set(ra_db::WORKSPACE, Default::default());
-        db.query_mut(crate::input::CrateGraphQuery)
+        db.query_mut(ra_db::CrateGraphQuery)
            .set((), Default::default());
-        db.query_mut(crate::input::LibrariesQuery)
+        db.query_mut(ra_db::LibrariesQuery)
            .set((), Default::default());
        db
    }
 }
-pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
-    if db.salsa_runtime().is_current_revision_canceled() {
-        Err(Canceled)
-    } else {
-        Ok(())
-    }
-}
 impl salsa::ParallelDatabase for RootDatabase {
    fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
        salsa::Snapshot::new(RootDatabase {
-            events: Default::default(),
            runtime: self.runtime.snapshot(self),
            id_maps: self.id_maps.clone(),
        })
    }
 }
-impl IdDatabase for RootDatabase {
+impl BaseDatabase for RootDatabase {}
-    fn id_maps(&self) -> &IdMaps {
-        &self.id_maps
-    }
-}
-#[cfg(test)]
+impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
-impl RootDatabase {
+    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
-    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<RootDatabase>> {
+        &self.id_maps.defs
-        *self.events.lock() = Some(Vec::new());
-        f();
-        let events = self.events.lock().take().unwrap();
-        events
    }
+}
-    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
-        let events = self.log(f);
+    fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
-        events
+        &self.id_maps.fns
-            .into_iter()
-            .filter_map(|e| match e.kind {
-                // This pretty horrible, but `Debug` is the only way to inspect
-                // QueryDescriptor at the moment.
-                salsa::EventKind::WillExecute { descriptor } => Some(format!("{:?}", descriptor)),
-                _ => None,
-            })
-            .collect()
    }
 }
 salsa::database_storage! {
    pub(crate) struct RootDatabaseStorage for RootDatabase {
-        impl crate::input::FilesDatabase {
+        impl ra_db::FilesDatabase {
-            fn file_text() for crate::input::FileTextQuery;
+            fn file_text() for ra_db::FileTextQuery;
-            fn file_source_root() for crate::input::FileSourceRootQuery;
+            fn file_source_root() for ra_db::FileSourceRootQuery;
-            fn source_root() for crate::input::SourceRootQuery;
+            fn source_root() for ra_db::SourceRootQuery;
-            fn libraries() for crate::input::LibrariesQuery;
+            fn libraries() for ra_db::LibrariesQuery;
-            fn library_symbols() for crate::input::LibrarySymbolsQuery;
+            fn crate_graph() for ra_db::CrateGraphQuery;
-            fn crate_graph() for crate::input::CrateGraphQuery;
-        }
-        impl SyntaxDatabase {
-            fn file_syntax() for FileSyntaxQuery;
-            fn file_lines() for FileLinesQuery;
-            fn file_symbols() for FileSymbolsQuery;
-            fn resolve_syntax_ptr() for ResolveSyntaxPtrQuery;
-        }
-        impl DescriptorDatabase {
-            fn module_tree() for ModuleTreeQuery;
-            fn fn_scopes() for FnScopesQuery;
-            fn _input_module_items() for InputModuleItemsQuery;
-            fn _item_map() for ItemMapQuery;
-            fn _fn_syntax() for FnSyntaxQuery;
-            fn _submodules() for SubmodulesQuery;
        }
-    }
+        impl ra_db::SyntaxDatabase {
-}
+            fn source_file() for ra_db::SourceFileQuery;
+            fn file_lines() for ra_db::FileLinesQuery;
-salsa::query_group! {
-    pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase {
-        fn file_syntax(file_id: FileId) -> SourceFileNode {
-            type FileSyntaxQuery;
        }
-        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
+        impl symbol_index::SymbolsDatabase {
-            type FileLinesQuery;
+            fn file_symbols() for symbol_index::FileSymbolsQuery;
+            fn library_symbols() for symbol_index::LibrarySymbolsQuery;
        }
-        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+        impl hir::db::HirDatabase {
-            type FileSymbolsQuery;
+            fn module_tree() for hir::db::ModuleTreeQuery;
-        }
+            fn fn_scopes() for hir::db::FnScopesQuery;
-        fn resolve_syntax_ptr(ptr: SyntaxPtr) -> SyntaxNode {
+            fn file_items() for hir::db::SourceFileItemsQuery;
-            type ResolveSyntaxPtrQuery;
+            fn file_item() for hir::db::FileItemQuery;
-            // Don't retain syntax trees in memory
+            fn input_module_items() for hir::db::InputModuleItemsQuery;
-            storage volatile;
+            fn item_map() for hir::db::ItemMapQuery;
-            use fn crate::syntax_ptr::resolve_syntax_ptr;
+            fn fn_syntax() for hir::db::FnSyntaxQuery;
+            fn submodules() for hir::db::SubmodulesQuery;
        }
    }
 }
-fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
-    let text = db.file_text(file_id);
-    SourceFileNode::parse(&*text)
-}
-fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
-    let text = db.file_text(file_id);
-    Arc::new(LineIndex::new(&*text))
-}
-fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
-    db::check_canceled(db)?;
-    let syntax = db.file_syntax(file_id);
-    Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
-}
diff --git a/crates/ra_analysis/src/descriptors/function/imp.rs b/crates/ra_analysis/src/descriptors/function/imp.rs
deleted file mode 100644
index e09deba0f..000000000
--- a/crates/ra_analysis/src/descriptors/function/imp.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use std::sync::Arc;
-use ra_syntax::ast::{AstNode, FnDef, FnDefNode};
-use crate::descriptors::{
-    function::{FnId, FnScopes},
-    DescriptorDatabase,
-};
-/// Resolve `FnId` to the corresponding `SyntaxNode`
-pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode {
-    let ptr = db.id_maps().fn_ptr(fn_id);
-    let syntax = db.resolve_syntax_ptr(ptr);
-    FnDef::cast(syntax.borrowed()).unwrap().owned()
-}
-pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> {
-    let syntax = db._fn_syntax(fn_id);
-    let res = FnScopes::new(syntax.borrowed());
-    Arc::new(res)
-}
diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
deleted file mode 100644
index 97750ea64..000000000
--- a/crates/ra_analysis/src/descriptors/mod.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-pub(crate) mod function;
-pub(crate) mod module;
-mod path;
-use std::sync::Arc;
-use ra_syntax::{
-    ast::{self, FnDefNode, AstNode},
-    TextRange,
-};
-use crate::{
-    db::SyntaxDatabase,
-    descriptors::function::{resolve_local_name, FnId, FnScopes},
-    descriptors::module::{ModuleId, ModuleTree, ModuleSource, nameres::{ItemMap, InputModuleItems}},
-    input::SourceRootId,
-    loc2id::IdDatabase,
-    syntax_ptr::LocalSyntaxPtr,
-    Cancelable,
-};
-pub(crate) use self::path::{Path, PathKind};
-salsa::query_group! {
-    pub(crate) trait DescriptorDatabase: SyntaxDatabase + IdDatabase {
-        fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
-            type FnScopesQuery;
-            use fn function::imp::fn_scopes;
-        }
-        fn _input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<InputModuleItems>> {
-            type InputModuleItemsQuery;
-            use fn module::nameres::input_module_items;
-        }
-        fn _item_map(source_root_id: SourceRootId) -> Cancelable<Arc<ItemMap>> {
-            type ItemMapQuery;
-            use fn module::nameres::item_map;
-        }
-        fn _module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
-            type ModuleTreeQuery;
-            use fn module::imp::module_tree;
-        }
-        fn _fn_syntax(fn_id: FnId) -> FnDefNode {
-            type FnSyntaxQuery;
-            // Don't retain syntax trees in memory
-            storage volatile;
-            use fn function::imp::fn_syntax;
-        }
-        fn _submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
-            type SubmodulesQuery;
-            use fn module::imp::submodules;
-        }
-    }
-}
-#[derive(Debug)]
-pub struct ReferenceDescriptor {
-    pub range: TextRange,
-    pub name: String,
-}
-#[derive(Debug)]
-pub struct DeclarationDescriptor<'a> {
-    pat: ast::BindPat<'a>,
-    pub range: TextRange,
-}
-impl<'a> DeclarationDescriptor<'a> {
-    pub fn new(pat: ast::BindPat) -> DeclarationDescriptor {
-        let range = pat.syntax().range();
-        DeclarationDescriptor { pat, range }
-    }
-    pub fn find_all_refs(&self) -> Vec<ReferenceDescriptor> {
-        let name_ptr = LocalSyntaxPtr::new(self.pat.syntax());
-        let fn_def = match self.pat.syntax().ancestors().find_map(ast::FnDef::cast) {
-            Some(def) => def,
-            None => return Default::default(),
-        };
-        let fn_scopes = FnScopes::new(fn_def);
-        let refs: Vec<_> = fn_def
-            .syntax()
-            .descendants()
-            .filter_map(ast::NameRef::cast)
-            .filter(|name_ref| match resolve_local_name(*name_ref, &fn_scopes) {
-                None => false,
-                Some(entry) => entry.ptr() == name_ptr,
-            })
-            .map(|name_ref| ReferenceDescriptor {
-                name: name_ref.syntax().text().to_string(),
-                range: name_ref.syntax().range(),
-            })
-            .collect();
-        refs
-    }
-}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index ad6b52371..f5cb3550e 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,94 +1,33 @@
 use std::{
    fmt,
-    hash::{Hash, Hasher},
    sync::Arc,
 };
 use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit};
 use ra_syntax::{
    ast::{self, ArgListOwner, Expr, NameOwner},
-    AstNode, SourceFileNode, SmolStr,
+    AstNode, SourceFileNode,
    SyntaxKind::*,
    SyntaxNodeRef, TextRange, TextUnit,
 };
+use ra_db::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE, SyntaxDatabase, SourceFileQuery};
 use rayon::prelude::*;
-use relative_path::RelativePath;
 use rustc_hash::FxHashSet;
 use salsa::{Database, ParallelDatabase};
+use hir::{
+    self,
+    FnSignatureInfo,
+    Problem,
+};
 use crate::{
    completion::{completions, CompletionItem},
-    db::{self, FileSyntaxQuery, SyntaxDatabase},
+    db,
-    descriptors::{
+    symbol_index::{SymbolIndex, SymbolsDatabase},
-        function::{FnDescriptor, FnId},
+    AnalysisChange, Cancelable, CrateId, Diagnostic, FileId,
-        module::{ModuleDescriptor, Problem},
-        DeclarationDescriptor, DescriptorDatabase,
-    },
-    input::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE},
-    symbol_index::SymbolIndex,
-    AnalysisChange, Cancelable, CrateGraph, CrateId, Diagnostic, FileId, FileResolver,
    FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
 };
-#[derive(Clone, Debug)]
-pub(crate) struct FileResolverImp {
-    inner: Arc<FileResolver>,
-}
-impl PartialEq for FileResolverImp {
-    fn eq(&self, other: &FileResolverImp) -> bool {
-        self.inner() == other.inner()
-    }
-}
-impl Eq for FileResolverImp {}
-impl Hash for FileResolverImp {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        self.inner().hash(hasher);
-    }
-}
-impl FileResolverImp {
-    pub(crate) fn new(inner: Arc<FileResolver>) -> FileResolverImp {
-        FileResolverImp { inner }
-    }
-    pub(crate) fn file_stem(&self, file_id: FileId) -> String {
-        self.inner.file_stem(file_id)
-    }
-    pub(crate) fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
-        self.inner.resolve(file_id, path)
-    }
-    pub(crate) fn debug_path(&self, file_id: FileId) -> Option<std::path::PathBuf> {
-        self.inner.debug_path(file_id)
-    }
-    fn inner(&self) -> *const FileResolver {
-        &*self.inner
-    }
-}
-impl Default for FileResolverImp {
-    fn default() -> FileResolverImp {
-        #[derive(Debug)]
-        struct DummyResolver;
-        impl FileResolver for DummyResolver {
-            fn file_stem(&self, _file_: FileId) -> String {
-                panic!("file resolver not set")
-            }
-            fn resolve(
-                &self,
-                _file_id: FileId,
-                _path: &::relative_path::RelativePath,
-            ) -> Option<FileId> {
-                panic!("file resolver not set")
-            }
-        }
-        FileResolverImp {
-            inner: Arc::new(DummyResolver),
-        }
-    }
-}
 #[derive(Debug, Default)]
 pub(crate) struct AnalysisHostImpl {
    db: db::RootDatabase,
@@ -105,7 +44,7 @@ impl AnalysisHostImpl {
        for (file_id, text) in change.files_changed {
            self.db
-                .query_mut(crate::input::FileTextQuery)
+                .query_mut(ra_db::FileTextQuery)
                .set(file_id, Arc::new(text))
        }
        if !(change.files_added.is_empty() && change.files_removed.is_empty()) {
@@ -115,22 +54,22 @@ impl AnalysisHostImpl {
            let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE));
            for (file_id, text) in change.files_added {
                self.db
-                    .query_mut(crate::input::FileTextQuery)
+                    .query_mut(ra_db::FileTextQuery)
                    .set(file_id, Arc::new(text));
                self.db
-                    .query_mut(crate::input::FileSourceRootQuery)
+                    .query_mut(ra_db::FileSourceRootQuery)
-                    .set(file_id, crate::input::WORKSPACE);
+                    .set(file_id, ra_db::WORKSPACE);
                source_root.files.insert(file_id);
            }
            for file_id in change.files_removed {
                self.db
-                    .query_mut(crate::input::FileTextQuery)
+                    .query_mut(ra_db::FileTextQuery)
                    .set(file_id, Arc::new(String::new()));
                source_root.files.remove(&file_id);
            }
            source_root.file_resolver = file_resolver;
            self.db
-                .query_mut(crate::input::SourceRootQuery)
+                .query_mut(ra_db::SourceRootQuery)
                .set(WORKSPACE, Arc::new(source_root))
        }
        if !change.libraries_added.is_empty() {
@@ -147,10 +86,10 @@ impl AnalysisHostImpl {
                        library.file_resolver.debug_path(file_id)
                    );
                    self.db
-                        .query_mut(crate::input::FileSourceRootQuery)
+                        .query_mut(ra_db::FileSourceRootQuery)
                        .set_constant(file_id, source_root_id);
                    self.db
-                        .query_mut(crate::input::FileTextQuery)
+                        .query_mut(ra_db::FileTextQuery)
                        .set_constant(file_id, Arc::new(text));
                }
                let source_root = SourceRoot {
@@ -158,19 +97,19 @@ impl AnalysisHostImpl {
                    file_resolver: library.file_resolver,
                };
                self.db
-                    .query_mut(crate::input::SourceRootQuery)
+                    .query_mut(ra_db::SourceRootQuery)
                    .set(source_root_id, Arc::new(source_root));
                self.db
-                    .query_mut(crate::input::LibrarySymbolsQuery)
+                    .query_mut(crate::symbol_index::LibrarySymbolsQuery)
                    .set(source_root_id, Arc::new(library.symbol_index));
            }
            self.db
-                .query_mut(crate::input::LibrariesQuery)
+                .query_mut(ra_db::LibrariesQuery)
                .set((), Arc::new(libraries));
        }
        if let Some(crate_graph) = change.crate_graph {
            self.db
-                .query_mut(crate::input::CrateGraphQuery)
+                .query_mut(ra_db::CrateGraphQuery)
                .set((), Arc::new(crate_graph))
        }
    }
@@ -189,7 +128,7 @@ impl fmt::Debug for AnalysisImpl {
 impl AnalysisImpl {
    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
-        self.db.file_syntax(file_id)
+        self.db.source_file(file_id)
    }
    pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
        self.db.file_lines(file_id)
@@ -220,14 +159,14 @@ impl AnalysisImpl {
                .collect()
        };
        self.db
-            .query(FileSyntaxQuery)
+            .query(SourceFileQuery)
            .sweep(salsa::SweepStrategy::default().discard_values());
        Ok(query.search(&buf))
    }
    /// This return `Vec`: 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 ModuleDescriptor::guess_from_position(&*self.db, position)? {
+        let descr = match hir::Module::guess_from_position(&*self.db, position)? {
            None => return Ok(Vec::new()),
            Some(it) => it,
        };
@@ -246,7 +185,7 @@ impl AnalysisImpl {
    }
    /// Returns `Vec` for the same reason as `parent_module`
    pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
-        let descr = match ModuleDescriptor::guess_from_file_id(&*self.db, file_id)? {
+        let descr = match hir::Module::guess_from_file_id(&*self.db, file_id)? {
            None => return Ok(Vec::new()),
            Some(it) => it,
        };
@@ -261,7 +200,7 @@ impl AnalysisImpl {
        Ok(crate_id.into_iter().collect())
    }
    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        self.db.crate_graph().crate_roots[&crate_id]
+        self.db.crate_graph().crate_root(crate_id)
    }
    pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
        completions(&self.db, position)
@@ -270,33 +209,36 @@ impl AnalysisImpl {
        &self,
        position: FilePosition,
    ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
-        let file = self.db.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
        let syntax = file.syntax();
        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
-            // First try to resolve the symbol locally
+            if let Some(fn_descr) =
-            return if let Some((name, range)) =
+                hir::Function::guess_for_name_ref(&*self.db, position.file_id, name_ref)
-                resolve_local_name(&self.db, position.file_id, name_ref)
            {
-                let mut vec = vec![];
+                let scope = fn_descr.scope(&*self.db);
-                vec.push((
+                // First try to resolve the symbol locally
-                    position.file_id,
+                return if let Some(entry) = scope.resolve_local_name(name_ref) {
-                    FileSymbol {
+                    let mut vec = vec![];
-                        name,
+                    vec.push((
-                        node_range: range,
+                        position.file_id,
-                        kind: NAME,
+                        FileSymbol {
-                    },
+                            name: entry.name().clone(),
-                ));
+                            node_range: entry.ptr().range(),
-                Ok(vec)
+                            kind: NAME,
-            } else {
+                        },
-                // If that fails try the index based approach.
+                    ));
-                self.index_resolve(name_ref)
+                    Ok(vec)
-            };
+                } else {
+                    // If that fails try the index based approach.
+                    self.index_resolve(name_ref)
+                };
+            }
        }
        if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
            if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
                if module.has_semi() {
                    let parent_module =
-                        ModuleDescriptor::guess_from_file_id(&*self.db, position.file_id)?;
+                        hir::Module::guess_from_file_id(&*self.db, position.file_id)?;
                    let child_name = module.name();
                    match (parent_module, child_name) {
                        (Some(parent_module), Some(child_name)) => {
@@ -319,32 +261,42 @@ impl AnalysisImpl {
    }
    pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
-        let file = self.db.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
-        let syntax = file.syntax();
        // Find the binding associated with the offset
-        let maybe_binding =
+        let (binding, descr) = match find_binding(&self.db, &file, position) {
-            find_node_at_offset::<ast::BindPat>(syntax, position.offset).or_else(|| {
-                let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
-                let resolved = resolve_local_name(&self.db, position.file_id, name_ref)?;
-                find_node_at_offset::<ast::BindPat>(syntax, resolved.1.end())
-            });
-        let binding = match maybe_binding {
            None => return Vec::new(),
            Some(it) => it,
        };
-        let decl = DeclarationDescriptor::new(binding);
+        let mut ret = vec![(position.file_id, binding.syntax().range())];
-        let mut ret = vec![(position.file_id, decl.range)];
        ret.extend(
-            decl.find_all_refs()
+            descr
+                .scope(&*self.db)
+                .find_all_refs(binding)
                .into_iter()
                .map(|ref_desc| (position.file_id, ref_desc.range)),
        );
-        ret
+        return ret;
+        fn find_binding<'a>(
+            db: &db::RootDatabase,
+            source_file: &'a SourceFileNode,
+            position: FilePosition,
+        ) -> Option<(ast::BindPat<'a>, hir::Function)> {
+            let syntax = source_file.syntax();
+            if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
+                let descr = hir::Function::guess_for_bind_pat(db, position.file_id, binding)?;
+                return Some((binding, descr));
+            };
+            let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
+            let descr = hir::Function::guess_for_name_ref(db, position.file_id, name_ref)?;
+            let scope = descr.scope(db);
+            let resolved = scope.resolve_local_name(name_ref)?;
+            let resolved = resolved.ptr().resolve(source_file);
+            let binding = find_node_at_offset::<ast::BindPat>(syntax, resolved.range().end())?;
+            Some((binding, descr))
+        }
    }
    pub fn doc_comment_for(
@@ -352,13 +304,13 @@ impl AnalysisImpl {
        file_id: FileId,
        symbol: FileSymbol,
    ) -> Cancelable<Option<String>> {
-        let file = self.db.file_syntax(file_id);
+        let file = self.db.source_file(file_id);
        Ok(symbol.docs(&file))
    }
    pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
-        let syntax = self.db.file_syntax(file_id);
+        let syntax = self.db.source_file(file_id);
        let mut res = ra_editor::diagnostics(&syntax)
            .into_iter()
@@ -368,7 +320,7 @@ impl AnalysisImpl {
                fix: None,
            })
            .collect::<Vec<_>>();
-        if let Some(m) = ModuleDescriptor::guess_from_file_id(&*self.db, file_id)? {
+        if let Some(m) = hir::Module::guess_from_file_id(&*self.db, file_id)? {
            for (name_node, problem) in m.problems(&*self.db) {
                let diag = match problem {
                    Problem::UnresolvedModule { candidate } => {
@@ -445,27 +397,22 @@ impl AnalysisImpl {
    pub fn resolve_callable(
        &self,
        position: FilePosition,
-    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
+    ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
-        let file = self.db.file_syntax(position.file_id);
+        let file = self.db.source_file(position.file_id);
        let syntax = file.syntax();
        // Find the calling expression and it's NameRef
-        let calling_node = match FnCallNode::with_node(syntax, position.offset) {
+        let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
-            Some(node) => node,
+        let name_ref = ctry!(calling_node.name_ref());
-            None => return Ok(None),
-        };
-        let name_ref = match calling_node.name_ref() {
-            Some(name) => name,
-            None => return Ok(None),
-        };
        // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
        let file_symbols = self.index_resolve(name_ref)?;
-        for (fn_fiel_id, fs) in file_symbols {
+        for (fn_file_id, fs) in file_symbols {
            if fs.kind == FN_DEF {
-                let fn_file = self.db.file_syntax(fn_fiel_id);
+                let fn_file = self.db.source_file(fn_file_id);
                if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) {
-                    if let Some(descriptor) = FnDescriptor::new(fn_def) {
+                    let descr = hir::Function::guess_from_source(&*self.db, fn_file_id, fn_def);
+                    if let Some(descriptor) = descr.signature_info(&*self.db) {
                        // If we have a calling expression let's find which argument we are on
                        let mut current_parameter = None;
@@ -538,16 +485,6 @@ impl SourceChange {
    }
 }
-impl CrateGraph {
-    fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
-        let (&crate_id, _) = self
-            .crate_roots
-            .iter()
-            .find(|(_crate_id, &root_id)| root_id == file_id)?;
-        Some(crate_id)
-    }
-}
 enum FnCallNode<'a> {
    CallExpr(ast::CallExpr<'a>),
    MethodCallExpr(ast::MethodCallExpr<'a>),
@@ -586,16 +523,3 @@ impl<'a> FnCallNode<'a> {
        }
    }
 }
-fn resolve_local_name(
-    db: &db::RootDatabase,
-    file_id: FileId,
-    name_ref: ast::NameRef,
-) -> Option<(SmolStr, TextRange)> {
-    let fn_def = name_ref.syntax().ancestors().find_map(ast::FnDef::cast)?;
-    let fn_id = FnId::get(db, file_id, fn_def);
-    let scopes = db.fn_scopes(fn_id);
-    let scope_entry = crate::descriptors::function::resolve_local_name(name_ref, &scopes)?;
-    let syntax = db.resolve_syntax_ptr(scope_entry.ptr().into_global(file_id));
-    Some((scope_entry.name().clone(), syntax.range()))
-}
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index cedbd1fc8..12df580ba 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -9,49 +9,45 @@ extern crate relative_path;
 extern crate rustc_hash;
 extern crate salsa;
-mod arena;
+macro_rules! ctry {
+    ($expr:expr) => {
+        match $expr {
+            None => return Ok(None),
+            Some(it) => it,
+        }
+    };
+}
 mod db;
-mod loc2id;
-mod input;
 mod imp;
 mod completion;
-mod descriptors;
 mod symbol_index;
-mod syntax_ptr;
 pub mod mock_analysis;
 use std::{fmt, sync::Arc};
 use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit};
+use ra_db::FileResolverImp;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
 use crate::{
-    imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp},
+    imp::{AnalysisHostImpl, AnalysisImpl},
    symbol_index::SymbolIndex,
 };
 pub use crate::{
    completion::CompletionItem,
-    descriptors::function::FnDescriptor,
-    input::{CrateGraph, CrateId, FileId, FileResolver},
 };
 pub use ra_editor::{
    FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
 };
+pub use hir::FnSignatureInfo;
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub use ra_db::{
-pub struct Canceled;
+    Canceled, Cancelable, FilePosition,
+    CrateGraph, CrateId, FileId, FileResolver
-pub type Cancelable<T> = Result<T, Canceled>;
+};
-impl std::fmt::Display for Canceled {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        fmt.write_str("Canceled")
-    }
-}
-impl std::error::Error for Canceled {}
 #[derive(Default)]
 pub struct AnalysisChange {
@@ -121,12 +117,6 @@ impl AnalysisHost {
    }
 }
-#[derive(Clone, Copy, Debug)]
-pub struct FilePosition {
-    pub file_id: FileId,
-    pub offset: TextUnit,
-}
 #[derive(Debug)]
 pub struct SourceChange {
    pub label: String,
@@ -296,7 +286,7 @@ impl Analysis {
    pub fn resolve_callable(
        &self,
        position: FilePosition,
-    ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> {
+    ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
        self.imp.resolve_callable(position)
    }
 }
diff --git a/crates/ra_analysis/src/loc2id.rs b/crates/ra_analysis/src/loc2id.rs
deleted file mode 100644
index e4b55f9b0..000000000
--- a/crates/ra_analysis/src/loc2id.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use parking_lot::Mutex;
-use std::{
-    hash::Hash,
-    sync::Arc,
-};
-use rustc_hash::FxHashMap;
-use crate::{
-    descriptors::module::ModuleId,
-    syntax_ptr::SyntaxPtr,
-    input::SourceRootId,
-};
-/// There are two principle ways to refer to things:
-///   - by their locatinon (module in foo/bar/baz.rs at line 42)
-///   - by their numeric id (module `ModuleId(42)`)
-///
-/// The first one is more powerful (you can actually find the thing in question
-/// by id), but the second one is so much more compact.
-///
-/// `Loc2IdMap` allows us to have a cake an eat it as well: by maintaining a
-/// bidirectional mapping between positional and numeric ids, we can use compact
-/// representation wich still allows us to get the actual item
-#[derive(Debug)]
-pub(crate) struct Loc2IdMap<L, ID>
-where
-    ID: NumericId,
-    L: Clone + Eq + Hash,
-{
-    loc2id: FxHashMap<L, ID>,
-    id2loc: FxHashMap<ID, L>,
-}
-impl<L, ID> Default for Loc2IdMap<L, ID>
-where
-    ID: NumericId,
-    L: Clone + Eq + Hash,
-{
-    fn default() -> Self {
-        Loc2IdMap {
-            loc2id: FxHashMap::default(),
-            id2loc: FxHashMap::default(),
-        }
-    }
-}
-impl<L, ID> Loc2IdMap<L, ID>
-where
-    ID: NumericId,
-    L: Clone + Eq + Hash,
-{
-    pub fn loc2id(&mut self, loc: &L) -> ID {
-        match self.loc2id.get(loc) {
-            Some(id) => return id.clone(),
-            None => (),
-        }
-        let id = self.loc2id.len();
-        assert!(id < u32::max_value() as usize);
-        let id = ID::from_u32(id as u32);
-        self.loc2id.insert(loc.clone(), id.clone());
-        self.id2loc.insert(id.clone(), loc.clone());
-        id
-    }
-    pub fn id2loc(&self, id: ID) -> L {
-        self.id2loc[&id].clone()
-    }
-}
-pub(crate) trait NumericId: Clone + Eq + Hash {
-    fn from_u32(id: u32) -> Self;
-    fn to_u32(self) -> u32;
-}
-macro_rules! impl_numeric_id {
-    ($id:ident) => {
-        impl NumericId for $id {
-            fn from_u32(id: u32) -> Self {
-                $id(id)
-            }
-            fn to_u32(self) -> u32 {
-                self.0
-            }
-        }
-    };
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct FnId(u32);
-impl_numeric_id!(FnId);
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct DefId(u32);
-impl_numeric_id!(DefId);
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub(crate) enum DefLoc {
-    Module {
-        id: ModuleId,
-        source_root: SourceRootId,
-    },
-    Item {
-        ptr: SyntaxPtr,
-    },
-}
-pub(crate) trait IdDatabase: salsa::Database {
-    fn id_maps(&self) -> &IdMaps;
-}
-#[derive(Debug, Default, Clone)]
-pub(crate) struct IdMaps {
-    inner: Arc<IdMapsInner>,
-}
-impl IdMaps {
-    pub(crate) fn fn_id(&self, ptr: SyntaxPtr) -> FnId {
-        self.inner.fns.lock().loc2id(&ptr)
-    }
-    pub(crate) fn fn_ptr(&self, fn_id: FnId) -> SyntaxPtr {
-        self.inner.fns.lock().id2loc(fn_id)
-    }
-    pub(crate) fn def_id(&self, loc: DefLoc) -> DefId {
-        self.inner.defs.lock().loc2id(&loc)
-    }
-    pub(crate) fn def_loc(&self, def_id: DefId) -> DefLoc {
-        self.inner.defs.lock().id2loc(def_id)
-    }
-}
-#[derive(Debug, Default)]
-struct IdMapsInner {
-    fns: Mutex<Loc2IdMap<SyntaxPtr, FnId>>,
-    defs: Mutex<Loc2IdMap<DefLoc, DefId>>,
-}
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 8e8f969f4..0d9a7a147 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -1,9 +1,10 @@
 use std::sync::Arc;
-use relative_path::{RelativePath, RelativePathBuf};
+use relative_path::{RelativePathBuf};
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
+use ra_db::mock::FileMap;
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FileResolver, FilePosition};
+use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition};
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -76,16 +77,15 @@ impl MockAnalysis {
    }
    pub fn analysis_host(self) -> AnalysisHost {
        let mut host = AnalysisHost::default();
-        let mut file_map = Vec::new();
+        let mut file_map = FileMap::default();
        let mut change = AnalysisChange::new();
-        for (id, (path, contents)) in self.files.into_iter().enumerate() {
+        for (path, contents) in self.files.into_iter() {
-            let file_id = FileId((id + 1) as u32);
            assert!(path.starts_with('/'));
            let path = RelativePathBuf::from_path(&path[1..]).unwrap();
+            let file_id = file_map.add(path);
            change.add_file(file_id, contents);
-            file_map.push((file_id, path));
        }
-        change.set_file_resolver(Arc::new(FileMap(file_map)));
+        change.set_file_resolver(Arc::new(file_map));
        host.apply_change(change);
        host
    }
@@ -113,29 +113,3 @@ pub fn single_file_with_position(code: &str) -> (Analysis, FilePosition) {
    let pos = mock.add_file_with_position("/main.rs", code);
    (mock.analysis(), pos)
 }
-#[derive(Debug)]
-struct FileMap(Vec<(FileId, RelativePathBuf)>);
-impl FileMap {
-    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
-        self.0
-            .iter()
-            .map(|(id, path)| (*id, path.as_relative_path()))
-    }
-    fn path(&self, id: FileId) -> &RelativePath {
-        self.iter().find(|&(it, _)| it == id).unwrap().1
-    }
-}
-impl FileResolver for FileMap {
-    fn file_stem(&self, id: FileId) -> String {
-        self.path(id).file_stem().unwrap().to_string()
-    }
-    fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
-        let path = self.path(id).join(rel).normalize();
-        let id = self.iter().find(|&(_, p)| path == p)?.0;
-        Some(id)
-    }
-}
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 3a0667ecd..b48a37229 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -4,14 +4,36 @@ use std::{
 };
 use fst::{self, Streamer};
-use ra_editor::{file_symbols, FileSymbol};
+use ra_editor::{self, FileSymbol};
 use ra_syntax::{
    SourceFileNode,
    SyntaxKind::{self, *},
 };
+use ra_db::{SyntaxDatabase, SourceRootId};
 use rayon::prelude::*;
-use crate::{FileId, Query};
+use crate::{
+    Cancelable,
+    FileId, Query,
+};
+salsa::query_group! {
+    pub(crate) trait SymbolsDatabase: SyntaxDatabase {
+        fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
+            type FileSymbolsQuery;
+        }
+        fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
+            type LibrarySymbolsQuery;
+            storage input;
+        }
+    }
+}
+fn file_symbols(db: &impl SyntaxDatabase, 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)))
+}
 #[derive(Default, Debug)]
 pub(crate) struct SymbolIndex {
@@ -39,7 +61,7 @@ impl SymbolIndex {
    ) -> SymbolIndex {
        let mut symbols = files
            .flat_map(|(file_id, file)| {
-                file_symbols(&file)
+                ra_editor::file_symbols(&file)
                    .into_iter()
                    .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
                    .collect::<Vec<_>>()
diff --git a/crates/ra_analysis/src/syntax_ptr.rs b/crates/ra_analysis/src/syntax_ptr.rs
deleted file mode 100644
index 194b94584..000000000
--- a/crates/ra_analysis/src/syntax_ptr.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
-use crate::db::SyntaxDatabase;
-use crate::FileId;
-pub(crate) fn resolve_syntax_ptr(db: &impl SyntaxDatabase, ptr: SyntaxPtr) -> SyntaxNode {
-    let syntax = db.file_syntax(ptr.file_id);
-    ptr.local.resolve(&syntax)
-}
-/// SyntaxPtr is a cheap `Copy` id which identifies a particular syntax node,
-/// without retaining syntax tree in memory. You need to explicitly `resolve`
-/// `SyntaxPtr` to get a `SyntaxNode`
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct SyntaxPtr {
-    file_id: FileId,
-    local: LocalSyntaxPtr,
-}
-impl SyntaxPtr {
-    pub(crate) fn new(file_id: FileId, node: SyntaxNodeRef) -> SyntaxPtr {
-        let local = LocalSyntaxPtr::new(node);
-        SyntaxPtr { file_id, local }
-    }
-    pub(crate) fn file_id(self) -> FileId {
-        self.file_id
-    }
-}
-/// A pionter to a syntax node inside a file.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct LocalSyntaxPtr {
-    range: TextRange,
-    kind: SyntaxKind,
-}
-impl LocalSyntaxPtr {
-    pub(crate) fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
-        LocalSyntaxPtr {
-            range: node.range(),
-            kind: node.kind(),
-        }
-    }
-    pub(crate) fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
-        let mut curr = file.syntax();
-        loop {
-            if curr.range() == self.range && curr.kind() == self.kind {
-                return curr.owned();
-            }
-            curr = curr
-                .children()
-                .find(|it| self.range.is_subrange(&it.range()))
-                .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
-        }
-    }
-    pub(crate) fn into_global(self, file_id: FileId) -> SyntaxPtr {
-        SyntaxPtr {
-            file_id,
-            local: self,
-        }
-    }
-    // Seems unfortunate to expose
-    pub(crate) fn range(self) -> TextRange {
-        self.range
-    }
-}
-#[test]
-fn test_local_syntax_ptr() {
-    use ra_syntax::{ast, AstNode};
-    let file = SourceFileNode::parse("struct Foo { f: u32, }");
-    let field = file
-        .syntax()
-        .descendants()
-        .find_map(ast::NamedFieldDef::cast)
-        .unwrap();
-    let ptr = LocalSyntaxPtr::new(field.syntax());
-    let field_syntax = ptr.resolve(&file);
-    assert_eq!(field.syntax(), field_syntax);
-}
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 72b2ebf97..fbe89f444 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -10,10 +10,10 @@ use test_utils::assert_eq_dbg;
 use ra_analysis::{
    mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis},
-    AnalysisChange, CrateGraph, FileId, FnDescriptor,
+    AnalysisChange, CrateGraph, FileId, FnSignatureInfo,
 };
-fn get_signature(text: &str) -> (FnDescriptor, Option<usize>) {
+fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
    let (analysis, position) = single_file_with_position(text);
    analysis.resolve_callable(position).unwrap().unwrap()
 }
@@ -126,7 +126,7 @@ fn test_resolve_crate_root() {
    let mut host = mock.analysis_host();
    assert!(host.analysis().crate_for(mod_file).unwrap().is_empty());
-    let mut crate_graph = CrateGraph::new();
+    let mut crate_graph = CrateGraph::default();
    let crate_id = crate_graph.add_crate_root(root_file);
    let mut change = AnalysisChange::new();
    change.set_crate_graph(crate_graph);
diff --git a/crates/ra_db/Cargo.toml b/crates/ra_db/Cargo.toml
new file mode 100644
index 000000000..f316c0ab2
--- /dev/null
+++ b/crates/ra_db/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+edition = "2018"
+name = "ra_db"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+[dependencies]
+relative-path = "0.4.0"
+salsa = "0.8.0"
+rustc-hash = "1.0"
+parking_lot = "0.6.4"
+ra_syntax = { path = "../ra_syntax" }
+ra_editor = { path = "../ra_editor" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_db/src/file_resolver.rs b/crates/ra_db/src/file_resolver.rs
new file mode 100644
index 000000000..f849ac752
--- /dev/null
+++ b/crates/ra_db/src/file_resolver.rs
@@ -0,0 +1,76 @@
+use std::{
+    sync::Arc,
+    hash::{Hash, Hasher},
+    fmt,
+};
+use relative_path::RelativePath;
+use crate::input::FileId;
+pub trait FileResolver: fmt::Debug + Send + Sync + 'static {
+    fn file_stem(&self, file_id: FileId) -> String;
+    fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId>;
+    fn debug_path(&self, _1file_id: FileId) -> Option<std::path::PathBuf> {
+        None
+    }
+}
+#[derive(Clone, Debug)]
+pub struct FileResolverImp {
+    inner: Arc<FileResolver>,
+}
+impl PartialEq for FileResolverImp {
+    fn eq(&self, other: &FileResolverImp) -> bool {
+        self.inner() == other.inner()
+    }
+}
+impl Eq for FileResolverImp {}
+impl Hash for FileResolverImp {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.inner().hash(hasher);
+    }
+}
+impl FileResolverImp {
+    pub fn new(inner: Arc<FileResolver>) -> FileResolverImp {
+        FileResolverImp { inner }
+    }
+    pub fn file_stem(&self, file_id: FileId) -> String {
+        self.inner.file_stem(file_id)
+    }
+    pub fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
+        self.inner.resolve(file_id, path)
+    }
+    pub fn debug_path(&self, file_id: FileId) -> Option<std::path::PathBuf> {
+        self.inner.debug_path(file_id)
+    }
+    fn inner(&self) -> *const FileResolver {
+        &*self.inner
+    }
+}
+impl Default for FileResolverImp {
+    fn default() -> FileResolverImp {
+        #[derive(Debug)]
+        struct DummyResolver;
+        impl FileResolver for DummyResolver {
+            fn file_stem(&self, _file_: FileId) -> String {
+                panic!("file resolver not set")
+            }
+            fn resolve(
+                &self,
+                _file_id: FileId,
+                _path: &::relative_path::RelativePath,
+            ) -> Option<FileId> {
+                panic!("file resolver not set")
+            }
+        }
+        FileResolverImp {
+            inner: Arc::new(DummyResolver),
+        }
+    }
+}
diff --git a/crates/ra_analysis/src/input.rs b/crates/ra_db/src/input.rs
index a78b6e397..9101ac7a8 100644
--- a/crates/ra_analysis/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -1,11 +1,10 @@
-use std::{fmt, sync::Arc};
+use std::sync::Arc;
-use relative_path::RelativePath;
 use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 use salsa;
-use crate::{symbol_index::SymbolIndex, FileResolverImp};
+use crate::file_resolver::FileResolverImp;
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct FileId(pub u32);
@@ -19,8 +18,8 @@ pub struct CrateGraph {
 }
 impl CrateGraph {
-    pub fn new() -> CrateGraph {
+    pub fn crate_root(&self, crate_id: CrateId) -> FileId {
-        CrateGraph::default()
+        self.crate_roots[&crate_id]
    }
    pub fn add_crate_root(&mut self, file_id: FileId) -> CrateId {
        let crate_id = CrateId(self.crate_roots.len() as u32);
@@ -28,18 +27,17 @@ impl CrateGraph {
        assert!(prev.is_none());
        crate_id
    }
-}
+    pub fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
+        let (&crate_id, _) = self
-pub trait FileResolver: fmt::Debug + Send + Sync + 'static {
+            .crate_roots
-    fn file_stem(&self, file_id: FileId) -> String;
+            .iter()
-    fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId>;
+            .find(|(_crate_id, &root_id)| root_id == file_id)?;
-    fn debug_path(&self, _file_id: FileId) -> Option<std::path::PathBuf> {
+        Some(crate_id)
-        None
    }
 }
 salsa::query_group! {
-    pub(crate) trait FilesDatabase: salsa::Database {
+    pub trait FilesDatabase: salsa::Database {
        fn file_text(file_id: FileId) -> Arc<String> {
            type FileTextQuery;
            storage input;
@@ -56,10 +54,6 @@ salsa::query_group! {
            type LibrariesQuery;
            storage input;
        }
-        fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
-            type LibrarySymbolsQuery;
-            storage input;
-        }
        fn crate_graph() -> Arc<CrateGraph> {
            type CrateGraphQuery;
            storage input;
@@ -68,12 +62,12 @@ salsa::query_group! {
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub(crate) struct SourceRootId(pub(crate) u32);
+pub struct SourceRootId(pub u32);
 #[derive(Default, Clone, Debug, PartialEq, Eq)]
-pub(crate) struct SourceRoot {
+pub struct SourceRoot {
-    pub(crate) file_resolver: FileResolverImp,
+    pub file_resolver: FileResolverImp,
-    pub(crate) files: FxHashSet<FileId>,
+    pub files: FxHashSet<FileId>,
 }
-pub(crate) const WORKSPACE: SourceRootId = SourceRootId(0);
+pub const WORKSPACE: SourceRootId = SourceRootId(0);
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
new file mode 100644
index 000000000..53805aada
--- /dev/null
+++ b/crates/ra_db/src/lib.rs
@@ -0,0 +1,83 @@
+//! ra_db defines basic database traits. Concrete DB is defined by ra_analysis.
+mod syntax_ptr;
+mod file_resolver;
+mod input;
+mod loc2id;
+pub mod mock;
+use std::sync::Arc;
+use ra_editor::LineIndex;
+use ra_syntax::{TextUnit, SourceFileNode};
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct Canceled;
+pub type Cancelable<T> = Result<T, Canceled>;
+impl std::fmt::Display for Canceled {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt.write_str("Canceled")
+    }
+}
+impl std::error::Error for Canceled {}
+pub use crate::{
+    syntax_ptr::LocalSyntaxPtr,
+    file_resolver::{FileResolver, FileResolverImp},
+    input::{
+        FilesDatabase, FileId, CrateId, SourceRoot, SourceRootId, CrateGraph, WORKSPACE,
+        FileTextQuery, FileSourceRootQuery, SourceRootQuery, LibrariesQuery, CrateGraphQuery,
+    },
+    loc2id::{LocationIntener, NumericId},
+};
+#[macro_export]
+macro_rules! impl_numeric_id {
+    ($id:ident) => {
+        impl $crate::NumericId for $id {
+            fn from_u32(id: u32) -> Self {
+                $id(id)
+            }
+            fn to_u32(self) -> u32 {
+                self.0
+            }
+        }
+    };
+}
+pub trait BaseDatabase: salsa::Database {
+    fn check_canceled(&self) -> Cancelable<()> {
+        if self.salsa_runtime().is_current_revision_canceled() {
+            Err(Canceled)
+        } else {
+            Ok(())
+        }
+    }
+}
+salsa::query_group! {
+    pub trait SyntaxDatabase: crate::input::FilesDatabase + BaseDatabase {
+        fn source_file(file_id: FileId) -> SourceFileNode {
+            type SourceFileQuery;
+        }
+        fn file_lines(file_id: FileId) -> Arc<LineIndex> {
+            type FileLinesQuery;
+        }
+    }
+}
+fn source_file(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
+    let text = db.file_text(file_id);
+    SourceFileNode::parse(&*text)
+}
+fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
+    let text = db.file_text(file_id);
+    Arc::new(LineIndex::new(&*text))
+}
+#[derive(Clone, Copy, Debug)]
+pub struct FilePosition {
+    pub file_id: FileId,
+    pub offset: TextUnit,
+}
diff --git a/crates/ra_db/src/loc2id.rs b/crates/ra_db/src/loc2id.rs
new file mode 100644
index 000000000..69ba43d0f
--- /dev/null
+++ b/crates/ra_db/src/loc2id.rs
@@ -0,0 +1,100 @@
+use parking_lot::Mutex;
+use std::hash::Hash;
+use rustc_hash::FxHashMap;
+/// There are two principle ways to refer to things:
+///   - by their locatinon (module in foo/bar/baz.rs at line 42)
+///   - by their numeric id (module `ModuleId(42)`)
+///
+/// The first one is more powerful (you can actually find the thing in question
+/// by id), but the second one is so much more compact.
+///
+/// `Loc2IdMap` allows us to have a cake an eat it as well: by maintaining a
+/// bidirectional mapping between positional and numeric ids, we can use compact
+/// representation wich still allows us to get the actual item
+#[derive(Debug)]
+struct Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    loc2id: FxHashMap<LOC, ID>,
+    id2loc: FxHashMap<ID, LOC>,
+}
+impl<LOC, ID> Default for Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    fn default() -> Self {
+        Loc2IdMap {
+            loc2id: FxHashMap::default(),
+            id2loc: FxHashMap::default(),
+        }
+    }
+}
+impl<LOC, ID> Loc2IdMap<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    pub fn loc2id(&mut self, loc: &LOC) -> ID {
+        match self.loc2id.get(loc) {
+            Some(id) => return id.clone(),
+            None => (),
+        }
+        let id = self.loc2id.len();
+        assert!(id < u32::max_value() as usize);
+        let id = ID::from_u32(id as u32);
+        self.loc2id.insert(loc.clone(), id.clone());
+        self.id2loc.insert(id.clone(), loc.clone());
+        id
+    }
+    pub fn id2loc(&self, id: ID) -> LOC {
+        self.id2loc[&id].clone()
+    }
+}
+pub trait NumericId: Clone + Eq + Hash {
+    fn from_u32(id: u32) -> Self;
+    fn to_u32(self) -> u32;
+}
+#[derive(Debug)]
+pub struct LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    map: Mutex<Loc2IdMap<LOC, ID>>,
+}
+impl<LOC, ID> Default for LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    fn default() -> Self {
+        LocationIntener {
+            map: Default::default(),
+        }
+    }
+}
+impl<LOC, ID> LocationIntener<LOC, ID>
+where
+    ID: NumericId,
+    LOC: Clone + Eq + Hash,
+{
+    pub fn loc2id(&self, loc: &LOC) -> ID {
+        self.map.lock().loc2id(loc)
+    }
+    pub fn id2loc(&self, id: ID) -> LOC {
+        self.map.lock().id2loc(id)
+    }
+}
diff --git a/crates/ra_db/src/mock.rs b/crates/ra_db/src/mock.rs
new file mode 100644
index 000000000..2840f9655
--- /dev/null
+++ b/crates/ra_db/src/mock.rs
@@ -0,0 +1,51 @@
+use std::sync::Arc;
+use rustc_hash::FxHashSet;
+use relative_path::{RelativePath, RelativePathBuf};
+use crate::{FileId, FileResolver, SourceRoot, FileResolverImp};
+#[derive(Default, Debug)]
+pub struct FileMap(Vec<(FileId, RelativePathBuf)>);
+impl FileMap {
+    pub fn add(&mut self, path: RelativePathBuf) -> FileId {
+        let file_id = FileId((self.0.len() + 1) as u32);
+        self.0.push((file_id, path));
+        file_id
+    }
+    pub fn into_source_root(self) -> SourceRoot {
+        let files = self.files();
+        let file_resolver = FileResolverImp::new(Arc::new(self));
+        SourceRoot {
+            file_resolver,
+            files,
+        }
+    }
+    pub fn files(&self) -> FxHashSet<FileId> {
+        self.iter().map(|(id, _)| id).collect()
+    }
+    fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
+        self.0
+            .iter()
+            .map(|(id, path)| (*id, path.as_relative_path()))
+    }
+    fn path(&self, id: FileId) -> &RelativePath {
+        self.iter().find(|&(it, _)| it == id).unwrap().1
+    }
+}
+impl FileResolver for FileMap {
+    fn file_stem(&self, id: FileId) -> String {
+        self.path(id).file_stem().unwrap().to_string()
+    }
+    fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
+        let path = self.path(id).join(rel).normalize();
+        let id = self.iter().find(|&(_, p)| path == p)?.0;
+        Some(id)
+    }
+}
diff --git a/crates/ra_db/src/syntax_ptr.rs b/crates/ra_db/src/syntax_ptr.rs
new file mode 100644
index 000000000..dac94dd36
--- /dev/null
+++ b/crates/ra_db/src/syntax_ptr.rs
@@ -0,0 +1,48 @@
+use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
+/// A pionter to a syntax node inside a file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LocalSyntaxPtr {
+    range: TextRange,
+    kind: SyntaxKind,
+}
+impl LocalSyntaxPtr {
+    pub fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
+        LocalSyntaxPtr {
+            range: node.range(),
+            kind: node.kind(),
+        }
+    }
+    pub fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
+        let mut curr = file.syntax();
+        loop {
+            if curr.range() == self.range && curr.kind() == self.kind {
+                return curr.owned();
+            }
+            curr = curr
+                .children()
+                .find(|it| self.range.is_subrange(&it.range()))
+                .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
+        }
+    }
+    pub fn range(self) -> TextRange {
+        self.range
+    }
+}
+#[test]
+fn test_local_syntax_ptr() {
+    use ra_syntax::{ast, AstNode};
+    let file = SourceFileNode::parse("struct Foo { f: u32, }");
+    let field = file
+        .syntax()
+        .descendants()
+        .find_map(ast::NamedFieldDef::cast)
+        .unwrap();
+    let ptr = LocalSyntaxPtr::new(field.syntax());
+    let field_syntax = ptr.resolve(&file);
+    assert_eq!(field.syntax(), field_syntax);
+}
diff --git a/crates/ra_editor/src/code_actions.rs b/crates/ra_editor/src/code_actions.rs
index 0139b19d3..6979251d1 100644
--- a/crates/ra_editor/src/code_actions.rs
+++ b/crates/ra_editor/src/code_actions.rs
@@ -4,7 +4,7 @@ use ra_syntax::{
    algo::{find_covering_node, find_leaf_at_offset},
    ast::{self, AstNode, AttrsOwner, NameOwner, TypeParamsOwner},
    Direction, SourceFileNode,
-    SyntaxKind::{COMMA, WHITESPACE},
+    SyntaxKind::{COMMA, WHITESPACE, COMMENT},
    SyntaxNodeRef, TextRange, TextUnit,
 };
@@ -41,7 +41,8 @@ pub fn add_derive<'a>(
    offset: TextUnit,
 ) -> Option<impl FnOnce() -> LocalEdit + 'a> {
    let nominal = find_node_at_offset::<ast::NominalDef>(file.syntax(), offset)?;
-    Some(move || {
+    let node_start = derive_insertion_offset(nominal)?;
+    return Some(move || {
        let derive_attr = nominal
            .attrs()
            .filter_map(|x| x.as_call())
@@ -51,7 +52,6 @@ pub fn add_derive<'a>(
        let mut edit = EditBuilder::new();
        let offset = match derive_attr {
            None => {
-                let node_start = nominal.syntax().range().start();
                edit.insert(node_start, "#[derive()]\n".to_string());
                node_start + TextUnit::of_str("#[derive(")
            }
@@ -61,7 +61,16 @@ pub fn add_derive<'a>(
            edit: edit.finish(),
            cursor_position: Some(offset),
        }
-    })
+    });
+    // Insert `derive` after doc comments.
+    fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
+        let non_ws_child = nominal
+            .syntax()
+            .children()
+            .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+        Some(non_ws_child.range().start())
+    }
 }
 pub fn add_impl<'a>(
@@ -113,7 +122,7 @@ pub fn introduce_variable<'a>(
    let node = find_covering_node(file.syntax(), range);
    let expr = node.ancestors().filter_map(ast::Expr::cast).next()?;
-    let anchor_stmt = ahchor_stmt(expr)?;
+    let anchor_stmt = anchor_stmt(expr)?;
    let indent = anchor_stmt.prev_sibling()?;
    if indent.kind() != WHITESPACE {
        return None;
@@ -124,7 +133,12 @@ pub fn introduce_variable<'a>(
        buf.push_str("let var_name = ");
        expr.syntax().text().push_to(&mut buf);
-        if expr.syntax().range().start() == anchor_stmt.range().start() {
+        let is_full_stmt = if let Some(expr_stmt) = ast::ExprStmt::cast(anchor_stmt) {
+            Some(expr.syntax()) == expr_stmt.expr().map(|e| e.syntax())
+        } else {
+            false
+        };
+        if is_full_stmt {
            edit.replace(expr.syntax().range(), buf);
        } else {
            buf.push_str(";");
@@ -141,7 +155,7 @@ pub fn introduce_variable<'a>(
    /// Statement or last in the block expression, which will follow
    /// the freshly introduced var.
-    fn ahchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
+    fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
        expr.syntax().ancestors().find(|&node| {
            if ast::Stmt::cast(node).is_some() {
                return true;
@@ -181,7 +195,7 @@ mod tests {
    }
    #[test]
-    fn test_add_derive() {
+    fn add_derive_new() {
        check_action(
            "struct Foo { a: i32, <|>}",
            "#[derive(<|>)]\nstruct Foo { a: i32, }",
@@ -192,6 +206,10 @@ mod tests {
            "#[derive(<|>)]\nstruct Foo {  a: i32, }",
            |file, off| add_derive(file, off).map(|f| f()),
        );
+    }
+    #[test]
+    fn add_derive_existing() {
        check_action(
            "#[derive(Clone)]\nstruct Foo { a: i32<|>, }",
            "#[derive(Clone<|>)]\nstruct Foo { a: i32, }",
@@ -200,6 +218,24 @@ mod tests {
    }
    #[test]
+    fn add_derive_new_with_doc_comment() {
+        check_action(
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+struct Foo { a: i32<|>, }
+            ",
+            "
+/// `Foo` is a pretty important struct.
+/// It does stuff.
+#[derive(<|>)]
+struct Foo { a: i32, }
+            ",
+            |file, off| add_derive(file, off).map(|f| f()),
+        );
+    }
+    #[test]
    fn test_add_impl() {
        check_action(
            "struct Foo {<|>}\n",
@@ -219,7 +255,7 @@ mod tests {
    }
    #[test]
-    fn test_intrdoduce_var_simple() {
+    fn test_introduce_var_simple() {
        check_action_range(
            "
 fn foo() {
@@ -235,7 +271,7 @@ fn foo() {
    }
    #[test]
-    fn test_intrdoduce_var_expr_stmt() {
+    fn test_introduce_var_expr_stmt() {
        check_action_range(
            "
 fn foo() {
@@ -250,7 +286,23 @@ fn foo() {
    }
    #[test]
-    fn test_intrdoduce_var_last_expr() {
+    fn test_introduce_var_part_of_expr_stmt() {
+        check_action_range(
+            "
+fn foo() {
+    <|>1<|> + 1;
+}",
+            "
+fn foo() {
+    let <|>var_name = 1;
+    var_name + 1;
+}",
+            |file, range| introduce_variable(file, range).map(|f| f()),
+        );
+    }
+    #[test]
+    fn test_introduce_var_last_expr() {
        check_action_range(
            "
 fn foo() {
@@ -265,4 +317,20 @@ fn foo() {
        );
    }
+    #[test]
+    fn test_introduce_var_last_full_expr() {
+        check_action_range(
+            "
+fn foo() {
+    <|>bar(1 + 1)<|>
+}",
+            "
+fn foo() {
+    let <|>var_name = bar(1 + 1);
+    var_name
+}",
+            |file, range| introduce_variable(file, range).map(|f| f()),
+        );
+    }
 }
diff --git a/crates/ra_editor/src/edit.rs b/crates/ra_editor/src/edit.rs
index c3149ec54..372b8d14c 100644
--- a/crates/ra_editor/src/edit.rs
+++ b/crates/ra_editor/src/edit.rs
@@ -26,7 +26,7 @@ impl EditBuilder {
    }
    pub fn finish(self) -> Edit {
        let mut atoms = self.atoms;
-        atoms.sort_by_key(|a| a.delete.start());
+        atoms.sort_by_key(|a| (a.delete.start(), a.delete.end()));
        for (a1, a2) in atoms.iter().zip(atoms.iter().skip(1)) {
            assert!(a1.delete.end() <= a2.delete.start())
        }
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
new file mode 100644
index 000000000..1b9e148b2
--- /dev/null
+++ b/crates/ra_hir/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+edition = "2018"
+name = "ra_hir"
+version = "0.1.0"
+authors = ["Aleksey Kladov <[email protected]>"]
+[dependencies]
+log = "0.4.5"
+relative-path = "0.4.0"
+salsa = "0.8.0"
+rustc-hash = "1.0"
+parking_lot = "0.6.4"
+id-arena = "2.0"
+ra_syntax = { path = "../ra_syntax" }
+ra_editor = { path = "../ra_editor" }
+ra_db = { path = "../ra_db" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/ra_hir/src/arena.rs b/crates/ra_hir/src/arena.rs
new file mode 100644
index 000000000..d4f9d9cb9
--- /dev/null
+++ b/crates/ra_hir/src/arena.rs
@@ -0,0 +1,66 @@
+//! A simple id-based arena, similar to https://github.com/fitzgen/id-arena.
+//! We use our own version for more compact id's and to allow inherent impls
+//! on Ids.
+use std::{
+    fmt,
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+};
+pub struct Id<T> {
+    idx: u32,
+    _ty: PhantomData<fn() -> T>,
+}
+impl<T> fmt::Debug for Id<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_tuple("Id").field(&self.idx).finish()
+    }
+}
+impl<T> Copy for Id<T> {}
+impl<T> Clone for Id<T> {
+    fn clone(&self) -> Id<T> {
+        *self
+    }
+}
+impl<T> PartialEq for Id<T> {
+    fn eq(&self, other: &Id<T>) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for Id<T> {}
+impl<T> Hash for Id<T> {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        self.idx.hash(h);
+    }
+}
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct ArenaBehavior<T> {
+    _ty: PhantomData<T>,
+}
+impl<T> id_arena::ArenaBehavior for ArenaBehavior<T> {
+    type Id = Id<T>;
+    fn new_arena_id() -> u32 {
+        0
+    }
+    fn new_id(_arena_id: u32, index: usize) -> Id<T> {
+        Id {
+            idx: index as u32,
+            _ty: PhantomData,
+        }
+    }
+    fn index(id: Id<T>) -> usize {
+        id.idx as usize
+    }
+    fn arena_id(_id: Id<T>) -> u32 {
+        0
+    }
+}
+pub(crate) type Arena<T> = id_arena::Arena<T, ArenaBehavior<T>>;
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
new file mode 100644
index 000000000..2f01bae6d
--- /dev/null
+++ b/crates/ra_hir/src/db.rs
@@ -0,0 +1,66 @@
+use std::sync::Arc;
+use ra_syntax::{
+    SyntaxNode,
+    ast::FnDefNode,
+};
+use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, FileId, Cancelable};
+use crate::{
+    DefLoc, DefId, FnId,
+    SourceFileItems, SourceItemId,
+    query_definitions,
+    FnScopes,
+    module::{ModuleId, ModuleTree, ModuleSource,
+    nameres::{ItemMap, InputModuleItems}},
+};
+salsa::query_group! {
+pub trait HirDatabase: SyntaxDatabase
+    + AsRef<LocationIntener<DefLoc, DefId>>
+    + AsRef<LocationIntener<SourceItemId, FnId>>
+{
+    fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
+        type FnScopesQuery;
+        use fn query_definitions::fn_scopes;
+    }
+    fn fn_syntax(fn_id: FnId) -> FnDefNode {
+        type FnSyntaxQuery;
+        // Don't retain syntax trees in memory
+        storage dependencies;
+        use fn query_definitions::fn_syntax;
+    }
+    fn file_items(file_id: FileId) -> Arc<SourceFileItems> {
+        type SourceFileItemsQuery;
+        storage dependencies;
+        use fn query_definitions::file_items;
+    }
+    fn file_item(source_item_id: SourceItemId) -> SyntaxNode {
+        type FileItemQuery;
+        storage dependencies;
+        use fn query_definitions::file_item;
+    }
+    fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<crate::module::imp::Submodule>>> {
+        type SubmodulesQuery;
+        use fn query_definitions::submodules;
+    }
+    fn input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<InputModuleItems>> {
+        type InputModuleItemsQuery;
+        use fn query_definitions::input_module_items;
+    }
+    fn item_map(source_root_id: SourceRootId) -> Cancelable<Arc<ItemMap>> {
+        type ItemMapQuery;
+        use fn query_definitions::item_map;
+    }
+    fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
+        type ModuleTreeQuery;
+        use fn crate::module::imp::module_tree;
+    }
+}
+}
diff --git a/crates/ra_analysis/src/descriptors/function/mod.rs b/crates/ra_hir/src/function/mod.rs
index 86eee5e93..c8af2e54f 100644
--- a/crates/ra_analysis/src/descriptors/function/mod.rs
+++ b/crates/ra_hir/src/function/mod.rs
@@ -1,30 +1,83 @@
-pub(super) mod imp;
 mod scope;
-use std::cmp::{max, min};
+use std::{
+    cmp::{max, min},
+    sync::Arc,
+};
 use ra_syntax::{
+    TextRange, TextUnit, SyntaxNodeRef,
    ast::{self, AstNode, DocCommentsOwner, NameOwner},
-    TextRange, TextUnit,
 };
+use ra_db::FileId;
 use crate::{
-    syntax_ptr::SyntaxPtr, FileId,
+    FnId, HirDatabase, SourceItemId,
-    loc2id::IdDatabase,
 };
-pub(crate) use self::scope::{resolve_local_name, FnScopes};
+pub use self::scope::FnScopes;
-pub(crate) use crate::loc2id::FnId;
 impl FnId {
-    pub(crate) fn get(db: &impl IdDatabase, file_id: FileId, fn_def: ast::FnDef) -> FnId {
+    pub fn get(db: &impl HirDatabase, file_id: FileId, fn_def: ast::FnDef) -> FnId {
-        let ptr = SyntaxPtr::new(file_id, fn_def.syntax());
+        let file_items = db.file_items(file_id);
-        db.id_maps().fn_id(ptr)
+        let item_id = file_items.id_of(fn_def.syntax());
+        let item_id = SourceItemId { file_id, item_id };
+        FnId::from_loc(db, &item_id)
+    }
+}
+pub struct Function {
+    fn_id: FnId,
+}
+impl Function {
+    pub fn guess_from_source(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        fn_def: ast::FnDef,
+    ) -> Function {
+        let fn_id = FnId::get(db, file_id, fn_def);
+        Function { fn_id }
+    }
+    pub fn guess_for_name_ref(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        name_ref: ast::NameRef,
+    ) -> Option<Function> {
+        Function::guess_for_node(db, file_id, name_ref.syntax())
+    }
+    pub fn guess_for_bind_pat(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        bind_pat: ast::BindPat,
+    ) -> Option<Function> {
+        Function::guess_for_node(db, file_id, bind_pat.syntax())
+    }
+    fn guess_for_node(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        node: SyntaxNodeRef,
+    ) -> Option<Function> {
+        let fn_def = node.ancestors().find_map(ast::FnDef::cast)?;
+        let res = Function::guess_from_source(db, file_id, fn_def);
+        Some(res)
+    }
+    pub fn scope(&self, db: &impl HirDatabase) -> Arc<FnScopes> {
+        db.fn_scopes(self.fn_id)
+    }
+    pub fn signature_info(&self, db: &impl HirDatabase) -> Option<FnSignatureInfo> {
+        let syntax = db.fn_syntax(self.fn_id);
+        FnSignatureInfo::new(syntax.borrowed())
    }
 }
 #[derive(Debug, Clone)]
-pub struct FnDescriptor {
+pub struct FnSignatureInfo {
    pub name: String,
    pub label: String,
    pub ret_type: Option<String>,
@@ -32,8 +85,8 @@ pub struct FnDescriptor {
    pub doc: Option<String>,
 }
-impl FnDescriptor {
+impl FnSignatureInfo {
-    pub fn new(node: ast::FnDef) -> Option<Self> {
+    fn new(node: ast::FnDef) -> Option<Self> {
        let name = node.name()?.text().to_string();
        let mut doc = None;
@@ -52,7 +105,7 @@ impl FnDescriptor {
            node.syntax().text().to_string()
        };
-        if let Some((comment_range, docs)) = FnDescriptor::extract_doc_comments(node) {
+        if let Some((comment_range, docs)) = FnSignatureInfo::extract_doc_comments(node) {
            let comment_range = comment_range
                .checked_sub(node.syntax().range().start())
                .unwrap();
@@ -84,10 +137,10 @@ impl FnDescriptor {
            }
        }
-        let params = FnDescriptor::param_list(node);
+        let params = FnSignatureInfo::param_list(node);
        let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
-        Some(FnDescriptor {
+        Some(FnSignatureInfo {
            name,
            ret_type,
            params,
diff --git a/crates/ra_analysis/src/descriptors/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 54d7fa456..863453291 100644
--- a/crates/ra_analysis/src/descriptors/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -1,13 +1,13 @@
 use rustc_hash::{FxHashMap, FxHashSet};
 use ra_syntax::{
+    AstNode, SmolStr, SyntaxNodeRef, TextRange,
    algo::generate,
    ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
-    AstNode, SmolStr, SyntaxNodeRef,
 };
+use ra_db::LocalSyntaxPtr;
 use crate::{
-    syntax_ptr::LocalSyntaxPtr,
    arena::{Arena, Id},
 };
@@ -15,7 +15,7 @@ pub(crate) type ScopeId = Id<ScopeData>;
 #[derive(Debug, PartialEq, Eq)]
 pub struct FnScopes {
-    pub(crate) self_param: Option<LocalSyntaxPtr>,
+    pub self_param: Option<LocalSyntaxPtr>,
    scopes: Arena<ScopeData>,
    scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
 }
@@ -27,13 +27,13 @@ pub struct ScopeEntry {
 }
 #[derive(Debug, PartialEq, Eq)]
-pub(crate) struct ScopeData {
+pub struct ScopeData {
    parent: Option<ScopeId>,
    entries: Vec<ScopeEntry>,
 }
 impl FnScopes {
-    pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
+    pub fn new(fn_def: ast::FnDef) -> FnScopes {
        let mut scopes = FnScopes {
            self_param: fn_def
                .param_list()
@@ -49,7 +49,7 @@ impl FnScopes {
        }
        scopes
    }
-    pub(crate) fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
+    pub fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
        &self.scopes[scope].entries
    }
    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
@@ -57,14 +57,45 @@ impl FnScopes {
            self.scopes[scope].parent
        })
    }
+    pub fn resolve_local_name<'a>(&'a self, name_ref: ast::NameRef) -> Option<&'a ScopeEntry> {
+        let mut shadowed = FxHashSet::default();
+        let ret = self
+            .scope_chain(name_ref.syntax())
+            .flat_map(|scope| self.entries(scope).iter())
+            .filter(|entry| shadowed.insert(entry.name()))
+            .filter(|entry| entry.name() == &name_ref.text())
+            .nth(0);
+        ret
+    }
+    pub fn find_all_refs(&self, pat: ast::BindPat) -> Vec<ReferenceDescriptor> {
+        let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
+        let name_ptr = LocalSyntaxPtr::new(pat.syntax());
+        let refs: Vec<_> = fn_def
+            .syntax()
+            .descendants()
+            .filter_map(ast::NameRef::cast)
+            .filter(|name_ref| match self.resolve_local_name(*name_ref) {
+                None => false,
+                Some(entry) => entry.ptr() == name_ptr,
+            })
+            .map(|name_ref| ReferenceDescriptor {
+                name: name_ref.syntax().text().to_string(),
+                range: name_ref.syntax().range(),
+            })
+            .collect();
+        refs
+    }
    fn root_scope(&mut self) -> ScopeId {
-        self.scopes.push(ScopeData {
+        self.scopes.alloc(ScopeData {
            parent: None,
            entries: vec![],
        })
    }
    fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
-        self.scopes.push(ScopeData {
+        self.scopes.alloc(ScopeData {
            parent: Some(parent),
            entries: vec![],
        })
@@ -104,10 +135,10 @@ impl ScopeEntry {
        };
        Some(res)
    }
-    pub(crate) fn name(&self) -> &SmolStr {
+    pub fn name(&self) -> &SmolStr {
        &self.name
    }
-    pub(crate) fn ptr(&self) -> LocalSyntaxPtr {
+    pub fn ptr(&self) -> LocalSyntaxPtr {
        self.ptr
    }
 }
@@ -249,18 +280,10 @@ fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
    }
 }
-pub fn resolve_local_name<'a>(
+#[derive(Debug)]
-    name_ref: ast::NameRef,
+pub struct ReferenceDescriptor {
-    scopes: &'a FnScopes,
+    pub range: TextRange,
-) -> Option<&'a ScopeEntry> {
+    pub name: String,
-    let mut shadowed = FxHashSet::default();
-    let ret = scopes
-        .scope_chain(name_ref.syntax())
-        .flat_map(|scope| scopes.entries(scope).iter())
-        .filter(|entry| shadowed.insert(entry.name()))
-        .filter(|entry| entry.name() == &name_ref.text())
-        .nth(0);
-    ret
 }
 #[cfg(test)]
@@ -376,7 +399,7 @@ mod tests {
        let scopes = FnScopes::new(fn_def);
-        let local_name_entry = resolve_local_name(name_ref, &scopes).unwrap();
+        let local_name_entry = scopes.resolve_local_name(name_ref).unwrap();
        let local_name = local_name_entry.ptr().resolve(&file);
        let expected_name =
            find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into()).unwrap();
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
new file mode 100644
index 000000000..e7b6a81f4
--- /dev/null
+++ b/crates/ra_hir/src/lib.rs
@@ -0,0 +1,141 @@
+//! HIR (previsouly known as descriptors) provides a high-level OO acess to Rust
+//! code.
+//!
+//! The principal difference between HIR and syntax trees is that HIR is bound
+//! to a particular crate instance. That is, it has cfg flags and features
+//! applied. So, there relation between syntax and HIR is many-to-one.
+macro_rules! ctry {
+    ($expr:expr) => {
+        match $expr {
+            None => return Ok(None),
+            Some(it) => it,
+        }
+    };
+}
+pub mod db;
+#[cfg(test)]
+mod mock;
+mod query_definitions;
+mod function;
+mod module;
+mod path;
+mod arena;
+use std::ops::Index;
+use ra_syntax::{SyntaxNodeRef, SyntaxNode};
+use ra_db::{LocationIntener, SourceRootId, FileId, Cancelable};
+use crate::{
+    db::HirDatabase,
+    arena::{Arena, Id},
+};
+pub use self::{
+    path::{Path, PathKind},
+    module::{Module, ModuleId, Problem, nameres::ItemMap},
+    function::{Function, FnScopes},
+};
+pub use self::function::FnSignatureInfo;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct FnId(u32);
+ra_db::impl_numeric_id!(FnId);
+impl FnId {
+    pub fn from_loc(
+        db: &impl AsRef<LocationIntener<SourceItemId, FnId>>,
+        loc: &SourceItemId,
+    ) -> FnId {
+        db.as_ref().loc2id(loc)
+    }
+    pub fn loc(self, db: &impl AsRef<LocationIntener<SourceItemId, FnId>>) -> SourceItemId {
+        db.as_ref().id2loc(self)
+    }
+}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct DefId(u32);
+ra_db::impl_numeric_id!(DefId);
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub enum DefLoc {
+    Module {
+        id: ModuleId,
+        source_root: SourceRootId,
+    },
+    Item {
+        source_item_id: SourceItemId,
+    },
+}
+impl DefId {
+    pub fn loc(self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefLoc {
+        db.as_ref().id2loc(self)
+    }
+}
+impl DefLoc {
+    pub fn id(&self, db: &impl AsRef<LocationIntener<DefLoc, DefId>>) -> DefId {
+        db.as_ref().loc2id(&self)
+    }
+}
+pub enum Def {
+    Module(Module),
+    Item,
+}
+impl DefId {
+    pub fn resolve(self, db: &impl HirDatabase) -> Cancelable<Def> {
+        let loc = self.loc(db);
+        let res = match loc {
+            DefLoc::Module { id, source_root } => {
+                let descr = Module::new(db, source_root, id)?;
+                Def::Module(descr)
+            }
+            DefLoc::Item { .. } => Def::Item,
+        };
+        Ok(res)
+    }
+}
+/// Identifier of item within a specific file. This is stable over reparses, so
+/// it's OK to use it as a salsa key/value.
+pub(crate) type SourceFileItemId = Id<SyntaxNode>;
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SourceItemId {
+    file_id: FileId,
+    item_id: SourceFileItemId,
+}
+/// Maps item's `SyntaxNode`s to `SourceFileItemId` and back.
+#[derive(Debug, PartialEq, Eq, Default)]
+pub struct SourceFileItems {
+    arena: Arena<SyntaxNode>,
+}
+impl SourceFileItems {
+    fn alloc(&mut self, item: SyntaxNode) -> SourceFileItemId {
+        self.arena.alloc(item)
+    }
+    pub fn id_of(&self, item: SyntaxNodeRef) -> SourceFileItemId {
+        let (id, _item) = self
+            .arena
+            .iter()
+            .find(|(_id, i)| i.borrowed() == item)
+            .unwrap();
+        id
+    }
+}
+impl Index<SourceFileItemId> for SourceFileItems {
+    type Output = SyntaxNode;
+    fn index(&self, idx: SourceFileItemId) -> &SyntaxNode {
+        &self.arena[idx]
+    }
+}
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
new file mode 100644
index 000000000..8e256b89f
--- /dev/null
+++ b/crates/ra_hir/src/mock.rs
@@ -0,0 +1,172 @@
+use std::sync::Arc;
+use parking_lot::Mutex;
+use salsa::{self, Database};
+use ra_db::{LocationIntener, BaseDatabase, FilePosition, mock::FileMap, FileId, WORKSPACE};
+use relative_path::RelativePathBuf;
+use test_utils::{parse_fixture, CURSOR_MARKER, extract_offset};
+use crate::{db, DefId, DefLoc, FnId, SourceItemId};
+#[derive(Debug)]
+pub(crate) struct MockDatabase {
+    events: Mutex<Option<Vec<salsa::Event<MockDatabase>>>>,
+    runtime: salsa::Runtime<MockDatabase>,
+    id_maps: Arc<IdMaps>,
+}
+impl MockDatabase {
+    pub(crate) fn with_position(fixture: &str) -> (MockDatabase, FilePosition) {
+        let mut db = MockDatabase::default();
+        let mut position = None;
+        let mut file_map = FileMap::default();
+        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(db.add_file_with_position(&mut file_map, &entry.meta, &entry.text));
+            } else {
+                db.add_file(&mut file_map, &entry.meta, &entry.text);
+            }
+        }
+        let position = position.expect("expected a marker (<|>)");
+        let source_root = file_map.into_source_root();
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(WORKSPACE, Arc::new(source_root));
+        (db, position)
+    }
+    fn add_file(&mut self, file_map: &mut FileMap, path: &str, text: &str) -> FileId {
+        assert!(path.starts_with('/'));
+        let path = RelativePathBuf::from_path(&path[1..]).unwrap();
+        let file_id = file_map.add(path);
+        let text = Arc::new(text.to_string());
+        self.query_mut(ra_db::FileTextQuery).set(file_id, text);
+        self.query_mut(ra_db::FileSourceRootQuery)
+            .set(file_id, WORKSPACE);
+        file_id
+    }
+    fn add_file_with_position(
+        &mut self,
+        file_map: &mut FileMap,
+        path: &str,
+        text: &str,
+    ) -> FilePosition {
+        let (offset, text) = extract_offset(text);
+        let file_id = self.add_file(file_map, path, &text);
+        FilePosition { file_id, offset }
+    }
+}
+#[derive(Debug, Default)]
+struct IdMaps {
+    fns: LocationIntener<SourceItemId, FnId>,
+    defs: LocationIntener<DefLoc, DefId>,
+}
+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(),
+            id_maps: Default::default(),
+        };
+        db.query_mut(ra_db::SourceRootQuery)
+            .set(ra_db::WORKSPACE, Default::default());
+        db.query_mut(ra_db::CrateGraphQuery)
+            .set((), Default::default());
+        db.query_mut(ra_db::LibrariesQuery)
+            .set((), Default::default());
+        db
+    }
+}
+impl salsa::ParallelDatabase for MockDatabase {
+    fn snapshot(&self) -> salsa::Snapshot<MockDatabase> {
+        salsa::Snapshot::new(MockDatabase {
+            events: Default::default(),
+            runtime: self.runtime.snapshot(self),
+            id_maps: self.id_maps.clone(),
+        })
+    }
+}
+impl BaseDatabase for MockDatabase {}
+impl AsRef<LocationIntener<DefLoc, DefId>> for MockDatabase {
+    fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
+        &self.id_maps.defs
+    }
+}
+impl AsRef<LocationIntener<SourceItemId, FnId>> for MockDatabase {
+    fn as_ref(&self) -> &LocationIntener<SourceItemId, FnId> {
+        &self.id_maps.fns
+    }
+}
+impl MockDatabase {
+    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<MockDatabase>> {
+        *self.events.lock() = Some(Vec::new());
+        f();
+        let events = self.events.lock().take().unwrap();
+        events
+    }
+    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.
+                salsa::EventKind::WillExecute { descriptor } => Some(format!("{:?}", descriptor)),
+                _ => None,
+            })
+            .collect()
+    }
+}
+salsa::database_storage! {
+    pub(crate) struct MockDatabaseStorage for MockDatabase {
+        impl ra_db::FilesDatabase {
+            fn file_text() for ra_db::FileTextQuery;
+            fn file_source_root() for ra_db::FileSourceRootQuery;
+            fn source_root() for ra_db::SourceRootQuery;
+            fn libraries() for ra_db::LibrariesQuery;
+            fn crate_graph() for ra_db::CrateGraphQuery;
+        }
+        impl ra_db::SyntaxDatabase {
+            fn source_file() for ra_db::SourceFileQuery;
+            fn file_lines() for ra_db::FileLinesQuery;
+        }
+        impl db::HirDatabase {
+            fn module_tree() for db::ModuleTreeQuery;
+            fn fn_scopes() for db::FnScopesQuery;
+            fn file_items() for db::SourceFileItemsQuery;
+            fn file_item() for db::FileItemQuery;
+            fn input_module_items() for db::InputModuleItemsQuery;
+            fn item_map() for db::ItemMapQuery;
+            fn fn_syntax() for db::FnSyntaxQuery;
+            fn submodules() for db::SubmodulesQuery;
+        }
+    }
+}
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_hir/src/module/imp.rs
index 80892acb7..76ea129a7 100644
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ b/crates/ra_hir/src/module/imp.rs
@@ -6,21 +6,19 @@ use ra_syntax::{
 };
 use relative_path::RelativePathBuf;
 use rustc_hash::{FxHashMap, FxHashSet};
+use ra_db::{SourceRoot, SourceRootId, FileResolverImp, Cancelable, FileId,};
 use crate::{
-    db,
+    HirDatabase,
-    descriptors::DescriptorDatabase,
-    input::{SourceRoot, SourceRootId},
-    Cancelable, FileId, FileResolverImp,
 };
 use super::{
-    LinkData, LinkId, ModuleData, ModuleId, ModuleSource, ModuleSourceNode,
+    LinkData, LinkId, ModuleData, ModuleId, ModuleSource,
    ModuleTree, Problem,
 };
 #[derive(Clone, Hash, PartialEq, Eq, Debug)]
-pub(crate) enum Submodule {
+pub enum Submodule {
    Declaration(SmolStr),
    Definition(SmolStr, ModuleSource),
 }
@@ -34,39 +32,6 @@ impl Submodule {
    }
 }
-pub(crate) fn submodules(
-    db: &impl DescriptorDatabase,
-    source: ModuleSource,
-) -> Cancelable<Arc<Vec<Submodule>>> {
-    db::check_canceled(db)?;
-    let file_id = source.file_id();
-    let submodules = match source.resolve(db) {
-        ModuleSourceNode::SourceFile(it) => collect_submodules(file_id, it.borrowed()),
-        ModuleSourceNode::Module(it) => it
-            .borrowed()
-            .item_list()
-            .map(|it| collect_submodules(file_id, it))
-            .unwrap_or_else(Vec::new),
-    };
-    return Ok(Arc::new(submodules));
-    fn collect_submodules<'a>(
-        file_id: FileId,
-        root: impl ast::ModuleItemOwner<'a>,
-    ) -> Vec<Submodule> {
-        modules(root)
-            .map(|(name, m)| {
-                if m.has_semi() {
-                    Submodule::Declaration(name)
-                } else {
-                    let src = ModuleSource::new_inline(file_id, m);
-                    Submodule::Definition(name, src)
-                }
-            })
-            .collect()
-    }
-}
 pub(crate) fn modules<'a>(
    root: impl ast::ModuleItemOwner<'a>,
 ) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
@@ -82,16 +47,16 @@ pub(crate) fn modules<'a>(
 }
 pub(crate) fn module_tree(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: SourceRootId,
 ) -> Cancelable<Arc<ModuleTree>> {
-    db::check_canceled(db)?;
+    db.check_canceled()?;
    let res = create_module_tree(db, source_root)?;
    Ok(Arc::new(res))
 }
 fn create_module_tree<'a>(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: SourceRootId,
 ) -> Cancelable<ModuleTree> {
    let mut tree = ModuleTree::default();
@@ -121,7 +86,7 @@ fn create_module_tree<'a>(
 }
 fn build_subtree(
-    db: &impl DescriptorDatabase,
+    db: &impl HirDatabase,
    source_root: &SourceRoot,
    tree: &mut ModuleTree,
    visited: &mut FxHashSet<ModuleSource>,
@@ -135,7 +100,7 @@ fn build_subtree(
        parent,
        children: Vec::new(),
    });
-    for sub in db._submodules(source)?.iter() {
+    for sub in db.submodules(source)?.iter() {
        let link = tree.push_link(LinkData {
            name: sub.name().clone(),
            owner: id,
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_hir/src/module/mod.rs
index 54ff95b66..3ae83d8cb 100644
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ b/crates/ra_hir/src/module/mod.rs
@@ -10,64 +10,63 @@ use ra_syntax::{
    ast::{self, AstNode, NameOwner},
    SmolStr, SyntaxNode,
 };
+use ra_db::{SourceRootId, FileId, FilePosition, Cancelable};
 use relative_path::RelativePathBuf;
 use crate::{
-    db::SyntaxDatabase, syntax_ptr::SyntaxPtr, FileId, FilePosition, Cancelable,
+    DefLoc, DefId, Path, PathKind, HirDatabase, SourceItemId,
-    descriptors::{Path, PathKind, DescriptorDatabase},
-    input::SourceRootId,
    arena::{Arena, Id},
 };
-pub(crate) use self::nameres::ModuleScope;
+pub use self::nameres::ModuleScope;
-/// `ModuleDescriptor` is API entry point to get all the information
+/// `Module` is API entry point to get all the information
 /// about a particular module.
 #[derive(Debug, Clone)]
-pub(crate) struct ModuleDescriptor {
+pub struct Module {
    tree: Arc<ModuleTree>,
    source_root_id: SourceRootId,
    module_id: ModuleId,
 }
-impl ModuleDescriptor {
+impl Module {
-    /// Lookup `ModuleDescriptor` by `FileId`. Note that this is inherently
+    /// Lookup `Module` by `FileId`. Note that this is inherently
    /// lossy transformation: in general, a single source might correspond to
    /// several modules.
    pub fn guess_from_file_id(
-        db: &impl DescriptorDatabase,
+        db: &impl HirDatabase,
        file_id: FileId,
-    ) -> Cancelable<Option<ModuleDescriptor>> {
+    ) -> Cancelable<Option<Module>> {
-        ModuleDescriptor::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
+        Module::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
    }
-    /// Lookup `ModuleDescriptor` by position in the source code. Note that this
+    /// Lookup `Module` by position in the source code. Note that this
    /// is inherently lossy transformation: in general, a single source might
    /// correspond to several modules.
    pub fn guess_from_position(
-        db: &impl DescriptorDatabase,
+        db: &impl HirDatabase,
        position: FilePosition,
-    ) -> Cancelable<Option<ModuleDescriptor>> {
+    ) -> Cancelable<Option<Module>> {
-        let file = db.file_syntax(position.file_id);
+        let file = db.source_file(position.file_id);
        let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
        {
-            Some(m) if !m.has_semi() => ModuleSource::new_inline(position.file_id, m),
+            Some(m) if !m.has_semi() => ModuleSource::new_inline(db, position.file_id, m),
            _ => ModuleSource::SourceFile(position.file_id),
        };
-        ModuleDescriptor::guess_from_source(db, position.file_id, module_source)
+        Module::guess_from_source(db, position.file_id, module_source)
    }
    fn guess_from_source(
-        db: &impl DescriptorDatabase,
+        db: &impl HirDatabase,
        file_id: FileId,
        module_source: ModuleSource,
-    ) -> Cancelable<Option<ModuleDescriptor>> {
+    ) -> Cancelable<Option<Module>> {
        let source_root_id = db.file_source_root(file_id);
-        let module_tree = db._module_tree(source_root_id)?;
+        let module_tree = db.module_tree(source_root_id)?;
        let res = match module_tree.any_module_for_source(module_source) {
            None => None,
-            Some(module_id) => Some(ModuleDescriptor {
+            Some(module_id) => Some(Module {
                tree: module_tree,
                source_root_id,
                module_id,
@@ -76,12 +75,23 @@ impl ModuleDescriptor {
        Ok(res)
    }
+    pub(super) fn new(
+        db: &impl HirDatabase,
+        source_root_id: SourceRootId,
+        module_id: ModuleId,
+    ) -> Cancelable<Module> {
+        let module_tree = db.module_tree(source_root_id)?;
+        let res = Module {
+            tree: module_tree,
+            source_root_id,
+            module_id,
+        };
+        Ok(res)
+    }
    /// Returns `mod foo;` or `mod foo {}` node whihc declared this module.
    /// Returns `None` for the root module
-    pub fn parent_link_source(
+    pub fn parent_link_source(&self, db: &impl HirDatabase) -> Option<(FileId, ast::ModuleNode)> {
-        &self,
-        db: &impl DescriptorDatabase,
-    ) -> Option<(FileId, ast::ModuleNode)> {
        let link = self.module_id.parent_link(&self.tree)?;
        let file_id = link.owner(&self.tree).source(&self.tree).file_id();
        let src = link.bind_source(&self.tree, db);
@@ -93,60 +103,74 @@ impl ModuleDescriptor {
    }
    /// Parent module. Returns `None` if this is a root module.
-    pub fn parent(&self) -> Option<ModuleDescriptor> {
+    pub fn parent(&self) -> Option<Module> {
        let parent_id = self.module_id.parent(&self.tree)?;
-        Some(ModuleDescriptor {
+        Some(Module {
            module_id: parent_id,
            ..self.clone()
        })
    }
    /// The root of the tree this module is part of
-    pub fn crate_root(&self) -> ModuleDescriptor {
+    pub fn crate_root(&self) -> Module {
        let root_id = self.module_id.crate_root(&self.tree);
-        ModuleDescriptor {
+        Module {
            module_id: root_id,
            ..self.clone()
        }
    }
    /// `name` is `None` for the crate's root module
-    #[allow(unused)]
    pub fn name(&self) -> Option<SmolStr> {
        let link = self.module_id.parent_link(&self.tree)?;
        Some(link.name(&self.tree))
    }
+    pub fn def_id(&self, db: &impl HirDatabase) -> DefId {
+        let def_loc = DefLoc::Module {
+            id: self.module_id,
+            source_root: self.source_root_id,
+        };
+        def_loc.id(db)
+    }
    /// Finds a child module with the specified name.
-    pub fn child(&self, name: &str) -> Option<ModuleDescriptor> {
+    pub fn child(&self, name: &str) -> Option<Module> {
        let child_id = self.module_id.child(&self.tree, name)?;
-        Some(ModuleDescriptor {
+        Some(Module {
            module_id: child_id,
            ..self.clone()
        })
    }
    /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub(crate) fn scope(&self, db: &impl DescriptorDatabase) -> Cancelable<ModuleScope> {
+    pub fn scope(&self, db: &impl HirDatabase) -> Cancelable<ModuleScope> {
-        let item_map = db._item_map(self.source_root_id)?;
+        let item_map = db.item_map(self.source_root_id)?;
        let res = item_map.per_module[&self.module_id].clone();
        Ok(res)
    }
-    pub(crate) fn resolve_path(&self, path: Path) -> Option<ModuleDescriptor> {
+    pub fn resolve_path(&self, db: &impl HirDatabase, path: Path) -> Cancelable<Option<DefId>> {
        let mut curr = match path.kind {
            PathKind::Crate => self.crate_root(),
            PathKind::Self_ | PathKind::Plain => self.clone(),
-            PathKind::Super => self.parent()?,
+            PathKind::Super => ctry!(self.parent()),
-        };
+        }
+        .def_id(db);
        let segments = path.segments;
-        for name in segments {
+        for name in segments.iter() {
-            curr = curr.child(&name)?;
+            let module = match curr.loc(db) {
+                DefLoc::Module { id, source_root } => Module::new(db, source_root, id)?,
+                _ => return Ok(None),
+            };
+            let scope = module.scope(db)?;
+            curr = ctry!(ctry!(scope.get(&name)).def_id);
        }
-        Some(curr)
+        Ok(Some(curr))
    }
-    pub fn problems(&self, db: &impl DescriptorDatabase) -> Vec<(SyntaxNode, Problem)> {
+    pub fn problems(&self, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> {
        self.module_id.problems(&self.tree, db)
    }
 }
@@ -159,19 +183,19 @@ impl ModuleDescriptor {
 /// (which can have multiple parents) to the precise world of modules (which
 /// always have one parent).
 #[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct ModuleTree {
+pub struct ModuleTree {
    mods: Arena<ModuleData>,
    links: Arena<LinkData>,
 }
 impl ModuleTree {
-    fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
+    pub(crate) fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
-        self.mods.keys()
+        self.mods.iter().map(|(id, _)| id)
    }
    fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
        self.mods
-            .items()
+            .iter()
            .filter(|(_idx, it)| it.source == source)
            .map(|(idx, _)| idx)
            .collect()
@@ -185,20 +209,19 @@ impl ModuleTree {
 /// `ModuleSource` is the syntax tree element that produced this module:
 /// either a file, or an inlinde module.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub(crate) enum ModuleSource {
+pub enum ModuleSource {
    SourceFile(FileId),
-    #[allow(dead_code)]
+    Module(SourceItemId),
-    Module(SyntaxPtr),
 }
 /// An owned syntax node for a module. Unlike `ModuleSource`,
 /// this holds onto the AST for the whole file.
-enum ModuleSourceNode {
+pub(crate) enum ModuleSourceNode {
    SourceFile(ast::SourceFileNode),
    Module(ast::ModuleNode),
 }
-pub(crate) type ModuleId = Id<ModuleData>;
+pub type ModuleId = Id<ModuleData>;
 type LinkId = Id<LinkData>;
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -213,7 +236,7 @@ pub enum Problem {
 }
 impl ModuleId {
-    fn source(self, tree: &ModuleTree) -> ModuleSource {
+    pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource {
        tree.mods[self].source
    }
    fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
@@ -243,7 +266,7 @@ impl ModuleId {
            Some((link.name.clone(), module))
        })
    }
-    fn problems(self, tree: &ModuleTree, db: &impl SyntaxDatabase) -> Vec<(SyntaxNode, Problem)> {
+    fn problems(self, tree: &ModuleTree, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> {
        tree.mods[self]
            .children
            .iter()
@@ -264,7 +287,7 @@ impl LinkId {
    fn name(self, tree: &ModuleTree) -> SmolStr {
        tree.links[self].name.clone()
    }
-    fn bind_source<'a>(self, tree: &ModuleTree, db: &impl SyntaxDatabase) -> ast::ModuleNode {
+    fn bind_source<'a>(self, tree: &ModuleTree, db: &impl HirDatabase) -> ast::ModuleNode {
        let owner = self.owner(tree);
        match owner.source(tree).resolve(db) {
            ModuleSourceNode::SourceFile(root) => {
@@ -280,41 +303,47 @@ impl LinkId {
 }
 #[derive(Debug, PartialEq, Eq, Hash)]
-pub(crate) struct ModuleData {
+pub struct ModuleData {
    source: ModuleSource,
    parent: Option<LinkId>,
    children: Vec<LinkId>,
 }
 impl ModuleSource {
-    fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
+    pub(crate) fn new_inline(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        module: ast::Module,
+    ) -> ModuleSource {
        assert!(!module.has_semi());
-        let ptr = SyntaxPtr::new(file_id, module.syntax());
+        let items = db.file_items(file_id);
-        ModuleSource::Module(ptr)
+        let item_id = items.id_of(module.syntax());
+        let id = SourceItemId { file_id, item_id };
+        ModuleSource::Module(id)
    }
-    pub(crate) fn as_file(self) -> Option<FileId> {
+    pub fn as_file(self) -> Option<FileId> {
        match self {
            ModuleSource::SourceFile(f) => Some(f),
            ModuleSource::Module(..) => None,
        }
    }
-    pub(crate) fn file_id(self) -> FileId {
+    pub fn file_id(self) -> FileId {
        match self {
            ModuleSource::SourceFile(f) => f,
-            ModuleSource::Module(ptr) => ptr.file_id(),
+            ModuleSource::Module(source_item_id) => source_item_id.file_id,
        }
    }
-    fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
+    pub(crate) fn resolve(self, db: &impl HirDatabase) -> ModuleSourceNode {
        match self {
            ModuleSource::SourceFile(file_id) => {
-                let syntax = db.file_syntax(file_id);
+                let syntax = db.source_file(file_id);
                ModuleSourceNode::SourceFile(syntax.ast().owned())
            }
-            ModuleSource::Module(ptr) => {
+            ModuleSource::Module(item_id) => {
-                let syntax = db.resolve_syntax_ptr(ptr);
+                let syntax = db.file_item(item_id);
                let syntax = syntax.borrowed();
                let module = ast::Module::cast(syntax).unwrap();
                ModuleSourceNode::Module(module.owned())
@@ -333,11 +362,11 @@ struct LinkData {
 impl ModuleTree {
    fn push_mod(&mut self, data: ModuleData) -> ModuleId {
-        self.mods.push(data)
+        self.mods.alloc(data)
    }
    fn push_link(&mut self, data: LinkData) -> LinkId {
        let owner = data.owner;
-        let id = self.links.push(data);
+        let id = self.links.alloc(data);
        self.mods[owner].children.push(id);
        id
    }
diff --git a/crates/ra_analysis/src/descriptors/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs
index 648ec5e43..8529e16b3 100644
--- a/crates/ra_analysis/src/descriptors/module/nameres.rs
+++ b/crates/ra_hir/src/module/nameres.rs
@@ -16,38 +16,44 @@
 //! structure itself is modified.
 use std::{
    sync::Arc,
-    time::Instant,
 };
 use rustc_hash::FxHashMap;
 use ra_syntax::{
+    TextRange,
    SmolStr, SyntaxKind::{self, *},
-    ast::{self, ModuleItemOwner}
+    ast::{self, AstNode}
 };
+use ra_db::SourceRootId;
 use crate::{
-    Cancelable,
+    Cancelable, FileId,
-    loc2id::{DefId, DefLoc},
+    DefId, DefLoc,
-    descriptors::{
+    SourceItemId, SourceFileItemId, SourceFileItems,
-        Path, PathKind,
+    Path, PathKind,
-        DescriptorDatabase,
+    HirDatabase,
-        module::{ModuleId, ModuleTree, ModuleSourceNode},
+    module::{ModuleId, ModuleTree},
-    },
-    syntax_ptr::{LocalSyntaxPtr},
-    input::SourceRootId,
 };
 /// Item map is the result of the name resolution. Item map contains, for each
 /// module, the set of visible items.
 #[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct ItemMap {
+pub struct ItemMap {
-    pub(crate) per_module: FxHashMap<ModuleId, ModuleScope>,
+    pub per_module: FxHashMap<ModuleId, ModuleScope>,
 }
 #[derive(Debug, Default, PartialEq, Eq, Clone)]
-pub(crate) struct ModuleScope {
+pub struct ModuleScope {
-    pub(crate) items: FxHashMap<SmolStr, Resolution>,
+    items: FxHashMap<SmolStr, Resolution>,
+}
+impl ModuleScope {
+    pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a SmolStr, &Resolution)> + 'a {
+        self.items.iter()
+    }
+    pub fn get(&self, name: &SmolStr) -> Option<&Resolution> {
+        self.items.get(name)
+    }
 }
 /// A set of items and imports declared inside a module, without relation to
@@ -57,85 +63,63 @@ pub(crate) struct ModuleScope {
 /// recomputing name res: if `InputModuleItems` are the same, we can avoid
 /// running name resolution.
 #[derive(Debug, Default, PartialEq, Eq)]
-pub(crate) struct InputModuleItems {
+pub struct InputModuleItems {
    items: Vec<ModuleItem>,
    imports: Vec<Import>,
 }
+#[derive(Debug, PartialEq, Eq)]
+struct ModuleItem {
+    id: SourceFileItemId,
+    name: SmolStr,
+    kind: SyntaxKind,
+    vis: Vis,
+}
+#[derive(Debug, PartialEq, Eq)]
+enum Vis {
+    // Priv,
+    Other,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct Import {
    path: Path,
    kind: ImportKind,
 }
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum ImportKind {
+pub struct NamedImport {
-    Glob,
+    pub file_item_id: SourceFileItemId,
-    // TODO: make offset independent
+    pub relative_range: TextRange,
-    Named(LocalSyntaxPtr),
 }
-pub(crate) fn input_module_items(
+impl NamedImport {
-    db: &impl DescriptorDatabase,
+    pub fn range(&self, db: &impl HirDatabase, file_id: FileId) -> TextRange {
-    source_root: SourceRootId,
+        let source_item_id = SourceItemId {
-    module_id: ModuleId,
+            file_id,
-) -> Cancelable<Arc<InputModuleItems>> {
+            item_id: self.file_item_id,
-    let module_tree = db._module_tree(source_root)?;
+        };
-    let source = module_id.source(&module_tree);
+        let syntax = db.file_item(source_item_id);
-    let res = match source.resolve(db) {
+        let offset = syntax.borrowed().range().start();
-        ModuleSourceNode::SourceFile(it) => {
+        self.relative_range + offset
-            let items = it.borrowed().items();
+    }
-            InputModuleItems::new(items)
-        }
-        ModuleSourceNode::Module(it) => {
-            let items = it
-                .borrowed()
-                .item_list()
-                .into_iter()
-                .flat_map(|it| it.items());
-            InputModuleItems::new(items)
-        }
-    };
-    Ok(Arc::new(res))
 }
-pub(crate) fn item_map(
+#[derive(Debug, Clone, PartialEq, Eq)]
-    db: &impl DescriptorDatabase,
+enum ImportKind {
-    source_root: SourceRootId,
+    Glob,
-) -> Cancelable<Arc<ItemMap>> {
+    Named(NamedImport),
-    let start = Instant::now();
-    let module_tree = db._module_tree(source_root)?;
-    let input = module_tree
-        .modules()
-        .map(|id| {
-            let items = db._input_module_items(source_root, id)?;
-            Ok((id, items))
-        })
-        .collect::<Cancelable<FxHashMap<_, _>>>()?;
-    let mut resolver = Resolver {
-        db: db,
-        input: &input,
-        source_root,
-        module_tree,
-        result: ItemMap::default(),
-    };
-    resolver.resolve()?;
-    let res = resolver.result;
-    let elapsed = start.elapsed();
-    log::info!("item_map: {:?}", elapsed);
-    Ok(Arc::new(res))
 }
 /// Resolution is basically `DefId` atm, but it should account for stuff like
 /// multiple namespaces, ambiguity and errors.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct Resolution {
+pub struct Resolution {
    /// None for unresolved
-    pub(crate) def_id: Option<DefId>,
+    pub def_id: Option<DefId>,
    /// ident by whitch this is imported into local scope.
-    /// TODO: make this offset-independent.
+    pub import: Option<NamedImport>,
-    pub(crate) import_name: Option<LocalSyntaxPtr>,
 }
 // #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -150,55 +134,49 @@ pub(crate) struct Resolution {
 //     values: Option<T>,
 // }
-#[derive(Debug, PartialEq, Eq)]
-struct ModuleItem {
-    ptr: LocalSyntaxPtr,
-    name: SmolStr,
-    kind: SyntaxKind,
-    vis: Vis,
-}
-#[derive(Debug, PartialEq, Eq)]
-enum Vis {
-    // Priv,
-    Other,
-}
 impl InputModuleItems {
-    fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> InputModuleItems {
+    pub(crate) fn new<'a>(
+        file_items: &SourceFileItems,
+        items: impl Iterator<Item = ast::ModuleItem<'a>>,
+    ) -> InputModuleItems {
        let mut res = InputModuleItems::default();
        for item in items {
-            res.add_item(item);
+            res.add_item(file_items, item);
        }
        res
    }
-    fn add_item(&mut self, item: ast::ModuleItem) -> Option<()> {
+    fn add_item(&mut self, file_items: &SourceFileItems, item: ast::ModuleItem) -> Option<()> {
        match item {
-            ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
            ast::ModuleItem::ImplItem(_) => {
                // impls don't define items
            }
-            ast::ModuleItem::UseItem(it) => self.add_use_item(it),
+            ast::ModuleItem::UseItem(it) => self.add_use_item(file_items, it),
            ast::ModuleItem::ExternCrateItem(_) => {
                // TODO
            }
-            ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(file_items, it)?),
-            ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(it)?),
+            ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(file_items, it)?),
        }
        Some(())
    }
-    fn add_use_item(&mut self, item: ast::UseItem) {
+    fn add_use_item(&mut self, file_items: &SourceFileItems, item: ast::UseItem) {
-        Path::expand_use_item(item, |path, ptr| {
+        let file_item_id = file_items.id_of(item.syntax());
-            let kind = match ptr {
+        let start_offset = item.syntax().range().start();
+        Path::expand_use_item(item, |path, range| {
+            let kind = match range {
                None => ImportKind::Glob,
-                Some(ptr) => ImportKind::Named(ptr),
+                Some(range) => ImportKind::Named(NamedImport {
+                    file_item_id,
+                    relative_range: range - start_offset,
+                }),
            };
            self.imports.push(Import { kind, path })
        })
@@ -206,13 +184,13 @@ impl InputModuleItems {
 }
 impl ModuleItem {
-    fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
+    fn new<'a>(file_items: &SourceFileItems, item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
        let name = item.name()?.text();
-        let ptr = LocalSyntaxPtr::new(item.syntax());
        let kind = item.syntax().kind();
        let vis = Vis::Other;
+        let id = file_items.id_of(item.syntax());
        let res = ModuleItem {
-            ptr,
+            id,
            name,
            kind,
            vis,
@@ -221,28 +199,28 @@ impl ModuleItem {
    }
 }
-struct Resolver<'a, DB> {
+pub(crate) struct Resolver<'a, DB> {
-    db: &'a DB,
+    pub(crate) db: &'a DB,
-    input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
+    pub(crate) input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
-    source_root: SourceRootId,
+    pub(crate) source_root: SourceRootId,
-    module_tree: Arc<ModuleTree>,
+    pub(crate) module_tree: Arc<ModuleTree>,
-    result: ItemMap,
+    pub(crate) result: ItemMap,
 }
 impl<'a, DB> Resolver<'a, DB>
 where
-    DB: DescriptorDatabase,
+    DB: HirDatabase,
 {
-    fn resolve(&mut self) -> Cancelable<()> {
+    pub(crate) fn resolve(mut self) -> Cancelable<ItemMap> {
        for (&module_id, items) in self.input.iter() {
            self.populate_module(module_id, items)
        }
        for &module_id in self.input.keys() {
-            crate::db::check_canceled(self.db)?;
+            self.db.check_canceled()?;
            self.resolve_imports(module_id);
        }
-        Ok(())
+        Ok(self.result)
    }
    fn populate_module(&mut self, module_id: ModuleId, input: &InputModuleItems) {
@@ -252,12 +230,12 @@ where
        for import in input.imports.iter() {
            if let Some(name) = import.path.segments.iter().last() {
-                if let ImportKind::Named(ptr) = import.kind {
+                if let ImportKind::Named(import) = import.kind {
                    module_items.items.insert(
                        name.clone(),
                        Resolution {
                            def_id: None,
-                            import_name: Some(ptr),
+                            import: Some(import),
                        },
                    );
                }
@@ -269,12 +247,16 @@ where
                // handle submodules separatelly
                continue;
            }
-            let ptr = item.ptr.into_global(file_id);
+            let def_loc = DefLoc::Item {
-            let def_loc = DefLoc::Item { ptr };
+                source_item_id: SourceItemId {
-            let def_id = self.db.id_maps().def_id(def_loc);
+                    file_id,
+                    item_id: item.id,
+                },
+            };
+            let def_id = def_loc.id(self.db);
            let resolution = Resolution {
                def_id: Some(def_id),
-                import_name: None,
+                import: None,
            };
            module_items.items.insert(item.name.clone(), resolution);
        }
@@ -284,10 +266,10 @@ where
                id: mod_id,
                source_root: self.source_root,
            };
-            let def_id = self.db.id_maps().def_id(def_loc);
+            let def_id = def_loc.id(self.db);
            let resolution = Resolution {
                def_id: Some(def_id),
-                import_name: None,
+                import: None,
            };
            module_items.items.insert(name, resolution);
        }
@@ -333,7 +315,7 @@ where
            };
            if !is_last {
-                curr = match self.db.id_maps().def_loc(def_id) {
+                curr = match def_id.loc(self.db) {
                    DefLoc::Module { id, .. } => id,
                    _ => return,
                }
@@ -341,7 +323,7 @@ where
                self.update(module_id, |items| {
                    let res = Resolution {
                        def_id: Some(def_id),
-                        import_name: Some(ptr),
+                        import: Some(ptr),
                    };
                    items.items.insert(name.clone(), res);
                })
@@ -357,23 +339,24 @@ where
 #[cfg(test)]
 mod tests {
+    use std::sync::Arc;
+    use salsa::Database;
+    use ra_db::FilesDatabase;
+    use ra_syntax::SmolStr;
    use crate::{
-        AnalysisChange,
+        self as hir,
-        mock_analysis::{MockAnalysis, analysis_and_position},
+        db::HirDatabase,
-        descriptors::{DescriptorDatabase, module::ModuleDescriptor},
+        mock::MockDatabase,
-        input::FilesDatabase,
 };
-    use super::*;
-    fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
+    fn item_map(fixture: &str) -> (Arc<hir::ItemMap>, hir::ModuleId) {
-        let (analysis, pos) = analysis_and_position(fixture);
+        let (db, pos) = MockDatabase::with_position(fixture);
-        let db = analysis.imp.db;
        let source_root = db.file_source_root(pos.file_id);
-        let descr = ModuleDescriptor::guess_from_position(&*db, pos)
+        let module = hir::Module::guess_from_position(&db, pos).unwrap().unwrap();
-            .unwrap()
+        let module_id = module.module_id;
-            .unwrap();
+        (db.item_map(source_root).unwrap(), module_id)
-        let module_id = descr.module_id;
-        (db._item_map(source_root).unwrap(), module_id)
    }
    #[test]
@@ -400,10 +383,10 @@ mod tests {
    #[test]
    fn typing_inside_a_function_should_not_invalidate_item_map() {
-        let mock_analysis = MockAnalysis::with_files(
+        let (mut db, pos) = MockDatabase::with_position(
            "
            //- /lib.rs
-            mod foo;
+            mod foo;<|>
            use crate::foo::bar::Baz;
@@ -417,45 +400,35 @@ mod tests {
            pub struct Baz;
        ",
        );
+        let source_root = db.file_source_root(pos.file_id);
-        let file_id = mock_analysis.id_of("/lib.rs");
-        let mut host = mock_analysis.analysis_host();
-        let source_root = host.analysis().imp.db.file_source_root(file_id);
        {
-            let db = host.analysis().imp.db;
            let events = db.log_executed(|| {
-                db._item_map(source_root).unwrap();
+                db.item_map(source_root).unwrap();
            });
-            assert!(format!("{:?}", events).contains("_item_map"))
+            assert!(format!("{:?}", events).contains("item_map"))
        }
-        let mut change = AnalysisChange::new();
+        let new_text = "
-        change.change_file(
-            file_id,
-            "
            mod foo;
            use crate::foo::bar::Baz;
            fn foo() -> i32 { 92 }
        "
-            .to_string(),
+        .to_string();
-        );
-        host.apply_change(change);
+        db.query_mut(ra_db::FileTextQuery)
+            .set(pos.file_id, Arc::new(new_text));
        {
-            let db = host.analysis().imp.db;
            let events = db.log_executed(|| {
-                db._item_map(source_root).unwrap();
+                db.item_map(source_root).unwrap();
            });
-            // assert!(
+            assert!(
-            //     !format!("{:?}", events).contains("_item_map"),
+                !format!("{:?}", events).contains("_item_map"),
-            //     "{:#?}", events
+                "{:#?}",
-            // )
+                events
+            )
        }
    }
 }
diff --git a/crates/ra_analysis/src/descriptors/path.rs b/crates/ra_hir/src/path.rs
index 99fca18b1..4a2e427cd 100644
--- a/crates/ra_analysis/src/descriptors/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -1,15 +1,13 @@
-use ra_syntax::{SmolStr, ast, AstNode};
+use ra_syntax::{SmolStr, ast, AstNode, TextRange};
-use crate::syntax_ptr::LocalSyntaxPtr;
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct Path {
+pub struct Path {
-    pub(crate) kind: PathKind,
+    pub kind: PathKind,
-    pub(crate) segments: Vec<SmolStr>,
+    pub segments: Vec<SmolStr>,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) enum PathKind {
+pub enum PathKind {
    Plain,
    Self_,
    Super,
@@ -18,17 +16,14 @@ pub(crate) enum PathKind {
 impl Path {
    /// Calls `cb` with all paths, represented by this use item.
-    pub(crate) fn expand_use_item(
+    pub fn expand_use_item(item: ast::UseItem, mut cb: impl FnMut(Path, Option<TextRange>)) {
-        item: ast::UseItem,
-        mut cb: impl FnMut(Path, Option<LocalSyntaxPtr>),
-    ) {
        if let Some(tree) = item.use_tree() {
            expand_use_tree(None, tree, &mut cb);
        }
    }
    /// Converts an `ast::Path` to `Path`. Works with use trees.
-    pub(crate) fn from_ast(mut path: ast::Path) -> Option<Path> {
+    pub fn from_ast(mut path: ast::Path) -> Option<Path> {
        let mut kind = PathKind::Plain;
        let mut segments = Vec::new();
        loop {
@@ -69,7 +64,7 @@ impl Path {
    }
    /// `true` is this path is a single identifier, like `foo`
-    pub(crate) fn is_ident(&self) -> bool {
+    pub fn is_ident(&self) -> bool {
        self.kind == PathKind::Plain && self.segments.len() == 1
    }
 }
@@ -77,7 +72,7 @@ impl Path {
 fn expand_use_tree(
    prefix: Option<Path>,
    tree: ast::UseTree,
-    cb: &mut impl FnMut(Path, Option<LocalSyntaxPtr>),
+    cb: &mut impl FnMut(Path, Option<TextRange>),
 ) {
    if let Some(use_tree_list) = tree.use_tree_list() {
        let prefix = match tree.path() {
@@ -93,13 +88,13 @@ fn expand_use_tree(
    } else {
        if let Some(ast_path) = tree.path() {
            if let Some(path) = convert_path(prefix, ast_path) {
-                let ptr = if tree.has_star() {
+                let range = if tree.has_star() {
                    None
                } else {
-                    let ptr = LocalSyntaxPtr::new(ast_path.segment().unwrap().syntax());
+                    let range = ast_path.segment().unwrap().syntax().range();
-                    Some(ptr)
+                    Some(range)
                };
-                cb(path, ptr)
+                cb(path, range)
            }
        }
    }
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
new file mode 100644
index 000000000..6f602878c
--- /dev/null
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -0,0 +1,154 @@
+use std::{
+    sync::Arc,
+    time::Instant,
+};
+use rustc_hash::FxHashMap;
+use ra_syntax::{
+    AstNode,  SyntaxNode, SmolStr,
+    ast::{self, FnDef, FnDefNode, NameOwner, ModuleItemOwner}
+};
+use ra_db::{SourceRootId, FileId, Cancelable,};
+use crate::{
+        FnId,
+        SourceFileItems, SourceItemId,
+        db::HirDatabase,
+        function::FnScopes,
+        module::{
+            ModuleSource, ModuleSourceNode, ModuleId,
+            imp::Submodule,
+            nameres::{InputModuleItems, ItemMap, Resolver},
+        },
+};
+/// Resolve `FnId` to the corresponding `SyntaxNode`
+pub(super) fn fn_syntax(db: &impl HirDatabase, fn_id: FnId) -> FnDefNode {
+    let item_id = fn_id.loc(db);
+    let syntax = db.file_item(item_id);
+    FnDef::cast(syntax.borrowed()).unwrap().owned()
+}
+pub(super) fn fn_scopes(db: &impl HirDatabase, fn_id: FnId) -> Arc<FnScopes> {
+    let syntax = db.fn_syntax(fn_id);
+    let res = FnScopes::new(syntax.borrowed());
+    Arc::new(res)
+}
+pub(super) fn file_items(db: &impl HirDatabase, file_id: FileId) -> Arc<SourceFileItems> {
+    let source_file = db.source_file(file_id);
+    let source_file = source_file.borrowed();
+    let mut res = SourceFileItems::default();
+    source_file
+        .syntax()
+        .descendants()
+        .filter_map(ast::ModuleItem::cast)
+        .map(|it| it.syntax().owned())
+        .for_each(|it| {
+            res.alloc(it);
+        });
+    Arc::new(res)
+}
+pub(super) fn file_item(db: &impl HirDatabase, source_item_id: SourceItemId) -> SyntaxNode {
+    db.file_items(source_item_id.file_id)[source_item_id.item_id].clone()
+}
+pub(crate) fn submodules(
+    db: &impl HirDatabase,
+    source: ModuleSource,
+) -> Cancelable<Arc<Vec<Submodule>>> {
+    db.check_canceled()?;
+    let file_id = source.file_id();
+    let submodules = match source.resolve(db) {
+        ModuleSourceNode::SourceFile(it) => collect_submodules(db, file_id, it.borrowed()),
+        ModuleSourceNode::Module(it) => it
+            .borrowed()
+            .item_list()
+            .map(|it| collect_submodules(db, file_id, it))
+            .unwrap_or_else(Vec::new),
+    };
+    return Ok(Arc::new(submodules));
+    fn collect_submodules<'a>(
+        db: &impl HirDatabase,
+        file_id: FileId,
+        root: impl ast::ModuleItemOwner<'a>,
+    ) -> Vec<Submodule> {
+        modules(root)
+            .map(|(name, m)| {
+                if m.has_semi() {
+                    Submodule::Declaration(name)
+                } else {
+                    let src = ModuleSource::new_inline(db, file_id, m);
+                    Submodule::Definition(name, src)
+                }
+            })
+            .collect()
+    }
+}
+pub(crate) fn modules<'a>(
+    root: impl ast::ModuleItemOwner<'a>,
+) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
+    root.items()
+        .filter_map(|item| match item {
+            ast::ModuleItem::Module(m) => Some(m),
+            _ => None,
+        })
+        .filter_map(|module| {
+            let name = module.name()?.text();
+            Some((name, module))
+        })
+}
+pub(super) fn input_module_items(
+    db: &impl HirDatabase,
+    source_root: SourceRootId,
+    module_id: ModuleId,
+) -> Cancelable<Arc<InputModuleItems>> {
+    let module_tree = db.module_tree(source_root)?;
+    let source = module_id.source(&module_tree);
+    let file_items = db.file_items(source.file_id());
+    let res = match source.resolve(db) {
+        ModuleSourceNode::SourceFile(it) => {
+            let items = it.borrowed().items();
+            InputModuleItems::new(&file_items, items)
+        }
+        ModuleSourceNode::Module(it) => {
+            let items = it
+                .borrowed()
+                .item_list()
+                .into_iter()
+                .flat_map(|it| it.items());
+            InputModuleItems::new(&file_items, items)
+        }
+    };
+    Ok(Arc::new(res))
+}
+pub(super) fn item_map(
+    db: &impl HirDatabase,
+    source_root: SourceRootId,
+) -> Cancelable<Arc<ItemMap>> {
+    let start = Instant::now();
+    let module_tree = db.module_tree(source_root)?;
+    let input = module_tree
+        .modules()
+        .map(|id| {
+            let items = db.input_module_items(source_root, id)?;
+            Ok((id, items))
+        })
+        .collect::<Cancelable<FxHashMap<_, _>>>()?;
+    let resolver = Resolver {
+        db: db,
+        input: &input,
+        source_root,
+        module_tree,
+        result: ItemMap::default(),
+    };
+    let res = resolver.resolve()?;
+    let elapsed = start.elapsed();
+    log::info!("item_map: {:?}", elapsed);
+    Ok(Arc::new(res))
+}
diff --git a/crates/ra_lsp_server/src/conv.rs b/crates/ra_lsp_server/src/conv.rs
index 5d5a0c55e..28368787c 100644
--- a/crates/ra_lsp_server/src/conv.rs
+++ b/crates/ra_lsp_server/src/conv.rs
@@ -63,10 +63,7 @@ impl ConvWith for TextUnit {
    fn conv_with(self, line_index: &LineIndex) -> Position {
        let line_col = line_index.line_col(self);
-        Position::new(
+        Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16))
-            u64::from(line_col.line),
-            u64::from(u32::from(line_col.col_utf16)),
-        )
    }
 }
@@ -204,10 +201,8 @@ impl TryConvWith for SourceChange {
                    .map(|it| it.edits.as_slice())
                    .unwrap_or(&[]);
                let line_col = translate_offset_with_edit(&*line_index, pos.offset, edits);
-                let position = Position::new(
+                let position =
-                    u64::from(line_col.line),
+                    Position::new(u64::from(line_col.line), u64::from(line_col.col_utf16));
-                    u64::from(u32::from(line_col.col_utf16)),
-                );
                Some(TextDocumentPositionParams {
                    text_document: TextDocumentIdentifier::new(pos.file_id.try_conv_with(world)?),
                    position,
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index 26bcddd8e..8301a1044 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -65,27 +65,3 @@ fn main_inner() -> Result<()> {
    info!("... IO is down");
    Ok(())
 }
-/*
-                    (let ((backend (eglot-xref-backend)))
-                      (mapcar
-                       (lambda (xref)
-                         (let ((loc (xref-item-location xref)))
-                           (propertize
-                            (concat
-                             (when (xref-file-location-p loc)
-                               (with-slots (file line column) loc
-                                 (format "%s:%s:%s:"
-                                         (propertize (file-relative-name file)
-                                                     'face 'compilation-info)
-                                         (propertize (format "%s" line)
-                                                     'face 'compilation-line
-                                                     )
-                                         column)))
-                             (xref-item-summary xref))
-                            'xref xref)))
-                       (xref-backend-apropos backend "Analysis"))
-                      )
-*/
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 27933a7ae..6d5622b15 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -384,7 +384,7 @@ pub fn handle_completion(
    let completion_triggered_after_single_colon = {
        let mut res = false;
        if let Some(ctx) = params.context {
-            if ctx.trigger_character.unwrap_or(String::new()) == ":" {
+            if ctx.trigger_character.unwrap_or_default() == ":" {
                let source_file = world.analysis().file_syntax(position.file_id);
                let syntax = source_file.syntax();
                let text = syntax.text();
@@ -567,10 +567,13 @@ pub fn handle_rename(world: ServerWorld, params: RenameParams) -> Result<Option<
    let mut changes = HashMap::new();
    for r in refs {
        if let Ok(loc) = to_location(r.0, r.1, &world, &line_index) {
-            changes.entry(loc.uri).or_insert(Vec::new()).push(TextEdit {
+            changes
-                range: loc.range,
+                .entry(loc.uri)
-                new_text: params.new_name.clone(),
+                .or_insert_with(Vec::new)
-            });
+                .push(TextEdit {
+                    range: loc.range,
+                    new_text: params.new_name.clone(),
+                });
        }
    }
diff --git a/crates/ra_lsp_server/src/path_map.rs b/crates/ra_lsp_server/src/path_map.rs
index a624043d8..02e54629c 100644
--- a/crates/ra_lsp_server/src/path_map.rs
+++ b/crates/ra_lsp_server/src/path_map.rs
@@ -43,7 +43,7 @@ impl PathMap {
        (inserted, file_id)
    }
    pub fn get_id(&self, path: &Path) -> Option<FileId> {
-        self.path2id.get(path).map(|&id| id)
+        self.path2id.get(path).cloned()
    }
    pub fn get_path(&self, file_id: FileId) -> &Path {
        self.id2path.get(&file_id).unwrap().as_path()
diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs
index 3e7670fcc..12faeb93a 100644
--- a/crates/ra_lsp_server/src/server_world.rs
+++ b/crates/ra_lsp_server/src/server_world.rs
@@ -140,7 +140,7 @@ impl ServerWorldState {
        Ok(file_id)
    }
    pub fn set_workspaces(&mut self, ws: Vec<CargoWorkspace>) {
-        let mut crate_graph = CrateGraph::new();
+        let mut crate_graph = CrateGraph::default();
        ws.iter()
            .flat_map(|ws| {
                ws.packages()