73 files changed, 1995 insertions, 1375 deletions

diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index b5f8afb4e..ee8bff346 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -36,7 +36,7 @@ pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
 
     // We want to only apply this to non-union structs with named fields
     let field_list = match (strukt.kind(), strukt.is_union()) {
-        (StructKind::Named(named), false) => named,
+        (StructKind::Record(named), false) => named,
         _ => return None,
     };
 
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 9354466d9..8482897c5 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -101,7 +101,7 @@ fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
                 iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
             make::tuple_struct_pat(path, pats).into()
         }
-        ast::StructKind::Named(field_list) => {
+        ast::StructKind::Record(field_list) => {
             let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
             make::record_pat(path, pats).into()
         }
diff --git a/crates/ra_assists/src/test_db.rs b/crates/ra_assists/src/test_db.rs
index 5be7383ed..5f96c974b 100644
--- a/crates/ra_assists/src/test_db.rs
+++ b/crates/ra_assists/src/test_db.rs
@@ -10,7 +10,6 @@ use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath
     hir::db::InternDatabaseStorage,
     hir::db::AstDatabaseStorage,
     hir::db::DefDatabaseStorage,
-    hir::db::DefDatabase2Storage,
     hir::db::HirDatabaseStorage
 )]
 #[derive(Debug, Default)]
diff --git a/crates/ra_db/src/fixture.rs b/crates/ra_db/src/fixture.rs
index ade187629..e8f335e33 100644
--- a/crates/ra_db/src/fixture.rs
+++ b/crates/ra_db/src/fixture.rs
@@ -8,7 +8,7 @@ use rustc_hash::FxHashMap;
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
 
 use crate::{
-    CrateGraph, CrateId, Edition, FileId, FilePosition, RelativePathBuf, SourceDatabaseExt,
+    CrateGraph, CrateId, Edition, Env, FileId, FilePosition, RelativePathBuf, SourceDatabaseExt,
     SourceRoot, SourceRootId,
 };
 
@@ -53,7 +53,12 @@ fn with_single_file(db: &mut dyn SourceDatabaseExt, text: &str) -> FileId {
     source_root.insert_file(rel_path.clone(), file_id);
 
     let mut crate_graph = CrateGraph::default();
-    crate_graph.add_crate_root(file_id, Edition::Edition2018, CfgOptions::default());
+    crate_graph.add_crate_root(
+        file_id,
+        Edition::Edition2018,
+        CfgOptions::default(),
+        Env::default(),
+    );
 
     db.set_file_text(file_id, Arc::new(text.to_string()));
     db.set_file_relative_path(file_id, rel_path);
@@ -93,7 +98,8 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
         assert!(meta.path.starts_with(&source_root_prefix));
 
         if let Some(krate) = meta.krate {
-            let crate_id = crate_graph.add_crate_root(file_id, meta.edition, meta.cfg);
+            let crate_id =
+                crate_graph.add_crate_root(file_id, meta.edition, meta.cfg, Env::default());
             let prev = crates.insert(krate.clone(), crate_id);
             assert!(prev.is_none());
             for dep in meta.deps {
@@ -123,7 +129,12 @@ fn with_files(db: &mut dyn SourceDatabaseExt, fixture: &str) -> Option<FilePosit
 
     if crates.is_empty() {
         let crate_root = default_crate_root.unwrap();
-        crate_graph.add_crate_root(crate_root, Edition::Edition2018, CfgOptions::default());
+        crate_graph.add_crate_root(
+            crate_root,
+            Edition::Edition2018,
+            CfgOptions::default(),
+            Env::default(),
+        );
     } else {
         for (from, to) in crate_deps {
             let from_id = crates[&from];
diff --git a/crates/ra_db/src/input.rs b/crates/ra_db/src/input.rs
index c0d95a13f..b6d851776 100644
--- a/crates/ra_db/src/input.rs
+++ b/crates/ra_db/src/input.rs
@@ -6,14 +6,14 @@
 //! actual IO. See `vfs` and `project_model` in the `ra_lsp_server` crate for how
 //! actual IO is done and lowered to input.
 
-use rustc_hash::FxHashMap;
+use std::{fmt, str::FromStr};
 
 use ra_cfg::CfgOptions;
 use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
 use rustc_hash::FxHashSet;
 
 use crate::{RelativePath, RelativePathBuf};
-use std::str::FromStr;
 
 /// `FileId` is an integer which uniquely identifies a file. File paths are
 /// messy and system-dependent, so most of the code should work directly with
@@ -80,56 +80,27 @@ pub struct CrateGraph {
     arena: FxHashMap<CrateId, CrateData>,
 }
 
-#[derive(Debug)]
-pub struct CyclicDependencies;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct CrateId(pub u32);
 
-impl CrateId {
-    pub fn shift(self, amount: u32) -> CrateId {
-        CrateId(self.0 + amount)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Edition {
-    Edition2018,
-    Edition2015,
-}
-
-#[derive(Debug)]
-pub struct ParseEditionError {
-    pub msg: String,
-}
-
-impl FromStr for Edition {
-    type Err = ParseEditionError;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "2015" => Ok(Edition::Edition2015),
-            "2018" => Ok(Edition::Edition2018),
-            _ => Err(ParseEditionError { msg: format!("unknown edition: {}", s) }),
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct CrateData {
     file_id: FileId,
     edition: Edition,
-    dependencies: Vec<Dependency>,
     cfg_options: CfgOptions,
+    env: Env,
+    dependencies: Vec<Dependency>,
 }
 
-impl CrateData {
-    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions) -> CrateData {
-        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options }
-    }
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Edition {
+    Edition2018,
+    Edition2015,
+}
 
-    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
-        self.dependencies.push(Dependency { name, crate_id })
-    }
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct Env {
+    entries: FxHashMap<String, String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -138,21 +109,17 @@ pub struct Dependency {
     pub name: SmolStr,
 }
 
-impl Dependency {
-    pub fn crate_id(&self) -> CrateId {
-        self.crate_id
-    }
-}
-
 impl CrateGraph {
     pub fn add_crate_root(
         &mut self,
         file_id: FileId,
         edition: Edition,
         cfg_options: CfgOptions,
+        env: Env,
     ) -> CrateId {
+        let data = CrateData::new(file_id, edition, cfg_options, env);
         let crate_id = CrateId(self.arena.len() as u32);
-        let prev = self.arena.insert(crate_id, CrateData::new(file_id, edition, cfg_options));
+        let prev = self.arena.insert(crate_id, data);
         assert!(prev.is_none());
         crate_id
     }
@@ -166,9 +133,9 @@ impl CrateGraph {
         from: CrateId,
         name: SmolStr,
         to: CrateId,
-    ) -> Result<(), CyclicDependencies> {
+    ) -> Result<(), CyclicDependenciesError> {
         if self.dfs_find(from, to, &mut FxHashSet::default()) {
-            return Err(CyclicDependencies);
+            return Err(CyclicDependenciesError);
         }
         self.arena.get_mut(&from).unwrap().add_dep(name, to);
         Ok(())
@@ -239,16 +206,70 @@ impl CrateGraph {
     }
 }
 
+impl CrateId {
+    pub fn shift(self, amount: u32) -> CrateId {
+        CrateId(self.0 + amount)
+    }
+}
+
+impl CrateData {
+    fn new(file_id: FileId, edition: Edition, cfg_options: CfgOptions, env: Env) -> CrateData {
+        CrateData { file_id, edition, dependencies: Vec::new(), cfg_options, env }
+    }
+
+    fn add_dep(&mut self, name: SmolStr, crate_id: CrateId) {
+        self.dependencies.push(Dependency { name, crate_id })
+    }
+}
+
+impl FromStr for Edition {
+    type Err = ParseEditionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let res = match s {
+            "2015" => Edition::Edition2015,
+            "2018" => Edition::Edition2018,
+            _ => Err(ParseEditionError { invalid_input: s.to_string() })?,
+        };
+        Ok(res)
+    }
+}
+
+impl Dependency {
+    pub fn crate_id(&self) -> CrateId {
+        self.crate_id
+    }
+}
+
+#[derive(Debug)]
+pub struct ParseEditionError {
+    invalid_input: String,
+}
+
+impl fmt::Display for ParseEditionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid edition: {:?}", self.invalid_input)
+    }
+}
+
+impl std::error::Error for ParseEditionError {}
+
+#[derive(Debug)]
+pub struct CyclicDependenciesError;
+
 #[cfg(test)]
 mod tests {
-    use super::{CfgOptions, CrateGraph, Edition::Edition2018, FileId, SmolStr};
+    use super::{CfgOptions, CrateGraph, Edition::Edition2018, Env, FileId, SmolStr};
 
     #[test]
     fn it_should_panic_because_of_cycle_dependencies() {
         let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
+        let crate1 =
+            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate2 =
+            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate3 =
+            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
         assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
         assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
         assert!(graph.add_dep(crate3, SmolStr::new("crate1"), crate1).is_err());
@@ -257,9 +278,12 @@ mod tests {
     #[test]
     fn it_works() {
         let mut graph = CrateGraph::default();
-        let crate1 = graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default());
-        let crate2 = graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default());
-        let crate3 = graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default());
+        let crate1 =
+            graph.add_crate_root(FileId(1u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate2 =
+            graph.add_crate_root(FileId(2u32), Edition2018, CfgOptions::default(), Env::default());
+        let crate3 =
+            graph.add_crate_root(FileId(3u32), Edition2018, CfgOptions::default(), Env::default());
         assert!(graph.add_dep(crate1, SmolStr::new("crate2"), crate2).is_ok());
         assert!(graph.add_dep(crate2, SmolStr::new("crate3"), crate3).is_ok());
     }
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index b6bfd531d..f9d012cb0 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -10,7 +10,7 @@ use ra_syntax::{ast, Parse, SourceFile, TextRange, TextUnit};
 
 pub use crate::{
     cancellation::Canceled,
-    input::{CrateGraph, CrateId, Dependency, Edition, FileId, SourceRoot, SourceRootId},
+    input::{CrateGraph, CrateId, Dependency, Edition, Env, FileId, SourceRoot, SourceRootId},
 };
 pub use relative_path::{RelativePath, RelativePathBuf};
 pub use salsa;
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 5690040a7..fd7776fb7 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,8 +1,6 @@
 //! FIXME: write short doc here
 
 pub(crate) mod src;
-pub(crate) mod docs;
-pub(crate) mod attrs;
 
 use std::sync::Arc;
 
@@ -10,29 +8,30 @@ use hir_def::{
     adt::VariantData,
     body::scope::ExprScopes,
     builtin_type::BuiltinType,
-    nameres::per_ns::PerNs,
+    docs::Documentation,
+    per_ns::PerNs,
     resolver::{HasResolver, TypeNs},
-    traits::TraitData,
-    type_ref::{Mutability, TypeRef},
-    ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalStructFieldId, Lookup,
-    ModuleId, UnionId,
+    type_ref::TypeRef,
+    ContainerId, HasModule, ImplId, LocalEnumVariantId, LocalImportId, LocalModuleId,
+    LocalStructFieldId, Lookup, ModuleId, UnionId,
 };
 use hir_expand::{
     diagnostics::DiagnosticSink,
     name::{self, AsName},
+    AstId,
 };
-use ra_db::{CrateId, Edition};
-use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
+use ra_db::{CrateId, Edition, FileId, FilePosition};
+use ra_syntax::{ast, AstNode, SyntaxNode};
 
 use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
+    db::{DefDatabase, HirDatabase},
     expr::{BindingAnnotation, Body, BodySourceMap, ExprValidator, Pat, PatId},
     ids::{
         AstItemDef, ConstId, EnumId, FunctionId, MacroDefId, StaticId, StructId, TraitId,
         TypeAliasId,
     },
     ty::{InferenceResult, Namespace, TraitRef},
-    Either, HasSource, ImportId, Name, Source, Ty,
+    Either, HasSource, Name, Source, Ty,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -80,6 +79,64 @@ impl Crate {
     }
 }
 
+pub enum ModuleSource {
+    SourceFile(ast::SourceFile),
+    Module(ast::Module),
+}
+
+impl ModuleSource {
+    pub fn new(
+        db: &impl DefDatabase,
+        file_id: Option<FileId>,
+        decl_id: Option<AstId<ast::Module>>,
+    ) -> ModuleSource {
+        match (file_id, decl_id) {
+            (Some(file_id), _) => {
+                let source_file = db.parse(file_id).tree();
+                ModuleSource::SourceFile(source_file)
+            }
+            (None, Some(item_id)) => {
+                let module = item_id.to_node(db);
+                assert!(module.item_list().is_some(), "expected inline module");
+                ModuleSource::Module(module)
+            }
+            (None, None) => panic!(),
+        }
+    }
+
+    // FIXME: this methods do not belong here
+    pub fn from_position(db: &impl DefDatabase, position: FilePosition) -> ModuleSource {
+        let parse = db.parse(position.file_id);
+        match &ra_syntax::algo::find_node_at_offset::<ast::Module>(
+            parse.tree().syntax(),
+            position.offset,
+        ) {
+            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
+            _ => {
+                let source_file = parse.tree();
+                ModuleSource::SourceFile(source_file)
+            }
+        }
+    }
+
+    pub fn from_child_node(db: &impl DefDatabase, child: Source<&SyntaxNode>) -> ModuleSource {
+        if let Some(m) =
+            child.value.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
+        {
+            ModuleSource::Module(m)
+        } else {
+            let file_id = child.file_id.original_file(db);
+            let source_file = db.parse(file_id).tree();
+            ModuleSource::SourceFile(source_file)
+        }
+    }
+
+    pub fn from_file_id(db: &impl DefDatabase, file_id: FileId) -> ModuleSource {
+        let source_file = db.parse(file_id).tree();
+        ModuleSource::SourceFile(source_file)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
     pub(crate) id: ModuleId,
@@ -111,10 +168,10 @@ impl_froms!(
     BuiltinType
 );
 
-pub use hir_def::ModuleSource;
+pub use hir_def::attr::Attrs;
 
 impl Module {
-    pub(crate) fn new(krate: Crate, crate_module_id: CrateModuleId) -> Module {
+    pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
         Module { id: ModuleId { krate: krate.crate_id, module_id: crate_module_id } }
     }
 
@@ -131,17 +188,6 @@ impl Module {
         })
     }
 
-    /// Returns the syntax of the last path segment corresponding to this import
-    pub fn import_source(
-        self,
-        db: &impl HirDatabase,
-        import: ImportId,
-    ) -> Either<ast::UseTree, ast::ExternCrateItem> {
-        let src = self.definition_source(db);
-        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
-        source_map.get(&src.value, import)
-    }
-
     /// Returns the crate this module is part of.
     pub fn krate(self) -> Crate {
         Crate { crate_id: self.id.krate }
@@ -191,11 +237,13 @@ impl Module {
     }
 
     /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<ImportId>)> {
+    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<Import>)> {
         db.crate_def_map(self.id.krate)[self.id.module_id]
             .scope
             .entries()
-            .map(|(name, res)| (name.clone(), res.def.into(), res.import))
+            .map(|(name, res)| {
+                (name.clone(), res.def.into(), res.import.map(|id| Import { parent: self, id }))
+            })
             .collect()
     }
 
@@ -233,11 +281,16 @@ impl Module {
         def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
     }
 
-    fn with_module_id(self, module_id: CrateModuleId) -> Module {
+    fn with_module_id(self, module_id: LocalModuleId) -> Module {
         Module::new(self.krate(), module_id)
     }
 }
 
+pub struct Import {
+    pub(crate) parent: Module,
+    pub(crate) id: LocalImportId,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StructField {
     pub(crate) parent: VariantDef,
@@ -561,77 +614,6 @@ pub struct Function {
     pub(crate) id: FunctionId,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FnData {
-    pub(crate) name: Name,
-    pub(crate) params: Vec<TypeRef>,
-    pub(crate) ret_type: TypeRef,
-    /// True if the first param is `self`. This is relevant to decide whether this
-    /// can be called as a method.
-    pub(crate) has_self_param: bool,
-}
-
-impl FnData {
-    pub(crate) fn fn_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        func: Function,
-    ) -> Arc<FnData> {
-        let src = func.source(db);
-        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
-        let mut params = Vec::new();
-        let mut has_self_param = false;
-        if let Some(param_list) = src.value.param_list() {
-            if let Some(self_param) = param_list.self_param() {
-                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
-                    TypeRef::from_ast(type_ref)
-                } else {
-                    let self_type = TypeRef::Path(name::SELF_TYPE.into());
-                    match self_param.kind() {
-                        ast::SelfParamKind::Owned => self_type,
-                        ast::SelfParamKind::Ref => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Shared)
-                        }
-                        ast::SelfParamKind::MutRef => {
-                            TypeRef::Reference(Box::new(self_type), Mutability::Mut)
-                        }
-                    }
-                };
-                params.push(self_type);
-                has_self_param = true;
-            }
-            for param in param_list.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
-                params.push(type_ref);
-            }
-        }
-        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
-            TypeRef::from_ast(type_ref)
-        } else {
-            TypeRef::unit()
-        };
-
-        let sig = FnData { name, params, ret_type, has_self_param };
-        Arc::new(sig)
-    }
-    pub fn name(&self) -> &Name {
-        &self.name
-    }
-
-    pub fn params(&self) -> &[TypeRef] {
-        &self.params
-    }
-
-    pub fn ret_type(&self) -> &TypeRef {
-        &self.ret_type
-    }
-
-    /// True if the first arg is `self`. This is relevant to decide whether this
-    /// can be called as a method.
-    pub fn has_self_param(&self) -> bool {
-        self.has_self_param
-    }
-}
-
 impl Function {
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.lookup(db).module(db).into()
@@ -642,7 +624,15 @@ impl Function {
     }
 
     pub fn name(self, db: &impl HirDatabase) -> Name {
-        self.data(db).name.clone()
+        db.function_data(self.id).name.clone()
+    }
+
+    pub fn has_self_param(self, db: &impl HirDatabase) -> bool {
+        db.function_data(self.id).has_self_param
+    }
+
+    pub fn params(self, db: &impl HirDatabase) -> Vec<TypeRef> {
+        db.function_data(self.id).params.clone()
     }
 
     pub(crate) fn body_source_map(self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
@@ -657,10 +647,6 @@ impl Function {
         db.type_for_def(self.into(), Namespace::Values)
     }
 
-    pub fn data(self, db: &impl HirDatabase) -> Arc<FnData> {
-        db.fn_data(self)
-    }
-
     pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
         db.infer(self.into())
     }
@@ -711,12 +697,8 @@ impl Const {
         Some(self.module(db).krate())
     }
 
-    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
-        db.const_data(self)
-    }
-
     pub fn name(self, db: &impl HirDatabase) -> Option<Name> {
-        self.data(db).name().cloned()
+        db.const_data(self.id).name.clone()
     }
 
     pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
@@ -748,45 +730,6 @@ impl Const {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ConstData {
-    pub(crate) name: Option<Name>,
-    pub(crate) type_ref: TypeRef,
-}
-
-impl ConstData {
-    pub fn name(&self) -> Option<&Name> {
-        self.name.as_ref()
-    }
-
-    pub fn type_ref(&self) -> &TypeRef {
-        &self.type_ref
-    }
-
-    pub(crate) fn const_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        konst: Const,
-    ) -> Arc<ConstData> {
-        let node = konst.source(db).value;
-        const_data_for(&node)
-    }
-
-    pub(crate) fn static_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        konst: Static,
-    ) -> Arc<ConstData> {
-        let node = konst.source(db).value;
-        const_data_for(&node)
-    }
-}
-
-fn const_data_for<N: NameOwner + TypeAscriptionOwner>(node: &N) -> Arc<ConstData> {
-    let name = node.name().map(|n| n.as_name());
-    let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
-    let sig = ConstData { name, type_ref };
-    Arc::new(sig)
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Static {
     pub(crate) id: StaticId,
@@ -801,10 +744,6 @@ impl Static {
         Some(self.module(db).krate())
     }
 
-    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
-        db.static_data(self)
-    }
-
     pub fn infer(self, db: &impl HirDatabase) -> Arc<InferenceResult> {
         db.infer(self.into())
     }
@@ -821,11 +760,11 @@ impl Trait {
     }
 
     pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
-        self.trait_data(db).name.clone()
+        db.trait_data(self.id).name.clone()
     }
 
     pub fn items(self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        self.trait_data(db).items.iter().map(|it| (*it).into()).collect()
+        db.trait_data(self.id).items.iter().map(|it| (*it).into()).collect()
     }
 
     fn direct_super_traits(self, db: &impl HirDatabase) -> Vec<Trait> {
@@ -871,7 +810,7 @@ impl Trait {
     }
 
     pub fn associated_type_by_name(self, db: &impl DefDatabase, name: &Name) -> Option<TypeAlias> {
-        let trait_data = self.trait_data(db);
+        let trait_data = db.trait_data(self.id);
         let res =
             trait_data.associated_types().map(TypeAlias::from).find(|t| &t.name(db) == name)?;
         Some(res)
@@ -885,16 +824,12 @@ impl Trait {
         self.all_super_traits(db).into_iter().find_map(|t| t.associated_type_by_name(db, name))
     }
 
-    pub(crate) fn trait_data(self, db: &impl DefDatabase) -> Arc<TraitData> {
-        db.trait_data(self.id)
-    }
-
     pub fn trait_ref(self, db: &impl HirDatabase) -> TraitRef {
         TraitRef::for_trait(db, self)
     }
 
     pub fn is_auto(self, db: &impl DefDatabase) -> bool {
-        self.trait_data(db).auto
+        db.trait_data(self.id).auto
     }
 }
 
@@ -937,7 +872,7 @@ impl TypeAlias {
     }
 
     pub fn type_ref(self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.type_alias_data(self).type_ref.clone()
+        db.type_alias_data(self.id).type_ref.clone()
     }
 
     pub fn ty(self, db: &impl HirDatabase) -> Ty {
@@ -945,7 +880,7 @@ impl TypeAlias {
     }
 
     pub fn name(self, db: &impl DefDatabase) -> Name {
-        db.type_alias_data(self).name.clone()
+        db.type_alias_data(self.id).name.clone()
     }
 }
 
@@ -1110,3 +1045,51 @@ impl From<PerNs> for ScopeDef {
             .unwrap_or(ScopeDef::Unknown)
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AttrDef {
+    Module(Module),
+    StructField(StructField),
+    Adt(Adt),
+    Function(Function),
+    EnumVariant(EnumVariant),
+    Static(Static),
+    Const(Const),
+    Trait(Trait),
+    TypeAlias(TypeAlias),
+    MacroDef(MacroDef),
+}
+
+impl_froms!(
+    AttrDef: Module,
+    StructField,
+    Adt(Struct, Enum, Union),
+    EnumVariant,
+    Static,
+    Const,
+    Function,
+    Trait,
+    TypeAlias,
+    MacroDef
+);
+
+pub trait HasAttrs {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs;
+}
+
+impl<T: Into<AttrDef>> HasAttrs for T {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs {
+        let def: AttrDef = self.into();
+        db.attrs(def.into())
+    }
+}
+
+pub trait Docs {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation>;
+}
+impl<T: Into<AttrDef> + Copy> Docs for T {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        let def: AttrDef = (*self).into();
+        db.documentation(def.into())
+    }
+}
diff --git a/crates/ra_hir/src/code_model/attrs.rs b/crates/ra_hir/src/code_model/attrs.rs
deleted file mode 100644
index 9e304217c..000000000
--- a/crates/ra_hir/src/code_model/attrs.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-//! FIXME: write short doc here
-
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Const, Enum, EnumVariant, FieldSource, Function, HasSource, MacroDef, Module, Static,
-    Struct, StructField, Trait, TypeAlias, Union,
-};
-use hir_def::attr::Attr;
-use hir_expand::hygiene::Hygiene;
-use ra_syntax::ast;
-use std::sync::Arc;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum AttrDef {
-    Module(Module),
-    StructField(StructField),
-    Adt(Adt),
-    Function(Function),
-    EnumVariant(EnumVariant),
-    Static(Static),
-    Const(Const),
-    Trait(Trait),
-    TypeAlias(TypeAlias),
-    MacroDef(MacroDef),
-}
-
-impl_froms!(
-    AttrDef: Module,
-    StructField,
-    Adt(Struct, Enum, Union),
-    EnumVariant,
-    Static,
-    Const,
-    Function,
-    Trait,
-    TypeAlias,
-    MacroDef
-);
-
-pub trait Attrs {
-    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>>;
-}
-
-pub(crate) fn attributes_query(
-    db: &(impl DefDatabase + AstDatabase),
-    def: AttrDef,
-) -> Option<Arc<[Attr]>> {
-    match def {
-        AttrDef::Module(it) => {
-            let src = it.declaration_source(db)?;
-            let hygiene = Hygiene::new(db, src.file_id);
-            Attr::from_attrs_owner(&src.value, &hygiene)
-        }
-        AttrDef::StructField(it) => match it.source(db).value {
-            FieldSource::Named(named) => {
-                let src = it.source(db);
-                let hygiene = Hygiene::new(db, src.file_id);
-                Attr::from_attrs_owner(&named, &hygiene)
-            }
-            FieldSource::Pos(..) => None,
-        },
-        AttrDef::Adt(it) => match it {
-            Adt::Struct(it) => attrs_from_ast(it, db),
-            Adt::Enum(it) => attrs_from_ast(it, db),
-            Adt::Union(it) => attrs_from_ast(it, db),
-        },
-        AttrDef::EnumVariant(it) => attrs_from_ast(it, db),
-        AttrDef::Static(it) => attrs_from_ast(it, db),
-        AttrDef::Const(it) => attrs_from_ast(it, db),
-        AttrDef::Function(it) => attrs_from_ast(it, db),
-        AttrDef::Trait(it) => attrs_from_ast(it, db),
-        AttrDef::TypeAlias(it) => attrs_from_ast(it, db),
-        AttrDef::MacroDef(it) => attrs_from_ast(it, db),
-    }
-}
-
-fn attrs_from_ast<T, D>(node: T, db: &D) -> Option<Arc<[Attr]>>
-where
-    T: HasSource,
-    T::Ast: ast::AttrsOwner,
-    D: DefDatabase + AstDatabase,
-{
-    let src = node.source(db);
-    let hygiene = Hygiene::new(db, src.file_id);
-    Attr::from_attrs_owner(&src.value, &hygiene)
-}
-
-impl<T: Into<AttrDef> + Copy> Attrs for T {
-    fn attrs(&self, db: &impl HirDatabase) -> Option<Arc<[Attr]>> {
-        db.attrs((*self).into())
-    }
-}
diff --git a/crates/ra_hir/src/code_model/docs.rs b/crates/ra_hir/src/code_model/docs.rs
deleted file mode 100644
index e40efef34..000000000
--- a/crates/ra_hir/src/code_model/docs.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-//! FIXME: write short doc here
-
-use std::sync::Arc;
-
-use ra_syntax::ast;
-
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Const, Enum, EnumVariant, FieldSource, Function, HasSource, MacroDef, Module, Static,
-    Struct, StructField, Trait, TypeAlias, Union,
-};
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
-pub enum DocDef {
-    Module(Module),
-    StructField(StructField),
-    Adt(Adt),
-    EnumVariant(EnumVariant),
-    Static(Static),
-    Const(Const),
-    Function(Function),
-    Trait(Trait),
-    TypeAlias(TypeAlias),
-    MacroDef(MacroDef),
-}
-
-impl_froms!(
-    DocDef: Module,
-    StructField,
-    Adt(Struct, Enum, Union),
-    EnumVariant,
-    Static,
-    Const,
-    Function,
-    Trait,
-    TypeAlias,
-    MacroDef
-);
-
-/// Holds documentation
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Documentation(Arc<str>);
-
-impl Documentation {
-    fn new(s: &str) -> Documentation {
-        Documentation(s.into())
-    }
-
-    pub fn as_str(&self) -> &str {
-        &*self.0
-    }
-}
-
-impl Into<String> for Documentation {
-    fn into(self) -> String {
-        self.as_str().to_owned()
-    }
-}
-
-pub trait Docs {
-    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation>;
-}
-
-pub(crate) fn docs_from_ast(node: &impl ast::DocCommentsOwner) -> Option<Documentation> {
-    node.doc_comment_text().map(|it| Documentation::new(&it))
-}
-
-pub(crate) fn documentation_query(
-    db: &(impl DefDatabase + AstDatabase),
-    def: DocDef,
-) -> Option<Documentation> {
-    match def {
-        DocDef::Module(it) => docs_from_ast(&it.declaration_source(db)?.value),
-        DocDef::StructField(it) => match it.source(db).value {
-            FieldSource::Named(named) => docs_from_ast(&named),
-            FieldSource::Pos(..) => None,
-        },
-        DocDef::Adt(it) => match it {
-            Adt::Struct(it) => docs_from_ast(&it.source(db).value),
-            Adt::Enum(it) => docs_from_ast(&it.source(db).value),
-            Adt::Union(it) => docs_from_ast(&it.source(db).value),
-        },
-        DocDef::EnumVariant(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Static(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Const(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Function(it) => docs_from_ast(&it.source(db).value),
-        DocDef::Trait(it) => docs_from_ast(&it.source(db).value),
-        DocDef::TypeAlias(it) => docs_from_ast(&it.source(db).value),
-        DocDef::MacroDef(it) => docs_from_ast(&it.source(db).value),
-    }
-}
-
-impl<T: Into<DocDef> + Copy> Docs for T {
-    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
-        db.documentation((*self).into())
-    }
-}
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index 4aa427de4..b7bafe23d 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,151 +1,127 @@
 //! FIXME: write short doc here
 
-use hir_def::{HasSource as _, Lookup};
+use hir_def::{HasChildSource, HasSource as _, Lookup, VariantId};
+use hir_expand::either::Either;
 use ra_syntax::ast::{self, AstNode};
 
 use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
+    db::{DefDatabase, HirDatabase},
     ids::AstItemDef,
-    Const, Either, Enum, EnumVariant, FieldSource, Function, HasBody, HirFileId, MacroDef, Module,
-    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
+    Const, Enum, EnumVariant, FieldSource, Function, HasBody, Import, MacroDef, Module,
+    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
 };
 
 pub use hir_expand::Source;
 
 pub trait HasSource {
     type Ast;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<Self::Ast>;
+    fn source(self, db: &impl DefDatabase) -> Source<Self::Ast>;
 }
 
 /// NB: Module is !HasSource, because it has two source nodes at the same time:
 /// definition and declaration.
 impl Module {
     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
-    pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ModuleSource> {
+    pub fn definition_source(self, db: &impl DefDatabase) -> Source<ModuleSource> {
         let def_map = db.crate_def_map(self.id.krate);
-        let decl_id = def_map[self.id.module_id].declaration;
-        let file_id = def_map[self.id.module_id].definition;
-        let value = ModuleSource::new(db, file_id, decl_id);
-        let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id());
-        Source { file_id, value }
+        let src = def_map[self.id.module_id].definition_source(db);
+        src.map(|it| match it {
+            Either::A(it) => ModuleSource::SourceFile(it),
+            Either::B(it) => ModuleSource::Module(it),
+        })
     }
 
     /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
     /// `None` for the crate root.
-    pub fn declaration_source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> Option<Source<ast::Module>> {
+    pub fn declaration_source(self, db: &impl DefDatabase) -> Option<Source<ast::Module>> {
         let def_map = db.crate_def_map(self.id.krate);
-        let decl = def_map[self.id.module_id].declaration?;
-        let value = decl.to_node(db);
-        Some(Source { file_id: decl.file_id(), value })
+        def_map[self.id.module_id].declaration_source(db)
     }
 }
 
 impl HasSource for StructField {
     type Ast = FieldSource;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<FieldSource> {
-        let var_data = self.parent.variant_data(db);
-        let fields = var_data.fields().unwrap();
-        let ss;
-        let es;
-        let (file_id, struct_kind) = match self.parent {
-            VariantDef::Struct(s) => {
-                ss = s.source(db);
-                (ss.file_id, ss.value.kind())
-            }
-            VariantDef::EnumVariant(e) => {
-                es = e.source(db);
-                (es.file_id, es.value.kind())
-            }
-        };
-
-        let field_sources = match struct_kind {
-            ast::StructKind::Tuple(fl) => fl.fields().map(|it| FieldSource::Pos(it)).collect(),
-            ast::StructKind::Named(fl) => fl.fields().map(|it| FieldSource::Named(it)).collect(),
-            ast::StructKind::Unit => Vec::new(),
-        };
-        let value = field_sources
-            .into_iter()
-            .zip(fields.iter())
-            .find(|(_syntax, (id, _))| *id == self.id)
-            .unwrap()
-            .0;
-        Source { file_id, value }
+    fn source(self, db: &impl DefDatabase) -> Source<FieldSource> {
+        let var = VariantId::from(self.parent);
+        let src = var.child_source(db);
+        src.map(|it| match it[self.id].clone() {
+            Either::A(it) => FieldSource::Pos(it),
+            Either::B(it) => FieldSource::Named(it),
+        })
     }
 }
 impl HasSource for Struct {
     type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StructDef> {
         self.id.0.source(db)
     }
 }
 impl HasSource for Union {
     type Ast = ast::StructDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StructDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StructDef> {
         self.id.0.source(db)
     }
 }
 impl HasSource for Enum {
     type Ast = ast::EnumDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::EnumDef> {
         self.id.source(db)
     }
 }
 impl HasSource for EnumVariant {
     type Ast = ast::EnumVariant;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::EnumVariant> {
-        let enum_data = db.enum_data(self.parent.id);
-        let src = self.parent.id.source(db);
-        let value = src
-            .value
-            .variant_list()
-            .into_iter()
-            .flat_map(|it| it.variants())
-            .zip(enum_data.variants.iter())
-            .find(|(_syntax, (id, _))| *id == self.id)
-            .unwrap()
-            .0;
-        Source { file_id: src.file_id, value }
+    fn source(self, db: &impl DefDatabase) -> Source<ast::EnumVariant> {
+        self.parent.id.child_source(db).map(|map| map[self.id].clone())
     }
 }
 impl HasSource for Function {
     type Ast = ast::FnDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::FnDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::FnDef> {
         self.id.lookup(db).source(db)
     }
 }
 impl HasSource for Const {
     type Ast = ast::ConstDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::ConstDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::ConstDef> {
         self.id.lookup(db).source(db)
     }
 }
 impl HasSource for Static {
     type Ast = ast::StaticDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::StaticDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::StaticDef> {
         self.id.source(db)
     }
 }
 impl HasSource for Trait {
     type Ast = ast::TraitDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TraitDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::TraitDef> {
         self.id.source(db)
     }
 }
 impl HasSource for TypeAlias {
     type Ast = ast::TypeAliasDef;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::TypeAliasDef> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::TypeAliasDef> {
         self.id.lookup(db).source(db)
     }
 }
 impl HasSource for MacroDef {
     type Ast = ast::MacroCall;
-    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ast::MacroCall> {
+    fn source(self, db: &impl DefDatabase) -> Source<ast::MacroCall> {
         Source { file_id: self.id.ast_id.file_id(), value: self.id.ast_id.to_node(db) }
     }
 }
+impl HasSource for Import {
+    type Ast = Either<ast::UseTree, ast::ExternCrateItem>;
+
+    /// Returns the syntax of the last path segment corresponding to this import
+    fn source(self, db: &impl DefDatabase) -> Source<Self::Ast> {
+        let src = self.parent.definition_source(db);
+        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
+        let root = db.parse_or_expand(src.file_id).unwrap();
+        let ptr = source_map.get(self.id);
+        src.with_value(ptr.map(|it| it.to_node(&root), |it| it.to_node(&root)))
+    }
+}
 
 pub trait HasBodySource: HasBody + HasSource
 where
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index ed0d68001..3ae5df8d5 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,71 +2,34 @@
 
 use std::sync::Arc;
 
-use hir_def::attr::Attr;
 use ra_db::salsa;
-use ra_syntax::SmolStr;
 
 use crate::{
-    debug::HirDebugDatabase,
     ids,
-    lang_item::{LangItemTarget, LangItems},
     ty::{
         method_resolution::CrateImplBlocks,
         traits::{AssocTyValue, Impl},
         CallableDef, FnSig, GenericPredicate, InferenceResult, Namespace, Substs, Ty, TypableDef,
         TypeCtor,
     },
-    type_alias::TypeAliasData,
-    Const, ConstData, Crate, DefWithBody, FnData, Function, GenericDef, ImplBlock, Module, Static,
-    StructField, Trait, TypeAlias,
+    Crate, DefWithBody, GenericDef, ImplBlock, StructField, Trait,
 };
 
 pub use hir_def::db::{
-    BodyQuery, BodyWithSourceMapQuery, CrateDefMapQuery, DefDatabase2, DefDatabase2Storage,
-    EnumDataQuery, ExprScopesQuery, GenericParamsQuery, ImplDataQuery, InternDatabase,
-    InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
-    TraitDataQuery,
+    BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQuery, CrateLangItemsQuery,
+    DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery, ExprScopesQuery,
+    FunctionDataQuery, GenericParamsQuery, ImplDataQuery, InternDatabase, InternDatabaseStorage,
+    LangItemQuery, ModuleLangItemsQuery, RawItemsQuery, RawItemsWithSourceMapQuery,
+    StaticDataQuery, StructDataQuery, TraitDataQuery, TypeAliasDataQuery,
 };
 pub use hir_expand::db::{
     AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
     ParseMacroQuery,
 };
 
-// This database uses `AstDatabase` internally,
-#[salsa::query_group(DefDatabaseStorage)]
-#[salsa::requires(AstDatabase)]
-pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
-    #[salsa::invoke(FnData::fn_data_query)]
-    fn fn_data(&self, func: Function) -> Arc<FnData>;
-
-    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
-    fn type_alias_data(&self, typ: TypeAlias) -> Arc<TypeAliasData>;
-
-    #[salsa::invoke(ConstData::const_data_query)]
-    fn const_data(&self, konst: Const) -> Arc<ConstData>;
-
-    #[salsa::invoke(ConstData::static_data_query)]
-    fn static_data(&self, konst: Static) -> Arc<ConstData>;
-
-    #[salsa::invoke(LangItems::module_lang_items_query)]
-    fn module_lang_items(&self, module: Module) -> Option<Arc<LangItems>>;
-
-    #[salsa::invoke(LangItems::crate_lang_items_query)]
-    fn crate_lang_items(&self, krate: Crate) -> Arc<LangItems>;
-
-    #[salsa::invoke(LangItems::lang_item_query)]
-    fn lang_item(&self, start_crate: Crate, item: SmolStr) -> Option<LangItemTarget>;
-
-    #[salsa::invoke(crate::code_model::docs::documentation_query)]
-    fn documentation(&self, def: crate::DocDef) -> Option<crate::Documentation>;
-
-    #[salsa::invoke(crate::code_model::attrs::attributes_query)]
-    fn attrs(&self, def: crate::AttrDef) -> Option<Arc<[Attr]>>;
-}
-
 #[salsa::query_group(HirDatabaseStorage)]
 #[salsa::requires(salsa::Database)]
-pub trait HirDatabase: DefDatabase + AstDatabase {
+pub trait HirDatabase: DefDatabase {
     #[salsa::invoke(crate::ty::infer_query)]
     fn infer(&self, def: DefWithBody) -> Arc<InferenceResult>;
 
diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs
index 4f3e922c3..8ec371f6e 100644
--- a/crates/ra_hir/src/debug.rs
+++ b/crates/ra_hir/src/debug.rs
@@ -1,3 +1,5 @@
+//! XXX: This does not work at the moment.
+//!
 //! printf debugging infrastructure for rust-analyzer.
 //!
 //! When you print a hir type, like a module, using `eprintln!("{:?}", module)`,
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
index e8ed04056..529ac8251 100644
--- a/crates/ra_hir/src/from_id.rs
+++ b/crates/ra_hir/src/from_id.rs
@@ -4,14 +4,14 @@
 //! are splitting the hir.
 
 use hir_def::{
-    AdtId, AssocItemId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId, GenericDefId,
-    ModuleDefId, StaticId, StructId, TypeAliasId, UnionId,
+    AdtId, AssocItemId, AttrDefId, ConstId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
+    GenericDefId, ModuleDefId, StaticId, StructFieldId, StructId, TypeAliasId, UnionId, VariantId,
 };
 
 use crate::{
     ty::{CallableDef, TypableDef},
-    Adt, AssocItem, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef, ModuleDef,
-    Static, TypeAlias,
+    Adt, AssocItem, AttrDef, Const, Crate, DefWithBody, EnumVariant, Function, GenericDef,
+    ModuleDef, Static, StructField, TypeAlias, VariantDef,
 };
 
 impl From<ra_db::CrateId> for Crate {
@@ -70,6 +70,12 @@ impl From<EnumVariantId> for EnumVariant {
     }
 }
 
+impl From<EnumVariant> for EnumVariantId {
+    fn from(def: EnumVariant) -> Self {
+        EnumVariantId { parent: def.parent.id, local_id: def.id }
+    }
+}
+
 impl From<ModuleDefId> for ModuleDef {
     fn from(id: ModuleDefId) -> Self {
         match id {
@@ -219,3 +225,35 @@ impl From<CallableDef> for GenericDefId {
         }
     }
 }
+
+impl From<VariantDef> for VariantId {
+    fn from(def: VariantDef) -> Self {
+        match def {
+            VariantDef::Struct(it) => VariantId::StructId(it.id),
+            VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
+        }
+    }
+}
+
+impl From<StructField> for StructFieldId {
+    fn from(def: StructField) -> Self {
+        StructFieldId { parent: def.parent.into(), local_id: def.id }
+    }
+}
+
+impl From<AttrDef> for AttrDefId {
+    fn from(def: AttrDef) -> Self {
+        match def {
+            AttrDef::Module(it) => AttrDefId::ModuleId(it.id),
+            AttrDef::StructField(it) => AttrDefId::StructFieldId(it.into()),
+            AttrDef::Adt(it) => AttrDefId::AdtId(it.into()),
+            AttrDef::Function(it) => AttrDefId::FunctionId(it.id),
+            AttrDef::EnumVariant(it) => AttrDefId::EnumVariantId(it.into()),
+            AttrDef::Static(it) => AttrDefId::StaticId(it.id),
+            AttrDef::Const(it) => AttrDefId::ConstId(it.id),
+            AttrDef::Trait(it) => AttrDefId::TraitId(it.id),
+            AttrDef::TypeAlias(it) => AttrDefId::TypeAliasId(it.id),
+            AttrDef::MacroDef(it) => AttrDefId::MacroDefId(it.id),
+        }
+    }
+}
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 774fa1d96..334eeebac 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -18,11 +18,11 @@ impl HasSource for ImplBlock {
 
 impl ImplBlock {
     pub fn target_trait(&self, db: &impl DefDatabase) -> Option<TypeRef> {
-        db.impl_data(self.id).target_trait().cloned()
+        db.impl_data(self.id).target_trait.clone()
     }
 
     pub fn target_type(&self, db: &impl DefDatabase) -> TypeRef {
-        db.impl_data(self.id).target_type().clone()
+        db.impl_data(self.id).target_type.clone()
     }
 
     pub fn target_ty(&self, db: &impl HirDatabase) -> Ty {
@@ -35,11 +35,11 @@ impl ImplBlock {
     }
 
     pub fn items(&self, db: &impl DefDatabase) -> Vec<AssocItem> {
-        db.impl_data(self.id).items().iter().map(|it| (*it).into()).collect()
+        db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect()
     }
 
     pub fn is_negative(&self, db: &impl DefDatabase) -> bool {
-        db.impl_data(self.id).is_negative()
+        db.impl_data(self.id).is_negative
     }
 
     pub fn module(&self, db: &impl DefDatabase) -> Module {
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
deleted file mode 100644
index 89fd85f59..000000000
--- a/crates/ra_hir/src/lang_item.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-//! FIXME: write short doc here
-
-use rustc_hash::FxHashMap;
-use std::sync::Arc;
-
-use ra_syntax::{ast::AttrsOwner, SmolStr};
-
-use crate::{
-    db::{AstDatabase, DefDatabase, HirDatabase},
-    Adt, Crate, Enum, Function, HasSource, ImplBlock, Module, ModuleDef, Static, Struct, Trait,
-};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum LangItemTarget {
-    Enum(Enum),
-    Function(Function),
-    ImplBlock(ImplBlock),
-    Static(Static),
-    Struct(Struct),
-    Trait(Trait),
-}
-
-impl LangItemTarget {
-    pub(crate) fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
-        Some(match self {
-            LangItemTarget::Enum(e) => e.module(db).krate(),
-            LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.krate(db),
-            LangItemTarget::Static(s) => s.module(db).krate(),
-            LangItemTarget::Struct(s) => s.module(db).krate(),
-            LangItemTarget::Trait(t) => t.module(db).krate(),
-        })
-    }
-}
-
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub struct LangItems {
-    items: FxHashMap<SmolStr, LangItemTarget>,
-}
-
-impl LangItems {
-    pub fn target<'a>(&'a self, item: &str) -> Option<&'a LangItemTarget> {
-        self.items.get(item)
-    }
-
-    /// Salsa query. This will look for lang items in a specific crate.
-    pub(crate) fn crate_lang_items_query(
-        db: &(impl DefDatabase + AstDatabase),
-        krate: Crate,
-    ) -> Arc<LangItems> {
-        let mut lang_items = LangItems::default();
-
-        if let Some(module) = krate.root_module(db) {
-            lang_items.collect_lang_items_recursive(db, module);
-        }
-
-        Arc::new(lang_items)
-    }
-
-    pub(crate) fn module_lang_items_query(
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) -> Option<Arc<LangItems>> {
-        let mut lang_items = LangItems::default();
-        lang_items.collect_lang_items(db, module);
-        if lang_items.items.is_empty() {
-            None
-        } else {
-            Some(Arc::new(lang_items))
-        }
-    }
-
-    /// Salsa query. Look for a lang item, starting from the specified crate and recursively
-    /// traversing its dependencies.
-    pub(crate) fn lang_item_query(
-        db: &impl DefDatabase,
-        start_crate: Crate,
-        item: SmolStr,
-    ) -> Option<LangItemTarget> {
-        let lang_items = db.crate_lang_items(start_crate);
-        let start_crate_target = lang_items.items.get(&item);
-        if let Some(target) = start_crate_target {
-            Some(*target)
-        } else {
-            for dep in start_crate.dependencies(db) {
-                let dep_crate = dep.krate;
-                let dep_target = db.lang_item(dep_crate, item.clone());
-                if dep_target.is_some() {
-                    return dep_target;
-                }
-            }
-            None
-        }
-    }
-
-    fn collect_lang_items(&mut self, db: &(impl DefDatabase + AstDatabase), module: Module) {
-        // Look for impl targets
-        for impl_block in module.impl_blocks(db) {
-            let src = impl_block.source(db);
-            if let Some(lang_item_name) = lang_item_name(&src.value) {
-                self.items
-                    .entry(lang_item_name)
-                    .or_insert_with(|| LangItemTarget::ImplBlock(impl_block));
-            }
-        }
-
-        for def in module.declarations(db) {
-            match def {
-                ModuleDef::Trait(trait_) => {
-                    self.collect_lang_item(db, trait_, LangItemTarget::Trait)
-                }
-                ModuleDef::Adt(Adt::Enum(e)) => self.collect_lang_item(db, e, LangItemTarget::Enum),
-                ModuleDef::Adt(Adt::Struct(s)) => {
-                    self.collect_lang_item(db, s, LangItemTarget::Struct)
-                }
-                ModuleDef::Function(f) => self.collect_lang_item(db, f, LangItemTarget::Function),
-                ModuleDef::Static(s) => self.collect_lang_item(db, s, LangItemTarget::Static),
-                _ => {}
-            }
-        }
-    }
-
-    fn collect_lang_items_recursive(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        module: Module,
-    ) {
-        if let Some(module_lang_items) = db.module_lang_items(module) {
-            self.items.extend(module_lang_items.items.iter().map(|(k, v)| (k.clone(), *v)))
-        }
-
-        // Look for lang items in the children
-        for child in module.children(db) {
-            self.collect_lang_items_recursive(db, child);
-        }
-    }
-
-    fn collect_lang_item<T, N>(
-        &mut self,
-        db: &(impl DefDatabase + AstDatabase),
-        item: T,
-        constructor: fn(T) -> LangItemTarget,
-    ) where
-        T: Copy + HasSource<Ast = N>,
-        N: AttrsOwner,
-    {
-        let node = item.source(db).value;
-        if let Some(lang_item_name) = lang_item_name(&node) {
-            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
-        }
-    }
-}
-
-fn lang_item_name<T: AttrsOwner>(node: &T) -> Option<SmolStr> {
-    node.attrs()
-        .filter_map(|a| a.as_simple_key_value())
-        .filter(|(key, _)| key == "lang")
-        .map(|(_, val)| val)
-        .nth(0)
-}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 8c6834392..e51d4d063 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -32,11 +32,9 @@ pub mod db;
 pub mod source_binder;
 
 mod ids;
-mod type_alias;
 mod ty;
 mod impl_block;
 mod expr;
-mod lang_item;
 pub mod diagnostics;
 mod util;
 
@@ -52,13 +50,11 @@ mod marks;
 
 pub use crate::{
     code_model::{
-        attrs::{AttrDef, Attrs},
-        docs::{DocDef, Docs, Documentation},
         src::{HasBodySource, HasSource},
-        Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum,
-        EnumVariant, FieldSource, FnData, Function, GenericDef, GenericParam, HasBody, ImplBlock,
-        Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct, StructField,
-        Trait, TypeAlias, Union, VariantDef,
+        Adt, AssocItem, AttrDef, Const, Container, Crate, CrateDependency, DefWithBody, Docs, Enum,
+        EnumVariant, FieldSource, Function, GenericDef, GenericParam, HasAttrs, HasBody, ImplBlock,
+        Import, Local, MacroDef, Module, ModuleDef, ModuleSource, ScopeDef, Static, Struct,
+        StructField, Trait, TypeAlias, Union, VariantDef,
     },
     expr::ExprScopes,
     from_source::FromSource,
@@ -73,7 +69,7 @@ pub use crate::{
 
 pub use hir_def::{
     builtin_type::BuiltinType,
-    nameres::{per_ns::PerNs, raw::ImportId},
+    docs::Documentation,
     path::{Path, PathKind},
     type_ref::Mutability,
 };
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index c42ceabdf..797f90d50 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -131,6 +131,7 @@ pub struct ReferenceDescriptor {
 }
 
 pub struct Expansion {
+    macro_file_kind: MacroFileKind,
     macro_call_id: MacroCallId,
 }
 
@@ -145,7 +146,7 @@ impl Expansion {
     }
 
     pub fn file_id(&self) -> HirFileId {
-        self.macro_call_id.as_file(MacroFileKind::Items)
+        self.macro_call_id.as_file(self.macro_file_kind)
     }
 }
 
@@ -439,7 +440,10 @@ impl SourceAnalyzer {
             db.ast_id_map(macro_call.file_id).ast_id(macro_call.value),
         );
         let macro_call_loc = MacroCallLoc { def, ast_id };
-        Some(Expansion { macro_call_id: db.intern_macro(macro_call_loc) })
+        Some(Expansion {
+            macro_call_id: db.intern_macro(macro_call_loc),
+            macro_file_kind: to_macro_file_kind(macro_call.value),
+        })
     }
 
     #[cfg(test)]
@@ -538,3 +542,35 @@ fn adjust(
         })
         .map(|(_ptr, scope)| *scope)
 }
+
+/// Given a `ast::MacroCall`, return what `MacroKindFile` it belongs to.
+/// FIXME: Not completed  
+fn to_macro_file_kind(macro_call: &ast::MacroCall) -> MacroFileKind {
+    let syn = macro_call.syntax();
+    let parent = match syn.parent() {
+        Some(it) => it,
+        None => {
+            // FIXME:
+            // If it is root, which means the parent HirFile
+            // MacroKindFile must be non-items
+            // return expr now.
+            return MacroFileKind::Expr;
+        }
+    };
+
+    match parent.kind() {
+        MACRO_ITEMS | SOURCE_FILE => MacroFileKind::Items,
+        LET_STMT => {
+            // FIXME: Handle Pattern
+            MacroFileKind::Expr
+        }
+        EXPR_STMT => MacroFileKind::Statements,
+        BLOCK => MacroFileKind::Statements,
+        ARG_LIST => MacroFileKind::Expr,
+        TRY_EXPR => MacroFileKind::Expr,
+        _ => {
+            // Unknown , Just guess it is `Items`
+            MacroFileKind::Items
+        }
+    }
+}
diff --git a/crates/ra_hir/src/test_db.rs b/crates/ra_hir/src/test_db.rs
index 1caa2e875..03c7ac155 100644
--- a/crates/ra_hir/src/test_db.rs
+++ b/crates/ra_hir/src/test_db.rs
@@ -2,7 +2,7 @@
 
 use std::{panic, sync::Arc};
 
-use hir_def::{db::DefDatabase2, ModuleId};
+use hir_def::{db::DefDatabase, ModuleId};
 use hir_expand::diagnostics::DiagnosticSink;
 use parking_lot::Mutex;
 use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath, SourceDatabase};
@@ -15,7 +15,6 @@ use crate::{db, debug::HirDebugHelper};
     db::InternDatabaseStorage,
     db::AstDatabaseStorage,
     db::DefDatabaseStorage,
-    db::DefDatabase2Storage,
     db::HirDatabaseStorage
 )]
 #[derive(Debug, Default)]
diff --git a/crates/ra_hir/src/ty/autoderef.rs b/crates/ra_hir/src/ty/autoderef.rs
index b60e4bb31..41c99d227 100644
--- a/crates/ra_hir/src/ty/autoderef.rs
+++ b/crates/ra_hir/src/ty/autoderef.rs
@@ -5,12 +5,13 @@
 
 use std::iter::successors;
 
-use hir_def::resolver::Resolver;
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
 use hir_expand::name;
 use log::{info, warn};
 
+use crate::{db::HirDatabase, Trait};
+
 use super::{traits::Solution, Canonical, Substs, Ty, TypeWalk};
-use crate::db::HirDatabase;
 
 const AUTODEREF_RECURSION_LIMIT: usize = 10;
 
@@ -41,7 +42,7 @@ fn deref_by_trait(
 ) -> Option<Canonical<Ty>> {
     let krate = resolver.krate()?;
     let deref_trait = match db.lang_item(krate.into(), "deref".into())? {
-        crate::lang_item::LangItemTarget::Trait(t) => t,
+        LangItemTarget::TraitId(t) => Trait::from(t),
         _ => return None,
     };
     let target = deref_trait.associated_type_by_name(db, &name::TARGET_TYPE)?;
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 69b13baef..471bdc387 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -22,6 +22,7 @@ use ena::unify::{InPlaceUnificationTable, NoError, UnifyKey, UnifyValue};
 use rustc_hash::FxHashMap;
 
 use hir_def::{
+    data::{ConstData, FunctionData},
     path::known,
     resolver::{HasResolver, Resolver, TypeNs},
     type_ref::{Mutability, TypeRef},
@@ -43,8 +44,8 @@ use crate::{
     db::HirDatabase,
     expr::{BindingAnnotation, Body, ExprId, PatId},
     ty::infer::diagnostics::InferenceDiagnostic,
-    Adt, AssocItem, ConstData, DefWithBody, FloatTy, FnData, Function, HasBody, IntTy, Path,
-    StructField, Trait, VariantDef,
+    Adt, AssocItem, DefWithBody, FloatTy, Function, HasBody, IntTy, Path, StructField, Trait,
+    VariantDef,
 };
 
 macro_rules! ty_app {
@@ -68,10 +69,10 @@ pub fn infer_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResu
     let resolver = DefWithBodyId::from(def).resolver(db);
     let mut ctx = InferenceContext::new(db, def, resolver);
 
-    match def {
-        DefWithBody::Const(ref c) => ctx.collect_const(&c.data(db)),
-        DefWithBody::Function(ref f) => ctx.collect_fn(&f.data(db)),
-        DefWithBody::Static(ref s) => ctx.collect_const(&s.data(db)),
+    match &def {
+        DefWithBody::Const(c) => ctx.collect_const(&db.const_data(c.id)),
+        DefWithBody::Function(f) => ctx.collect_fn(&db.function_data(f.id)),
+        DefWithBody::Static(s) => ctx.collect_const(&db.static_data(s.id)),
     }
 
     ctx.infer_body();
@@ -559,17 +560,17 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     }
 
     fn collect_const(&mut self, data: &ConstData) {
-        self.return_ty = self.make_ty(data.type_ref());
+        self.return_ty = self.make_ty(&data.type_ref);
     }
 
-    fn collect_fn(&mut self, data: &FnData) {
+    fn collect_fn(&mut self, data: &FunctionData) {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
-        for (type_ref, pat) in data.params().iter().zip(body.params()) {
+        for (type_ref, pat) in data.params.iter().zip(body.params()) {
             let ty = self.make_ty(type_ref);
 
             self.infer_pat(*pat, &ty, BindingMode::default());
         }
-        self.return_ty = self.make_ty(data.ret_type());
+        self.return_ty = self.make_ty(&data.ret_type);
     }
 
     fn infer_body(&mut self) {
diff --git a/crates/ra_hir/src/ty/infer/coerce.rs b/crates/ra_hir/src/ty/infer/coerce.rs
index 0772b9df5..4ea038d99 100644
--- a/crates/ra_hir/src/ty/infer/coerce.rs
+++ b/crates/ra_hir/src/ty/infer/coerce.rs
@@ -4,13 +4,12 @@
 //!
 //! See: https://doc.rust-lang.org/nomicon/coercions.html
 
-use hir_def::resolver::Resolver;
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver};
 use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
     db::HirDatabase,
-    lang_item::LangItemTarget,
     ty::{autoderef, Substs, Ty, TypeCtor, TypeWalk},
     Adt, Mutability,
 };
@@ -50,7 +49,9 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     ) -> FxHashMap<(TypeCtor, TypeCtor), usize> {
         let krate = resolver.krate().unwrap();
         let impls = match db.lang_item(krate.into(), "coerce_unsized".into()) {
-            Some(LangItemTarget::Trait(trait_)) => db.impls_for_trait(krate.into(), trait_),
+            Some(LangItemTarget::TraitId(trait_)) => {
+                db.impls_for_trait(krate.into(), trait_.into())
+            }
             _ => return FxHashMap::default(),
         };
 
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs
index 75c552569..2272510e8 100644
--- a/crates/ra_hir/src/ty/lower.rs
+++ b/crates/ra_hir/src/ty/lower.rs
@@ -622,10 +622,10 @@ pub(crate) fn generic_defaults_query(db: &impl HirDatabase, def: GenericDef) ->
 }
 
 fn fn_sig_for_fn(db: &impl HirDatabase, def: Function) -> FnSig {
-    let data = def.data(db);
+    let data = db.function_data(def.id);
     let resolver = def.id.resolver(db);
-    let params = data.params().iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
-    let ret = Ty::from_hir(db, &resolver, data.ret_type());
+    let params = data.params.iter().map(|tr| Ty::from_hir(db, &resolver, tr)).collect::<Vec<_>>();
+    let ret = Ty::from_hir(db, &resolver, &data.ret_type);
     FnSig::from_params_and_return(params, ret)
 }
 
@@ -639,18 +639,18 @@ fn type_for_fn(db: &impl HirDatabase, def: Function) -> Ty {
 
 /// Build the declared type of a const.
 fn type_for_const(db: &impl HirDatabase, def: Const) -> Ty {
-    let data = def.data(db);
+    let data = db.const_data(def.id);
     let resolver = def.id.resolver(db);
 
-    Ty::from_hir(db, &resolver, data.type_ref())
+    Ty::from_hir(db, &resolver, &data.type_ref)
 }
 
 /// Build the declared type of a static.
 fn type_for_static(db: &impl HirDatabase, def: Static) -> Ty {
-    let data = def.data(db);
+    let data = db.static_data(def.id);
     let resolver = def.id.resolver(db);
 
-    Ty::from_hir(db, &resolver, data.type_ref())
+    Ty::from_hir(db, &resolver, &data.type_ref)
 }
 
 /// Build the declared type of a static.
diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs
index 64adb814d..caa5f5f74 100644
--- a/crates/ra_hir/src/ty/method_resolution.rs
+++ b/crates/ra_hir/src/ty/method_resolution.rs
@@ -5,7 +5,7 @@
 use std::sync::Arc;
 
 use arrayvec::ArrayVec;
-use hir_def::resolver::Resolver;
+use hir_def::{lang_item::LangItemTarget, resolver::Resolver, AstItemDef};
 use rustc_hash::FxHashMap;
 
 use crate::{
@@ -91,34 +91,43 @@ fn def_crates(db: &impl HirDatabase, cur_crate: Crate, ty: &Ty) -> Option<ArrayV
     // Types like slice can have inherent impls in several crates, (core and alloc).
     // The corresponding impls are marked with lang items, so we can use them to find the required crates.
     macro_rules! lang_item_crate {
-        ($db:expr, $cur_crate:expr, $($name:expr),+ $(,)?) => {{
-            let mut v = ArrayVec::<[Crate; 2]>::new();
+        ($($name:expr),+ $(,)?) => {{
+            let mut v = ArrayVec::<[LangItemTarget; 2]>::new();
             $(
-                v.extend($db.lang_item($cur_crate, $name.into()).and_then(|item| item.krate($db)));
+                v.extend(db.lang_item(cur_crate.crate_id, $name.into()));
             )+
-            Some(v)
+            v
         }};
     }
 
-    match ty {
+    let lang_item_targets = match ty {
         Ty::Apply(a_ty) => match a_ty.ctor {
-            TypeCtor::Adt(def_id) => Some(std::iter::once(def_id.krate(db)?).collect()),
-            TypeCtor::Bool => lang_item_crate!(db, cur_crate, "bool"),
-            TypeCtor::Char => lang_item_crate!(db, cur_crate, "char"),
+            TypeCtor::Adt(def_id) => return Some(std::iter::once(def_id.krate(db)?).collect()),
+            TypeCtor::Bool => lang_item_crate!("bool"),
+            TypeCtor::Char => lang_item_crate!("char"),
             TypeCtor::Float(Uncertain::Known(f)) => match f.bitness {
                 // There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
-                FloatBitness::X32 => lang_item_crate!(db, cur_crate, "f32", "f32_runtime"),
-                FloatBitness::X64 => lang_item_crate!(db, cur_crate, "f64", "f64_runtime"),
+                FloatBitness::X32 => lang_item_crate!("f32", "f32_runtime"),
+                FloatBitness::X64 => lang_item_crate!("f64", "f64_runtime"),
             },
-            TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(db, cur_crate, i.ty_to_string()),
-            TypeCtor::Str => lang_item_crate!(db, cur_crate, "str_alloc", "str"),
-            TypeCtor::Slice => lang_item_crate!(db, cur_crate, "slice_alloc", "slice"),
-            TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!(db, cur_crate, "const_ptr"),
-            TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!(db, cur_crate, "mut_ptr"),
-            _ => None,
+            TypeCtor::Int(Uncertain::Known(i)) => lang_item_crate!(i.ty_to_string()),
+            TypeCtor::Str => lang_item_crate!("str_alloc", "str"),
+            TypeCtor::Slice => lang_item_crate!("slice_alloc", "slice"),
+            TypeCtor::RawPtr(Mutability::Shared) => lang_item_crate!("const_ptr"),
+            TypeCtor::RawPtr(Mutability::Mut) => lang_item_crate!("mut_ptr"),
+            _ => return None,
         },
-        _ => None,
-    }
+        _ => return None,
+    };
+    let res = lang_item_targets
+        .into_iter()
+        .filter_map(|it| match it {
+            LangItemTarget::ImplBlockId(it) => Some(it),
+            _ => None,
+        })
+        .map(|it| it.module(db).krate.into())
+        .collect();
+    Some(res)
 }
 
 /// Look up the method with the given name, returning the actual autoderefed
@@ -233,7 +242,7 @@ fn iterate_trait_method_candidates<T>(
         .chain(traits_from_env)
         .chain(resolver.traits_in_scope(db).into_iter().map(Trait::from));
     'traits: for t in traits {
-        let data = t.trait_data(db);
+        let data = db.trait_data(t.id);
 
         // we'll be lazy about checking whether the type implements the
         // trait, but if we find out it doesn't, we'll skip the rest of the
@@ -291,9 +300,9 @@ fn is_valid_candidate(
 ) -> bool {
     match item {
         AssocItem::Function(m) => {
-            let data = m.data(db);
-            name.map_or(true, |name| data.name() == name)
-                && (data.has_self_param() || mode == LookupMode::Path)
+            let data = db.function_data(m.id);
+            name.map_or(true, |name| data.name == *name)
+                && (data.has_self_param || mode == LookupMode::Path)
         }
         AssocItem::Const(c) => {
             name.map_or(true, |name| Some(name) == c.name(db).as_ref())
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index 74c12a0a2..17a50cf74 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -4857,3 +4857,41 @@ fn main() {
     "###
     );
 }
+
+#[test]
+fn infer_builtin_macros_file() {
+    assert_snapshot!(
+        infer(r#"
+#[rustc_builtin_macro]
+macro_rules! file {() => {}}
+
+fn main() {
+    let x = file!();
+}
+"#),
+        @r###"
+    ![0; 2) '""': &str
+    [64; 88) '{     ...!(); }': ()
+    [74; 75) 'x': &str
+    "###
+    );
+}
+
+#[test]
+fn infer_builtin_macros_column() {
+    assert_snapshot!(
+        infer(r#"
+#[rustc_builtin_macro]
+macro_rules! column {() => {}}
+
+fn main() {
+    let x = column!();
+}
+"#),
+        @r###"
+    ![0; 2) '13': i32
+    [66; 92) '{     ...!(); }': ()
+    [76; 77) 'x': i32
+    "###
+    );
+}
diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs
index 88785f305..53818a5e5 100644
--- a/crates/ra_hir/src/ty/traits/chalk.rs
+++ b/crates/ra_hir/src/ty/traits/chalk.rs
@@ -9,6 +9,7 @@ use chalk_ir::{
 };
 use chalk_rust_ir::{AssociatedTyDatum, AssociatedTyValue, ImplDatum, StructDatum, TraitDatum};
 
+use hir_def::lang_item::LangItemTarget;
 use hir_expand::name;
 
 use ra_db::salsa::{InternId, InternKey};
@@ -832,9 +833,9 @@ fn closure_fn_trait_output_assoc_ty_value(
 }
 
 fn get_fn_trait(db: &impl HirDatabase, krate: Crate, fn_trait: super::FnTrait) -> Option<Trait> {
-    let target = db.lang_item(krate, fn_trait.lang_item_name().into())?;
+    let target = db.lang_item(krate.crate_id, fn_trait.lang_item_name().into())?;
     match target {
-        crate::lang_item::LangItemTarget::Trait(t) => Some(t),
+        LangItemTarget::TraitId(t) => Some(t.into()),
         _ => None,
     }
 }
diff --git a/crates/ra_hir/src/type_alias.rs b/crates/ra_hir/src/type_alias.rs
deleted file mode 100644
index 392f244cf..000000000
--- a/crates/ra_hir/src/type_alias.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! HIR for type aliases (i.e. the `type` keyword).
-
-use std::sync::Arc;
-
-use hir_def::type_ref::TypeRef;
-use hir_expand::name::{AsName, Name};
-
-use ra_syntax::ast::NameOwner;
-
-use crate::{
-    db::{AstDatabase, DefDatabase},
-    HasSource, TypeAlias,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TypeAliasData {
-    pub(crate) name: Name,
-    pub(crate) type_ref: Option<TypeRef>,
-}
-
-impl TypeAliasData {
-    pub(crate) fn type_alias_data_query(
-        db: &(impl DefDatabase + AstDatabase),
-        typ: TypeAlias,
-    ) -> Arc<TypeAliasData> {
-        let node = typ.source(db).value;
-        let name = node.name().map_or_else(Name::missing, |n| n.as_name());
-        let type_ref = node.type_ref().map(TypeRef::from_ast);
-        Arc::new(TypeAliasData { name, type_ref })
-    }
-}
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index d04f54e15..20e9a1eb5 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -2,13 +2,17 @@
 
 use std::sync::Arc;
 
-use hir_expand::name::{AsName, Name};
-use ra_arena::Arena;
+use hir_expand::{
+    either::Either,
+    name::{AsName, Name},
+    Source,
+};
+use ra_arena::{map::ArenaMap, Arena};
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 
 use crate::{
-    db::DefDatabase2, type_ref::TypeRef, AstItemDef, EnumId, LocalEnumVariantId,
-    LocalStructFieldId, StructOrUnionId,
+    db::DefDatabase, trace::Trace, type_ref::TypeRef, AstItemDef, EnumId, HasChildSource,
+    LocalEnumVariantId, LocalStructFieldId, StructOrUnionId, VariantId,
 };
 
 /// Note that we use `StructData` for unions as well!
@@ -30,13 +34,9 @@ pub struct EnumVariantData {
     pub variant_data: Arc<VariantData>,
 }
 
-/// Fields of an enum variant or struct
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct VariantData(VariantDataInner);
-
 #[derive(Debug, Clone, PartialEq, Eq)]
-enum VariantDataInner {
-    Struct(Arena<LocalStructFieldId, StructFieldData>),
+pub enum VariantData {
+    Record(Arena<LocalStructFieldId, StructFieldData>),
     Tuple(Arena<LocalStructFieldId, StructFieldData>),
     Unit,
 }
@@ -49,10 +49,7 @@ pub struct StructFieldData {
 }
 
 impl StructData {
-    pub(crate) fn struct_data_query(
-        db: &impl DefDatabase2,
-        id: StructOrUnionId,
-    ) -> Arc<StructData> {
+    pub(crate) fn struct_data_query(db: &impl DefDatabase, id: StructOrUnionId) -> Arc<StructData> {
         let src = id.source(db);
         let name = src.value.name().map(|n| n.as_name());
         let variant_data = VariantData::new(src.value.kind());
@@ -62,20 +59,12 @@ impl StructData {
 }
 
 impl EnumData {
-    pub(crate) fn enum_data_query(db: &impl DefDatabase2, e: EnumId) -> Arc<EnumData> {
+    pub(crate) fn enum_data_query(db: &impl DefDatabase, e: EnumId) -> Arc<EnumData> {
         let src = e.source(db);
         let name = src.value.name().map(|n| n.as_name());
-        let variants = src
-            .value
-            .variant_list()
-            .into_iter()
-            .flat_map(|it| it.variants())
-            .map(|var| EnumVariantData {
-                name: var.name().map(|it| it.as_name()),
-                variant_data: Arc::new(VariantData::new(var.kind())),
-            })
-            .collect();
-        Arc::new(EnumData { name, variants })
+        let mut trace = Trace::new_for_arena();
+        lower_enum(&mut trace, &src.value);
+        Arc::new(EnumData { name, variants: trace.into_arena() })
     }
 
     pub(crate) fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
@@ -84,39 +73,109 @@ impl EnumData {
     }
 }
 
+impl HasChildSource for EnumId {
+    type ChildId = LocalEnumVariantId;
+    type Value = ast::EnumVariant;
+    fn child_source(&self, db: &impl DefDatabase) -> Source<ArenaMap<Self::ChildId, Self::Value>> {
+        let src = self.source(db);
+        let mut trace = Trace::new_for_map();
+        lower_enum(&mut trace, &src.value);
+        src.with_value(trace.into_map())
+    }
+}
+
+fn lower_enum(
+    trace: &mut Trace<LocalEnumVariantId, EnumVariantData, ast::EnumVariant>,
+    ast: &ast::EnumDef,
+) {
+    for var in ast.variant_list().into_iter().flat_map(|it| it.variants()) {
+        trace.alloc(
+            || var.clone(),
+            || EnumVariantData {
+                name: var.name().map(|it| it.as_name()),
+                variant_data: Arc::new(VariantData::new(var.kind())),
+            },
+        )
+    }
+}
+
 impl VariantData {
     fn new(flavor: ast::StructKind) -> Self {
-        let inner = match flavor {
-            ast::StructKind::Tuple(fl) => {
-                let fields = fl
-                    .fields()
-                    .enumerate()
-                    .map(|(i, fd)| StructFieldData {
+        let mut trace = Trace::new_for_arena();
+        match lower_struct(&mut trace, &flavor) {
+            StructKind::Tuple => VariantData::Tuple(trace.into_arena()),
+            StructKind::Record => VariantData::Record(trace.into_arena()),
+            StructKind::Unit => VariantData::Unit,
+        }
+    }
+
+    pub fn fields(&self) -> Option<&Arena<LocalStructFieldId, StructFieldData>> {
+        match &self {
+            VariantData::Record(fields) | VariantData::Tuple(fields) => Some(fields),
+            _ => None,
+        }
+    }
+}
+
+impl HasChildSource for VariantId {
+    type ChildId = LocalStructFieldId;
+    type Value = Either<ast::TupleFieldDef, ast::RecordFieldDef>;
+
+    fn child_source(&self, db: &impl DefDatabase) -> Source<ArenaMap<Self::ChildId, Self::Value>> {
+        let src = match self {
+            VariantId::EnumVariantId(it) => {
+                // I don't really like the fact that we call into parent source
+                // here, this might add to more queries then necessary.
+                let src = it.parent.child_source(db);
+                src.map(|map| map[it.local_id].kind())
+            }
+            VariantId::StructId(it) => it.0.source(db).map(|it| it.kind()),
+        };
+        let mut trace = Trace::new_for_map();
+        lower_struct(&mut trace, &src.value);
+        src.with_value(trace.into_map())
+    }
+}
+
+enum StructKind {
+    Tuple,
+    Record,
+    Unit,
+}
+
+fn lower_struct(
+    trace: &mut Trace<
+        LocalStructFieldId,
+        StructFieldData,
+        Either<ast::TupleFieldDef, ast::RecordFieldDef>,
+    >,
+    ast: &ast::StructKind,
+) -> StructKind {
+    match ast {
+        ast::StructKind::Tuple(fl) => {
+            for (i, fd) in fl.fields().enumerate() {
+                trace.alloc(
+                    || Either::A(fd.clone()),
+                    || StructFieldData {
                         name: Name::new_tuple_field(i),
                         type_ref: TypeRef::from_ast_opt(fd.type_ref()),
-                    })
-                    .collect();
-                VariantDataInner::Tuple(fields)
+                    },
+                )
             }
-            ast::StructKind::Named(fl) => {
-                let fields = fl
-                    .fields()
-                    .map(|fd| StructFieldData {
+            StructKind::Tuple
+        }
+        ast::StructKind::Record(fl) => {
+            for fd in fl.fields() {
+                trace.alloc(
+                    || Either::B(fd.clone()),
+                    || StructFieldData {
                         name: fd.name().map(|n| n.as_name()).unwrap_or_else(Name::missing),
                         type_ref: TypeRef::from_ast_opt(fd.ascribed_type()),
-                    })
-                    .collect();
-                VariantDataInner::Struct(fields)
+                    },
+                )
             }
-            ast::StructKind::Unit => VariantDataInner::Unit,
-        };
-        VariantData(inner)
-    }
-
-    pub fn fields(&self) -> Option<&Arena<LocalStructFieldId, StructFieldData>> {
-        match &self.0 {
-            VariantDataInner::Struct(fields) | VariantDataInner::Tuple(fields) => Some(fields),
-            _ => None,
+            StructKind::Record
         }
+        ast::StructKind::Unit => StructKind::Unit,
     }
 }
diff --git a/crates/ra_hir_def/src/attr.rs b/crates/ra_hir_def/src/attr.rs
index 0e961ca12..48ce8cd93 100644
--- a/crates/ra_hir_def/src/attr.rs
+++ b/crates/ra_hir_def/src/attr.rs
@@ -1,8 +1,8 @@
 //! A higher level attributes based on TokenTree, with also some shortcuts.
 
-use std::sync::Arc;
+use std::{ops, sync::Arc};
 
-use hir_expand::hygiene::Hygiene;
+use hir_expand::{either::Either, hygiene::Hygiene, AstId};
 use mbe::ast_to_token_tree;
 use ra_cfg::CfgOptions;
 use ra_syntax::{
@@ -11,7 +11,81 @@ use ra_syntax::{
 };
 use tt::Subtree;
 
-use crate::path::Path;
+use crate::{
+    db::DefDatabase, path::Path, AdtId, AstItemDef, AttrDefId, HasChildSource, HasSource, Lookup,
+};
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct Attrs {
+    entries: Option<Arc<[Attr]>>,
+}
+
+impl ops::Deref for Attrs {
+    type Target = [Attr];
+
+    fn deref(&self) -> &[Attr] {
+        match &self.entries {
+            Some(it) => &*it,
+            None => &[],
+        }
+    }
+}
+
+impl Attrs {
+    pub(crate) fn attrs_query(db: &impl DefDatabase, def: AttrDefId) -> Attrs {
+        match def {
+            AttrDefId::ModuleId(module) => {
+                let def_map = db.crate_def_map(module.krate);
+                let src = match def_map[module.module_id].declaration_source(db) {
+                    Some(it) => it,
+                    None => return Attrs::default(),
+                };
+                let hygiene = Hygiene::new(db, src.file_id);
+                Attr::from_attrs_owner(&src.value, &hygiene)
+            }
+            AttrDefId::StructFieldId(it) => {
+                let src = it.parent.child_source(db);
+                match &src.value[it.local_id] {
+                    Either::A(_tuple) => Attrs::default(),
+                    Either::B(record) => {
+                        let hygiene = Hygiene::new(db, src.file_id);
+                        Attr::from_attrs_owner(record, &hygiene)
+                    }
+                }
+            }
+            AttrDefId::EnumVariantId(it) => {
+                let src = it.parent.child_source(db);
+                let hygiene = Hygiene::new(db, src.file_id);
+                Attr::from_attrs_owner(&src.value[it.local_id], &hygiene)
+            }
+            AttrDefId::AdtId(it) => match it {
+                AdtId::StructId(it) => attrs_from_ast(it.0.lookup_intern(db).ast_id, db),
+                AdtId::EnumId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
+                AdtId::UnionId(it) => attrs_from_ast(it.0.lookup_intern(db).ast_id, db),
+            },
+            AttrDefId::StaticId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
+            AttrDefId::TraitId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
+            AttrDefId::MacroDefId(it) => attrs_from_ast(it.ast_id, db),
+            AttrDefId::ImplId(it) => attrs_from_ast(it.lookup_intern(db).ast_id, db),
+            AttrDefId::ConstId(it) => attrs_from_loc(it.lookup(db), db),
+            AttrDefId::FunctionId(it) => attrs_from_loc(it.lookup(db), db),
+            AttrDefId::TypeAliasId(it) => attrs_from_loc(it.lookup(db), db),
+        }
+    }
+
+    pub fn has_atom(&self, atom: &str) -> bool {
+        self.iter().any(|it| it.is_simple_atom(atom))
+    }
+
+    pub fn find_string_value(&self, key: &str) -> Option<SmolStr> {
+        self.iter().filter(|attr| attr.is_simple_atom(key)).find_map(|attr| {
+            match attr.input.as_ref()? {
+                AttrInput::Literal(it) => Some(it.clone()),
+                _ => None,
+            }
+        })
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Attr {
@@ -43,13 +117,15 @@ impl Attr {
         Some(Attr { path, input })
     }
 
-    pub fn from_attrs_owner(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Option<Arc<[Attr]>> {
+    pub fn from_attrs_owner(owner: &dyn AttrsOwner, hygiene: &Hygiene) -> Attrs {
         let mut attrs = owner.attrs().peekable();
-        if attrs.peek().is_none() {
+        let entries = if attrs.peek().is_none() {
             // Avoid heap allocation
-            return None;
-        }
-        Some(attrs.flat_map(|ast| Attr::from_src(ast, hygiene)).collect())
+            None
+        } else {
+            Some(attrs.flat_map(|ast| Attr::from_src(ast, hygiene)).collect())
+        };
+        Attrs { entries }
     }
 
     pub fn is_simple_atom(&self, name: &str) -> bool {
@@ -82,3 +158,23 @@ impl Attr {
         cfg_options.is_cfg_enabled(self.as_cfg()?)
     }
 }
+
+fn attrs_from_ast<D, N>(src: AstId<N>, db: &D) -> Attrs
+where
+    N: ast::AttrsOwner,
+    D: DefDatabase,
+{
+    let hygiene = Hygiene::new(db, src.file_id());
+    Attr::from_attrs_owner(&src.to_node(db), &hygiene)
+}
+
+fn attrs_from_loc<T, D>(node: T, db: &D) -> Attrs
+where
+    T: HasSource,
+    T::Value: ast::AttrsOwner,
+    D: DefDatabase,
+{
+    let src = node.source(db);
+    let hygiene = Hygiene::new(db, src.file_id);
+    Attr::from_attrs_owner(&src.value, &hygiene)
+}
diff --git a/crates/ra_hir_def/src/body.rs b/crates/ra_hir_def/src/body.rs
index dfb79a30a..225638b42 100644
--- a/crates/ra_hir_def/src/body.rs
+++ b/crates/ra_hir_def/src/body.rs
@@ -13,7 +13,7 @@ use ra_syntax::{ast, AstNode, AstPtr};
 use rustc_hash::FxHashMap;
 
 use crate::{
-    db::DefDatabase2,
+    db::DefDatabase,
     expr::{Expr, ExprId, Pat, PatId},
     nameres::CrateDefMap,
     path::Path,
@@ -28,7 +28,7 @@ pub struct Expander {
 }
 
 impl Expander {
-    pub fn new(db: &impl DefDatabase2, current_file_id: HirFileId, module: ModuleId) -> Expander {
+    pub fn new(db: &impl DefDatabase, current_file_id: HirFileId, module: ModuleId) -> Expander {
         let crate_def_map = db.crate_def_map(module.krate);
         let hygiene = Hygiene::new(db, current_file_id);
         Expander { crate_def_map, current_file_id, hygiene, module }
@@ -36,7 +36,7 @@ impl Expander {
 
     fn enter_expand(
         &mut self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         macro_call: ast::MacroCall,
     ) -> Option<(Mark, ast::Expr)> {
         let ast_id = AstId::new(
@@ -67,7 +67,7 @@ impl Expander {
         None
     }
 
-    fn exit(&mut self, db: &impl DefDatabase2, mark: Mark) {
+    fn exit(&mut self, db: &impl DefDatabase, mark: Mark) {
         self.hygiene = Hygiene::new(db, mark.file_id);
         self.current_file_id = mark.file_id;
         std::mem::forget(mark);
@@ -81,7 +81,7 @@ impl Expander {
         Path::from_src(path, &self.hygiene)
     }
 
-    fn resolve_path_as_macro(&self, db: &impl DefDatabase2, path: &Path) -> Option<MacroDefId> {
+    fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
         self.crate_def_map.resolve_path(db, self.module.module_id, path).0.get_macros()
     }
 }
@@ -142,7 +142,7 @@ pub struct BodySourceMap {
 
 impl Body {
     pub(crate) fn body_with_source_map_query(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         def: DefWithBodyId,
     ) -> (Arc<Body>, Arc<BodySourceMap>) {
         let mut params = None;
@@ -169,12 +169,12 @@ impl Body {
         (Arc::new(body), Arc::new(source_map))
     }
 
-    pub(crate) fn body_query(db: &impl DefDatabase2, def: DefWithBodyId) -> Arc<Body> {
+    pub(crate) fn body_query(db: &impl DefDatabase, def: DefWithBodyId) -> Arc<Body> {
         db.body_with_source_map(def).0
     }
 
     fn new(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         expander: Expander,
         params: Option<ast::ParamList>,
         body: Option<ast::Expr>,
diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index d8e911aa5..f4640dfa4 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -17,7 +17,7 @@ use test_utils::tested_by;
 use crate::{
     body::{Body, BodySourceMap, Expander, PatPtr},
     builtin_type::{BuiltinFloat, BuiltinInt},
-    db::DefDatabase2,
+    db::DefDatabase,
     expr::{
         ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
         MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
@@ -28,7 +28,7 @@ use crate::{
 };
 
 pub(super) fn lower(
-    db: &impl DefDatabase2,
+    db: &impl DefDatabase,
     expander: Expander,
     params: Option<ast::ParamList>,
     body: Option<ast::Expr>,
@@ -57,7 +57,7 @@ struct ExprCollector<DB> {
 
 impl<'a, DB> ExprCollector<&'a DB>
 where
-    DB: DefDatabase2,
+    DB: DefDatabase,
 {
     fn collect(
         mut self,
diff --git a/crates/ra_hir_def/src/body/scope.rs b/crates/ra_hir_def/src/body/scope.rs
index 58740b679..20d707bc4 100644
--- a/crates/ra_hir_def/src/body/scope.rs
+++ b/crates/ra_hir_def/src/body/scope.rs
@@ -7,7 +7,7 @@ use rustc_hash::FxHashMap;
 
 use crate::{
     body::Body,
-    db::DefDatabase2,
+    db::DefDatabase,
     expr::{Expr, ExprId, Pat, PatId, Statement},
     DefWithBodyId,
 };
@@ -45,7 +45,7 @@ pub struct ScopeData {
 }
 
 impl ExprScopes {
-    pub(crate) fn expr_scopes_query(db: &impl DefDatabase2, def: DefWithBodyId) -> Arc<ExprScopes> {
+    pub(crate) fn expr_scopes_query(db: &impl DefDatabase, def: DefWithBodyId) -> Arc<ExprScopes> {
         let body = db.body(def);
         Arc::new(ExprScopes::new(&*body))
     }
@@ -176,7 +176,7 @@ mod tests {
     use ra_syntax::{algo::find_node_at_offset, ast, AstNode};
     use test_utils::{assert_eq_text, covers, extract_offset};
 
-    use crate::{db::DefDatabase2, test_db::TestDB, FunctionId, ModuleDefId};
+    use crate::{db::DefDatabase, test_db::TestDB, FunctionId, ModuleDefId};
 
     fn find_function(db: &TestDB, file_id: FileId) -> FunctionId {
         let krate = db.test_crate();
diff --git a/crates/ra_hir_def/src/data.rs b/crates/ra_hir_def/src/data.rs
new file mode 100644
index 000000000..f0b3e198a
--- /dev/null
+++ b/crates/ra_hir_def/src/data.rs
@@ -0,0 +1,217 @@
+//! Contains basic data about various HIR declarations.
+
+use std::sync::Arc;
+
+use hir_expand::{
+    name::{self, AsName, Name},
+    AstId,
+};
+use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
+
+use crate::{
+    db::DefDatabase,
+    type_ref::{Mutability, TypeRef},
+    AssocItemId, AstItemDef, ConstId, ConstLoc, ContainerId, FunctionId, FunctionLoc, HasSource,
+    ImplId, Intern, Lookup, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FunctionData {
+    pub name: Name,
+    pub params: Vec<TypeRef>,
+    pub ret_type: TypeRef,
+    /// True if the first param is `self`. This is relevant to decide whether this
+    /// can be called as a method.
+    pub has_self_param: bool,
+}
+
+impl FunctionData {
+    pub(crate) fn fn_data_query(db: &impl DefDatabase, func: FunctionId) -> Arc<FunctionData> {
+        let src = func.lookup(db).source(db);
+        let name = src.value.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
+        let mut params = Vec::new();
+        let mut has_self_param = false;
+        if let Some(param_list) = src.value.param_list() {
+            if let Some(self_param) = param_list.self_param() {
+                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
+                    TypeRef::from_ast(type_ref)
+                } else {
+                    let self_type = TypeRef::Path(name::SELF_TYPE.into());
+                    match self_param.kind() {
+                        ast::SelfParamKind::Owned => self_type,
+                        ast::SelfParamKind::Ref => {
+                            TypeRef::Reference(Box::new(self_type), Mutability::Shared)
+                        }
+                        ast::SelfParamKind::MutRef => {
+                            TypeRef::Reference(Box::new(self_type), Mutability::Mut)
+                        }
+                    }
+                };
+                params.push(self_type);
+                has_self_param = true;
+            }
+            for param in param_list.params() {
+                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+                params.push(type_ref);
+            }
+        }
+        let ret_type = if let Some(type_ref) = src.value.ret_type().and_then(|rt| rt.type_ref()) {
+            TypeRef::from_ast(type_ref)
+        } else {
+            TypeRef::unit()
+        };
+
+        let sig = FunctionData { name, params, ret_type, has_self_param };
+        Arc::new(sig)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TypeAliasData {
+    pub name: Name,
+    pub type_ref: Option<TypeRef>,
+}
+
+impl TypeAliasData {
+    pub(crate) fn type_alias_data_query(
+        db: &impl DefDatabase,
+        typ: TypeAliasId,
+    ) -> Arc<TypeAliasData> {
+        let node = typ.lookup(db).source(db).value;
+        let name = node.name().map_or_else(Name::missing, |n| n.as_name());
+        let type_ref = node.type_ref().map(TypeRef::from_ast);
+        Arc::new(TypeAliasData { name, type_ref })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraitData {
+    pub name: Option<Name>,
+    pub items: Vec<AssocItemId>,
+    pub auto: bool,
+}
+
+impl TraitData {
+    pub(crate) fn trait_data_query(db: &impl DefDatabase, tr: TraitId) -> Arc<TraitData> {
+        let src = tr.source(db);
+        let name = src.value.name().map(|n| n.as_name());
+        let auto = src.value.is_auto();
+        let ast_id_map = db.ast_id_map(src.file_id);
+        let items = if let Some(item_list) = src.value.item_list() {
+            item_list
+                .impl_items()
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => FunctionLoc {
+                        container: ContainerId::TraitId(tr),
+                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    }
+                    .intern(db)
+                    .into(),
+                    ast::ImplItem::ConstDef(it) => ConstLoc {
+                        container: ContainerId::TraitId(tr),
+                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    }
+                    .intern(db)
+                    .into(),
+                    ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc {
+                        container: ContainerId::TraitId(tr),
+                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
+                    }
+                    .intern(db)
+                    .into(),
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+        Arc::new(TraitData { name, items, auto })
+    }
+
+    pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
+        self.items.iter().filter_map(|item| match item {
+            AssocItemId::TypeAliasId(t) => Some(*t),
+            _ => None,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImplData {
+    pub target_trait: Option<TypeRef>,
+    pub target_type: TypeRef,
+    pub items: Vec<AssocItemId>,
+    pub is_negative: bool,
+}
+
+impl ImplData {
+    pub(crate) fn impl_data_query(db: &impl DefDatabase, id: ImplId) -> Arc<ImplData> {
+        let src = id.source(db);
+        let items = db.ast_id_map(src.file_id);
+
+        let target_trait = src.value.target_trait().map(TypeRef::from_ast);
+        let target_type = TypeRef::from_ast_opt(src.value.target_type());
+        let is_negative = src.value.is_negative();
+
+        let items = if let Some(item_list) = src.value.item_list() {
+            item_list
+                .impl_items()
+                .map(|item_node| match item_node {
+                    ast::ImplItem::FnDef(it) => {
+                        let def = FunctionLoc {
+                            container: ContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
+                    }
+                    ast::ImplItem::ConstDef(it) => {
+                        let def = ConstLoc {
+                            container: ContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
+                    }
+                    ast::ImplItem::TypeAliasDef(it) => {
+                        let def = TypeAliasLoc {
+                            container: ContainerId::ImplId(id),
+                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
+                        }
+                        .intern(db);
+                        def.into()
+                    }
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+
+        let res = ImplData { target_trait, target_type, items, is_negative };
+        Arc::new(res)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConstData {
+    pub name: Option<Name>,
+    pub type_ref: TypeRef,
+}
+
+impl ConstData {
+    pub(crate) fn const_data_query(db: &impl DefDatabase, konst: ConstId) -> Arc<ConstData> {
+        let node = konst.lookup(db).source(db).value;
+        const_data_for(&node)
+    }
+
+    pub(crate) fn static_data_query(db: &impl DefDatabase, konst: StaticId) -> Arc<ConstData> {
+        let node = konst.source(db).value;
+        const_data_for(&node)
+    }
+}
+
+fn const_data_for<N: NameOwner + TypeAscriptionOwner>(node: &N) -> Arc<ConstData> {
+    let name = node.name().map(|n| n.as_name());
+    let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
+    let sig = ConstData { name, type_ref };
+    Arc::new(sig)
+}
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index 844f8bbe8..7fec2e8c0 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -3,43 +3,46 @@ use std::sync::Arc;
 
 use hir_expand::{db::AstDatabase, HirFileId};
 use ra_db::{salsa, CrateId, SourceDatabase};
-use ra_syntax::ast;
+use ra_syntax::{ast, SmolStr};
 
 use crate::{
     adt::{EnumData, StructData},
+    attr::Attrs,
     body::{scope::ExprScopes, Body, BodySourceMap},
+    data::{ConstData, FunctionData, ImplData, TraitData, TypeAliasData},
+    docs::Documentation,
     generics::GenericParams,
-    impls::ImplData,
+    lang_item::{LangItemTarget, LangItems},
     nameres::{
         raw::{ImportSourceMap, RawItems},
         CrateDefMap,
     },
-    traits::TraitData,
-    DefWithBodyId, EnumId, GenericDefId, ImplId, ItemLoc, StructOrUnionId, TraitId,
+    AttrDefId, ConstId, ConstLoc, DefWithBodyId, EnumId, FunctionId, FunctionLoc, GenericDefId,
+    ImplId, ItemLoc, ModuleId, StaticId, StructOrUnionId, TraitId, TypeAliasId, TypeAliasLoc,
 };
 
 #[salsa::query_group(InternDatabaseStorage)]
 pub trait InternDatabase: SourceDatabase {
     #[salsa::interned]
-    fn intern_function(&self, loc: crate::FunctionLoc) -> crate::FunctionId;
+    fn intern_function(&self, loc: FunctionLoc) -> FunctionId;
     #[salsa::interned]
-    fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> crate::StructOrUnionId;
+    fn intern_struct_or_union(&self, loc: ItemLoc<ast::StructDef>) -> StructOrUnionId;
     #[salsa::interned]
-    fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> crate::EnumId;
+    fn intern_enum(&self, loc: ItemLoc<ast::EnumDef>) -> EnumId;
     #[salsa::interned]
-    fn intern_const(&self, loc: crate::ConstLoc) -> crate::ConstId;
+    fn intern_const(&self, loc: ConstLoc) -> ConstId;
     #[salsa::interned]
-    fn intern_static(&self, loc: ItemLoc<ast::StaticDef>) -> crate::StaticId;
+    fn intern_static(&self, loc: ItemLoc<ast::StaticDef>) -> StaticId;
     #[salsa::interned]
-    fn intern_trait(&self, loc: ItemLoc<ast::TraitDef>) -> crate::TraitId;
+    fn intern_trait(&self, loc: ItemLoc<ast::TraitDef>) -> TraitId;
     #[salsa::interned]
-    fn intern_type_alias(&self, loc: crate::TypeAliasLoc) -> crate::TypeAliasId;
+    fn intern_type_alias(&self, loc: TypeAliasLoc) -> TypeAliasId;
     #[salsa::interned]
-    fn intern_impl(&self, loc: ItemLoc<ast::ImplBlock>) -> crate::ImplId;
+    fn intern_impl(&self, loc: ItemLoc<ast::ImplBlock>) -> ImplId;
 }
 
-#[salsa::query_group(DefDatabase2Storage)]
-pub trait DefDatabase2: InternDatabase + AstDatabase {
+#[salsa::query_group(DefDatabaseStorage)]
+pub trait DefDatabase: InternDatabase + AstDatabase {
     #[salsa::invoke(RawItems::raw_items_with_source_map_query)]
     fn raw_items_with_source_map(
         &self,
@@ -64,6 +67,18 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
     #[salsa::invoke(TraitData::trait_data_query)]
     fn trait_data(&self, e: TraitId) -> Arc<TraitData>;
 
+    #[salsa::invoke(TypeAliasData::type_alias_data_query)]
+    fn type_alias_data(&self, e: TypeAliasId) -> Arc<TypeAliasData>;
+
+    #[salsa::invoke(FunctionData::fn_data_query)]
+    fn function_data(&self, func: FunctionId) -> Arc<FunctionData>;
+
+    #[salsa::invoke(ConstData::const_data_query)]
+    fn const_data(&self, konst: ConstId) -> Arc<ConstData>;
+
+    #[salsa::invoke(ConstData::static_data_query)]
+    fn static_data(&self, konst: StaticId) -> Arc<ConstData>;
+
     #[salsa::invoke(Body::body_with_source_map_query)]
     fn body_with_source_map(&self, def: DefWithBodyId) -> (Arc<Body>, Arc<BodySourceMap>);
 
@@ -75,4 +90,21 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
 
     #[salsa::invoke(GenericParams::generic_params_query)]
     fn generic_params(&self, def: GenericDefId) -> Arc<GenericParams>;
+
+    #[salsa::invoke(Attrs::attrs_query)]
+    fn attrs(&self, def: AttrDefId) -> Attrs;
+
+    #[salsa::invoke(LangItems::module_lang_items_query)]
+    fn module_lang_items(&self, module: ModuleId) -> Option<Arc<LangItems>>;
+
+    #[salsa::invoke(LangItems::crate_lang_items_query)]
+    fn crate_lang_items(&self, krate: CrateId) -> Arc<LangItems>;
+
+    #[salsa::invoke(LangItems::lang_item_query)]
+    fn lang_item(&self, start_crate: CrateId, item: SmolStr) -> Option<LangItemTarget>;
+
+    // FIXME(https://github.com/rust-analyzer/rust-analyzer/issues/2148#issuecomment-550519102)
+    // Remove this query completely, in favor of `Attrs::docs` method
+    #[salsa::invoke(Documentation::documentation_query)]
+    fn documentation(&self, def: AttrDefId) -> Option<Documentation>;
 }
diff --git a/crates/ra_hir_def/src/docs.rs b/crates/ra_hir_def/src/docs.rs
new file mode 100644
index 000000000..69846fd1b
--- /dev/null
+++ b/crates/ra_hir_def/src/docs.rs
@@ -0,0 +1,68 @@
+//! FIXME: write short doc here
+
+use std::sync::Arc;
+
+use hir_expand::either::Either;
+use ra_syntax::ast;
+
+use crate::{db::DefDatabase, AdtId, AstItemDef, AttrDefId, HasChildSource, HasSource, Lookup};
+
+/// Holds documentation
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Documentation(Arc<str>);
+
+impl Into<String> for Documentation {
+    fn into(self) -> String {
+        self.as_str().to_owned()
+    }
+}
+
+impl Documentation {
+    fn new(s: &str) -> Documentation {
+        Documentation(s.into())
+    }
+
+    pub fn as_str(&self) -> &str {
+        &*self.0
+    }
+
+    pub(crate) fn documentation_query(
+        db: &impl DefDatabase,
+        def: AttrDefId,
+    ) -> Option<Documentation> {
+        match def {
+            AttrDefId::ModuleId(module) => {
+                let def_map = db.crate_def_map(module.krate);
+                let src = def_map[module.module_id].declaration_source(db)?;
+                docs_from_ast(&src.value)
+            }
+            AttrDefId::StructFieldId(it) => {
+                let src = it.parent.child_source(db);
+                match &src.value[it.local_id] {
+                    Either::A(_tuple) => None,
+                    Either::B(record) => docs_from_ast(record),
+                }
+            }
+            AttrDefId::AdtId(it) => match it {
+                AdtId::StructId(it) => docs_from_ast(&it.0.source(db).value),
+                AdtId::EnumId(it) => docs_from_ast(&it.source(db).value),
+                AdtId::UnionId(it) => docs_from_ast(&it.0.source(db).value),
+            },
+            AttrDefId::EnumVariantId(it) => {
+                let src = it.parent.child_source(db);
+                docs_from_ast(&src.value[it.local_id])
+            }
+            AttrDefId::StaticId(it) => docs_from_ast(&it.source(db).value),
+            AttrDefId::TraitId(it) => docs_from_ast(&it.source(db).value),
+            AttrDefId::MacroDefId(it) => docs_from_ast(&it.ast_id.to_node(db)),
+            AttrDefId::ConstId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::FunctionId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::TypeAliasId(it) => docs_from_ast(&it.lookup(db).source(db).value),
+            AttrDefId::ImplId(_) => None,
+        }
+    }
+}
+
+pub(crate) fn docs_from_ast(node: &impl ast::DocCommentsOwner) -> Option<Documentation> {
+    node.doc_comment_text().map(|it| Documentation::new(&it))
+}
diff --git a/crates/ra_hir_def/src/generics.rs b/crates/ra_hir_def/src/generics.rs
index 9e2e4c3cc..015fe772e 100644
--- a/crates/ra_hir_def/src/generics.rs
+++ b/crates/ra_hir_def/src/generics.rs
@@ -8,7 +8,7 @@ use hir_expand::name::{self, AsName, Name};
 use ra_syntax::ast::{self, NameOwner, TypeBoundsOwner, TypeParamsOwner};
 
 use crate::{
-    db::DefDatabase2,
+    db::DefDatabase,
     type_ref::{TypeBound, TypeRef},
     AdtId, AstItemDef, ContainerId, GenericDefId, HasSource, Lookup,
 };
@@ -42,7 +42,7 @@ pub struct WherePredicate {
 
 impl GenericParams {
     pub(crate) fn generic_params_query(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         def: GenericDefId,
     ) -> Arc<GenericParams> {
         let parent_generics = parent_generic_def(db, def).map(|it| db.generic_params(it));
@@ -50,7 +50,7 @@ impl GenericParams {
     }
 
     fn new(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         def: GenericDefId,
         parent_params: Option<Arc<GenericParams>>,
     ) -> GenericParams {
@@ -168,7 +168,7 @@ impl GenericParams {
     }
 }
 
-fn parent_generic_def(db: &impl DefDatabase2, def: GenericDefId) -> Option<GenericDefId> {
+fn parent_generic_def(db: &impl DefDatabase, def: GenericDefId) -> Option<GenericDefId> {
     let container = match def {
         GenericDefId::FunctionId(it) => it.lookup(db).container,
         GenericDefId::TypeAliasId(it) => it.lookup(db).container,
diff --git a/crates/ra_hir_def/src/impls.rs b/crates/ra_hir_def/src/impls.rs
deleted file mode 100644
index 750a869f2..000000000
--- a/crates/ra_hir_def/src/impls.rs
+++ /dev/null
@@ -1,86 +0,0 @@
-//! Defines hir-level representation of impls.
-//!
-//! The handling is similar, but is not quite the same as for other items,
-//! because `impl`s don't have names.
-
-use std::sync::Arc;
-
-use hir_expand::AstId;
-use ra_syntax::ast;
-
-use crate::{
-    db::DefDatabase2, type_ref::TypeRef, AssocItemId, AstItemDef, ConstLoc, ContainerId,
-    FunctionLoc, ImplId, Intern, TypeAliasLoc,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ImplData {
-    target_trait: Option<TypeRef>,
-    target_type: TypeRef,
-    items: Vec<AssocItemId>,
-    negative: bool,
-}
-
-impl ImplData {
-    pub(crate) fn impl_data_query(db: &impl DefDatabase2, id: ImplId) -> Arc<ImplData> {
-        let src = id.source(db);
-        let items = db.ast_id_map(src.file_id);
-
-        let target_trait = src.value.target_trait().map(TypeRef::from_ast);
-        let target_type = TypeRef::from_ast_opt(src.value.target_type());
-        let negative = src.value.is_negative();
-
-        let items = if let Some(item_list) = src.value.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => {
-                        let def = FunctionLoc {
-                            container: ContainerId::ImplId(id),
-                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
-                        }
-                        .intern(db);
-                        def.into()
-                    }
-                    ast::ImplItem::ConstDef(it) => {
-                        let def = ConstLoc {
-                            container: ContainerId::ImplId(id),
-                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
-                        }
-                        .intern(db);
-                        def.into()
-                    }
-                    ast::ImplItem::TypeAliasDef(it) => {
-                        let def = TypeAliasLoc {
-                            container: ContainerId::ImplId(id),
-                            ast_id: AstId::new(src.file_id, items.ast_id(&it)),
-                        }
-                        .intern(db);
-                        def.into()
-                    }
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-
-        let res = ImplData { target_trait, target_type, items, negative };
-        Arc::new(res)
-    }
-
-    pub fn target_trait(&self) -> Option<&TypeRef> {
-        self.target_trait.as_ref()
-    }
-
-    pub fn target_type(&self) -> &TypeRef {
-        &self.target_type
-    }
-
-    pub fn items(&self) -> &[AssocItemId] {
-        &self.items
-    }
-
-    pub fn is_negative(&self) -> bool {
-        self.negative
-    }
-}
diff --git a/crates/ra_hir_def/src/lang_item.rs b/crates/ra_hir_def/src/lang_item.rs
new file mode 100644
index 000000000..df951c533
--- /dev/null
+++ b/crates/ra_hir_def/src/lang_item.rs
@@ -0,0 +1,120 @@
+//! Collects lang items: items marked with `#[lang = "..."]` attribute.
+//!
+//! This attribute to tell the compiler about semi built-in std library
+//! features, such as Fn family of traits.
+use std::sync::Arc;
+
+use ra_syntax::SmolStr;
+use rustc_hash::FxHashMap;
+
+use crate::{
+    db::DefDatabase, AdtId, AttrDefId, CrateId, EnumId, FunctionId, ImplId, ModuleDefId, ModuleId,
+    StaticId, StructId, TraitId,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LangItemTarget {
+    EnumId(EnumId),
+    FunctionId(FunctionId),
+    ImplBlockId(ImplId),
+    StaticId(StaticId),
+    StructId(StructId),
+    TraitId(TraitId),
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub struct LangItems {
+    items: FxHashMap<SmolStr, LangItemTarget>,
+}
+
+impl LangItems {
+    pub fn target<'a>(&'a self, item: &str) -> Option<&'a LangItemTarget> {
+        self.items.get(item)
+    }
+
+    /// Salsa query. This will look for lang items in a specific crate.
+    pub(crate) fn crate_lang_items_query(db: &impl DefDatabase, krate: CrateId) -> Arc<LangItems> {
+        let mut lang_items = LangItems::default();
+
+        let crate_def_map = db.crate_def_map(krate);
+
+        crate_def_map
+            .modules()
+            .filter_map(|module_id| db.module_lang_items(ModuleId { krate, module_id }))
+            .for_each(|it| lang_items.items.extend(it.items.iter().map(|(k, v)| (k.clone(), *v))));
+
+        Arc::new(lang_items)
+    }
+
+    pub(crate) fn module_lang_items_query(
+        db: &impl DefDatabase,
+        module: ModuleId,
+    ) -> Option<Arc<LangItems>> {
+        let mut lang_items = LangItems::default();
+        lang_items.collect_lang_items(db, module);
+        if lang_items.items.is_empty() {
+            None
+        } else {
+            Some(Arc::new(lang_items))
+        }
+    }
+
+    /// Salsa query. Look for a lang item, starting from the specified crate and recursively
+    /// traversing its dependencies.
+    pub(crate) fn lang_item_query(
+        db: &impl DefDatabase,
+        start_crate: CrateId,
+        item: SmolStr,
+    ) -> Option<LangItemTarget> {
+        let lang_items = db.crate_lang_items(start_crate);
+        let start_crate_target = lang_items.items.get(&item);
+        if let Some(target) = start_crate_target {
+            return Some(*target);
+        }
+        db.crate_graph()
+            .dependencies(start_crate)
+            .find_map(|dep| db.lang_item(dep.crate_id, item.clone()))
+    }
+
+    fn collect_lang_items(&mut self, db: &impl DefDatabase, module: ModuleId) {
+        // Look for impl targets
+        let def_map = db.crate_def_map(module.krate);
+        let module_data = &def_map[module.module_id];
+        for &impl_block in module_data.impls.iter() {
+            self.collect_lang_item(db, impl_block, LangItemTarget::ImplBlockId)
+        }
+
+        for def in module_data.scope.declarations() {
+            match def {
+                ModuleDefId::TraitId(trait_) => {
+                    self.collect_lang_item(db, trait_, LangItemTarget::TraitId)
+                }
+                ModuleDefId::AdtId(AdtId::EnumId(e)) => {
+                    self.collect_lang_item(db, e, LangItemTarget::EnumId)
+                }
+                ModuleDefId::AdtId(AdtId::StructId(s)) => {
+                    self.collect_lang_item(db, s, LangItemTarget::StructId)
+                }
+                ModuleDefId::FunctionId(f) => {
+                    self.collect_lang_item(db, f, LangItemTarget::FunctionId)
+                }
+                ModuleDefId::StaticId(s) => self.collect_lang_item(db, s, LangItemTarget::StaticId),
+                _ => {}
+            }
+        }
+    }
+
+    fn collect_lang_item<T>(
+        &mut self,
+        db: &impl DefDatabase,
+        item: T,
+        constructor: fn(T) -> LangItemTarget,
+    ) where
+        T: Into<AttrDefId> + Copy,
+    {
+        let attrs = db.attrs(item.into());
+        if let Some(lang_item_name) = attrs.find_string_value("lang") {
+            self.items.entry(lang_item_name).or_insert_with(|| constructor(item));
+        }
+    }
+}
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index d579f5c7e..1d195d65d 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,103 +13,48 @@ pub mod path;
 pub mod type_ref;
 pub mod builtin_type;
 pub mod adt;
-pub mod impls;
 pub mod diagnostics;
 pub mod expr;
 pub mod body;
 pub mod generics;
-pub mod traits;
 pub mod resolver;
+pub mod data;
+pub mod lang_item;
+pub mod docs;
+pub mod per_ns;
+
+mod trace;
+mod nameres;
 
 #[cfg(test)]
 mod test_db;
 #[cfg(test)]
 mod marks;
 
-// FIXME: this should be private
-pub mod nameres;
-
 use std::hash::{Hash, Hasher};
 
-use hir_expand::{ast_id_map::FileAstId, db::AstDatabase, AstId, HirFileId, Source};
-use ra_arena::{impl_arena_id, RawId};
-use ra_db::{salsa, CrateId, FileId};
-use ra_syntax::{ast, AstNode, SyntaxNode};
+use hir_expand::{ast_id_map::FileAstId, db::AstDatabase, AstId, HirFileId, MacroDefId, Source};
+use ra_arena::{impl_arena_id, map::ArenaMap, RawId};
+use ra_db::{salsa, CrateId};
+use ra_syntax::{ast, AstNode};
 
 use crate::{builtin_type::BuiltinType, db::InternDatabase};
 
-pub enum ModuleSource {
-    SourceFile(ast::SourceFile),
-    Module(ast::Module),
-}
-
-impl ModuleSource {
-    pub fn new(
-        db: &impl db::DefDatabase2,
-        file_id: Option<FileId>,
-        decl_id: Option<AstId<ast::Module>>,
-    ) -> ModuleSource {
-        match (file_id, decl_id) {
-            (Some(file_id), _) => {
-                let source_file = db.parse(file_id).tree();
-                ModuleSource::SourceFile(source_file)
-            }
-            (None, Some(item_id)) => {
-                let module = item_id.to_node(db);
-                assert!(module.item_list().is_some(), "expected inline module");
-                ModuleSource::Module(module)
-            }
-            (None, None) => panic!(),
-        }
-    }
-
-    // FIXME: this methods do not belong here
-    pub fn from_position(
-        db: &impl db::DefDatabase2,
-        position: ra_db::FilePosition,
-    ) -> ModuleSource {
-        let parse = db.parse(position.file_id);
-        match &ra_syntax::algo::find_node_at_offset::<ast::Module>(
-            parse.tree().syntax(),
-            position.offset,
-        ) {
-            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
-            _ => {
-                let source_file = parse.tree();
-                ModuleSource::SourceFile(source_file)
-            }
-        }
-    }
-
-    pub fn from_child_node(db: &impl db::DefDatabase2, child: Source<&SyntaxNode>) -> ModuleSource {
-        if let Some(m) =
-            child.value.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
-        {
-            ModuleSource::Module(m)
-        } else {
-            let file_id = child.file_id.original_file(db);
-            let source_file = db.parse(file_id).tree();
-            ModuleSource::SourceFile(source_file)
-        }
-    }
-
-    pub fn from_file_id(db: &impl db::DefDatabase2, file_id: FileId) -> ModuleSource {
-        let source_file = db.parse(file_id).tree();
-        ModuleSource::SourceFile(source_file)
-    }
-}
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LocalImportId(RawId);
+impl_arena_id!(LocalImportId);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct ModuleId {
     pub krate: CrateId,
-    pub module_id: CrateModuleId,
+    pub module_id: LocalModuleId,
 }
 
 /// An ID of a module, **local** to a specific crate
 // FIXME: rename to `LocalModuleId`.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct CrateModuleId(RawId);
-impl_arena_id!(CrateModuleId);
+pub struct LocalModuleId(RawId);
+impl_arena_id!(LocalModuleId);
 
 macro_rules! impl_intern_key {
     ($name:ident) => {
@@ -208,14 +153,14 @@ pub struct FunctionLoc {
 
 impl Intern for FunctionLoc {
     type ID = FunctionId;
-    fn intern(self, db: &impl db::DefDatabase2) -> FunctionId {
+    fn intern(self, db: &impl db::DefDatabase) -> FunctionId {
         db.intern_function(self)
     }
 }
 
 impl Lookup for FunctionId {
     type Data = FunctionLoc;
-    fn lookup(&self, db: &impl db::DefDatabase2) -> FunctionLoc {
+    fn lookup(&self, db: &impl db::DefDatabase) -> FunctionLoc {
         db.lookup_intern_function(*self)
     }
 }
@@ -279,8 +224,8 @@ pub enum VariantId {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StructFieldId {
-    parent: VariantId,
-    local_id: LocalStructFieldId,
+    pub parent: VariantId,
+    pub local_id: LocalStructFieldId,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -298,14 +243,14 @@ pub struct ConstLoc {
 
 impl Intern for ConstLoc {
     type ID = ConstId;
-    fn intern(self, db: &impl db::DefDatabase2) -> ConstId {
+    fn intern(self, db: &impl db::DefDatabase) -> ConstId {
         db.intern_const(self)
     }
 }
 
 impl Lookup for ConstId {
     type Data = ConstLoc;
-    fn lookup(&self, db: &impl db::DefDatabase2) -> ConstLoc {
+    fn lookup(&self, db: &impl db::DefDatabase) -> ConstLoc {
         db.lookup_intern_const(*self)
     }
 }
@@ -346,14 +291,14 @@ pub struct TypeAliasLoc {
 
 impl Intern for TypeAliasLoc {
     type ID = TypeAliasId;
-    fn intern(self, db: &impl db::DefDatabase2) -> TypeAliasId {
+    fn intern(self, db: &impl db::DefDatabase) -> TypeAliasId {
         db.intern_type_alias(self)
     }
 }
 
 impl Lookup for TypeAliasId {
     type Data = TypeAliasLoc;
-    fn lookup(&self, db: &impl db::DefDatabase2) -> TypeAliasLoc {
+    fn lookup(&self, db: &impl db::DefDatabase) -> TypeAliasLoc {
         db.lookup_intern_type_alias(*self)
     }
 }
@@ -476,22 +421,51 @@ impl_froms!(
     ConstId
 );
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AttrDefId {
+    ModuleId(ModuleId),
+    StructFieldId(StructFieldId),
+    AdtId(AdtId),
+    FunctionId(FunctionId),
+    EnumVariantId(EnumVariantId),
+    StaticId(StaticId),
+    ConstId(ConstId),
+    TraitId(TraitId),
+    TypeAliasId(TypeAliasId),
+    MacroDefId(MacroDefId),
+    ImplId(ImplId),
+}
+
+impl_froms!(
+    AttrDefId: ModuleId,
+    StructFieldId,
+    AdtId(StructId, EnumId, UnionId),
+    EnumVariantId,
+    StaticId,
+    ConstId,
+    FunctionId,
+    TraitId,
+    TypeAliasId,
+    MacroDefId,
+    ImplId
+);
+
 trait Intern {
     type ID;
-    fn intern(self, db: &impl db::DefDatabase2) -> Self::ID;
+    fn intern(self, db: &impl db::DefDatabase) -> Self::ID;
 }
 
 pub trait Lookup {
     type Data;
-    fn lookup(&self, db: &impl db::DefDatabase2) -> Self::Data;
+    fn lookup(&self, db: &impl db::DefDatabase) -> Self::Data;
 }
 
 pub trait HasModule {
-    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId;
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId;
 }
 
 impl HasModule for FunctionLoc {
-    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
         match self.container {
             ContainerId::ModuleId(it) => it,
             ContainerId::ImplId(it) => it.module(db),
@@ -501,7 +475,7 @@ impl HasModule for FunctionLoc {
 }
 
 impl HasModule for TypeAliasLoc {
-    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
         match self.container {
             ContainerId::ModuleId(it) => it,
             ContainerId::ImplId(it) => it.module(db),
@@ -511,7 +485,7 @@ impl HasModule for TypeAliasLoc {
 }
 
 impl HasModule for ConstLoc {
-    fn module(&self, db: &impl db::DefDatabase2) -> ModuleId {
+    fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
         match self.container {
             ContainerId::ModuleId(it) => it,
             ContainerId::ImplId(it) => it.module(db),
@@ -522,13 +496,13 @@ impl HasModule for ConstLoc {
 
 pub trait HasSource {
     type Value;
-    fn source(&self, db: &impl db::DefDatabase2) -> Source<Self::Value>;
+    fn source(&self, db: &impl db::DefDatabase) -> Source<Self::Value>;
 }
 
 impl HasSource for FunctionLoc {
     type Value = ast::FnDef;
 
-    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::FnDef> {
+    fn source(&self, db: &impl db::DefDatabase) -> Source<ast::FnDef> {
         let node = self.ast_id.to_node(db);
         Source::new(self.ast_id.file_id(), node)
     }
@@ -537,7 +511,7 @@ impl HasSource for FunctionLoc {
 impl HasSource for TypeAliasLoc {
     type Value = ast::TypeAliasDef;
 
-    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::TypeAliasDef> {
+    fn source(&self, db: &impl db::DefDatabase) -> Source<ast::TypeAliasDef> {
         let node = self.ast_id.to_node(db);
         Source::new(self.ast_id.file_id(), node)
     }
@@ -546,8 +520,17 @@ impl HasSource for TypeAliasLoc {
 impl HasSource for ConstLoc {
     type Value = ast::ConstDef;
 
-    fn source(&self, db: &impl db::DefDatabase2) -> Source<ast::ConstDef> {
+    fn source(&self, db: &impl db::DefDatabase) -> Source<ast::ConstDef> {
         let node = self.ast_id.to_node(db);
         Source::new(self.ast_id.file_id(), node)
     }
 }
+
+pub trait HasChildSource {
+    type ChildId;
+    type Value;
+    fn child_source(
+        &self,
+        db: &impl db::DefDatabase,
+    ) -> Source<ArenaMap<Self::ChildId, Self::Value>>;
+}
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index c01e020ef..3b2e99647 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -47,8 +47,7 @@
 //! path and, upon success, we run macro expansion and "collect module" phase on
 //! the result
 
-pub mod raw;
-pub mod per_ns;
+pub(crate) mod raw;
 mod collector;
 mod mod_resolution;
 mod path_resolution;
@@ -58,7 +57,10 @@ mod tests;
 
 use std::sync::Arc;
 
-use hir_expand::{ast_id_map::FileAstId, diagnostics::DiagnosticSink, name::Name, MacroDefId};
+use hir_expand::{
+    ast_id_map::FileAstId, diagnostics::DiagnosticSink, either::Either, name::Name, MacroDefId,
+    Source,
+};
 use once_cell::sync::Lazy;
 use ra_arena::Arena;
 use ra_db::{CrateId, Edition, FileId};
@@ -68,12 +70,11 @@ use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::{
     builtin_type::BuiltinType,
-    db::DefDatabase2,
-    nameres::{
-        diagnostics::DefDiagnostic, path_resolution::ResolveMode, per_ns::PerNs, raw::ImportId,
-    },
+    db::DefDatabase,
+    nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode},
     path::Path,
-    AstId, CrateModuleId, FunctionId, ImplId, ModuleDefId, ModuleId, TraitId,
+    per_ns::PerNs,
+    AstId, FunctionId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
 };
 
 /// Contains all top-level defs from a macro-expanded crate
@@ -86,8 +87,8 @@ pub struct CrateDefMap {
     /// a dependency (`std` or `core`).
     prelude: Option<ModuleId>,
     extern_prelude: FxHashMap<Name, ModuleDefId>,
-    root: CrateModuleId,
-    modules: Arena<CrateModuleId, ModuleData>,
+    root: LocalModuleId,
+    modules: Arena<LocalModuleId, ModuleData>,
 
     /// Some macros are not well-behavior, which leads to infinite loop
     /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
@@ -104,24 +105,27 @@ pub struct CrateDefMap {
     diagnostics: Vec<DefDiagnostic>,
 }
 
-impl std::ops::Index<CrateModuleId> for CrateDefMap {
+impl std::ops::Index<LocalModuleId> for CrateDefMap {
     type Output = ModuleData;
-    fn index(&self, id: CrateModuleId) -> &ModuleData {
+    fn index(&self, id: LocalModuleId) -> &ModuleData {
         &self.modules[id]
     }
 }
 
 #[derive(Default, Debug, PartialEq, Eq)]
 pub struct ModuleData {
-    pub parent: Option<CrateModuleId>,
-    pub children: FxHashMap<Name, CrateModuleId>,
+    pub parent: Option<LocalModuleId>,
+    pub children: FxHashMap<Name, LocalModuleId>,
     pub scope: ModuleScope,
+
+    //  FIXME: these can't be both null, we need a three-state enum here.
     /// None for root
     pub declaration: Option<AstId<ast::Module>>,
     /// None for inline modules.
     ///
     /// Note that non-inline modules, by definition, live inside non-macro file.
     pub definition: Option<FileId>,
+
     pub impls: Vec<ImplId>,
 }
 
@@ -207,21 +211,21 @@ pub struct Resolution {
     /// None for unresolved
     pub def: PerNs,
     /// ident by which this is imported into local scope.
-    pub import: Option<ImportId>,
+    pub import: Option<LocalImportId>,
 }
 
 impl CrateDefMap {
     pub(crate) fn crate_def_map_query(
         // Note that this doesn't have `+ AstDatabase`!
         // This gurantess that `CrateDefMap` is stable across reparses.
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         krate: CrateId,
     ) -> Arc<CrateDefMap> {
         let _p = profile("crate_def_map_query");
         let def_map = {
             let crate_graph = db.crate_graph();
             let edition = crate_graph.edition(krate);
-            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
             let root = modules.alloc(ModuleData::default());
             CrateDefMap {
                 krate,
@@ -242,7 +246,7 @@ impl CrateDefMap {
         self.krate
     }
 
-    pub fn root(&self) -> CrateModuleId {
+    pub fn root(&self) -> LocalModuleId {
         self.root
     }
 
@@ -256,8 +260,8 @@ impl CrateDefMap {
 
     pub fn add_diagnostics(
         &self,
-        db: &impl DefDatabase2,
-        module: CrateModuleId,
+        db: &impl DefDatabase,
+        module: LocalModuleId,
         sink: &mut DiagnosticSink,
     ) {
         self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
@@ -265,19 +269,19 @@ impl CrateDefMap {
 
     pub fn resolve_path(
         &self,
-        db: &impl DefDatabase2,
-        original_module: CrateModuleId,
+        db: &impl DefDatabase,
+        original_module: LocalModuleId,
         path: &Path,
     ) -> (PerNs, Option<usize>) {
         let res = self.resolve_path_fp_with_macro(db, ResolveMode::Other, original_module, path);
         (res.resolved_def, res.segment_index)
     }
 
-    pub fn modules(&self) -> impl Iterator<Item = CrateModuleId> + '_ {
+    pub fn modules(&self) -> impl Iterator<Item = LocalModuleId> + '_ {
         self.modules.iter().map(|(id, _data)| id)
     }
 
-    pub fn modules_for_file(&self, file_id: FileId) -> impl Iterator<Item = CrateModuleId> + '_ {
+    pub fn modules_for_file(&self, file_id: FileId) -> impl Iterator<Item = LocalModuleId> + '_ {
         self.modules
             .iter()
             .filter(move |(_id, data)| data.definition == Some(file_id))
@@ -285,17 +289,40 @@ impl CrateDefMap {
     }
 }
 
+impl ModuleData {
+    /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
+    pub fn definition_source(
+        &self,
+        db: &impl DefDatabase,
+    ) -> Source<Either<ast::SourceFile, ast::Module>> {
+        if let Some(file_id) = self.definition {
+            let sf = db.parse(file_id).tree();
+            return Source::new(file_id.into(), Either::A(sf));
+        }
+        let decl = self.declaration.unwrap();
+        Source::new(decl.file_id(), Either::B(decl.to_node(db)))
+    }
+
+    /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
+    /// `None` for the crate root.
+    pub fn declaration_source(&self, db: &impl DefDatabase) -> Option<Source<ast::Module>> {
+        let decl = self.declaration?;
+        let value = decl.to_node(db);
+        Some(Source { file_id: decl.file_id(), value })
+    }
+}
+
 mod diagnostics {
     use hir_expand::diagnostics::DiagnosticSink;
     use ra_db::RelativePathBuf;
     use ra_syntax::{ast, AstPtr};
 
-    use crate::{db::DefDatabase2, diagnostics::UnresolvedModule, nameres::CrateModuleId, AstId};
+    use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
 
     #[derive(Debug, PartialEq, Eq)]
     pub(super) enum DefDiagnostic {
         UnresolvedModule {
-            module: CrateModuleId,
+            module: LocalModuleId,
             declaration: AstId<ast::Module>,
             candidate: RelativePathBuf,
         },
@@ -304,8 +331,8 @@ mod diagnostics {
     impl DefDiagnostic {
         pub(super) fn add_to(
             &self,
-            db: &impl DefDatabase2,
-            target_module: CrateModuleId,
+            db: &impl DefDatabase,
+            target_module: LocalModuleId,
             sink: &mut DiagnosticSink,
         ) {
             match self {
diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index aae3dcadf..b02364e86 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -12,19 +12,20 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
-    attr::Attr,
-    db::DefDatabase2,
+    attr::Attrs,
+    db::DefDatabase,
     nameres::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
-        per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
+        raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
     },
     path::{Path, PathKind},
-    AdtId, AstId, AstItemDef, ConstLoc, ContainerId, CrateModuleId, EnumId, EnumVariantId,
-    FunctionLoc, ImplId, Intern, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
+    per_ns::PerNs,
+    AdtId, AstId, AstItemDef, ConstLoc, ContainerId, EnumId, EnumVariantId, FunctionLoc, ImplId,
+    Intern, LocalImportId, LocalModuleId, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
     StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
 };
 
-pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
+pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
     let crate_graph = db.crate_graph();
 
     // populate external prelude
@@ -94,10 +95,10 @@ impl MacroStackMonitor {
 struct DefCollector<'a, DB> {
     db: &'a DB,
     def_map: CrateDefMap,
-    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
-    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
-    unexpanded_macros: Vec<(CrateModuleId, AstId<ast::MacroCall>, Path)>,
-    mod_dirs: FxHashMap<CrateModuleId, ModDir>,
+    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
+    unresolved_imports: Vec<(LocalModuleId, LocalImportId, raw::ImportData)>,
+    unexpanded_macros: Vec<(LocalModuleId, AstId<ast::MacroCall>, Path)>,
+    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
 
     /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
     /// To prevent stack overflow, we add a deep counter here for prevent that.
@@ -108,7 +109,7 @@ struct DefCollector<'a, DB> {
 
 impl<DB> DefCollector<'_, DB>
 where
-    DB: DefDatabase2,
+    DB: DefDatabase,
 {
     fn collect(&mut self) {
         let crate_graph = self.db.crate_graph();
@@ -173,7 +174,7 @@ where
     /// ```
     fn define_macro(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         name: Name,
         macro_: MacroDefId,
         export: bool,
@@ -200,7 +201,7 @@ where
     /// the definition of current module.
     /// And also, `macro_use` on a module will import all legacy macros visable inside to
     /// current legacy scope, with possible shadowing.
-    fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDefId) {
+    fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, macro_: MacroDefId) {
         // Always shadowing
         self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_);
     }
@@ -208,7 +209,7 @@ where
     /// Import macros from `#[macro_use] extern crate`.
     fn import_macros_from_extern_crate(
         &mut self,
-        current_module_id: CrateModuleId,
+        current_module_id: LocalModuleId,
         import: &raw::ImportData,
     ) {
         log::debug!(
@@ -235,7 +236,7 @@ where
     /// Exported macros are just all macros in the root module scope.
     /// Note that it contains not only all `#[macro_export]` macros, but also all aliases
     /// created by `use` in the root module, ignoring the visibility of `use`.
-    fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: CrateId) {
+    fn import_all_macros_exported(&mut self, current_module_id: LocalModuleId, krate: CrateId) {
         let def_map = self.db.crate_def_map(krate);
         for (name, def) in def_map[def_map.root].scope.macros() {
             // `macro_use` only bring things into legacy scope.
@@ -265,7 +266,7 @@ where
 
     fn resolve_import(
         &self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         import: &raw::ImportData,
     ) -> (PerNs, ReachedFixedPoint) {
         log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
@@ -291,9 +292,9 @@ where
 
     fn record_resolved_import(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         def: PerNs,
-        import_id: raw::ImportId,
+        import_id: LocalImportId,
         import: &raw::ImportData,
     ) {
         if import.is_glob {
@@ -387,8 +388,8 @@ where
 
     fn update(
         &mut self,
-        module_id: CrateModuleId,
-        import: Option<raw::ImportId>,
+        module_id: LocalModuleId,
+        import: Option<LocalImportId>,
         resolutions: &[(Name, Resolution)],
     ) {
         self.update_recursive(module_id, import, resolutions, 0)
@@ -396,8 +397,8 @@ where
 
     fn update_recursive(
         &mut self,
-        module_id: CrateModuleId,
-        import: Option<raw::ImportId>,
+        module_id: LocalModuleId,
+        import: Option<LocalImportId>,
         resolutions: &[(Name, Resolution)],
         depth: usize,
     ) {
@@ -484,7 +485,7 @@ where
 
     fn collect_macro_expansion(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         macro_call_id: MacroCallId,
         macro_def_id: MacroDefId,
     ) {
@@ -522,7 +523,7 @@ where
 /// Walks a single module, populating defs, imports and macros
 struct ModCollector<'a, D> {
     def_collector: D,
-    module_id: CrateModuleId,
+    module_id: LocalModuleId,
     file_id: HirFileId,
     raw_items: &'a raw::RawItems,
     mod_dir: ModDir,
@@ -530,7 +531,7 @@ struct ModCollector<'a, D> {
 
 impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
 where
-    DB: DefDatabase2,
+    DB: DefDatabase,
 {
     fn collect(&mut self, items: &[raw::RawItem]) {
         // Note: don't assert that inserted value is fresh: it's simply not true
@@ -549,7 +550,7 @@ where
         // `#[macro_use] extern crate` is hoisted to imports macros before collecting
         // any other items.
         for item in items {
-            if self.is_cfg_enabled(item.attrs()) {
+            if self.is_cfg_enabled(&item.attrs) {
                 if let raw::RawItemKind::Import(import_id) = item.kind {
                     let import = self.raw_items[import_id].clone();
                     if import.is_extern_crate && import.is_macro_use {
@@ -560,10 +561,10 @@ where
         }
 
         for item in items {
-            if self.is_cfg_enabled(item.attrs()) {
+            if self.is_cfg_enabled(&item.attrs) {
                 match item.kind {
                     raw::RawItemKind::Module(m) => {
-                        self.collect_module(&self.raw_items[m], item.attrs())
+                        self.collect_module(&self.raw_items[m], &item.attrs)
                     }
                     raw::RawItemKind::Import(import_id) => self
                         .def_collector
@@ -585,9 +586,9 @@ where
         }
     }
 
-    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &[Attr]) {
+    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &Attrs) {
         let path_attr = self.path_attr(attrs);
-        let is_macro_use = self.is_macro_use(attrs);
+        let is_macro_use = attrs.has_atom("macro_use");
         match module {
             // inline module, just recurse
             raw::ModuleData::Definition { name, items, ast_id } => {
@@ -647,7 +648,7 @@ where
         name: Name,
         declaration: AstId<ast::Module>,
         definition: Option<FileId>,
-    ) -> CrateModuleId {
+    ) -> LocalModuleId {
         let modules = &mut self.def_collector.def_map.modules;
         let res = modules.alloc(ModuleData::default());
         modules[res].parent = Some(self.module_id);
@@ -772,24 +773,20 @@ where
         self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path));
     }
 
-    fn import_all_legacy_macros(&mut self, module_id: CrateModuleId) {
+    fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
         let macros = self.def_collector.def_map[module_id].scope.legacy_macros.clone();
         for (name, macro_) in macros {
             self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
         }
     }
 
-    fn is_cfg_enabled(&self, attrs: &[Attr]) -> bool {
+    fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
         attrs.iter().all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
     }
 
-    fn path_attr<'a>(&self, attrs: &'a [Attr]) -> Option<&'a SmolStr> {
+    fn path_attr<'a>(&self, attrs: &'a Attrs) -> Option<&'a SmolStr> {
         attrs.iter().find_map(|attr| attr.as_path())
     }
-
-    fn is_macro_use<'a>(&self, attrs: &'a [Attr]) -> bool {
-        attrs.iter().any(|attr| attr.is_simple_atom("macro_use"))
-    }
 }
 
 fn is_macro_rules(path: &Path) -> bool {
@@ -802,12 +799,12 @@ mod tests {
     use ra_db::{fixture::WithFixture, SourceDatabase};
     use rustc_hash::FxHashSet;
 
-    use crate::{db::DefDatabase2, test_db::TestDB};
+    use crate::{db::DefDatabase, test_db::TestDB};
 
     use super::*;
 
     fn do_collect_defs(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         def_map: CrateDefMap,
         monitor: MacroStackMonitor,
     ) -> CrateDefMap {
@@ -831,7 +828,7 @@ mod tests {
 
         let def_map = {
             let edition = db.crate_graph().edition(krate);
-            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
             let root = modules.alloc(ModuleData::default());
             CrateDefMap {
                 krate,
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index b3b1379d0..14fb8ba3a 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -3,7 +3,7 @@ use hir_expand::name::Name;
 use ra_db::{FileId, RelativePathBuf};
 use ra_syntax::SmolStr;
 
-use crate::{db::DefDatabase2, HirFileId};
+use crate::{db::DefDatabase, HirFileId};
 
 #[derive(Clone, Debug)]
 pub(super) struct ModDir {
@@ -40,7 +40,7 @@ impl ModDir {
 
     pub(super) fn resolve_declaration(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         file_id: HirFileId,
         name: &Name,
         attr_path: Option<&SmolStr>,
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 95692f826..9455f22bb 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -15,10 +15,11 @@ use ra_db::Edition;
 use test_utils::tested_by;
 
 use crate::{
-    db::DefDatabase2,
-    nameres::{per_ns::PerNs, CrateDefMap},
+    db::DefDatabase,
+    nameres::CrateDefMap,
     path::{Path, PathKind},
-    AdtId, CrateModuleId, EnumVariantId, ModuleDefId, ModuleId,
+    per_ns::PerNs,
+    AdtId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -63,9 +64,9 @@ impl CrateDefMap {
     // the result.
     pub(super) fn resolve_path_fp_with_macro(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         mode: ResolveMode,
-        original_module: CrateModuleId,
+        original_module: LocalModuleId,
         path: &Path,
     ) -> ResolvePathResult {
         let mut segments = path.segments.iter().enumerate();
@@ -216,8 +217,8 @@ impl CrateDefMap {
 
     fn resolve_name_in_module(
         &self,
-        db: &impl DefDatabase2,
-        module: CrateModuleId,
+        db: &impl DefDatabase,
+        module: LocalModuleId,
         name: &Name,
     ) -> PerNs {
         // Resolve in:
@@ -243,7 +244,7 @@ impl CrateDefMap {
         from_crate_root.or(from_extern_prelude)
     }
 
-    fn resolve_in_prelude(&self, db: &impl DefDatabase2, name: &Name) -> PerNs {
+    fn resolve_in_prelude(&self, db: &impl DefDatabase, name: &Name) -> PerNs {
         if let Some(prelude) = self.prelude {
             let keep;
             let def_map = if prelude.krate == self.krate {
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 7c68fd638..552cbe544 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -12,11 +12,16 @@ use hir_expand::{
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SourceFile,
+    AstNode, AstPtr,
 };
 use test_utils::tested_by;
 
-use crate::{attr::Attr, db::DefDatabase2, path::Path, FileAstId, HirFileId, ModuleSource, Source};
+use crate::{
+    attr::{Attr, Attrs},
+    db::DefDatabase,
+    path::Path,
+    FileAstId, HirFileId, LocalImportId, Source,
+};
 
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -25,7 +30,7 @@ use crate::{attr::Attr, db::DefDatabase2, path::Path, FileAstId, HirFileId, Modu
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct RawItems {
     modules: Arena<Module, ModuleData>,
-    imports: Arena<ImportId, ImportData>,
+    imports: Arena<LocalImportId, ImportData>,
     defs: Arena<Def, DefData>,
     macros: Arena<Macro, MacroData>,
     impls: Arena<Impl, ImplData>,
@@ -35,41 +40,31 @@ pub struct RawItems {
 
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, ImportSourcePtr>,
+    map: ArenaMap<LocalImportId, ImportSourcePtr>,
 }
 
 type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-type ImportSource = Either<ast::UseTree, ast::ExternCrateItem>;
-
-fn to_node(ptr: ImportSourcePtr, file: &SourceFile) -> ImportSource {
-    ptr.map(|ptr| ptr.to_node(file.syntax()), |ptr| ptr.to_node(file.syntax()))
-}
 
 impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, ptr: ImportSourcePtr) {
+    fn insert(&mut self, import: LocalImportId, ptr: ImportSourcePtr) {
         self.map.insert(import, ptr)
     }
 
-    pub fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource {
-        let file = match source {
-            ModuleSource::SourceFile(file) => file.clone(),
-            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
-        };
-
-        to_node(self.map[import], &file)
+    pub fn get(&self, import: LocalImportId) -> ImportSourcePtr {
+        self.map[import].clone()
     }
 }
 
 impl RawItems {
     pub(crate) fn raw_items_query(
-        db: &(impl DefDatabase2 + AstDatabase),
+        db: &(impl DefDatabase + AstDatabase),
         file_id: HirFileId,
     ) -> Arc<RawItems> {
         db.raw_items_with_source_map(file_id).0
     }
 
     pub(crate) fn raw_items_with_source_map_query(
-        db: &(impl DefDatabase2 + AstDatabase),
+        db: &(impl DefDatabase + AstDatabase),
         file_id: HirFileId,
     ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
         let mut collector = RawItemsCollector {
@@ -101,9 +96,9 @@ impl Index<Module> for RawItems {
     }
 }
 
-impl Index<ImportId> for RawItems {
+impl Index<LocalImportId> for RawItems {
     type Output = ImportData;
-    fn index(&self, idx: ImportId) -> &ImportData {
+    fn index(&self, idx: LocalImportId) -> &ImportData {
         &self.imports[idx]
     }
 }
@@ -129,25 +124,16 @@ impl Index<Impl> for RawItems {
     }
 }
 
-// Avoid heap allocation on items without attributes.
-type Attrs = Option<Arc<[Attr]>>;
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub(super) struct RawItem {
-    attrs: Attrs,
+    pub(super) attrs: Attrs,
     pub(super) kind: RawItemKind,
 }
 
-impl RawItem {
-    pub(super) fn attrs(&self) -> &[Attr] {
-        self.attrs.as_ref().map_or(&[], |it| &*it)
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub(super) enum RawItemKind {
     Module(Module),
-    Import(ImportId),
+    Import(LocalImportId),
     Def(Def),
     Macro(Macro),
     Impl(Impl),
@@ -163,10 +149,6 @@ pub(super) enum ModuleData {
     Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImportId(RawId);
-impl_arena_id!(ImportId);
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportData {
     pub(super) path: Path,
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 256f7d4be..f0b86af7c 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -10,7 +10,7 @@ use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, SourceDatabase};
 use test_utils::covers;
 
-use crate::{db::DefDatabase2, nameres::*, test_db::TestDB, CrateModuleId};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
 
 fn def_map(fixtute: &str) -> String {
     let dm = compute_crate_def_map(fixtute);
@@ -28,7 +28,7 @@ fn render_crate_def_map(map: &CrateDefMap) -> String {
     go(&mut buf, map, "\ncrate", map.root());
     return buf.trim().to_string();
 
-    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
         *buf += path;
         *buf += "\n";
 
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index eb7b85c07..e11530062 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -665,7 +665,7 @@ fn unresolved_module_diagnostics() {
         @r###"
     [
         UnresolvedModule {
-            module: CrateModuleId(
+            module: LocalModuleId(
                 0,
             ),
             declaration: AstId {
diff --git a/crates/ra_hir_def/src/nameres/per_ns.rs b/crates/ra_hir_def/src/per_ns.rs
index 717ed1ef9..717ed1ef9 100644
--- a/crates/ra_hir_def/src/nameres/per_ns.rs
+++ b/crates/ra_hir_def/src/per_ns.rs
diff --git a/crates/ra_hir_def/src/resolver.rs b/crates/ra_hir_def/src/resolver.rs
index 7b5c3ec06..b56de44dd 100644
--- a/crates/ra_hir_def/src/resolver.rs
+++ b/crates/ra_hir_def/src/resolver.rs
@@ -11,14 +11,15 @@ use rustc_hash::FxHashSet;
 use crate::{
     body::scope::{ExprScopes, ScopeId},
     builtin_type::BuiltinType,
-    db::DefDatabase2,
+    db::DefDatabase,
     expr::{ExprId, PatId},
     generics::GenericParams,
-    nameres::{per_ns::PerNs, CrateDefMap},
+    nameres::CrateDefMap,
     path::{Path, PathKind},
-    AdtId, AstItemDef, ConstId, ContainerId, CrateModuleId, DefWithBodyId, EnumId, EnumVariantId,
-    FunctionId, GenericDefId, ImplId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId,
-    TypeAliasId,
+    per_ns::PerNs,
+    AdtId, AstItemDef, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
+    GenericDefId, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId,
+    TraitId, TypeAliasId,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -30,7 +31,7 @@ pub struct Resolver {
 #[derive(Debug, Clone)]
 pub(crate) struct ModuleItemMap {
     crate_def_map: Arc<CrateDefMap>,
-    module_id: CrateModuleId,
+    module_id: LocalModuleId,
 }
 
 #[derive(Debug, Clone)]
@@ -87,7 +88,7 @@ pub enum ValueNs {
 
 impl Resolver {
     /// Resolve known trait from std, like `std::futures::Future`
-    pub fn resolve_known_trait(&self, db: &impl DefDatabase2, path: &Path) -> Option<TraitId> {
+    pub fn resolve_known_trait(&self, db: &impl DefDatabase, path: &Path) -> Option<TraitId> {
         let res = self.resolve_module_path(db, path).take_types()?;
         match res {
             ModuleDefId::TraitId(it) => Some(it),
@@ -96,7 +97,7 @@ impl Resolver {
     }
 
     /// Resolve known struct from std, like `std::boxed::Box`
-    pub fn resolve_known_struct(&self, db: &impl DefDatabase2, path: &Path) -> Option<StructId> {
+    pub fn resolve_known_struct(&self, db: &impl DefDatabase, path: &Path) -> Option<StructId> {
         let res = self.resolve_module_path(db, path).take_types()?;
         match res {
             ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it),
@@ -105,7 +106,7 @@ impl Resolver {
     }
 
     /// Resolve known enum from std, like `std::result::Result`
-    pub fn resolve_known_enum(&self, db: &impl DefDatabase2, path: &Path) -> Option<EnumId> {
+    pub fn resolve_known_enum(&self, db: &impl DefDatabase, path: &Path) -> Option<EnumId> {
         let res = self.resolve_module_path(db, path).take_types()?;
         match res {
             ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it),
@@ -114,7 +115,7 @@ impl Resolver {
     }
 
     /// pub only for source-binder
-    pub fn resolve_module_path(&self, db: &impl DefDatabase2, path: &Path) -> PerNs {
+    pub fn resolve_module_path(&self, db: &impl DefDatabase, path: &Path) -> PerNs {
         let (item_map, module) = match self.module() {
             Some(it) => it,
             None => return PerNs::none(),
@@ -128,7 +129,7 @@ impl Resolver {
 
     pub fn resolve_path_in_type_ns(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         path: &Path,
     ) -> Option<(TypeNs, Option<usize>)> {
         if path.is_type_relative() {
@@ -184,7 +185,7 @@ impl Resolver {
 
     pub fn resolve_path_in_type_ns_fully(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         path: &Path,
     ) -> Option<TypeNs> {
         let (res, unresolved) = self.resolve_path_in_type_ns(db, path)?;
@@ -196,7 +197,7 @@ impl Resolver {
 
     pub fn resolve_path_in_value_ns<'p>(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         path: &'p Path,
     ) -> Option<ResolveValueResult> {
         if path.is_type_relative() {
@@ -296,7 +297,7 @@ impl Resolver {
 
     pub fn resolve_path_in_value_ns_fully(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         path: &Path,
     ) -> Option<ValueNs> {
         match self.resolve_path_in_value_ns(db, path)? {
@@ -305,18 +306,18 @@ impl Resolver {
         }
     }
 
-    pub fn resolve_path_as_macro(&self, db: &impl DefDatabase2, path: &Path) -> Option<MacroDefId> {
+    pub fn resolve_path_as_macro(&self, db: &impl DefDatabase, path: &Path) -> Option<MacroDefId> {
         let (item_map, module) = self.module()?;
         item_map.resolve_path(db, module, path).0.get_macros()
     }
 
-    pub fn process_all_names(&self, db: &impl DefDatabase2, f: &mut dyn FnMut(Name, ScopeDef)) {
+    pub fn process_all_names(&self, db: &impl DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
         for scope in self.scopes.iter().rev() {
             scope.process_names(db, f);
         }
     }
 
-    pub fn traits_in_scope(&self, db: &impl DefDatabase2) -> FxHashSet<TraitId> {
+    pub fn traits_in_scope(&self, db: &impl DefDatabase) -> FxHashSet<TraitId> {
         let mut traits = FxHashSet::default();
         for scope in &self.scopes {
             if let Scope::ModuleScope(m) = scope {
@@ -330,7 +331,7 @@ impl Resolver {
         traits
     }
 
-    fn module(&self) -> Option<(&CrateDefMap, CrateModuleId)> {
+    fn module(&self) -> Option<(&CrateDefMap, LocalModuleId)> {
         self.scopes.iter().rev().find_map(|scope| match scope {
             Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
 
@@ -378,7 +379,7 @@ pub enum ScopeDef {
 }
 
 impl Scope {
-    fn process_names(&self, db: &impl DefDatabase2, f: &mut dyn FnMut(Name, ScopeDef)) {
+    fn process_names(&self, db: &impl DefDatabase, f: &mut dyn FnMut(Name, ScopeDef)) {
         match self {
             Scope::ModuleScope(m) => {
                 // FIXME: should we provide `self` here?
@@ -425,17 +426,13 @@ impl Scope {
 }
 
 // needs arbitrary_self_types to be a method... or maybe move to the def?
-pub fn resolver_for_expr(
-    db: &impl DefDatabase2,
-    owner: DefWithBodyId,
-    expr_id: ExprId,
-) -> Resolver {
+pub fn resolver_for_expr(db: &impl DefDatabase, owner: DefWithBodyId, expr_id: ExprId) -> Resolver {
     let scopes = db.expr_scopes(owner);
     resolver_for_scope(db, owner, scopes.scope_for(expr_id))
 }
 
 pub fn resolver_for_scope(
-    db: &impl DefDatabase2,
+    db: &impl DefDatabase,
     owner: DefWithBodyId,
     scope_id: Option<ScopeId>,
 ) -> Resolver {
@@ -454,7 +451,7 @@ impl Resolver {
         self
     }
 
-    fn push_generic_params_scope(self, db: &impl DefDatabase2, def: GenericDefId) -> Resolver {
+    fn push_generic_params_scope(self, db: &impl DefDatabase, def: GenericDefId) -> Resolver {
         let params = db.generic_params(def);
         if params.params.is_empty() {
             self
@@ -470,7 +467,7 @@ impl Resolver {
     fn push_module_scope(
         self,
         crate_def_map: Arc<CrateDefMap>,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
     ) -> Resolver {
         self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
     }
@@ -487,24 +484,24 @@ impl Resolver {
 
 pub trait HasResolver {
     /// Builds a resolver for type references inside this def.
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver;
+    fn resolver(self, db: &impl DefDatabase) -> Resolver;
 }
 
 impl HasResolver for ModuleId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         let def_map = db.crate_def_map(self.krate);
         Resolver::default().push_module_scope(def_map, self.module_id)
     }
 }
 
 impl HasResolver for TraitId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.module(db).resolver(db).push_generic_params_scope(db, self.into())
     }
 }
 
 impl<T: Into<AdtId>> HasResolver for T {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         let def = self.into();
         let module = match def {
             AdtId::StructId(it) => it.0.module(db),
@@ -520,13 +517,13 @@ impl<T: Into<AdtId>> HasResolver for T {
 }
 
 impl HasResolver for FunctionId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
     }
 }
 
 impl HasResolver for DefWithBodyId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         match self {
             DefWithBodyId::ConstId(c) => c.resolver(db),
             DefWithBodyId::FunctionId(f) => f.resolver(db),
@@ -536,25 +533,25 @@ impl HasResolver for DefWithBodyId {
 }
 
 impl HasResolver for ConstId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.lookup(db).container.resolver(db)
     }
 }
 
 impl HasResolver for StaticId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.module(db).resolver(db)
     }
 }
 
 impl HasResolver for TypeAliasId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.lookup(db).container.resolver(db).push_generic_params_scope(db, self.into())
     }
 }
 
 impl HasResolver for ContainerId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         match self {
             ContainerId::TraitId(it) => it.resolver(db),
             ContainerId::ImplId(it) => it.resolver(db),
@@ -564,7 +561,7 @@ impl HasResolver for ContainerId {
 }
 
 impl HasResolver for GenericDefId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         match self {
             GenericDefId::FunctionId(inner) => inner.resolver(db),
             GenericDefId::AdtId(adt) => adt.resolver(db),
@@ -578,7 +575,7 @@ impl HasResolver for GenericDefId {
 }
 
 impl HasResolver for ImplId {
-    fn resolver(self, db: &impl DefDatabase2) -> Resolver {
+    fn resolver(self, db: &impl DefDatabase) -> Resolver {
         self.module(db)
             .resolver(db)
             .push_generic_params_scope(db, self.into())
diff --git a/crates/ra_hir_def/src/test_db.rs b/crates/ra_hir_def/src/test_db.rs
index 8ee8e40d0..439e8a412 100644
--- a/crates/ra_hir_def/src/test_db.rs
+++ b/crates/ra_hir_def/src/test_db.rs
@@ -12,7 +12,7 @@ use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath
     ra_db::SourceDatabaseStorage,
     hir_expand::db::AstDatabaseStorage,
     crate::db::InternDatabaseStorage,
-    crate::db::DefDatabase2Storage
+    crate::db::DefDatabaseStorage
 )]
 #[derive(Debug, Default)]
 pub struct TestDB {
diff --git a/crates/ra_hir_def/src/trace.rs b/crates/ra_hir_def/src/trace.rs
new file mode 100644
index 000000000..fc26f5a48
--- /dev/null
+++ b/crates/ra_hir_def/src/trace.rs
@@ -0,0 +1,49 @@
+//! Trace is a pretty niche data structure which is used when lowering a CST
+//! into HIR.
+//!
+//! Lowering process calculates two bits of information:
+//! * the lowered syntax itself
+//! * a mapping between lowered syntax and original syntax
+//!
+//! Due to the way salsa works, the mapping is usually hot lava, as it contains
+//! absolute offsets. The `Trace` structure (inspired, at least in name, by
+//! Kotlin's `BindingTrace`) allows use the same code to compute both
+//! projections.
+use ra_arena::{map::ArenaMap, Arena, ArenaId, RawId};
+
+pub(crate) struct Trace<ID: ArenaId, T, V> {
+    for_arena: bool,
+    arena: Arena<ID, T>,
+    map: ArenaMap<ID, V>,
+    len: u32,
+}
+
+impl<ID: ra_arena::ArenaId, T, V> Trace<ID, T, V> {
+    pub(crate) fn new_for_arena() -> Trace<ID, T, V> {
+        Trace { for_arena: true, arena: Arena::default(), map: ArenaMap::default(), len: 0 }
+    }
+
+    pub(crate) fn new_for_map() -> Trace<ID, T, V> {
+        Trace { for_arena: false, arena: Arena::default(), map: ArenaMap::default(), len: 0 }
+    }
+
+    pub(crate) fn alloc(&mut self, value: impl Fn() -> V, data: impl Fn() -> T) {
+        if self.for_arena {
+            self.arena.alloc(data());
+        } else {
+            let id = ID::from_raw(RawId::from(self.len));
+            self.len += 1;
+            self.map.insert(id, value());
+        }
+    }
+
+    pub(crate) fn into_arena(self) -> Arena<ID, T> {
+        assert!(self.for_arena);
+        self.arena
+    }
+
+    pub(crate) fn into_map(self) -> ArenaMap<ID, V> {
+        assert!(!self.for_arena);
+        self.map
+    }
+}
diff --git a/crates/ra_hir_def/src/traits.rs b/crates/ra_hir_def/src/traits.rs
deleted file mode 100644
index 6c2d5b2a9..000000000
--- a/crates/ra_hir_def/src/traits.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! HIR for trait definitions.
-
-use std::sync::Arc;
-
-use hir_expand::{
-    name::{AsName, Name},
-    AstId,
-};
-
-use ra_syntax::ast::{self, NameOwner};
-
-use crate::{
-    db::DefDatabase2, AssocItemId, AstItemDef, ConstLoc, ContainerId, FunctionLoc, Intern, TraitId,
-    TypeAliasId, TypeAliasLoc,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct TraitData {
-    pub name: Option<Name>,
-    pub items: Vec<AssocItemId>,
-    pub auto: bool,
-}
-
-impl TraitData {
-    pub(crate) fn trait_data_query(db: &impl DefDatabase2, tr: TraitId) -> Arc<TraitData> {
-        let src = tr.source(db);
-        let name = src.value.name().map(|n| n.as_name());
-        let auto = src.value.is_auto();
-        let ast_id_map = db.ast_id_map(src.file_id);
-        let items = if let Some(item_list) = src.value.item_list() {
-            item_list
-                .impl_items()
-                .map(|item_node| match item_node {
-                    ast::ImplItem::FnDef(it) => FunctionLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                    }
-                    .intern(db)
-                    .into(),
-                    ast::ImplItem::ConstDef(it) => ConstLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                    }
-                    .intern(db)
-                    .into(),
-                    ast::ImplItem::TypeAliasDef(it) => TypeAliasLoc {
-                        container: ContainerId::TraitId(tr),
-                        ast_id: AstId::new(src.file_id, ast_id_map.ast_id(&it)),
-                    }
-                    .intern(db)
-                    .into(),
-                })
-                .collect()
-        } else {
-            Vec::new()
-        };
-        Arc::new(TraitData { name, items, auto })
-    }
-
-    pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
-        self.items.iter().filter_map(|item| match item {
-            AssocItemId::TypeAliasId(t) => Some(*t),
-            _ => None,
-        })
-    }
-}
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index 97fb0cb55..c0e0436c0 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -8,35 +8,47 @@ use crate::{
 
 use crate::quote;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum BuiltinExpander {
-    Line,
-}
+macro_rules! register_builtin {
+    ( $(($name:ident, $kind: ident) => $expand:ident),* ) => {
+        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+        pub enum BuiltinFnLikeExpander {
+            $($kind),*
+        }
 
-impl BuiltinExpander {
-    pub fn expand(
-        &self,
-        db: &dyn AstDatabase,
-        id: MacroCallId,
-        tt: &tt::Subtree,
-    ) -> Result<tt::Subtree, mbe::ExpandError> {
-        match self {
-            BuiltinExpander::Line => line_expand(db, id, tt),
+        impl BuiltinFnLikeExpander {
+            pub fn expand(
+                &self,
+                db: &dyn AstDatabase,
+                id: MacroCallId,
+                tt: &tt::Subtree,
+            ) -> Result<tt::Subtree, mbe::ExpandError> {
+                let expander = match *self {
+                    $( BuiltinFnLikeExpander::$kind => $expand, )*
+                };
+                expander(db, id, tt)
+            }
         }
-    }
+
+        pub fn find_builtin_macro(
+            ident: &name::Name,
+            krate: CrateId,
+            ast_id: AstId<ast::MacroCall>,
+        ) -> Option<MacroDefId> {
+            let kind = match ident {
+                 $( id if id == &name::$name => BuiltinFnLikeExpander::$kind, )*
+                 _ => return None,
+            };
+
+            Some(MacroDefId { krate, ast_id, kind: MacroDefKind::BuiltIn(kind) })
+        }
+    };
 }
 
-pub fn find_builtin_macro(
-    ident: &name::Name,
-    krate: CrateId,
-    ast_id: AstId<ast::MacroCall>,
-) -> Option<MacroDefId> {
-    // FIXME: Better registering method
-    if ident == &name::LINE_MACRO {
-        Some(MacroDefId { krate, ast_id, kind: MacroDefKind::BuiltIn(BuiltinExpander::Line) })
-    } else {
-        None
-    }
+register_builtin! {
+    (COLUMN_MACRO, Column) => column_expand,
+    (FILE_MACRO, File) => file_expand,
+    (LINE_MACRO, Line) => line_expand,
+    (STRINGIFY_MACRO, Stringify) => stringify_expand
 }
 
 fn to_line_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
@@ -78,3 +90,173 @@ fn line_expand(
 
     Ok(expanded)
 }
+
+fn stringify_expand(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+    _tt: &tt::Subtree,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+    let loc = db.lookup_intern_macro(id);
+    let macro_call = loc.ast_id.to_node(db);
+
+    let macro_content = {
+        let arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+        let macro_args = arg.syntax().clone();
+        let text = macro_args.text();
+        let without_parens = TextUnit::of_char('(')..text.len() - TextUnit::of_char(')');
+        text.slice(without_parens).to_string()
+    };
+
+    let expanded = quote! {
+        #macro_content
+    };
+
+    Ok(expanded)
+}
+
+fn to_col_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
+    // FIXME: Use expansion info
+    let file_id = file.original_file(db);
+    let text = db.file_text(file_id);
+    let mut col_num = 1;
+
+    for c in text[..pos.to_usize()].chars().rev() {
+        if c == '\n' {
+            break;
+        }
+        col_num = col_num + 1;
+    }
+
+    col_num
+}
+
+fn column_expand(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+    _tt: &tt::Subtree,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+    let loc = db.lookup_intern_macro(id);
+    let macro_call = loc.ast_id.to_node(db);
+
+    let _arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+    let col_start = macro_call.syntax().text_range().start();
+
+    let file = id.as_file(MacroFileKind::Expr);
+    let col_num = to_col_number(db, file, col_start);
+
+    let expanded = quote! {
+        #col_num
+    };
+
+    Ok(expanded)
+}
+
+fn file_expand(
+    db: &dyn AstDatabase,
+    id: MacroCallId,
+    _tt: &tt::Subtree,
+) -> Result<tt::Subtree, mbe::ExpandError> {
+    let loc = db.lookup_intern_macro(id);
+    let macro_call = loc.ast_id.to_node(db);
+
+    let _ = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
+
+    // FIXME: RA purposefully lacks knowledge of absolute file names
+    // so just return "".
+    let file_name = "";
+
+    let expanded = quote! {
+        #file_name
+    };
+
+    Ok(expanded)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{test_db::TestDB, MacroCallLoc};
+    use ra_db::{fixture::WithFixture, SourceDatabase};
+
+    fn expand_builtin_macro(s: &str, expander: BuiltinFnLikeExpander) -> String {
+        let (db, file_id) = TestDB::with_single_file(&s);
+        let parsed = db.parse(file_id);
+        let macro_calls: Vec<_> =
+            parsed.syntax_node().descendants().filter_map(|it| ast::MacroCall::cast(it)).collect();
+
+        let ast_id_map = db.ast_id_map(file_id.into());
+
+        // the first one should be a macro_rules
+        let def = MacroDefId {
+            krate: CrateId(0),
+            ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[0])),
+            kind: MacroDefKind::BuiltIn(expander),
+        };
+
+        let loc = MacroCallLoc {
+            def,
+            ast_id: AstId::new(file_id.into(), ast_id_map.ast_id(&macro_calls[1])),
+        };
+
+        let id = db.intern_macro(loc);
+        let parsed = db.parse_or_expand(id.as_file(MacroFileKind::Expr)).unwrap();
+
+        parsed.text().to_string()
+    }
+
+    #[test]
+    fn test_column_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+        #[rustc_builtin_macro]
+        macro_rules! column {() => {}}
+        column!()
+"#,
+            BuiltinFnLikeExpander::Column,
+        );
+
+        assert_eq!(expanded, "9");
+    }
+
+    #[test]
+    fn test_line_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+        #[rustc_builtin_macro]
+        macro_rules! line {() => {}}
+        line!()
+"#,
+            BuiltinFnLikeExpander::Line,
+        );
+
+        assert_eq!(expanded, "4");
+    }
+
+    #[test]
+    fn test_stringify_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+        #[rustc_builtin_macro]
+        macro_rules! stringify {() => {}}
+        stringify!(a b c)
+"#,
+            BuiltinFnLikeExpander::Stringify,
+        );
+
+        assert_eq!(expanded, "\"a b c\"");
+    }
+
+    #[test]
+    fn test_file_expand() {
+        let expanded = expand_builtin_macro(
+            r#"
+        #[rustc_builtin_macro]
+        macro_rules! file {() => {}}
+        file!()
+"#,
+            BuiltinFnLikeExpander::File,
+        );
+
+        assert_eq!(expanded, "\"\"");
+    }
+}
diff --git a/crates/ra_hir_expand/src/db.rs b/crates/ra_hir_expand/src/db.rs
index 3c11c8a22..8e46fa177 100644
--- a/crates/ra_hir_expand/src/db.rs
+++ b/crates/ra_hir_expand/src/db.rs
@@ -9,14 +9,14 @@ use ra_prof::profile;
 use ra_syntax::{AstNode, Parse, SyntaxNode};
 
 use crate::{
-    ast_id_map::AstIdMap, BuiltinExpander, HirFileId, HirFileIdRepr, MacroCallId, MacroCallLoc,
-    MacroDefId, MacroDefKind, MacroFile, MacroFileKind,
+    ast_id_map::AstIdMap, BuiltinFnLikeExpander, HirFileId, HirFileIdRepr, MacroCallId,
+    MacroCallLoc, MacroDefId, MacroDefKind, MacroFile, MacroFileKind,
 };
 
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum TokenExpander {
     MacroRules(mbe::MacroRules),
-    Builtin(BuiltinExpander),
+    Builtin(BuiltinFnLikeExpander),
 }
 
 impl TokenExpander {
@@ -151,6 +151,7 @@ pub(crate) fn parse_macro(
     let fragment_kind = match macro_file.macro_file_kind {
         MacroFileKind::Items => FragmentKind::Items,
         MacroFileKind::Expr => FragmentKind::Expr,
+        MacroFileKind::Statements => FragmentKind::Statements,
     };
     let (parse, rev_token_map) = mbe::token_tree_to_syntax_node(&tt, fragment_kind).ok()?;
     Some((parse, Arc::new(rev_token_map)))
diff --git a/crates/ra_hir_expand/src/lib.rs b/crates/ra_hir_expand/src/lib.rs
index 1389f64ce..4f3ccf1d0 100644
--- a/crates/ra_hir_expand/src/lib.rs
+++ b/crates/ra_hir_expand/src/lib.rs
@@ -24,7 +24,10 @@ use ra_syntax::{
 };
 
 use crate::ast_id_map::FileAstId;
-use crate::builtin_macro::BuiltinExpander;
+use crate::builtin_macro::BuiltinFnLikeExpander;
+
+#[cfg(test)]
+mod test_db;
 
 /// Input to the analyzer is a set of files, where each file is identified by
 /// `FileId` and contains source code. However, another source of source code in
@@ -109,6 +112,7 @@ pub struct MacroFile {
 pub enum MacroFileKind {
     Items,
     Expr,
+    Statements,
 }
 
 /// `MacroCallId` identifies a particular macro invocation, like
@@ -134,7 +138,7 @@ pub struct MacroDefId {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum MacroDefKind {
     Declarative,
-    BuiltIn(BuiltinExpander),
+    BuiltIn(BuiltinFnLikeExpander),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_expand/src/name.rs b/crates/ra_hir_expand/src/name.rs
index 1bf17d12b..eaea7a6a8 100644
--- a/crates/ra_hir_expand/src/name.rs
+++ b/crates/ra_hir_expand/src/name.rs
@@ -142,4 +142,7 @@ pub const TARGET_TYPE: Name = Name::new_inline_ascii(6, b"Target");
 pub const BOX_TYPE: Name = Name::new_inline_ascii(3, b"Box");
 
 // Builtin Macros
+pub const FILE_MACRO: Name = Name::new_inline_ascii(4, b"file");
+pub const COLUMN_MACRO: Name = Name::new_inline_ascii(6, b"column");
 pub const LINE_MACRO: Name = Name::new_inline_ascii(4, b"line");
+pub const STRINGIFY_MACRO: Name = Name::new_inline_ascii(9, b"stringify");
diff --git a/crates/ra_hir_expand/src/test_db.rs b/crates/ra_hir_expand/src/test_db.rs
new file mode 100644
index 000000000..d23e75d9e
--- /dev/null
+++ b/crates/ra_hir_expand/src/test_db.rs
@@ -0,0 +1,50 @@
+//! Database used for testing `hir_expand`.
+
+use std::{
+    panic,
+    sync::{Arc, Mutex},
+};
+
+use ra_db::{salsa, CrateId, FileId, FileLoader, FileLoaderDelegate, RelativePath};
+
+#[salsa::database(
+    ra_db::SourceDatabaseExtStorage,
+    ra_db::SourceDatabaseStorage,
+    crate::db::AstDatabaseStorage
+)]
+#[derive(Debug, Default)]
+pub struct TestDB {
+    runtime: salsa::Runtime<TestDB>,
+    events: Mutex<Option<Vec<salsa::Event<TestDB>>>>,
+}
+
+impl salsa::Database for TestDB {
+    fn salsa_runtime(&self) -> &salsa::Runtime<Self> {
+        &self.runtime
+    }
+
+    fn salsa_event(&self, event: impl Fn() -> salsa::Event<TestDB>) {
+        let mut events = self.events.lock().unwrap();
+        if let Some(events) = &mut *events {
+            events.push(event());
+        }
+    }
+}
+
+impl panic::RefUnwindSafe for TestDB {}
+
+impl FileLoader for TestDB {
+    fn file_text(&self, file_id: FileId) -> Arc<String> {
+        FileLoaderDelegate(self).file_text(file_id)
+    }
+    fn resolve_relative_path(
+        &self,
+        anchor: FileId,
+        relative_path: &RelativePath,
+    ) -> Option<FileId> {
+        FileLoaderDelegate(self).resolve_relative_path(anchor, relative_path)
+    }
+    fn relevant_crates(&self, file_id: FileId) -> Arc<Vec<CrateId>> {
+        FileLoaderDelegate(self).relevant_crates(file_id)
+    }
+}
diff --git a/crates/ra_ide_api/src/call_info.rs b/crates/ra_ide_api/src/call_info.rs
index 41ee81511..7c367230e 100644
--- a/crates/ra_ide_api/src/call_info.rs
+++ b/crates/ra_ide_api/src/call_info.rs
@@ -30,7 +30,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
             let (callable_def, _subst) = analyzer.type_of(db, &expr.expr()?)?.as_callable()?;
             match callable_def {
                 hir::CallableDef::Function(it) => {
-                    (CallInfo::with_fn(db, it), it.data(db).has_self_param())
+                    (CallInfo::with_fn(db, it), it.has_self_param(db))
                 }
                 hir::CallableDef::Struct(it) => (CallInfo::with_struct(db, it)?, false),
                 hir::CallableDef::EnumVariant(it) => (CallInfo::with_enum_variant(db, it)?, false),
@@ -38,7 +38,7 @@ pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<Cal
         }
         FnCallNode::MethodCallExpr(expr) => {
             let function = analyzer.resolve_method_call(&expr)?;
-            (CallInfo::with_fn(db, function), function.data(db).has_self_param())
+            (CallInfo::with_fn(db, function), function.has_self_param(db))
         }
         FnCallNode::MacroCallExpr(expr) => {
             let macro_def = analyzer.resolve_macro_call(db, &expr)?;
diff --git a/crates/ra_ide_api/src/change.rs b/crates/ra_ide_api/src/change.rs
index 3c607d5b5..8a05b287f 100644
--- a/crates/ra_ide_api/src/change.rs
+++ b/crates/ra_ide_api/src/change.rs
@@ -313,7 +313,7 @@ impl RootDatabase {
             hir::db::RawItemsQuery
             hir::db::CrateDefMapQuery
             hir::db::GenericParamsQuery
-            hir::db::FnDataQuery
+            hir::db::FunctionDataQuery
             hir::db::TypeAliasDataQuery
             hir::db::ConstDataQuery
             hir::db::StaticDataQuery
diff --git a/crates/ra_ide_api/src/completion/complete_dot.rs b/crates/ra_ide_api/src/completion/complete_dot.rs
index 4e2c497e1..5a3f9b5f6 100644
--- a/crates/ra_ide_api/src/completion/complete_dot.rs
+++ b/crates/ra_ide_api/src/completion/complete_dot.rs
@@ -59,8 +59,7 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty)
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: Ty) {
     let mut seen_methods = FxHashSet::default();
     ctx.analyzer.iterate_method_candidates(ctx.db, receiver, None, |_ty, func| {
-        let data = func.data(ctx.db);
-        if data.has_self_param() && seen_methods.insert(data.name().clone()) {
+        if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
             acc.add_function(ctx, func);
         }
         None::<()>
diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs
index 5d974cf6d..63e25e0bf 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -1,6 +1,6 @@
 //! FIXME: write short doc here
 
-use hir::{Adt, Either, PathResolution};
+use hir::{Adt, Either, HasSource, PathResolution};
 use ra_syntax::AstNode;
 use test_utils::tested_by;
 
@@ -27,7 +27,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                 }
                 if Some(module) == ctx.module {
                     if let Some(import) = import {
-                        if let Either::A(use_tree) = module.import_source(ctx.db, import) {
+                        if let Either::A(use_tree) = import.source(ctx.db).value {
                             if use_tree.syntax().text_range().contains_inclusive(ctx.offset) {
                                 // for `use self::foo<|>`, don't suggest `foo` as a completion
                                 tested_by!(dont_complete_current_use);
@@ -53,8 +53,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
             ctx.analyzer.iterate_path_candidates(ctx.db, ty.clone(), None, |_ty, item| {
                 match item {
                     hir::AssocItem::Function(func) => {
-                        let data = func.data(ctx.db);
-                        if !data.has_self_param() {
+                        if !func.has_self_param(ctx.db) {
                             acc.add_function(ctx, func);
                         }
                     }
@@ -80,8 +79,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
             for item in t.items(ctx.db) {
                 match item {
                     hir::AssocItem::Function(func) => {
-                        let data = func.data(ctx.db);
-                        if !data.has_self_param() {
+                        if !func.has_self_param(ctx.db) {
                             acc.add_function(ctx, func);
                         }
                     }
diff --git a/crates/ra_ide_api/src/completion/presentation.rs b/crates/ra_ide_api/src/completion/presentation.rs
index b20329459..896ad1517 100644
--- a/crates/ra_ide_api/src/completion/presentation.rs
+++ b/crates/ra_ide_api/src/completion/presentation.rs
@@ -1,6 +1,6 @@
 //! This modules takes care of rendering various definitions as completion items.
 
-use hir::{db::HirDatabase, Attrs, Docs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
+use hir::{db::HirDatabase, Docs, HasAttrs, HasSource, HirDisplay, ScopeDef, Ty, TypeWalk};
 use join_to_string::join;
 use ra_syntax::ast::NameOwner;
 use test_utils::tested_by;
@@ -199,14 +199,17 @@ impl Completions {
         name: Option<String>,
         func: hir::Function,
     ) {
-        let data = func.data(ctx.db);
-        let name = name.unwrap_or_else(|| data.name().to_string());
+        let func_name = func.name(ctx.db);
+        let has_self_param = func.has_self_param(ctx.db);
+        let params = func.params(ctx.db);
+
+        let name = name.unwrap_or_else(|| func_name.to_string());
         let ast_node = func.source(ctx.db).value;
         let detail = function_label(&ast_node);
 
         let mut builder =
             CompletionItem::new(CompletionKind::Reference, ctx.source_range(), name.clone())
-                .kind(if data.has_self_param() {
+                .kind(if has_self_param {
                     CompletionItemKind::Method
                 } else {
                     CompletionItemKind::Function
@@ -221,12 +224,11 @@ impl Completions {
             && ctx.db.feature_flags.get("completion.insertion.add-call-parenthesis")
         {
             tested_by!(inserts_parens_for_function_calls);
-            let (snippet, label) =
-                if data.params().is_empty() || data.has_self_param() && data.params().len() == 1 {
-                    (format!("{}()$0", data.name()), format!("{}()", name))
-                } else {
-                    (format!("{}($0)", data.name()), format!("{}(…)", name))
-                };
+            let (snippet, label) = if params.is_empty() || has_self_param && params.len() == 1 {
+                (format!("{}()$0", func_name), format!("{}()", name))
+            } else {
+                (format!("{}($0)", func_name), format!("{}(…)", name))
+            };
             builder = builder.lookup_by(name).label(label).insert_snippet(snippet);
         }
 
@@ -285,11 +287,8 @@ impl Completions {
     }
 }
 
-fn is_deprecated(node: impl Attrs, db: &impl HirDatabase) -> bool {
-    match node.attrs(db) {
-        None => false,
-        Some(attrs) => attrs.iter().any(|x| x.is_simple_atom("deprecated")),
-    }
+fn is_deprecated(node: impl HasAttrs, db: &impl HirDatabase) -> bool {
+    node.attrs(db).has_atom("deprecated")
 }
 
 fn has_non_default_type_params(def: hir::GenericDef, db: &db::RootDatabase) -> bool {
diff --git a/crates/ra_ide_api/src/db.rs b/crates/ra_ide_api/src/db.rs
index c96465b6a..c2a9dcdd1 100644
--- a/crates/ra_ide_api/src/db.rs
+++ b/crates/ra_ide_api/src/db.rs
@@ -22,7 +22,6 @@ use crate::{
     hir::db::InternDatabaseStorage,
     hir::db::AstDatabaseStorage,
     hir::db::DefDatabaseStorage,
-    hir::db::DefDatabase2Storage,
     hir::db::HirDatabaseStorage
 )]
 #[derive(Debug)]
diff --git a/crates/ra_ide_api/src/display/function_signature.rs b/crates/ra_ide_api/src/display/function_signature.rs
index f42dffc87..d96de4e4c 100644
--- a/crates/ra_ide_api/src/display/function_signature.rs
+++ b/crates/ra_ide_api/src/display/function_signature.rs
@@ -55,7 +55,7 @@ impl FunctionSignature {
     pub(crate) fn from_struct(db: &db::RootDatabase, st: hir::Struct) -> Option<Self> {
         let node: ast::StructDef = st.source(db).value;
         match node.kind() {
-            ast::StructKind::Named(_) => return None,
+            ast::StructKind::Record(_) => return None,
             _ => (),
         };
 
@@ -89,7 +89,7 @@ impl FunctionSignature {
     ) -> Option<Self> {
         let node: ast::EnumVariant = variant.source(db).value;
         match node.kind() {
-            ast::StructKind::Named(_) | ast::StructKind::Unit => return None,
+            ast::StructKind::Record(_) | ast::StructKind::Unit => return None,
             _ => (),
         };
 
diff --git a/crates/ra_ide_api/src/expand_macro.rs b/crates/ra_ide_api/src/expand_macro.rs
index 7f39262dc..673301b10 100644
--- a/crates/ra_ide_api/src/expand_macro.rs
+++ b/crates/ra_ide_api/src/expand_macro.rs
@@ -40,7 +40,7 @@ fn expand_macro_recur(
     let analyzer = hir::SourceAnalyzer::new(db, source, None);
     let expansion = analyzer.expand(db, macro_call)?;
     let macro_file_id = expansion.file_id();
-    let expanded: SyntaxNode = db.parse_or_expand(macro_file_id)?;
+    let mut expanded: SyntaxNode = db.parse_or_expand(macro_file_id)?;
 
     let children = expanded.descendants().filter_map(ast::MacroCall::cast);
     let mut replaces = FxHashMap::default();
@@ -49,7 +49,14 @@ fn expand_macro_recur(
         let node = hir::Source::new(macro_file_id, &child);
         let new_node = expand_macro_recur(db, source, node)?;
 
-        replaces.insert(child.syntax().clone().into(), new_node.into());
+        // Replace the whole node if it is root
+        // `replace_descendants` will not replace the parent node
+        // but `SyntaxNode::descendants include itself
+        if expanded == *child.syntax() {
+            expanded = new_node;
+        } else {
+            replaces.insert(child.syntax().clone().into(), new_node.into());
+        }
     }
 
     Some(replace_descendants(&expanded, &replaces))
@@ -84,24 +91,19 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
         };
 
         res += &match token.kind() {
-            k @ _
-                if (k.is_keyword() || k.is_literal() || k == IDENT)
-                    && is_next(|it| !it.is_punct(), true) =>
-            {
+            k @ _ if is_text(k) && is_next(|it| !it.is_punct(), true) => {
                 token.text().to_string() + " "
             }
             L_CURLY if is_next(|it| it != R_CURLY, true) => {
                 indent += 1;
-                format!(" {{\n{}", "  ".repeat(indent))
+                let leading_space = if is_last(|it| is_text(it), false) { " " } else { "" };
+                format!("{}{{\n{}", leading_space, "  ".repeat(indent))
             }
             R_CURLY if is_last(|it| it != L_CURLY, true) => {
                 indent = indent.checked_sub(1).unwrap_or(0);
-                format!("\n}}{}", "  ".repeat(indent))
-            }
-            R_CURLY => {
-                indent = indent.checked_sub(1).unwrap_or(0);
-                format!("}}\n{}", "  ".repeat(indent))
+                format!("\n{}}}", "  ".repeat(indent))
             }
+            R_CURLY => format!("}}\n{}", "  ".repeat(indent)),
             T![;] => format!(";\n{}", "  ".repeat(indent)),
             T![->] => " -> ".to_string(),
             T![=] => " = ".to_string(),
@@ -112,7 +114,11 @@ fn insert_whitespaces(syn: SyntaxNode) -> String {
         last = Some(token.kind());
     }
 
-    res
+    return res;
+
+    fn is_text(k: SyntaxKind) -> bool {
+        k.is_keyword() || k.is_literal() || k == IDENT
+    }
 }
 
 #[cfg(test)]
@@ -175,4 +181,70 @@ fn some_thing() -> u32 {
 }
 "###);
     }
+
+    #[test]
+    fn macro_expand_match_ast() {
+        let res = check_expand_macro(
+            r#"
+        //- /lib.rs
+        macro_rules! match_ast {
+            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };
+        
+            (match ($node:expr) {
+                $( ast::$ast:ident($it:ident) => $res:block, )*
+                _ => $catch_all:expr $(,)?
+            }) => {{
+                $( if let Some($it) = ast::$ast::cast($node.clone()) $res else )*
+                { $catch_all }
+            }};
+        }        
+
+        fn main() {
+            mat<|>ch_ast! {
+                match container {
+                    ast::TraitDef(it) => {},
+                    ast::ImplBlock(it) => {},
+                    _ => { continue },
+                }
+            }
+        }
+        "#,
+        );
+
+        assert_eq!(res.name, "match_ast");
+        assert_snapshot!(res.expansion, @r###"
+{
+  if let Some(it) = ast::TraitDef::cast(container.clone()){}
+  else if let Some(it) = ast::ImplBlock::cast(container.clone()){}
+  else {
+    {
+      continue
+    }
+  }
+}
+"###);
+    }
+
+    #[test]
+    fn macro_expand_match_ast_inside_let_statement() {
+        let res = check_expand_macro(
+            r#"
+        //- /lib.rs
+        macro_rules! match_ast {
+            (match $node:ident { $($tt:tt)* }) => { match_ast!(match ($node) { $($tt)* }) };        
+            (match ($node:expr) {}) => {{}};
+        }        
+
+        fn main() {        
+            let p = f(|it| {
+                let res = mat<|>ch_ast! { match c {}};
+                Some(res)
+            })?;
+        }
+        "#,
+        );
+
+        assert_eq!(res.name, "match_ast");
+        assert_snapshot!(res.expansion, @r###"{}"###);
+    }
 }
diff --git a/crates/ra_ide_api/src/lib.rs b/crates/ra_ide_api/src/lib.rs
index 62ad996bc..cb6c24eaa 100644
--- a/crates/ra_ide_api/src/lib.rs
+++ b/crates/ra_ide_api/src/lib.rs
@@ -54,7 +54,7 @@ use std::sync::Arc;
 use ra_cfg::CfgOptions;
 use ra_db::{
     salsa::{self, ParallelDatabase},
-    CheckCanceled, FileLoader, SourceDatabase,
+    CheckCanceled, Env, FileLoader, SourceDatabase,
 };
 use ra_syntax::{SourceFile, TextRange, TextUnit};
 
@@ -240,7 +240,7 @@ impl Analysis {
         // Default to enable test for single file.
         let mut cfg_options = CfgOptions::default();
         cfg_options.insert_atom("test".into());
-        crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options);
+        crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options, Env::default());
         change.add_file(source_root, file_id, "main.rs".into(), Arc::new(text));
         change.set_crate_graph(crate_graph);
         host.apply_change(change);
diff --git a/crates/ra_ide_api/src/mock_analysis.rs b/crates/ra_ide_api/src/mock_analysis.rs
index 2b1c96dbf..bf8a54932 100644
--- a/crates/ra_ide_api/src/mock_analysis.rs
+++ b/crates/ra_ide_api/src/mock_analysis.rs
@@ -3,7 +3,7 @@
 use std::sync::Arc;
 
 use ra_cfg::CfgOptions;
-use ra_db::RelativePathBuf;
+use ra_db::{Env, RelativePathBuf};
 use test_utils::{extract_offset, extract_range, parse_fixture, CURSOR_MARKER};
 
 use crate::{
@@ -96,9 +96,15 @@ impl MockAnalysis {
             let file_id = FileId(i as u32 + 1);
             let cfg_options = CfgOptions::default();
             if path == "/lib.rs" || path == "/main.rs" {
-                root_crate = Some(crate_graph.add_crate_root(file_id, Edition2018, cfg_options));
+                root_crate = Some(crate_graph.add_crate_root(
+                    file_id,
+                    Edition2018,
+                    cfg_options,
+                    Env::default(),
+                ));
             } else if path.ends_with("/lib.rs") {
-                let other_crate = crate_graph.add_crate_root(file_id, Edition2018, cfg_options);
+                let other_crate =
+                    crate_graph.add_crate_root(file_id, Edition2018, cfg_options, Env::default());
                 let crate_name = path.parent().unwrap().file_name().unwrap();
                 if let Some(root_crate) = root_crate {
                     crate_graph.add_dep(root_crate, crate_name.into(), other_crate).unwrap();
diff --git a/crates/ra_ide_api/src/parent_module.rs b/crates/ra_ide_api/src/parent_module.rs
index fa232a379..6027e7d54 100644
--- a/crates/ra_ide_api/src/parent_module.rs
+++ b/crates/ra_ide_api/src/parent_module.rs
@@ -34,12 +34,14 @@ pub(crate) fn crate_for(db: &RootDatabase, file_id: FileId) -> Vec<CrateId> {
 
 #[cfg(test)]
 mod tests {
+    use ra_cfg::CfgOptions;
+    use ra_db::Env;
+
     use crate::{
         mock_analysis::{analysis_and_position, MockAnalysis},
         AnalysisChange, CrateGraph,
         Edition::Edition2018,
     };
-    use ra_cfg::CfgOptions;
 
     #[test]
     fn test_resolve_parent_module() {
@@ -87,7 +89,12 @@ mod tests {
         assert!(host.analysis().crate_for(mod_file).unwrap().is_empty());
 
         let mut crate_graph = CrateGraph::default();
-        let crate_id = crate_graph.add_crate_root(root_file, Edition2018, CfgOptions::default());
+        let crate_id = crate_graph.add_crate_root(
+            root_file,
+            Edition2018,
+            CfgOptions::default(),
+            Env::default(),
+        );
         let mut change = AnalysisChange::new();
         change.set_crate_graph(crate_graph);
         host.apply_change(change);
diff --git a/crates/ra_ide_api/src/typing.rs b/crates/ra_ide_api/src/typing.rs
index d51132f73..21e5be9b3 100644
--- a/crates/ra_ide_api/src/typing.rs
+++ b/crates/ra_ide_api/src/typing.rs
@@ -40,9 +40,13 @@ pub(crate) fn on_enter(db: &RootDatabase, position: FilePosition) -> Option<Sour
     }
 
     let prefix = comment.prefix();
-    if position.offset
-        < comment.syntax().text_range().start() + TextUnit::of_str(prefix) + TextUnit::from(1)
-    {
+    let comment_range = comment.syntax().text_range();
+    if position.offset < comment_range.start() + TextUnit::of_str(prefix) + TextUnit::from(1) {
+        return None;
+    }
+
+    // Continuing non-doc line comments (like this one :) ) is annoying
+    if prefix == "//" && comment_range.end() == position.offset {
         return None;
     }
 
@@ -247,6 +251,30 @@ impl S {
 }
 ",
         );
+        do_check(
+            r"
+fn main() {
+    // Fix<|> me
+    let x = 1 + 1;
+}
+",
+            r"
+fn main() {
+    // Fix
+    // <|> me
+    let x = 1 + 1;
+}
+",
+        );
+        do_check_noop(
+            r"
+fn main() {
+    // Fix me<|>
+    let x = 1 + 1;
+}
+",
+        );
+
         do_check_noop(r"<|>//! docz");
     }
 
diff --git a/crates/ra_lsp_server/src/lib.rs b/crates/ra_lsp_server/src/lib.rs
index 0e5dbbbd5..9c36402b0 100644
--- a/crates/ra_lsp_server/src/lib.rs
+++ b/crates/ra_lsp_server/src/lib.rs
@@ -1,6 +1,26 @@
-//! FIXME: write short doc here
-
+//! Implementation of the LSP for rust-analyzer.
+//!
+//! This crate takes Rust-specific analysis results from ra_ide_api and
+//! translates into LSP types.
+//!
+//! It also is the root of all state. `world` module defines the bulk of the
+//! state, and `main_loop` module defines the rules for modifying it.
 #![recursion_limit = "512"]
+
+#[allow(unused)]
+macro_rules! println {
+    ($($tt:tt)*) => {
+        compile_error!("stdout is locked, use eprintln")
+    };
+}
+
+#[allow(unused)]
+macro_rules! print {
+    ($($tt:tt)*) => {
+        compile_error!("stdout is locked, use eprint")
+    };
+}
+
 mod caps;
 mod cargo_target_spec;
 mod conv;
diff --git a/crates/ra_lsp_server/src/main.rs b/crates/ra_lsp_server/src/main.rs
index 7d9a1d054..e13c8ca14 100644
--- a/crates/ra_lsp_server/src/main.rs
+++ b/crates/ra_lsp_server/src/main.rs
@@ -1,8 +1,7 @@
-//! FIXME: write short doc here
+//! `ra_lsp_server` binary
 
 use flexi_logger::{Duplicate, Logger};
 use lsp_server::Connection;
-
 use ra_lsp_server::{show_message, Result, ServerConfig};
 use ra_prof;
 
diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs
index d1c49c0b3..1de399fee 100644
--- a/crates/ra_mbe/src/syntax_bridge.rs
+++ b/crates/ra_mbe/src/syntax_bridge.rs
@@ -5,6 +5,7 @@ use ra_syntax::{
     ast, AstNode, AstToken, NodeOrToken, Parse, SmolStr, SyntaxKind, SyntaxKind::*, SyntaxNode,
     SyntaxTreeBuilder, TextRange, TextUnit, T,
 };
+use std::iter::successors;
 use tt::buffer::{Cursor, TokenBuffer};
 
 use crate::subtree_source::SubtreeTokenSource;
@@ -160,6 +161,31 @@ impl Convertor {
 
         let first_child = tt.first_child_or_token()?;
         let last_child = tt.last_child_or_token()?;
+
+        // ignore trivial first_child and last_child
+        let first_child = successors(Some(first_child), |it| {
+            if it.kind().is_trivia() {
+                it.next_sibling_or_token()
+            } else {
+                None
+            }
+        })
+        .last()
+        .unwrap();
+        if first_child.kind().is_trivia() {
+            return Some(tt::Subtree { token_trees: vec![], delimiter: tt::Delimiter::None });
+        }
+
+        let last_child = successors(Some(last_child), |it| {
+            if it.kind().is_trivia() {
+                it.prev_sibling_or_token()
+            } else {
+                None
+            }
+        })
+        .last()
+        .unwrap();
+
         let (delimiter, skip_first) = match (first_child.kind(), last_child.kind()) {
             (T!['('], T![')']) => (tt::Delimiter::Parenthesis, true),
             (T!['{'], T!['}']) => (tt::Delimiter::Brace, true),
@@ -363,6 +389,7 @@ mod tests {
     use super::*;
     use crate::tests::{create_rules, expand};
     use ra_parser::TokenSource;
+    use ra_syntax::algo::{insert_children, InsertPosition};
 
     #[test]
     fn convert_tt_token_source() {
@@ -423,4 +450,45 @@ mod tests {
         let expansion = expand(&rules, "stmts!();");
         assert!(token_tree_to_syntax_node(&expansion, FragmentKind::Expr).is_err());
     }
+
+    #[test]
+    fn test_token_tree_last_child_is_white_space() {
+        let source_file = ast::SourceFile::parse("f!({} );").ok().unwrap();
+        let macro_call = source_file.syntax().descendants().find_map(ast::MacroCall::cast).unwrap();
+        let token_tree = macro_call.token_tree().unwrap();
+
+        // Token Tree now is :
+        // TokenTree
+        // - T!['(']
+        // - TokenTree
+        //   - T!['{']
+        //   - T!['}']
+        // - WHITE_SPACE
+        // - T![')']
+
+        let rbrace =
+            token_tree.syntax().descendants_with_tokens().find(|it| it.kind() == T!['}']).unwrap();
+        let space = token_tree
+            .syntax()
+            .descendants_with_tokens()
+            .find(|it| it.kind() == SyntaxKind::WHITESPACE)
+            .unwrap();
+
+        // reorder th white space, such that the white is inside the inner token-tree.
+        let token_tree = insert_children(
+            &rbrace.parent().unwrap(),
+            InsertPosition::Last,
+            &mut std::iter::once(space),
+        );
+
+        // Token Tree now is :
+        // TokenTree
+        // - T!['{']
+        // - T!['}']
+        // - WHITE_SPACE
+        let token_tree = ast::TokenTree::cast(token_tree).unwrap();
+        let tt = ast_to_token_tree(&token_tree).unwrap().0;
+
+        assert_eq!(tt.delimiter, tt::Delimiter::Brace);
+    }
 }
diff --git a/crates/ra_project_model/src/cargo_workspace.rs b/crates/ra_project_model/src/cargo_workspace.rs
index cf88911b7..c128e608d 100644
--- a/crates/ra_project_model/src/cargo_workspace.rs
+++ b/crates/ra_project_model/src/cargo_workspace.rs
@@ -1,7 +1,6 @@
 //! FIXME: write short doc here
 
 use std::path::{Path, PathBuf};
-use std::str::FromStr;
 
 use cargo_metadata::{CargoOpt, MetadataCommand};
 use ra_arena::{impl_arena_id, Arena, RawId};
@@ -143,8 +142,7 @@ impl CargoWorkspace {
         for meta_pkg in meta.packages {
             let cargo_metadata::Package { id, edition, name, manifest_path, .. } = meta_pkg;
             let is_member = ws_members.contains(&id);
-            let edition = Edition::from_str(&edition)
-                .map_err(|e| (format!("metadata for package {} failed: {}", &name, e.msg)))?;
+            let edition = edition.parse::<Edition>()?;
             let pkg = packages.alloc(PackageData {
                 name,
                 manifest: manifest_path,
diff --git a/crates/ra_project_model/src/lib.rs b/crates/ra_project_model/src/lib.rs
index 0e14f1b70..d04a8cbe2 100644
--- a/crates/ra_project_model/src/lib.rs
+++ b/crates/ra_project_model/src/lib.rs
@@ -13,7 +13,7 @@ use std::{
 };
 
 use ra_cfg::CfgOptions;
-use ra_db::{CrateGraph, CrateId, Edition, FileId};
+use ra_db::{CrateGraph, CrateId, Edition, Env, FileId};
 use rustc_hash::FxHashMap;
 use serde_json::from_reader;
 
@@ -146,7 +146,12 @@ impl ProjectWorkspace {
                         };
                         crates.insert(
                             crate_id,
-                            crate_graph.add_crate_root(file_id, edition, cfg_options),
+                            crate_graph.add_crate_root(
+                                file_id,
+                                edition,
+                                cfg_options,
+                                Env::default(),
+                            ),
                         );
                     }
                 }
@@ -180,8 +185,12 @@ impl ProjectWorkspace {
                             opts
                         };
 
-                        let crate_id =
-                            crate_graph.add_crate_root(file_id, Edition::Edition2018, cfg_options);
+                        let crate_id = crate_graph.add_crate_root(
+                            file_id,
+                            Edition::Edition2018,
+                            cfg_options,
+                            Env::default(),
+                        );
                         sysroot_crates.insert(krate, crate_id);
                         names.insert(crate_id, krate.name(&sysroot).to_string());
                     }
@@ -216,8 +225,12 @@ impl ProjectWorkspace {
                                 opts.insert_features(pkg.features(&cargo).iter().map(Into::into));
                                 opts
                             };
-                            let crate_id =
-                                crate_graph.add_crate_root(file_id, edition, cfg_options);
+                            let crate_id = crate_graph.add_crate_root(
+                                file_id,
+                                edition,
+                                cfg_options,
+                                Env::default(),
+                            );
                             names.insert(crate_id, pkg.name(&cargo).to_string());
                             if tgt.kind(&cargo) == TargetKind::Lib {
                                 lib_tgt = Some(crate_id);
diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs
index 4851dacb2..513ed7920 100644
--- a/crates/ra_syntax/src/ast/extensions.rs
+++ b/crates/ra_syntax/src/ast/extensions.rs
@@ -178,15 +178,15 @@ impl ast::ImplBlock {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum StructKind {
+    Record(ast::RecordFieldDefList),
     Tuple(ast::TupleFieldDefList),
-    Named(ast::RecordFieldDefList),
     Unit,
 }
 
 impl StructKind {
     fn from_node<N: AstNode>(node: &N) -> StructKind {
         if let Some(nfdl) = child_opt::<_, ast::RecordFieldDefList>(node) {
-            StructKind::Named(nfdl)
+            StructKind::Record(nfdl)
         } else if let Some(pfl) = child_opt::<_, ast::TupleFieldDefList>(node) {
             StructKind::Tuple(pfl)
         } else {