Merge branch 'master' into feature/themes

author: Seivan Heidari <[email protected]> 2019-10-31 08:43:20 +0000
committer: Seivan Heidari <[email protected]> 2019-10-31 08:43:20 +0000
commit: 8edda0e7b164009d6c03bb3d4be603fb38ad2e2a (patch)
tree: 744cf81075d394e2f9c06afb07642a2601800dda /crates/ra_hir
parent: 49562d36b97ddde34cf7585a8c2e8f232519b657 (diff)
parent: d067afb064a7fa67b172abf561b7d80740cd6f18 (diff)
43 files changed, 431 insertions, 2454 deletions
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
index 54c09788a..5df371bc0 100644
--- a/crates/ra_hir/Cargo.toml
+++ b/crates/ra_hir/Cargo.toml
@@ -19,12 +19,14 @@ ra_cfg = { path = "../ra_cfg" }
 ra_db = { path = "../ra_db" }
 mbe = { path = "../ra_mbe", package = "ra_mbe" }
 tt = { path = "../ra_tt", package = "ra_tt" }
+hir_expand = { path = "../ra_hir_expand", package = "ra_hir_expand" }
+hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
 test_utils = { path = "../test_utils" }
 ra_prof = { path = "../ra_prof" }
-chalk-solve = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" }
-chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" }
-chalk-ir = { git = "https://github.com/rust-lang/chalk.git" }
+chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" }
 lalrpop-intern = "0.15.1"
 [dev-dependencies]
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 3e9cd3c63..4fa2062bd 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -3,13 +3,14 @@
 use std::sync::Arc;
+use hir_def::{type_ref::TypeRef, LocalEnumVariantId};
+use hir_expand::name::AsName;
 use ra_arena::{impl_arena_id, Arena, RawId};
 use ra_syntax::ast::{self, NameOwner, StructKind, TypeAscriptionOwner};
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
-    type_ref::TypeRef,
+    Enum, EnumVariant, FieldSource, HasSource, Module, Name, Source, Struct, StructField,
-    AsName, Enum, EnumVariant, FieldSource, HasSource, Module, Name, Source, Struct, StructField,
 };
 impl Struct {
@@ -67,7 +68,7 @@ impl EnumVariant {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EnumData {
    pub(crate) name: Option<Name>,
-    pub(crate) variants: Arena<EnumVariantId, EnumVariantData>,
+    pub(crate) variants: Arena<LocalEnumVariantId, EnumVariantData>,
 }
 impl EnumData {
@@ -84,10 +85,6 @@ impl EnumData {
    }
 }
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct EnumVariantId(RawId);
-impl_arena_id!(EnumVariantId);
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct EnumVariantData {
    pub(crate) name: Option<Name>,
diff --git a/crates/ra_hir/src/attr.rs b/crates/ra_hir/src/attr.rs
deleted file mode 100644
index bd159a566..000000000
--- a/crates/ra_hir/src/attr.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//! A higher level attributes based on TokenTree, with also some shortcuts.
-use std::sync::Arc;
-use mbe::ast_to_token_tree;
-use ra_cfg::CfgOptions;
-use ra_syntax::{
-    ast::{self, AstNode, AttrsOwner},
-    SmolStr,
-};
-use tt::Subtree;
-use crate::{db::AstDatabase, path::Path, HirFileId, Source};
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct Attr {
-    pub(crate) path: Path,
-    pub(crate) input: Option<AttrInput>,
-}
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum AttrInput {
-    Literal(SmolStr),
-    TokenTree(Subtree),
-}
-impl Attr {
-    pub(crate) fn from_src(
-        Source { file_id, ast }: Source<ast::Attr>,
-        db: &impl AstDatabase,
-    ) -> Option<Attr> {
-        let path = Path::from_src(Source { file_id, ast: ast.path()? }, db)?;
-        let input = match ast.input() {
-            None => None,
-            Some(ast::AttrInput::Literal(lit)) => {
-                // FIXME: escape? raw string?
-                let value = lit.syntax().first_token()?.text().trim_matches('"').into();
-                Some(AttrInput::Literal(value))
-            }
-            Some(ast::AttrInput::TokenTree(tt)) => {
-                Some(AttrInput::TokenTree(ast_to_token_tree(&tt)?.0))
-            }
-        };
-        Some(Attr { path, input })
-    }
-    pub(crate) fn from_attrs_owner(
-        file_id: HirFileId,
-        owner: &dyn AttrsOwner,
-        db: &impl AstDatabase,
-    ) -> Option<Arc<[Attr]>> {
-        let mut attrs = owner.attrs().peekable();
-        if attrs.peek().is_none() {
-            // Avoid heap allocation
-            return None;
-        }
-        Some(attrs.flat_map(|ast| Attr::from_src(Source { file_id, ast }, db)).collect())
-    }
-    pub(crate) fn is_simple_atom(&self, name: &str) -> bool {
-        // FIXME: Avoid cloning
-        self.path.as_ident().map_or(false, |s| s.to_string() == name)
-    }
-    // FIXME: handle cfg_attr :-)
-    pub(crate) fn as_cfg(&self) -> Option<&Subtree> {
-        if !self.is_simple_atom("cfg") {
-            return None;
-        }
-        match &self.input {
-            Some(AttrInput::TokenTree(subtree)) => Some(subtree),
-            _ => None,
-        }
-    }
-    pub(crate) fn as_path(&self) -> Option<&SmolStr> {
-        if !self.is_simple_atom("path") {
-            return None;
-        }
-        match &self.input {
-            Some(AttrInput::Literal(it)) => Some(it),
-            _ => None,
-        }
-    }
-    pub(crate) fn is_cfg_enabled(&self, cfg_options: &CfgOptions) -> Option<bool> {
-        cfg_options.is_cfg_enabled(self.as_cfg()?)
-    }
-}
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 8eb3c577d..b32aa145e 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -5,11 +5,17 @@ pub(crate) mod docs;
 use std::sync::Arc;
-use ra_db::{CrateId, Edition, FileId};
+use hir_def::{
+    builtin_type::BuiltinType,
+    type_ref::{Mutability, TypeRef},
+    CrateModuleId, LocalEnumVariantId, ModuleId,
+};
+use hir_expand::name::{self, AsName};
+use ra_db::{CrateId, Edition};
 use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
 use crate::{
-    adt::{EnumVariantId, StructFieldId, VariantDef},
+    adt::{StructFieldId, VariantDef},
    db::{AstDatabase, DefDatabase, HirDatabase},
    diagnostics::DiagnosticSink,
    expr::{validation::ExprValidator, Body, BodySourceMap},
@@ -19,20 +25,11 @@ use crate::{
        TypeAliasId,
    },
    impl_block::ImplBlock,
-    name::{
+    nameres::{ImportId, ModuleScope, Namespace},
-        BOOL, CHAR, F32, F64, I128, I16, I32, I64, I8, ISIZE, SELF_TYPE, STR, U128, U16, U32, U64,
-        U8, USIZE,
-    },
-    nameres::{CrateModuleId, ImportId, ModuleScope, Namespace},
    resolve::{Resolver, Scope, TypeNs},
    traits::TraitData,
-    ty::{
+    ty::{InferenceResult, TraitRef},
-        primitive::{FloatBitness, FloatTy, IntBitness, IntTy, Signedness},
+    Either, HasSource, Name, Ty,
-        InferenceResult, TraitRef,
-    },
-    type_ref::Mutability,
-    type_ref::TypeRef,
-    AsName, AstId, Either, HasSource, Name, Ty,
 };
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -67,8 +64,7 @@ impl Crate {
    pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> {
        let module_id = db.crate_def_map(self).root();
-        let module = Module { krate: self, module_id };
+        Some(Module::new(self, module_id))
-        Some(module)
    }
    pub fn edition(self, db: &impl DefDatabase) -> Edition {
@@ -83,43 +79,7 @@ impl Crate {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
-    pub(crate) krate: Crate,
+    pub(crate) id: ModuleId,
-    pub(crate) module_id: CrateModuleId,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum BuiltinType {
-    Char,
-    Bool,
-    Str,
-    Int(IntTy),
-    Float(FloatTy),
-}
-impl BuiltinType {
-    #[rustfmt::skip]
-    pub(crate) const ALL: &'static [(Name, BuiltinType)] = &[
-        (CHAR, BuiltinType::Char),
-        (BOOL, BuiltinType::Bool),
-        (STR, BuiltinType::Str),
-        (ISIZE, BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::Xsize })),
-        (I8,    BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::X8 })),
-        (I16,   BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::X16 })),
-        (I32,   BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::X32 })),
-        (I64,   BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::X64 })),
-        (I128,  BuiltinType::Int(IntTy { signedness: Signedness::Signed, bitness: IntBitness::X128 })),
-        (USIZE, BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::Xsize })),
-        (U8,    BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X8 })),
-        (U16,   BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X16 })),
-        (U32,   BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X32 })),
-        (U64,   BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X64 })),
-        (U128,  BuiltinType::Int(IntTy { signedness: Signedness::Unsigned, bitness: IntBitness::X128 })),
-        (F32, BuiltinType::Float(FloatTy { bitness: FloatBitness::X32 })),
-        (F64, BuiltinType::Float(FloatTy { bitness: FloatBitness::X64 })),
-    ];
 }
 /// The defs which can be visible in the module.
@@ -148,39 +108,19 @@ impl_froms!(
    BuiltinType
 );
-pub enum ModuleSource {
+pub use hir_def::ModuleSource;
-    SourceFile(ast::SourceFile),
-    Module(ast::Module),
-}
-impl ModuleSource {
+impl Module {
-    pub(crate) fn new(
+    pub(crate) fn new(krate: Crate, crate_module_id: CrateModuleId) -> Module {
-        db: &(impl DefDatabase + AstDatabase),
+        Module { id: ModuleId { krate: krate.crate_id, module_id: crate_module_id } }
-        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!(),
-        }
    }
-}
-impl Module {
    /// Name of this module.
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let parent = def_map[self.module_id].parent?;
+        let parent = def_map[self.id.module_id].parent?;
        def_map[parent].children.iter().find_map(|(name, module_id)| {
-            if *module_id == self.module_id {
+            if *module_id == self.id.module_id {
                Some(name.clone())
            } else {
                None
@@ -200,29 +140,29 @@ impl Module {
    }
    /// Returns the crate this module is part of.
-    pub fn krate(self, _db: &impl DefDatabase) -> Option<Crate> {
+    pub fn krate(self) -> Crate {
-        Some(self.krate)
+        Crate { crate_id: self.id.krate }
    }
    /// Topmost parent of this module. Every module has a `crate_root`, but some
    /// might be missing `krate`. This can happen if a module's file is not included
    /// in the module tree of any target in `Cargo.toml`.
    pub fn crate_root(self, db: &impl DefDatabase) -> Module {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
        self.with_module_id(def_map.root())
    }
    /// Finds a child module with the specified name.
    pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let child_id = def_map[self.module_id].children.get(name)?;
+        let child_id = def_map[self.id.module_id].children.get(name)?;
        Some(self.with_module_id(*child_id))
    }
    /// Iterates over all child modules.
    pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let children = def_map[self.module_id]
+        let children = def_map[self.id.module_id]
            .children
            .iter()
            .map(|(_, module_id)| self.with_module_id(*module_id))
@@ -232,8 +172,8 @@ impl Module {
    /// Finds a parent module.
    pub fn parent(self, db: &impl DefDatabase) -> Option<Module> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let parent_id = def_map[self.module_id].parent?;
+        let parent_id = def_map[self.id.module_id].parent?;
        Some(self.with_module_id(parent_id))
    }
@@ -249,11 +189,11 @@ impl Module {
    /// Returns a `ModuleScope`: a set of items, visible in this module.
    pub fn scope(self, db: &impl HirDatabase) -> ModuleScope {
-        db.crate_def_map(self.krate)[self.module_id].scope.clone()
+        db.crate_def_map(self.krate())[self.id.module_id].scope.clone()
    }
    pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
-        db.crate_def_map(self.krate).add_diagnostics(db, self.module_id, sink);
+        db.crate_def_map(self.krate()).add_diagnostics(db, self.id.module_id, sink);
        for decl in self.declarations(db) {
            match decl {
                crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
@@ -277,13 +217,13 @@ impl Module {
    }
    pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        Resolver::default().push_module_scope(def_map, self.module_id)
+        Resolver::default().push_module_scope(def_map, self.id.module_id)
    }
    pub fn declarations(self, db: &impl DefDatabase) -> Vec<ModuleDef> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        def_map[self.module_id]
+        def_map[self.id.module_id]
            .scope
            .entries()
            .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None })
@@ -303,7 +243,7 @@ impl Module {
    }
    fn with_module_id(self, module_id: CrateModuleId) -> Module {
-        Module { module_id, krate: self.krate }
+        Module::new(self.krate(), module_id)
    }
 }
@@ -340,11 +280,11 @@ pub struct Struct {
 impl Struct {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
@@ -402,7 +342,7 @@ impl Union {
    }
    pub fn module(self, db: &impl HirDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn ty(self, db: &impl HirDatabase) -> Ty {
@@ -428,11 +368,11 @@ pub struct Enum {
 impl Enum {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
@@ -470,7 +410,7 @@ impl Enum {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct EnumVariant {
    pub(crate) parent: Enum,
-    pub(crate) id: EnumVariantId,
+    pub(crate) id: LocalEnumVariantId,
 }
 impl EnumVariant {
@@ -523,12 +463,14 @@ impl Adt {
    }
    pub fn krate(self, db: &impl HirDatabase) -> Option<Crate> {
-        match self {
+        Some(
-            Adt::Struct(s) => s.module(db),
+            match self {
-            Adt::Union(s) => s.module(db),
+                Adt::Struct(s) => s.module(db),
-            Adt::Enum(e) => e.module(db),
+                Adt::Union(s) => s.module(db),
-        }
+                Adt::Enum(e) => e.module(db),
-        .krate(db)
+            }
+            .krate(),
+        )
    }
    pub(crate) fn resolver(self, db: &impl HirDatabase) -> Resolver {
@@ -643,7 +585,7 @@ impl FnData {
                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
                    TypeRef::from_ast(type_ref)
                } else {
-                    let self_type = TypeRef::Path(SELF_TYPE.into());
+                    let self_type = TypeRef::Path(name::SELF_TYPE.into());
                    match self_param.kind() {
                        ast::SelfParamKind::Owned => self_type,
                        ast::SelfParamKind::Ref => {
@@ -692,11 +634,11 @@ impl FnData {
 impl Function {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    pub fn name(self, db: &impl HirDatabase) -> Name {
@@ -770,11 +712,11 @@ pub struct Const {
 impl Const {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
@@ -867,11 +809,11 @@ pub struct Static {
 impl Static {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    pub fn data(self, db: &impl HirDatabase) -> Arc<ConstData> {
@@ -896,7 +838,7 @@ pub struct Trait {
 impl Trait {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
@@ -917,9 +859,7 @@ impl Trait {
            .where_predicates
            .iter()
            .filter_map(|pred| match &pred.type_ref {
-                TypeRef::Path(p) if p.as_ident() == Some(&crate::name::SELF_TYPE) => {
+                TypeRef::Path(p) if p.as_ident() == Some(&name::SELF_TYPE) => pred.bound.as_path(),
-                    pred.bound.as_path()
-                }
                _ => None,
            })
            .filter_map(|path| match resolver.resolve_path_in_type_ns_fully(db, path) {
@@ -998,11 +938,11 @@ pub struct TypeAlias {
 impl TypeAlias {
    pub fn module(self, db: &impl DefDatabase) -> Module {
-        self.id.module(db)
+        Module { id: self.id.module(db) }
    }
    pub fn krate(self, db: &impl DefDatabase) -> Option<Crate> {
-        self.module(db).krate(db)
+        Some(self.module(db).krate())
    }
    /// The containing impl block, if this is a method.
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index fdae26906..5c7f61eef 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -1,9 +1,6 @@
 //! FIXME: write short doc here
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode};
-    ast::{self, AstNode},
-    SyntaxNode,
-};
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
@@ -12,34 +9,21 @@ use crate::{
    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
 };
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub use hir_def::Source;
-pub struct Source<T> {
-    pub file_id: HirFileId,
-    pub ast: T,
-}
 pub trait HasSource {
    type Ast;
    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<Self::Ast>;
 }
-impl<T> Source<T> {
-    pub(crate) fn map<F: FnOnce(T) -> U, U>(self, f: F) -> Source<U> {
-        Source { file_id: self.file_id, ast: f(self.ast) }
-    }
-    pub(crate) fn file_syntax(&self, db: &impl AstDatabase) -> SyntaxNode {
-        db.parse_or_expand(self.file_id).expect("source created from invalid file")
-    }
-}
 /// 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> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let decl_id = def_map[self.module_id].declaration;
+        let decl_id = def_map[self.id.module_id].declaration;
-        let file_id = def_map[self.module_id].definition;
+        let file_id = def_map[self.id.module_id].definition;
        let ast = 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, ast }
@@ -51,8 +35,8 @@ impl Module {
        self,
        db: &(impl DefDatabase + AstDatabase),
    ) -> Option<Source<ast::Module>> {
-        let def_map = db.crate_def_map(self.krate);
+        let def_map = db.crate_def_map(self.krate());
-        let decl = def_map[self.module_id].declaration?;
+        let decl = def_map[self.id.module_id].declaration?;
        let ast = decl.to_node(db);
        Some(Source { file_id: decl.file_id(), ast })
    }
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 489a3b19c..ebfd970eb 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -2,8 +2,8 @@
 use std::sync::Arc;
-use ra_db::{salsa, SourceDatabase};
+use ra_db::salsa;
-use ra_syntax::{ast, Parse, SmolStr, SyntaxNode};
+use ra_syntax::SmolStr;
 use crate::{
    adt::{EnumData, StructData},
@@ -12,81 +12,30 @@ use crate::{
    ids,
    impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
    lang_item::{LangItemTarget, LangItems},
-    nameres::{CrateDefMap, ImportSourceMap, Namespace, RawItems},
+    nameres::{CrateDefMap, Namespace},
    traits::TraitData,
    ty::{
        method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate,
        InferenceResult, Substs, Ty, TypableDef, TypeCtor,
    },
    type_alias::TypeAliasData,
-    AstIdMap, Const, ConstData, Crate, DefWithBody, Enum, ErasedFileAstId, ExprScopes, FnData,
+    Const, ConstData, Crate, DefWithBody, Enum, ExprScopes, FnData, Function, Module, Static,
-    Function, HirFileId, MacroCallLoc, MacroDefId, Module, Static, Struct, StructField, Trait,
+    Struct, StructField, Trait, TypeAlias,
-    TypeAlias,
 };
-/// We store all interned things in the single QueryGroup.
+pub use hir_def::db::{
-///
+    DefDatabase2, DefDatabase2Storage, InternDatabase, InternDatabaseStorage, RawItemsQuery,
-/// This is done mainly to allow both "volatile" `AstDatabase` and "stable"
+    RawItemsWithSourceMapQuery,
-/// `DefDatabase` to access macros, without adding hard dependencies between the
+};
-/// two.
+pub use hir_expand::db::{
-#[salsa::query_group(InternDatabaseStorage)]
+    AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
-pub trait InternDatabase: SourceDatabase {
+    ParseMacroQuery,
-    #[salsa::interned]
+};
-    fn intern_macro(&self, macro_call: MacroCallLoc) -> ids::MacroCallId;
-    #[salsa::interned]
-    fn intern_function(&self, loc: ids::ItemLoc<ast::FnDef>) -> ids::FunctionId;
-    #[salsa::interned]
-    fn intern_struct(&self, loc: ids::ItemLoc<ast::StructDef>) -> ids::StructId;
-    #[salsa::interned]
-    fn intern_enum(&self, loc: ids::ItemLoc<ast::EnumDef>) -> ids::EnumId;
-    #[salsa::interned]
-    fn intern_const(&self, loc: ids::ItemLoc<ast::ConstDef>) -> ids::ConstId;
-    #[salsa::interned]
-    fn intern_static(&self, loc: ids::ItemLoc<ast::StaticDef>) -> ids::StaticId;
-    #[salsa::interned]
-    fn intern_trait(&self, loc: ids::ItemLoc<ast::TraitDef>) -> ids::TraitId;
-    #[salsa::interned]
-    fn intern_type_alias(&self, loc: ids::ItemLoc<ast::TypeAliasDef>) -> ids::TypeAliasId;
-    // Interned IDs for Chalk integration
-    #[salsa::interned]
-    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
-    #[salsa::interned]
-    fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId;
-}
-/// This database has access to source code, so queries here are not really
-/// incremental.
-#[salsa::query_group(AstDatabaseStorage)]
-pub trait AstDatabase: InternDatabase {
-    #[salsa::invoke(crate::source_id::AstIdMap::ast_id_map_query)]
-    fn ast_id_map(&self, file_id: HirFileId) -> Arc<AstIdMap>;
-    #[salsa::transparent]
-    #[salsa::invoke(crate::source_id::AstIdMap::file_item_query)]
-    fn ast_id_to_node(&self, file_id: HirFileId, ast_id: ErasedFileAstId) -> SyntaxNode;
-    #[salsa::transparent]
-    #[salsa::invoke(crate::ids::HirFileId::parse_or_expand_query)]
-    fn parse_or_expand(&self, file_id: HirFileId) -> Option<SyntaxNode>;
-    #[salsa::invoke(crate::ids::HirFileId::parse_macro_query)]
-    fn parse_macro(&self, macro_file: ids::MacroFile) -> Option<Parse<SyntaxNode>>;
-    #[salsa::invoke(crate::ids::macro_def_query)]
-    fn macro_def(&self, macro_id: MacroDefId) -> Option<Arc<mbe::MacroRules>>;
-    #[salsa::invoke(crate::ids::macro_arg_query)]
-    fn macro_arg(&self, macro_call: ids::MacroCallId) -> Option<Arc<tt::Subtree>>;
-    #[salsa::invoke(crate::ids::macro_expand_query)]
-    fn macro_expand(&self, macro_call: ids::MacroCallId) -> Result<Arc<tt::Subtree>, String>;
-}
 // This database uses `AstDatabase` internally,
 #[salsa::query_group(DefDatabaseStorage)]
 #[salsa::requires(AstDatabase)]
-pub trait DefDatabase: InternDatabase + HirDebugDatabase {
+pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
    #[salsa::invoke(crate::adt::StructData::struct_data_query)]
    fn struct_data(&self, s: Struct) -> Arc<StructData>;
@@ -99,15 +48,6 @@ pub trait DefDatabase: InternDatabase + HirDebugDatabase {
    #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)]
    fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex;
-    #[salsa::invoke(RawItems::raw_items_with_source_map_query)]
-    fn raw_items_with_source_map(
-        &self,
-        file_id: HirFileId,
-    ) -> (Arc<RawItems>, Arc<ImportSourceMap>);
-    #[salsa::invoke(RawItems::raw_items_query)]
-    fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
    #[salsa::invoke(CrateDefMap::crate_def_map_query)]
    fn crate_def_map(&self, krate: Crate) -> Arc<CrateDefMap>;
@@ -202,6 +142,12 @@ pub trait HirDatabase: DefDatabase + AstDatabase {
    #[salsa::invoke(crate::ty::traits::trait_solver_query)]
    fn trait_solver(&self, krate: Crate) -> crate::ty::traits::TraitSolver;
+    // Interned IDs for Chalk integration
+    #[salsa::interned]
+    fn intern_type_ctor(&self, type_ctor: TypeCtor) -> ids::TypeCtorId;
+    #[salsa::interned]
+    fn intern_impl(&self, impl_: Impl) -> ids::GlobalImplId;
    #[salsa::invoke(crate::ty::traits::chalk::associated_ty_data_query)]
    fn associated_ty_data(&self, id: chalk_ir::TypeId) -> Arc<chalk_rust_ir::AssociatedTyDatum>;
diff --git a/crates/ra_hir/src/debug.rs b/crates/ra_hir/src/debug.rs
index 48b69000b..4f3e922c3 100644
--- a/crates/ra_hir/src/debug.rs
+++ b/crates/ra_hir/src/debug.rs
@@ -36,12 +36,6 @@ impl Module {
    }
 }
-impl HirFileId {
-    pub fn debug(self, db: &impl HirDebugDatabase) -> impl fmt::Debug + '_ {
-        debug_fn(move |fmt| db.debug_hir_file_id(self, fmt))
-    }
-}
 pub trait HirDebugHelper: HirDatabase {
    fn crate_name(&self, _krate: CrateId) -> Option<String> {
        None
diff --git a/crates/ra_hir/src/either.rs b/crates/ra_hir/src/either.rs
deleted file mode 100644
index 83583ef8b..000000000
--- a/crates/ra_hir/src/either.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! FIXME: write short doc here
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Either<A, B> {
-    A(A),
-    B(B),
-}
-impl<A, B> Either<A, B> {
-    pub fn either<R, F1, F2>(self, f1: F1, f2: F2) -> R
-    where
-        F1: FnOnce(A) -> R,
-        F2: FnOnce(B) -> R,
-    {
-        match self {
-            Either::A(a) => f1(a),
-            Either::B(b) => f2(b),
-        }
-    }
-    pub fn map<U, V, F1, F2>(self, f1: F1, f2: F2) -> Either<U, V>
-    where
-        F1: FnOnce(A) -> U,
-        F2: FnOnce(B) -> V,
-    {
-        match self {
-            Either::A(a) => Either::A(f1(a)),
-            Either::B(b) => Either::B(f2(b)),
-        }
-    }
-    pub fn map_a<U, F>(self, f: F) -> Either<U, B>
-    where
-        F: FnOnce(A) -> U,
-    {
-        self.map(f, |it| it)
-    }
-    pub fn a(self) -> Option<A> {
-        match self {
-            Either::A(it) => Some(it),
-            Either::B(_) => None,
-        }
-    }
-    pub fn b(self) -> Option<B> {
-        match self {
-            Either::A(_) => None,
-            Either::B(it) => Some(it),
-        }
-    }
-    pub fn as_ref(&self) -> Either<&A, &B> {
-        match self {
-            Either::A(it) => Either::A(it),
-            Either::B(it) => Either::B(it),
-        }
-    }
-}
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index d238741ba..6e23197a4 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -6,15 +6,17 @@ pub(crate) mod validation;
 use std::{ops::Index, sync::Arc};
+use hir_def::{
+    path::GenericArgs,
+    type_ref::{Mutability, TypeRef},
+};
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{ast, AstPtr};
 use rustc_hash::FxHashMap;
 use crate::{
    db::HirDatabase,
-    path::GenericArgs,
    ty::primitive::{UncertainFloatTy, UncertainIntTy},
-    type_ref::{Mutability, TypeRef},
    DefWithBody, Either, HasSource, Name, Path, Resolver, Source,
 };
diff --git a/crates/ra_hir/src/expr/lower.rs b/crates/ra_hir/src/expr/lower.rs
index 50ea429ea..6463dd65e 100644
--- a/crates/ra_hir/src/expr/lower.rs
+++ b/crates/ra_hir/src/expr/lower.rs
@@ -1,5 +1,10 @@
 //! FIXME: write short doc here
+use hir_def::{path::GenericArgs, type_ref::TypeRef};
+use hir_expand::{
+    hygiene::Hygiene,
+    name::{self, AsName, Name},
+};
 use ra_arena::Arena;
 use ra_syntax::{
    ast::{
@@ -12,11 +17,8 @@ use test_utils::tested_by;
 use crate::{
    db::HirDatabase,
-    name::{AsName, Name, SELF_PARAM},
-    path::GenericArgs,
    ty::primitive::{FloatTy, IntTy, UncertainFloatTy, UncertainIntTy},
-    type_ref::TypeRef,
+    AstId, DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path, Resolver,
-    DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind, Mutability, Path, Resolver,
    Source,
 };
@@ -78,7 +80,7 @@ where
                let ptr = AstPtr::new(&self_param);
                let param_pat = self.alloc_pat(
                    Pat::Bind {
-                        name: SELF_PARAM,
+                        name: name::SELF_PARAM,
                        mode: BindingAnnotation::Unannotated,
                        subpat: None,
                    },
@@ -458,15 +460,14 @@ where
            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
            ast::Expr::MacroCall(e) => {
-                let ast_id = self
+                let ast_id = AstId::new(
-                    .db
+                    self.current_file_id,
-                    .ast_id_map(self.current_file_id)
+                    self.db.ast_id_map(self.current_file_id).ast_id(&e),
-                    .ast_id(&e)
+                );
-                    .with_file_id(self.current_file_id);
                if let Some(path) = e.path().and_then(|path| self.parse_path(path)) {
                    if let Some(def) = self.resolver.resolve_path_as_macro(self.db, &path) {
-                        let call_id = MacroCallLoc { def: def.id, ast_id }.id(self.db);
+                        let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id });
                        let file_id = call_id.as_file(MacroFileKind::Expr);
                        if let Some(node) = self.db.parse_or_expand(file_id) {
                            if let Some(expr) = ast::Expr::cast(node) {
@@ -596,7 +597,8 @@ where
    }
    fn parse_path(&mut self, path: ast::Path) -> Option<Path> {
-        Path::from_src(Source { ast: path, file_id: self.current_file_id }, self.db)
+        let hygiene = Hygiene::new(self.db, self.current_file_id);
+        Path::from_src(path, &hygiene)
    }
 }
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index 1aa853c3e..c685edda1 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -2,6 +2,7 @@
 use std::sync::Arc;
+use hir_def::path::known;
 use ra_syntax::ast;
 use rustc_hash::FxHashSet;
@@ -9,7 +10,6 @@ use crate::{
    db::HirDatabase,
    diagnostics::{DiagnosticSink, MissingFields, MissingOkInTailExpr},
    expr::AstPtr,
-    path::known,
    ty::{ApplicationTy, InferenceResult, Ty, TypeCtor},
    Adt, Function, Name, Path,
 };
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index f80d8eb5f..a9de01455 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -1,17 +1,12 @@
 //! FIXME: write short doc here
-use ra_db::{FileId, FilePosition};
+use hir_expand::name::AsName;
-use ra_syntax::{
+use ra_syntax::ast::{self, AstNode, NameOwner};
-    algo::find_node_at_offset,
-    ast::{self, AstNode, NameOwner},
-    SyntaxNode,
-};
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
    ids::{AstItemDef, LocationCtx},
-    name::AsName,
+    AstId, Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
-    Const, Crate, Enum, EnumVariant, FieldSource, Function, HasSource, ImplBlock, Module,
    ModuleSource, Source, Static, Struct, StructField, Trait, TypeAlias, Union, VariantDef,
 };
@@ -129,41 +124,6 @@ impl FromSource for StructField {
    }
 }
-// FIXME: simplify it
-impl ModuleSource {
-    pub fn from_position(
-        db: &(impl DefDatabase + AstDatabase),
-        position: FilePosition,
-    ) -> ModuleSource {
-        let parse = db.parse(position.file_id);
-        match &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 + AstDatabase),
-        file_id: FileId,
-        child: &SyntaxNode,
-    ) -> ModuleSource {
-        if let Some(m) = child.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi()) {
-            ModuleSource::Module(m)
-        } else {
-            let source_file = db.parse(file_id).tree();
-            ModuleSource::SourceFile(source_file)
-        }
-    }
-    pub fn from_file_id(db: &(impl DefDatabase + AstDatabase), file_id: FileId) -> ModuleSource {
-        let source_file = db.parse(file_id).tree();
-        ModuleSource::SourceFile(source_file)
-    }
-}
 impl Module {
    pub fn from_declaration(db: &impl HirDatabase, src: Source<ast::Module>) -> Option<Self> {
        let src_parent = Source {
@@ -183,7 +143,7 @@ impl Module {
            ModuleSource::Module(ref module) => {
                assert!(!module.has_semi());
                let ast_id_map = db.ast_id_map(src.file_id);
-                let item_id = ast_id_map.ast_id(module).with_file_id(src.file_id);
+                let item_id = AstId::new(src.file_id, ast_id_map.ast_id(module));
                Some(item_id)
            }
            ModuleSource::SourceFile(_) => None,
@@ -195,7 +155,7 @@ impl Module {
            .find_map(|krate| {
                let def_map = db.crate_def_map(krate);
                let module_id = def_map.find_module_by_source(src.file_id, decl_id)?;
-                Some(Module { krate, module_id })
+                Some(Module::new(krate, module_id))
            })
    }
 }
@@ -208,6 +168,6 @@ where
    let module_src =
        crate::ModuleSource::from_child_node(db, src.file_id.original_file(db), &src.ast.syntax());
    let module = Module::from_definition(db, Source { file_id: src.file_id, ast: module_src })?;
-    let ctx = LocationCtx::new(db, module, src.file_id);
+    let ctx = LocationCtx::new(db, module.id, src.file_id);
    Some(DEF::from_ast(ctx, &src.ast))
 }
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index 4ce7551c3..52e1fbf29 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -5,15 +5,17 @@
 use std::sync::Arc;
+use hir_def::{
+    path::Path,
+    type_ref::{TypeBound, TypeRef},
+};
+use hir_expand::name::{self, AsName};
 use ra_syntax::ast::{self, DefaultTypeParamOwner, NameOwner, TypeBoundsOwner, TypeParamsOwner};
 use crate::{
    db::{AstDatabase, DefDatabase, HirDatabase},
-    name::SELF_TYPE,
+    Adt, Const, Container, Enum, EnumVariant, Function, HasSource, ImplBlock, Name, Struct, Trait,
-    path::Path,
+    TypeAlias, Union,
-    type_ref::{TypeBound, TypeRef},
-    Adt, AsName, Const, Container, Enum, EnumVariant, Function, HasSource, ImplBlock, Name, Struct,
-    Trait, TypeAlias, Union,
 };
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -94,11 +96,15 @@ impl GenericParams {
            GenericDef::Adt(Adt::Enum(it)) => generics.fill(&it.source(db).ast, start),
            GenericDef::Trait(it) => {
                // traits get the Self type as an implicit first type parameter
-                generics.params.push(GenericParam { idx: start, name: SELF_TYPE, default: None });
+                generics.params.push(GenericParam {
+                    idx: start,
+                    name: name::SELF_TYPE,
+                    default: None,
+                });
                generics.fill(&it.source(db).ast, start + 1);
                // add super traits as bounds on Self
                // i.e., trait Foo: Bar is equivalent to trait Foo where Self: Bar
-                let self_param = TypeRef::Path(SELF_TYPE.into());
+                let self_param = TypeRef::Path(name::SELF_TYPE.into());
                generics.fill_bounds(&it.source(db).ast, self_param);
            }
            GenericDef::TypeAlias(it) => generics.fill(&it.source(db).ast, start),
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index 499dcafea..fe083c0c6 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,168 +1,17 @@
-//! FIXME: write short doc here
+//! hir makes heavy use of ids: integer (u32) handlers to various things. You
+//! can think of id as a pointer (but without a lifetime) or a file descriptor
-use std::{
+//! (but for hir objects).
-    hash::{Hash, Hasher},
+//!
-    sync::Arc,
+//! This module defines a bunch of ids we are using. The most important ones are
-};
+//! probably `HirFileId` and `DefId`.
-use mbe::MacroRules;
+use ra_db::salsa;
-use ra_db::{salsa, FileId};
-use ra_prof::profile;
+pub use hir_def::{
-use ra_syntax::{ast, AstNode, Parse, SyntaxNode};
+    AstItemDef, ConstId, EnumId, FunctionId, ItemLoc, LocationCtx, StaticId, StructId, TraitId,
+    TypeAliasId,
-use crate::{
-    db::{AstDatabase, DefDatabase, InternDatabase},
-    AstId, Crate, FileAstId, Module, Source,
 };
+pub use hir_expand::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile, MacroFileKind};
-/// hir makes heavy use of ids: integer (u32) handlers to various things. You
-/// can think of id as a pointer (but without a lifetime) or a file descriptor
-/// (but for hir objects).
-///
-/// This module defines a bunch of ids we are using. The most important ones are
-/// probably `HirFileId` and `DefId`.
-/// 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
-/// Rust are macros: each macro can be thought of as producing a "temporary
-/// file". To assign an id to such a file, we use the id of the macro call that
-/// produced the file. So, a `HirFileId` is either a `FileId` (source code
-/// written by user), or a `MacroCallId` (source code produced by macro).
-///
-/// What is a `MacroCallId`? Simplifying, it's a `HirFileId` of a file
-/// containing the call plus the offset of the macro call in the file. Note that
-/// this is a recursive definition! However, the size_of of `HirFileId` is
-/// finite (because everything bottoms out at the real `FileId`) and small
-/// (`MacroCallId` uses the location interner).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct HirFileId(HirFileIdRepr);
-impl HirFileId {
-    /// For macro-expansion files, returns the file original source file the
-    /// expansion originated from.
-    pub fn original_file(self, db: &impl InternDatabase) -> FileId {
-        match self.0 {
-            HirFileIdRepr::File(file_id) => file_id,
-            HirFileIdRepr::Macro(macro_file) => {
-                let loc = macro_file.macro_call_id.loc(db);
-                loc.ast_id.file_id().original_file(db)
-            }
-        }
-    }
-    /// Get the crate which the macro lives in, if it is a macro file.
-    pub(crate) fn macro_crate(self, db: &impl AstDatabase) -> Option<Crate> {
-        match self.0 {
-            HirFileIdRepr::File(_) => None,
-            HirFileIdRepr::Macro(macro_file) => {
-                let loc = macro_file.macro_call_id.loc(db);
-                Some(loc.def.krate)
-            }
-        }
-    }
-    pub(crate) fn parse_or_expand_query(
-        db: &impl AstDatabase,
-        file_id: HirFileId,
-    ) -> Option<SyntaxNode> {
-        match file_id.0 {
-            HirFileIdRepr::File(file_id) => Some(db.parse(file_id).tree().syntax().clone()),
-            HirFileIdRepr::Macro(macro_file) => {
-                db.parse_macro(macro_file).map(|it| it.syntax_node())
-            }
-        }
-    }
-    pub(crate) fn parse_macro_query(
-        db: &impl AstDatabase,
-        macro_file: MacroFile,
-    ) -> Option<Parse<SyntaxNode>> {
-        let _p = profile("parse_macro_query");
-        let macro_call_id = macro_file.macro_call_id;
-        let tt = db
-            .macro_expand(macro_call_id)
-            .map_err(|err| {
-                // Note:
-                // The final goal we would like to make all parse_macro success,
-                // such that the following log will not call anyway.
-                log::warn!("fail on macro_parse: (reason: {})", err,);
-            })
-            .ok()?;
-        match macro_file.macro_file_kind {
-            MacroFileKind::Items => mbe::token_tree_to_items(&tt).ok().map(Parse::to_syntax),
-            MacroFileKind::Expr => mbe::token_tree_to_expr(&tt).ok().map(Parse::to_syntax),
-        }
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-enum HirFileIdRepr {
-    File(FileId),
-    Macro(MacroFile),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroFile {
-    macro_call_id: MacroCallId,
-    macro_file_kind: MacroFileKind,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) enum MacroFileKind {
-    Items,
-    Expr,
-}
-impl From<FileId> for HirFileId {
-    fn from(file_id: FileId) -> HirFileId {
-        HirFileId(HirFileIdRepr::File(file_id))
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroDefId {
-    pub(crate) ast_id: AstId<ast::MacroCall>,
-    pub(crate) krate: Crate,
-}
-pub(crate) fn macro_def_query(db: &impl AstDatabase, id: MacroDefId) -> Option<Arc<MacroRules>> {
-    let macro_call = id.ast_id.to_node(db);
-    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(&arg).or_else(|| {
-        log::warn!("fail on macro_def to token tree: {:#?}", arg);
-        None
-    })?;
-    let rules = MacroRules::parse(&tt).ok().or_else(|| {
-        log::warn!("fail on macro_def parse: {:#?}", tt);
-        None
-    })?;
-    Some(Arc::new(rules))
-}
-pub(crate) fn macro_arg_query(db: &impl AstDatabase, id: MacroCallId) -> Option<Arc<tt::Subtree>> {
-    let loc = id.loc(db);
-    let macro_call = loc.ast_id.to_node(db);
-    let arg = macro_call.token_tree()?;
-    let (tt, _) = mbe::ast_to_token_tree(&arg)?;
-    Some(Arc::new(tt))
-}
-pub(crate) fn macro_expand_query(
-    db: &impl AstDatabase,
-    id: MacroCallId,
-) -> Result<Arc<tt::Subtree>, String> {
-    let loc = id.loc(db);
-    let macro_arg = db.macro_arg(id).ok_or("Fail to args in to tt::TokenTree")?;
-    let macro_rules = db.macro_def(loc.def).ok_or("Fail to find macro definition")?;
-    let tt = macro_rules.expand(&macro_arg).map_err(|err| format!("{:?}", err))?;
-    // Set a hard limit for the expanded tt
-    let count = tt.count();
-    if count > 65536 {
-        return Err(format!("Total tokens count exceed limit : count = {}", count));
-    }
-    Ok(Arc::new(tt))
-}
 macro_rules! impl_intern_key {
    ($name:ident) => {
@@ -177,192 +26,6 @@ macro_rules! impl_intern_key {
    };
 }
-/// `MacroCallId` identifies a particular macro invocation, like
-/// `println!("Hello, {}", world)`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct MacroCallId(salsa::InternId);
-impl_intern_key!(MacroCallId);
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct MacroCallLoc {
-    pub(crate) def: MacroDefId,
-    pub(crate) ast_id: AstId<ast::MacroCall>,
-}
-impl MacroCallId {
-    pub(crate) fn loc(self, db: &impl InternDatabase) -> MacroCallLoc {
-        db.lookup_intern_macro(self)
-    }
-    pub(crate) fn as_file(self, kind: MacroFileKind) -> HirFileId {
-        let macro_file = MacroFile { macro_call_id: self, macro_file_kind: kind };
-        HirFileId(HirFileIdRepr::Macro(macro_file))
-    }
-}
-impl MacroCallLoc {
-    pub(crate) fn id(self, db: &impl InternDatabase) -> MacroCallId {
-        db.intern_macro(self)
-    }
-}
-#[derive(Debug)]
-pub struct ItemLoc<N: AstNode> {
-    pub(crate) module: Module,
-    ast_id: AstId<N>,
-}
-impl<N: AstNode> PartialEq for ItemLoc<N> {
-    fn eq(&self, other: &Self) -> bool {
-        self.module == other.module && self.ast_id == other.ast_id
-    }
-}
-impl<N: AstNode> Eq for ItemLoc<N> {}
-impl<N: AstNode> Hash for ItemLoc<N> {
-    fn hash<H: Hasher>(&self, hasher: &mut H) {
-        self.module.hash(hasher);
-        self.ast_id.hash(hasher);
-    }
-}
-impl<N: AstNode> Clone for ItemLoc<N> {
-    fn clone(&self) -> ItemLoc<N> {
-        ItemLoc { module: self.module, ast_id: self.ast_id }
-    }
-}
-#[derive(Clone, Copy)]
-pub(crate) struct LocationCtx<DB> {
-    db: DB,
-    module: Module,
-    file_id: HirFileId,
-}
-impl<'a, DB: DefDatabase> LocationCtx<&'a DB> {
-    pub(crate) fn new(db: &'a DB, module: Module, file_id: HirFileId) -> LocationCtx<&'a DB> {
-        LocationCtx { db, module, file_id }
-    }
-}
-impl<'a, DB: DefDatabase + AstDatabase> LocationCtx<&'a DB> {
-    pub(crate) fn to_def<N, DEF>(self, ast: &N) -> DEF
-    where
-        N: AstNode,
-        DEF: AstItemDef<N>,
-    {
-        DEF::from_ast(self, ast)
-    }
-}
-pub(crate) trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<N>) -> Self;
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<N>;
-    fn from_ast(ctx: LocationCtx<&(impl AstDatabase + DefDatabase)>, ast: &N) -> Self {
-        let items = ctx.db.ast_id_map(ctx.file_id);
-        let item_id = items.ast_id(ast);
-        Self::from_ast_id(ctx, item_id)
-    }
-    fn from_ast_id(ctx: LocationCtx<&impl DefDatabase>, ast_id: FileAstId<N>) -> Self {
-        let loc = ItemLoc { module: ctx.module, ast_id: ast_id.with_file_id(ctx.file_id) };
-        Self::intern(ctx.db, loc)
-    }
-    fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source<N> {
-        let loc = self.lookup_intern(db);
-        let ast = loc.ast_id.to_node(db);
-        Source { file_id: loc.ast_id.file_id(), ast }
-    }
-    fn module(self, db: &impl DefDatabase) -> Module {
-        let loc = self.lookup_intern(db);
-        loc.module
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct FunctionId(salsa::InternId);
-impl_intern_key!(FunctionId);
-impl AstItemDef<ast::FnDef> for FunctionId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::FnDef>) -> Self {
-        db.intern_function(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::FnDef> {
-        db.lookup_intern_function(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StructId(salsa::InternId);
-impl_intern_key!(StructId);
-impl AstItemDef<ast::StructDef> for StructId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::StructDef>) -> Self {
-        db.intern_struct(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::StructDef> {
-        db.lookup_intern_struct(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct EnumId(salsa::InternId);
-impl_intern_key!(EnumId);
-impl AstItemDef<ast::EnumDef> for EnumId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::EnumDef>) -> Self {
-        db.intern_enum(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::EnumDef> {
-        db.lookup_intern_enum(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ConstId(salsa::InternId);
-impl_intern_key!(ConstId);
-impl AstItemDef<ast::ConstDef> for ConstId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::ConstDef>) -> Self {
-        db.intern_const(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::ConstDef> {
-        db.lookup_intern_const(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct StaticId(salsa::InternId);
-impl_intern_key!(StaticId);
-impl AstItemDef<ast::StaticDef> for StaticId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::StaticDef>) -> Self {
-        db.intern_static(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::StaticDef> {
-        db.lookup_intern_static(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TraitId(salsa::InternId);
-impl_intern_key!(TraitId);
-impl AstItemDef<ast::TraitDef> for TraitId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::TraitDef>) -> Self {
-        db.intern_trait(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::TraitDef> {
-        db.lookup_intern_trait(self)
-    }
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct TypeAliasId(salsa::InternId);
-impl_intern_key!(TypeAliasId);
-impl AstItemDef<ast::TypeAliasDef> for TypeAliasId {
-    fn intern(db: &impl DefDatabase, loc: ItemLoc<ast::TypeAliasDef>) -> Self {
-        db.intern_type_alias(loc)
-    }
-    fn lookup_intern(self, db: &impl DefDatabase) -> ItemLoc<ast::TypeAliasDef> {
-        db.lookup_intern_type_alias(self)
-    }
-}
 /// This exists just for Chalk, because Chalk just has a single `StructId` where
 /// we have different kinds of ADTs, primitive types and special type
 /// constructors like tuples and function pointers.
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 33ef87563..b1a014074 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -3,6 +3,8 @@
 use rustc_hash::FxHashMap;
 use std::sync::Arc;
+use hir_def::{attr::Attr, type_ref::TypeRef};
+use hir_expand::hygiene::Hygiene;
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_cfg::CfgOptions;
 use ra_syntax::{
@@ -11,7 +13,6 @@ use ra_syntax::{
 };
 use crate::{
-    attr::Attr,
    code_model::{Module, ModuleSource},
    db::{AstDatabase, DefDatabase, HirDatabase},
    generics::HasGenericParams,
@@ -19,8 +20,7 @@ use crate::{
    ids::MacroCallLoc,
    resolve::Resolver,
    ty::Ty,
-    type_ref::TypeRef,
+    AssocItem, AstId, Const, Function, HasSource, HirFileId, MacroFileKind, Path, Source, TraitRef,
-    AssocItem, Const, Function, HasSource, HirFileId, MacroFileKind, Path, Source, TraitRef,
    TypeAlias,
 };
@@ -129,7 +129,7 @@ impl ImplData {
    ) -> Self {
        let target_trait = node.target_trait().map(TypeRef::from_ast);
        let target_type = TypeRef::from_ast_opt(node.target_type());
-        let ctx = LocationCtx::new(db, module, file_id);
+        let ctx = LocationCtx::new(db, module.id, file_id);
        let negative = node.is_negative();
        let items = if let Some(item_list) = node.item_list() {
            item_list
@@ -182,7 +182,7 @@ impl ModuleImplBlocks {
    ) -> (Arc<ModuleImplBlocks>, Arc<ImplSourceMap>) {
        let mut source_map = ImplSourceMap::default();
        let crate_graph = db.crate_graph();
-        let cfg_options = crate_graph.cfg_options(module.krate.crate_id());
+        let cfg_options = crate_graph.cfg_options(module.id.krate);
        let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map);
        (Arc::new(result), Arc::new(source_map))
@@ -228,10 +228,11 @@ impl ModuleImplBlocks {
        owner: &dyn ast::ModuleItemOwner,
        file_id: HirFileId,
    ) {
+        let hygiene = Hygiene::new(db, file_id);
        for item in owner.items_with_macros() {
            match item {
                ast::ItemOrMacro::Item(ast::ModuleItem::ImplBlock(impl_block_ast)) => {
-                    let attrs = Attr::from_attrs_owner(file_id, &impl_block_ast, db);
+                    let attrs = Attr::from_attrs_owner(&impl_block_ast, &hygiene);
                    if attrs.map_or(false, |attrs| {
                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
                    }) {
@@ -248,7 +249,7 @@ impl ModuleImplBlocks {
                }
                ast::ItemOrMacro::Item(_) => (),
                ast::ItemOrMacro::Macro(macro_call) => {
-                    let attrs = Attr::from_attrs_owner(file_id, &macro_call, db);
+                    let attrs = Attr::from_attrs_owner(&macro_call, &hygiene);
                    if attrs.map_or(false, |attrs| {
                        attrs.iter().any(|attr| attr.is_cfg_enabled(cfg_options) == Some(false))
                    }) {
@@ -256,14 +257,13 @@ impl ModuleImplBlocks {
                    }
                    //FIXME: we should really cut down on the boilerplate required to process a macro
-                    let ast_id = db.ast_id_map(file_id).ast_id(&macro_call).with_file_id(file_id);
+                    let ast_id = AstId::new(file_id, db.ast_id_map(file_id).ast_id(&macro_call));
-                    if let Some(path) = macro_call
+                    if let Some(path) =
-                        .path()
+                        macro_call.path().and_then(|path| Path::from_src(path, &hygiene))
-                        .and_then(|path| Path::from_src(Source { ast: path, file_id }, db))
                    {
                        if let Some(def) = self.module.resolver(db).resolve_path_as_macro(db, &path)
                        {
-                            let call_id = MacroCallLoc { def: def.id, ast_id }.id(db);
+                            let call_id = db.intern_macro(MacroCallLoc { def: def.id, ast_id });
                            let file_id = call_id.as_file(MacroFileKind::Items);
                            if let Some(item_list) =
                                db.parse_or_expand(file_id).and_then(ast::MacroItems::cast)
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index 6c4e8ffbd..e1780ed38 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -22,14 +22,14 @@ pub enum LangItemTarget {
 impl LangItemTarget {
    pub(crate) fn krate(&self, db: &impl HirDatabase) -> Option<Crate> {
-        match self {
+        Some(match self {
-            LangItemTarget::Enum(e) => e.module(db).krate(db),
+            LangItemTarget::Enum(e) => e.module(db).krate(),
-            LangItemTarget::Function(f) => f.module(db).krate(db),
+            LangItemTarget::Function(f) => f.module(db).krate(),
-            LangItemTarget::ImplBlock(i) => i.module().krate(db),
+            LangItemTarget::ImplBlock(i) => i.module().krate(),
-            LangItemTarget::Static(s) => s.module(db).krate(db),
+            LangItemTarget::Static(s) => s.module(db).krate(),
-            LangItemTarget::Struct(s) => s.module(db).krate(db),
+            LangItemTarget::Struct(s) => s.module(db).krate(),
-            LangItemTarget::Trait(t) => t.module(db).krate(db),
+            LangItemTarget::Trait(t) => t.module(db).krate(),
-        }
+        })
    }
 }
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index ca261e8f5..40f5562b4 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -26,25 +26,19 @@ macro_rules! impl_froms {
    }
 }
-mod either;
 pub mod debug;
 pub mod db;
 #[macro_use]
 pub mod mock;
-mod path;
 pub mod source_binder;
-mod source_id;
 mod ids;
-mod name;
 mod nameres;
 mod adt;
 mod traits;
 mod type_alias;
-mod type_ref;
 mod ty;
-mod attr;
 mod impl_block;
 mod expr;
 mod lang_item;
@@ -60,37 +54,35 @@ pub mod from_source;
 #[cfg(test)]
 mod marks;
-use crate::{
+use hir_expand::AstId;
-    ids::MacroFileKind,
-    name::AsName,
+use crate::{ids::MacroFileKind, resolve::Resolver};
-    resolve::Resolver,
-    source_id::{AstId, FileAstId},
-};
-pub use self::{
+pub use crate::{
    adt::VariantDef,
-    either::Either,
+    code_model::{
+        docs::{DocDef, Docs, Documentation},
+        src::{HasBodySource, HasSource, Source},
+        Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum,
+        EnumVariant, FieldSource, FnData, Function, HasBody, MacroDef, Module, ModuleDef,
+        ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
+    },
    expr::ExprScopes,
    from_source::FromSource,
    generics::{GenericDef, GenericParam, GenericParams, HasGenericParams},
    ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile},
    impl_block::ImplBlock,
-    name::Name,
    nameres::{ImportId, Namespace, PerNs},
-    path::{Path, PathKind},
    resolve::ScopeDef,
    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
-    source_id::{AstIdMap, ErasedFileAstId},
    ty::{
        display::HirDisplay, ApplicationTy, CallableDef, Substs, TraitRef, Ty, TypeCtor, TypeWalk,
    },
-    type_ref::Mutability,
 };
-pub use self::code_model::{
+pub use hir_def::{
-    docs::{DocDef, Docs, Documentation},
+    builtin_type::BuiltinType,
-    src::{HasBodySource, HasSource, Source},
+    path::{Path, PathKind},
-    Adt, AssocItem, BuiltinType, Const, ConstData, Container, Crate, CrateDependency, DefWithBody,
+    type_ref::Mutability,
-    Enum, EnumVariant, FieldSource, FnData, Function, HasBody, MacroDef, Module, ModuleDef,
-    ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union,
 };
+pub use hir_expand::{either::Either, name::Name};
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs
index 79af24b20..b423489a1 100644
--- a/crates/ra_hir/src/marks.rs
+++ b/crates/ra_hir/src/marks.rs
@@ -2,6 +2,7 @@
 test_utils::marks!(
    bogus_paths
+    // FIXME: restore this mark once hir is split
    name_res_works_for_broken_modules
    can_import_enum_variant
    type_var_cycles_resolve_completely
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs
index 0b278deb3..35dfaf3ba 100644
--- a/crates/ra_hir/src/mock.rs
+++ b/crates/ra_hir/src/mock.rs
@@ -22,6 +22,7 @@ pub const WORKSPACE: SourceRootId = SourceRootId(0);
    db::InternDatabaseStorage,
    db::AstDatabaseStorage,
    db::DefDatabaseStorage,
+    db::DefDatabase2Storage,
    db::HirDatabaseStorage
 )]
 #[derive(Debug)]
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
deleted file mode 100644
index 1e0b8c350..000000000
--- a/crates/ra_hir/src/name.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-//! FIXME: write short doc here
-use std::fmt;
-use ra_syntax::{ast, SmolStr};
-/// `Name` is a wrapper around string, which is used in hir for both references
-/// and declarations. In theory, names should also carry hygiene info, but we are
-/// not there yet!
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Name(Repr);
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-enum Repr {
-    Text(SmolStr),
-    TupleField(usize),
-}
-impl fmt::Display for Name {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match &self.0 {
-            Repr::Text(text) => fmt::Display::fmt(&text, f),
-            Repr::TupleField(idx) => fmt::Display::fmt(&idx, f),
-        }
-    }
-}
-impl Name {
-    /// Note: this is private to make creating name from random string hard.
-    /// Hopefully, this should allow us to integrate hygiene cleaner in the
-    /// future, and to switch to interned representation of names.
-    const fn new_text(text: SmolStr) -> Name {
-        Name(Repr::Text(text))
-    }
-    pub(crate) fn new_tuple_field(idx: usize) -> Name {
-        Name(Repr::TupleField(idx))
-    }
-    /// Shortcut to create inline plain text name
-    const fn new_inline_ascii(len: usize, text: &[u8]) -> Name {
-        Name::new_text(SmolStr::new_inline_from_ascii(len, text))
-    }
-    /// Resolve a name from the text of token.
-    fn resolve(raw_text: &SmolStr) -> Name {
-        let raw_start = "r#";
-        if raw_text.as_str().starts_with(raw_start) {
-            Name::new_text(SmolStr::new(&raw_text[raw_start.len()..]))
-        } else {
-            Name::new_text(raw_text.clone())
-        }
-    }
-    pub(crate) fn missing() -> Name {
-        Name::new_text("[missing name]".into())
-    }
-    pub(crate) fn as_tuple_index(&self) -> Option<usize> {
-        match self.0 {
-            Repr::TupleField(idx) => Some(idx),
-            _ => None,
-        }
-    }
-}
-pub(crate) trait AsName {
-    fn as_name(&self) -> Name;
-}
-impl AsName for ast::NameRef {
-    fn as_name(&self) -> Name {
-        match self.as_tuple_field() {
-            Some(idx) => Name::new_tuple_field(idx),
-            None => Name::resolve(self.text()),
-        }
-    }
-}
-impl AsName for ast::Name {
-    fn as_name(&self) -> Name {
-        Name::resolve(self.text())
-    }
-}
-impl AsName for ast::FieldKind {
-    fn as_name(&self) -> Name {
-        match self {
-            ast::FieldKind::Name(nr) => nr.as_name(),
-            ast::FieldKind::Index(idx) => Name::new_tuple_field(idx.text().parse().unwrap()),
-        }
-    }
-}
-impl AsName for ra_db::Dependency {
-    fn as_name(&self) -> Name {
-        Name::new_text(self.name.clone())
-    }
-}
-// Primitives
-pub(crate) const ISIZE: Name = Name::new_inline_ascii(5, b"isize");
-pub(crate) const I8: Name = Name::new_inline_ascii(2, b"i8");
-pub(crate) const I16: Name = Name::new_inline_ascii(3, b"i16");
-pub(crate) const I32: Name = Name::new_inline_ascii(3, b"i32");
-pub(crate) const I64: Name = Name::new_inline_ascii(3, b"i64");
-pub(crate) const I128: Name = Name::new_inline_ascii(4, b"i128");
-pub(crate) const USIZE: Name = Name::new_inline_ascii(5, b"usize");
-pub(crate) const U8: Name = Name::new_inline_ascii(2, b"u8");
-pub(crate) const U16: Name = Name::new_inline_ascii(3, b"u16");
-pub(crate) const U32: Name = Name::new_inline_ascii(3, b"u32");
-pub(crate) const U64: Name = Name::new_inline_ascii(3, b"u64");
-pub(crate) const U128: Name = Name::new_inline_ascii(4, b"u128");
-pub(crate) const F32: Name = Name::new_inline_ascii(3, b"f32");
-pub(crate) const F64: Name = Name::new_inline_ascii(3, b"f64");
-pub(crate) const BOOL: Name = Name::new_inline_ascii(4, b"bool");
-pub(crate) const CHAR: Name = Name::new_inline_ascii(4, b"char");
-pub(crate) const STR: Name = Name::new_inline_ascii(3, b"str");
-// Special names
-pub(crate) const SELF_PARAM: Name = Name::new_inline_ascii(4, b"self");
-pub(crate) const SELF_TYPE: Name = Name::new_inline_ascii(4, b"Self");
-pub(crate) const MACRO_RULES: Name = Name::new_inline_ascii(11, b"macro_rules");
-// Components of known path (value or mod name)
-pub(crate) const STD: Name = Name::new_inline_ascii(3, b"std");
-pub(crate) const ITER: Name = Name::new_inline_ascii(4, b"iter");
-pub(crate) const OPS: Name = Name::new_inline_ascii(3, b"ops");
-pub(crate) const FUTURE: Name = Name::new_inline_ascii(6, b"future");
-pub(crate) const RESULT: Name = Name::new_inline_ascii(6, b"result");
-pub(crate) const BOXED: Name = Name::new_inline_ascii(5, b"boxed");
-// Components of known path (type name)
-pub(crate) const INTO_ITERATOR_TYPE: Name = Name::new_inline_ascii(12, b"IntoIterator");
-pub(crate) const ITEM_TYPE: Name = Name::new_inline_ascii(4, b"Item");
-pub(crate) const TRY_TYPE: Name = Name::new_inline_ascii(3, b"Try");
-pub(crate) const OK_TYPE: Name = Name::new_inline_ascii(2, b"Ok");
-pub(crate) const FUTURE_TYPE: Name = Name::new_inline_ascii(6, b"Future");
-pub(crate) const RESULT_TYPE: Name = Name::new_inline_ascii(6, b"Result");
-pub(crate) const OUTPUT_TYPE: Name = Name::new_inline_ascii(6, b"Output");
-pub(crate) const TARGET_TYPE: Name = Name::new_inline_ascii(6, b"Target");
-pub(crate) const BOX_TYPE: Name = Name::new_inline_ascii(3, b"Box");
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 67adcfa28..7ba031827 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -48,16 +48,15 @@
 //! on the result
 mod per_ns;
-mod raw;
 mod collector;
-mod mod_resolution;
 #[cfg(test)]
 mod tests;
 use std::sync::Arc;
+use hir_def::{builtin_type::BuiltinType, CrateModuleId};
 use once_cell::sync::Lazy;
-use ra_arena::{impl_arena_id, Arena, RawId};
+use ra_arena::Arena;
 use ra_db::{Edition, FileId};
 use ra_prof::profile;
 use ra_syntax::ast;
@@ -69,16 +68,12 @@ use crate::{
    diagnostics::DiagnosticSink,
    ids::MacroDefId,
    nameres::diagnostics::DefDiagnostic,
-    Adt, AstId, BuiltinType, Crate, HirFileId, MacroDef, Module, ModuleDef, Name, Path, PathKind,
+    Adt, AstId, Crate, HirFileId, MacroDef, Module, ModuleDef, Name, Path, PathKind, Trait,
-    Trait,
 };
-pub(crate) use self::raw::{ImportSourceMap, RawItems};
+pub use self::per_ns::{Namespace, PerNs};
-pub use self::{
+pub use hir_def::nameres::raw::ImportId;
-    per_ns::{Namespace, PerNs},
-    raw::ImportId,
-};
 /// Contains all top-level defs from a macro-expanded crate
 #[derive(Debug, PartialEq, Eq)]
@@ -115,13 +110,8 @@ impl std::ops::Index<CrateModuleId> for CrateDefMap {
    }
 }
-/// An ID of a module, **local** to a specific crate
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub(crate) struct CrateModuleId(RawId);
-impl_arena_id!(CrateModuleId);
 #[derive(Default, Debug, PartialEq, Eq)]
-pub(crate) struct ModuleData {
+pub struct ModuleData {
    pub(crate) parent: Option<CrateModuleId>,
    pub(crate) children: FxHashMap<Name, CrateModuleId>,
    pub(crate) scope: ModuleScope,
@@ -332,10 +322,11 @@ impl CrateDefMap {
    ) -> ResolvePathResult {
        let mut segments = path.segments.iter().enumerate();
        let mut curr_per_ns: PerNs = match path.kind {
-            PathKind::DollarCrate(krate) => {
+            PathKind::DollarCrate(crate_id) => {
+                let krate = Crate { crate_id };
                if krate == self.krate {
                    tested_by!(macro_dollar_crate_self);
-                    PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
+                    PerNs::types(Module::new(self.krate, self.root).into())
                } else {
                    match krate.root_module(db) {
                        Some(module) => {
@@ -346,12 +337,8 @@ impl CrateDefMap {
                    }
                }
            }
-            PathKind::Crate => {
+            PathKind::Crate => PerNs::types(Module::new(self.krate, self.root).into()),
-                PerNs::types(Module { krate: self.krate, module_id: self.root }.into())
+            PathKind::Self_ => PerNs::types(Module::new(self.krate, original_module).into()),
-            }
-            PathKind::Self_ => {
-                PerNs::types(Module { krate: self.krate, module_id: original_module }.into())
-            }
            // plain import or absolute path in 2015: crate-relative with
            // fallback to extern prelude (with the simplification in
            // rust-lang/rust#57745)
@@ -377,7 +364,7 @@ impl CrateDefMap {
            }
            PathKind::Super => {
                if let Some(p) = self.modules[original_module].parent {
-                    PerNs::types(Module { krate: self.krate, module_id: p }.into())
+                    PerNs::types(Module::new(self.krate, p).into())
                } else {
                    log::debug!("super path in root module");
                    return ResolvePathResult::empty(ReachedFixedPoint::Yes);
@@ -419,12 +406,12 @@ impl CrateDefMap {
            curr_per_ns = match curr {
                ModuleDef::Module(module) => {
-                    if module.krate != self.krate {
+                    if module.krate() != self.krate {
                        let path =
                            Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
                        log::debug!("resolving {:?} in other crate", path);
-                        let defp_map = db.crate_def_map(module.krate);
+                        let defp_map = db.crate_def_map(module.krate());
-                        let (def, s) = defp_map.resolve_path(db, module.module_id, &path);
+                        let (def, s) = defp_map.resolve_path(db, module.id.module_id, &path);
                        return ResolvePathResult::with(
                            def,
                            ReachedFixedPoint::Yes,
@@ -433,7 +420,7 @@ impl CrateDefMap {
                    }
                    // Since it is a qualified path here, it should not contains legacy macros
-                    match self[module.module_id].scope.get(&segment.name) {
+                    match self[module.id.module_id].scope.get(&segment.name) {
                        Some(res) => res.def,
                        _ => {
                            log::debug!("path segment {:?} not found", segment.name);
@@ -511,14 +498,14 @@ impl CrateDefMap {
    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 {
+            let def_map = if prelude.krate() == self.krate {
                self
            } else {
                // Extend lifetime
-                keep = db.crate_def_map(prelude.krate);
+                keep = db.crate_def_map(prelude.krate());
                &keep
            };
-            def_map[prelude.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
+            def_map[prelude.id.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
        } else {
            PerNs::none()
        }
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index b5fe16bfa..ee0a4c99f 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -1,5 +1,10 @@
 //! FIXME: write short doc here
+use hir_def::{
+    attr::Attr,
+    nameres::{mod_resolution::ModDir, raw},
+};
+use hir_expand::name;
 use ra_cfg::CfgOptions;
 use ra_db::FileId;
 use ra_syntax::{ast, SmolStr};
@@ -7,13 +12,11 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 use crate::{
-    attr::Attr,
    db::DefDatabase,
    ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind},
-    name::MACRO_RULES,
    nameres::{
-        diagnostics::DefDiagnostic, mod_resolution::ModDir, raw, Crate, CrateDefMap, CrateModuleId,
+        diagnostics::DefDiagnostic, Crate, CrateDefMap, CrateModuleId, ModuleData, ModuleDef,
-        ModuleData, ModuleDef, PerNs, ReachedFixedPoint, Resolution, ResolveMode,
+        PerNs, ReachedFixedPoint, Resolution, ResolveMode,
    },
    Adt, AstId, Const, Enum, Function, HirFileId, MacroDef, Module, Name, Path, PathKind, Static,
    Struct, Trait, TypeAlias, Union,
@@ -212,7 +215,7 @@ where
        if let Some(ModuleDef::Module(m)) = res.take_types() {
            tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
-            self.import_all_macros_exported(current_module_id, m.krate);
+            self.import_all_macros_exported(current_module_id, m.krate());
        }
    }
@@ -289,11 +292,11 @@ where
                    if import.is_prelude {
                        tested_by!(std_prelude);
                        self.def_map.prelude = Some(m);
-                    } else if m.krate != self.def_map.krate {
+                    } else if m.krate() != self.def_map.krate {
                        tested_by!(glob_across_crates);
                        // glob import from other crate => we can just import everything once
-                        let item_map = self.db.crate_def_map(m.krate);
+                        let item_map = self.db.crate_def_map(m.krate());
-                        let scope = &item_map[m.module_id].scope;
+                        let scope = &item_map[m.id.module_id].scope;
                        // Module scoped macros is included
                        let items = scope
@@ -307,7 +310,7 @@ where
                        // glob import from same crate => we do an initial
                        // import, and then need to propagate any further
                        // additions
-                        let scope = &self.def_map[m.module_id].scope;
+                        let scope = &self.def_map[m.id.module_id].scope;
                        // Module scoped macros is included
                        let items = scope
@@ -319,7 +322,7 @@ where
                        self.update(module_id, Some(import_id), &items);
                        // record the glob import in case we add further items
                        self.glob_imports
-                            .entry(m.module_id)
+                            .entry(m.id.module_id)
                            .or_default()
                            .push((module_id, import_id));
                    }
@@ -448,7 +451,7 @@ where
            );
            if let Some(def) = resolved_res.resolved_def.get_macros() {
-                let call_id = MacroCallLoc { def: def.id, ast_id: *ast_id }.id(self.db);
+                let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id: *ast_id });
                resolved.push((*module_id, call_id, def.id));
                res = ReachedFixedPoint::No;
                return false;
@@ -523,9 +526,10 @@ where
        // Prelude module is always considered to be `#[macro_use]`.
        if let Some(prelude_module) = self.def_collector.def_map.prelude {
-            if prelude_module.krate != self.def_collector.def_map.krate {
+            if prelude_module.krate() != self.def_collector.def_map.krate {
                tested_by!(prelude_is_macro_use);
-                self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
+                self.def_collector
+                    .import_all_macros_exported(self.module_id, prelude_module.krate());
            }
        }
@@ -567,7 +571,7 @@ where
            // inline module, just recurse
            raw::ModuleData::Definition { name, items, ast_id } => {
                let module_id =
-                    self.push_child_module(name.clone(), ast_id.with_file_id(self.file_id), None);
+                    self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None);
                ModCollector {
                    def_collector: &mut *self.def_collector,
@@ -583,7 +587,7 @@ where
            }
            // out of line module, resolve, parse and recurse
            raw::ModuleData::Declaration { name, ast_id } => {
-                let ast_id = ast_id.with_file_id(self.file_id);
+                let ast_id = AstId::new(self.file_id, *ast_id);
                match self.mod_dir.resolve_declaration(
                    self.def_collector.db,
                    self.file_id,
@@ -631,9 +635,7 @@ where
        modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone();
        modules[self.module_id].children.insert(name.clone(), res);
        let resolution = Resolution {
-            def: PerNs::types(
+            def: PerNs::types(Module::new(self.def_collector.def_map.krate, res).into()),
-                Module { krate: self.def_collector.def_map.krate, module_id: res }.into(),
-            ),
            import: None,
        };
        self.def_collector.update(self.module_id, None, &[(name, resolution)]);
@@ -641,8 +643,8 @@ where
    }
    fn define_def(&mut self, def: &raw::DefData) {
-        let module = Module { krate: self.def_collector.def_map.krate, module_id: self.module_id };
+        let module = Module::new(self.def_collector.def_map.krate, self.module_id);
-        let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
+        let ctx = LocationCtx::new(self.def_collector.db, module.id, self.file_id);
        macro_rules! def {
            ($kind:ident, $ast_id:ident) => {
@@ -671,28 +673,26 @@ where
    }
    fn collect_macro(&mut self, mac: &raw::MacroData) {
+        let ast_id = AstId::new(self.file_id, mac.ast_id);
        // Case 1: macro rules, define a macro in crate-global mutable scope
        if is_macro_rules(&mac.path) {
            if let Some(name) = &mac.name {
-                let macro_id = MacroDefId {
+                let macro_id =
-                    ast_id: mac.ast_id.with_file_id(self.file_id),
+                    MacroDefId { ast_id, krate: self.def_collector.def_map.krate.crate_id };
-                    krate: self.def_collector.def_map.krate,
-                };
                let macro_ = MacroDef { id: macro_id };
                self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export);
            }
            return;
        }
-        let ast_id = mac.ast_id.with_file_id(self.file_id);
        // Case 2: try to resolve in legacy scope and expand macro_rules, triggering
        // recursive item collection.
        if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
            self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
        }) {
            let def = macro_def.id;
-            let macro_call_id = MacroCallLoc { def, ast_id }.id(self.def_collector.db);
+            let macro_call_id = self.def_collector.db.intern_macro(MacroCallLoc { def, ast_id });
            self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, def);
            return;
@@ -728,7 +728,7 @@ where
 }
 fn is_macro_rules(path: &Path) -> bool {
-    path.as_ident() == Some(&MACRO_RULES)
+    path.as_ident() == Some(&name::MACRO_RULES)
 }
 #[cfg(test)]
diff --git a/crates/ra_hir/src/nameres/mod_resolution.rs b/crates/ra_hir/src/nameres/mod_resolution.rs
deleted file mode 100644
index e8b808514..000000000
--- a/crates/ra_hir/src/nameres/mod_resolution.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//! This module resolves `mod foo;` declaration to file.
-use ra_db::FileId;
-use ra_syntax::SmolStr;
-use relative_path::RelativePathBuf;
-use crate::{db::DefDatabase, HirFileId, Name};
-#[derive(Clone, Debug)]
-pub(super) struct ModDir {
-    /// `.` for `mod.rs`, `lib.rs`
-    /// `./foo` for `foo.rs`
-    /// `./foo/bar` for `mod bar { mod x; }` nested in `foo.rs`
-    path: RelativePathBuf,
-    /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/`
-    root_non_dir_owner: bool,
-}
-impl ModDir {
-    pub(super) fn root() -> ModDir {
-        ModDir { path: RelativePathBuf::default(), root_non_dir_owner: false }
-    }
-    pub(super) fn descend_into_definition(
-        &self,
-        name: &Name,
-        attr_path: Option<&SmolStr>,
-    ) -> ModDir {
-        let mut path = self.path.clone();
-        match attr_to_path(attr_path) {
-            None => path.push(&name.to_string()),
-            Some(attr_path) => {
-                if self.root_non_dir_owner {
-                    // Workaround for relative path API: turn `lib.rs` into ``.
-                    if !path.pop() {
-                        path = RelativePathBuf::default();
-                    }
-                }
-                path.push(attr_path);
-            }
-        }
-        ModDir { path, root_non_dir_owner: false }
-    }
-    pub(super) fn resolve_declaration(
-        &self,
-        db: &impl DefDatabase,
-        file_id: HirFileId,
-        name: &Name,
-        attr_path: Option<&SmolStr>,
-    ) -> Result<(FileId, ModDir), RelativePathBuf> {
-        let empty_path = RelativePathBuf::default();
-        let file_id = file_id.original_file(db);
-        let mut candidate_files = Vec::new();
-        match attr_to_path(attr_path) {
-            Some(attr_path) => {
-                let base = if self.root_non_dir_owner {
-                    self.path.parent().unwrap_or(&empty_path)
-                } else {
-                    &self.path
-                };
-                candidate_files.push(base.join(attr_path))
-            }
-            None => {
-                candidate_files.push(self.path.join(&format!("{}.rs", name)));
-                candidate_files.push(self.path.join(&format!("{}/mod.rs", name)));
-            }
-        };
-        for candidate in candidate_files.iter() {
-            if let Some(file_id) = db.resolve_relative_path(file_id, candidate) {
-                let mut root_non_dir_owner = false;
-                let mut mod_path = RelativePathBuf::new();
-                if !(candidate.ends_with("mod.rs") || attr_path.is_some()) {
-                    root_non_dir_owner = true;
-                    mod_path.push(&name.to_string());
-                }
-                return Ok((file_id, ModDir { path: mod_path, root_non_dir_owner }));
-            }
-        }
-        Err(candidate_files.remove(0))
-    }
-}
-fn attr_to_path(attr: Option<&SmolStr>) -> Option<RelativePathBuf> {
-    attr.and_then(|it| RelativePathBuf::from_path(&it.replace("\\", "/")).ok())
-}
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
deleted file mode 100644
index 57f2929c3..000000000
--- a/crates/ra_hir/src/nameres/raw.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-//! FIXME: write short doc here
-use std::{ops::Index, sync::Arc};
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
-use ra_syntax::{
-    ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SourceFile,
-};
-use test_utils::tested_by;
-use crate::{
-    attr::Attr,
-    db::{AstDatabase, DefDatabase},
-    AsName, AstIdMap, Either, FileAstId, HirFileId, ModuleSource, Name, Path, Source,
-};
-/// `RawItems` is a set of top-level items in a file (except for impls).
-///
-/// It is the input to name resolution algorithm. `RawItems` are not invalidated
-/// on most edits.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct RawItems {
-    modules: Arena<Module, ModuleData>,
-    imports: Arena<ImportId, ImportData>,
-    defs: Arena<Def, DefData>,
-    macros: Arena<Macro, MacroData>,
-    /// items for top-level module
-    items: Vec<RawItem>,
-}
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, ImportSourcePtr>,
-}
-type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-type ImportSource = Either<ast::UseTree, ast::ExternCrateItem>;
-impl ImportSourcePtr {
-    fn to_node(self, file: &SourceFile) -> ImportSource {
-        self.map(|ptr| ptr.to_node(file.syntax()), |ptr| ptr.to_node(file.syntax()))
-    }
-}
-impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, ptr: ImportSourcePtr) {
-        self.map.insert(import, ptr)
-    }
-    pub(crate) 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(),
-        };
-        self.map[import].to_node(&file)
-    }
-}
-impl RawItems {
-    pub(crate) fn raw_items_query(
-        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 DefDatabase + AstDatabase),
-        file_id: HirFileId,
-    ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
-        let mut collector = RawItemsCollector {
-            raw_items: RawItems::default(),
-            source_ast_id_map: db.ast_id_map(file_id),
-            source_map: ImportSourceMap::default(),
-            file_id,
-            db,
-        };
-        if let Some(node) = db.parse_or_expand(file_id) {
-            if let Some(source_file) = ast::SourceFile::cast(node.clone()) {
-                collector.process_module(None, source_file);
-            } else if let Some(item_list) = ast::MacroItems::cast(node) {
-                collector.process_module(None, item_list);
-            }
-        }
-        (Arc::new(collector.raw_items), Arc::new(collector.source_map))
-    }
-    pub(super) fn items(&self) -> &[RawItem] {
-        &self.items
-    }
-}
-impl Index<Module> for RawItems {
-    type Output = ModuleData;
-    fn index(&self, idx: Module) -> &ModuleData {
-        &self.modules[idx]
-    }
-}
-impl Index<ImportId> for RawItems {
-    type Output = ImportData;
-    fn index(&self, idx: ImportId) -> &ImportData {
-        &self.imports[idx]
-    }
-}
-impl Index<Def> for RawItems {
-    type Output = DefData;
-    fn index(&self, idx: Def) -> &DefData {
-        &self.defs[idx]
-    }
-}
-impl Index<Macro> for RawItems {
-    type Output = MacroData;
-    fn index(&self, idx: Macro) -> &MacroData {
-        &self.macros[idx]
-    }
-}
-// 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) 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),
-    Def(Def),
-    Macro(Macro),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Module(RawId);
-impl_arena_id!(Module);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module> },
-    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,
-    pub(super) alias: Option<Name>,
-    pub(super) is_glob: bool,
-    pub(super) is_prelude: bool,
-    pub(super) is_extern_crate: bool,
-    pub(super) is_macro_use: bool,
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Def(RawId);
-impl_arena_id!(Def);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct DefData {
-    pub(super) name: Name,
-    pub(super) kind: DefKind,
-}
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub(super) enum DefKind {
-    Function(FileAstId<ast::FnDef>),
-    Struct(FileAstId<ast::StructDef>),
-    Union(FileAstId<ast::StructDef>),
-    Enum(FileAstId<ast::EnumDef>),
-    Const(FileAstId<ast::ConstDef>),
-    Static(FileAstId<ast::StaticDef>),
-    Trait(FileAstId<ast::TraitDef>),
-    TypeAlias(FileAstId<ast::TypeAliasDef>),
-}
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub(super) struct Macro(RawId);
-impl_arena_id!(Macro);
-#[derive(Debug, PartialEq, Eq)]
-pub(super) struct MacroData {
-    pub(super) ast_id: FileAstId<ast::MacroCall>,
-    pub(super) path: Path,
-    pub(super) name: Option<Name>,
-    pub(super) export: bool,
-}
-struct RawItemsCollector<DB> {
-    raw_items: RawItems,
-    source_ast_id_map: Arc<AstIdMap>,
-    source_map: ImportSourceMap,
-    file_id: HirFileId,
-    db: DB,
-}
-impl<DB: AstDatabase> RawItemsCollector<&DB> {
-    fn process_module(&mut self, current_module: Option<Module>, body: impl ast::ModuleItemOwner) {
-        for item_or_macro in body.items_with_macros() {
-            match item_or_macro {
-                ast::ItemOrMacro::Macro(m) => self.add_macro(current_module, m),
-                ast::ItemOrMacro::Item(item) => self.add_item(current_module, item),
-            }
-        }
-    }
-    fn add_item(&mut self, current_module: Option<Module>, item: ast::ModuleItem) {
-        let attrs = self.parse_attrs(&item);
-        let (kind, name) = match item {
-            ast::ModuleItem::Module(module) => {
-                self.add_module(current_module, module);
-                return;
-            }
-            ast::ModuleItem::UseItem(use_item) => {
-                self.add_use_item(current_module, use_item);
-                return;
-            }
-            ast::ModuleItem::ExternCrateItem(extern_crate) => {
-                self.add_extern_crate_item(current_module, extern_crate);
-                return;
-            }
-            ast::ModuleItem::ImplBlock(_) => {
-                // impls don't participate in name resolution
-                return;
-            }
-            ast::ModuleItem::StructDef(it) => {
-                let id = self.source_ast_id_map.ast_id(&it);
-                let name = it.name();
-                if it.is_union() {
-                    (DefKind::Union(id), name)
-                } else {
-                    (DefKind::Struct(id), name)
-                }
-            }
-            ast::ModuleItem::EnumDef(it) => {
-                (DefKind::Enum(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::FnDef(it) => {
-                (DefKind::Function(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::TraitDef(it) => {
-                (DefKind::Trait(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::TypeAliasDef(it) => {
-                (DefKind::TypeAlias(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::ConstDef(it) => {
-                (DefKind::Const(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-            ast::ModuleItem::StaticDef(it) => {
-                (DefKind::Static(self.source_ast_id_map.ast_id(&it)), it.name())
-            }
-        };
-        if let Some(name) = name {
-            let name = name.as_name();
-            let def = self.raw_items.defs.alloc(DefData { name, kind });
-            self.push_item(current_module, attrs, RawItemKind::Def(def));
-        }
-    }
-    fn add_module(&mut self, current_module: Option<Module>, module: ast::Module) {
-        let name = match module.name() {
-            Some(it) => it.as_name(),
-            None => return,
-        };
-        let attrs = self.parse_attrs(&module);
-        let ast_id = self.source_ast_id_map.ast_id(&module);
-        if module.has_semi() {
-            let item = self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id });
-            self.push_item(current_module, attrs, RawItemKind::Module(item));
-            return;
-        }
-        if let Some(item_list) = module.item_list() {
-            let item = self.raw_items.modules.alloc(ModuleData::Definition {
-                name,
-                ast_id,
-                items: Vec::new(),
-            });
-            self.process_module(Some(item), item_list);
-            self.push_item(current_module, attrs, RawItemKind::Module(item));
-            return;
-        }
-        tested_by!(name_res_works_for_broken_modules);
-    }
-    fn add_use_item(&mut self, current_module: Option<Module>, use_item: ast::UseItem) {
-        // FIXME: cfg_attr
-        let is_prelude = use_item.has_atom_attr("prelude_import");
-        let attrs = self.parse_attrs(&use_item);
-        Path::expand_use_item(
-            Source { ast: use_item, file_id: self.file_id },
-            self.db,
-            |path, use_tree, is_glob, alias| {
-                let import_data = ImportData {
-                    path,
-                    alias,
-                    is_glob,
-                    is_prelude,
-                    is_extern_crate: false,
-                    is_macro_use: false,
-                };
-                self.push_import(
-                    current_module,
-                    attrs.clone(),
-                    import_data,
-                    Either::A(AstPtr::new(use_tree)),
-                );
-            },
-        )
-    }
-    fn add_extern_crate_item(
-        &mut self,
-        current_module: Option<Module>,
-        extern_crate: ast::ExternCrateItem,
-    ) {
-        if let Some(name_ref) = extern_crate.name_ref() {
-            let path = Path::from_name_ref(&name_ref);
-            let alias = extern_crate.alias().and_then(|a| a.name()).map(|it| it.as_name());
-            let attrs = self.parse_attrs(&extern_crate);
-            // FIXME: cfg_attr
-            let is_macro_use = extern_crate.has_atom_attr("macro_use");
-            let import_data = ImportData {
-                path,
-                alias,
-                is_glob: false,
-                is_prelude: false,
-                is_extern_crate: true,
-                is_macro_use,
-            };
-            self.push_import(
-                current_module,
-                attrs,
-                import_data,
-                Either::B(AstPtr::new(&extern_crate)),
-            );
-        }
-    }
-    fn add_macro(&mut self, current_module: Option<Module>, m: ast::MacroCall) {
-        let attrs = self.parse_attrs(&m);
-        let path = match m
-            .path()
-            .and_then(|path| Path::from_src(Source { ast: path, file_id: self.file_id }, self.db))
-        {
-            Some(it) => it,
-            _ => return,
-        };
-        let name = m.name().map(|it| it.as_name());
-        let ast_id = self.source_ast_id_map.ast_id(&m);
-        // FIXME: cfg_attr
-        let export = m.attrs().filter_map(|x| x.simple_name()).any(|name| name == "macro_export");
-        let m = self.raw_items.macros.alloc(MacroData { ast_id, path, name, export });
-        self.push_item(current_module, attrs, RawItemKind::Macro(m));
-    }
-    fn push_import(
-        &mut self,
-        current_module: Option<Module>,
-        attrs: Attrs,
-        data: ImportData,
-        source: ImportSourcePtr,
-    ) {
-        let import = self.raw_items.imports.alloc(data);
-        self.source_map.insert(import, source);
-        self.push_item(current_module, attrs, RawItemKind::Import(import))
-    }
-    fn push_item(&mut self, current_module: Option<Module>, attrs: Attrs, kind: RawItemKind) {
-        match current_module {
-            Some(module) => match &mut self.raw_items.modules[module] {
-                ModuleData::Definition { items, .. } => items,
-                ModuleData::Declaration { .. } => unreachable!(),
-            },
-            None => &mut self.raw_items.items,
-        }
-        .push(RawItem { attrs, kind })
-    }
-    fn parse_attrs(&self, item: &impl ast::AttrsOwner) -> Attrs {
-        Attr::from_attrs_owner(self.file_id, item, self.db)
-    }
-}
diff --git a/crates/ra_hir/src/nameres/tests/mod_resolution.rs b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
index f569aacdc..abfe8b1c3 100644
--- a/crates/ra_hir/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir/src/nameres/tests/mod_resolution.rs
@@ -2,7 +2,7 @@ use super::*;
 #[test]
 fn name_res_works_for_broken_modules() {
-    covers!(name_res_works_for_broken_modules);
+    // covers!(name_res_works_for_broken_modules);
    let map = def_map(
        "
        //- /lib.rs
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
deleted file mode 100644
index 394617e1a..000000000
--- a/crates/ra_hir/src/path.rs
+++ /dev/null
@@ -1,417 +0,0 @@
-//! FIXME: write short doc here
-use std::{iter, sync::Arc};
-use ra_syntax::{
-    ast::{self, NameOwner, TypeAscriptionOwner},
-    AstNode,
-};
-use crate::{db::AstDatabase, name, type_ref::TypeRef, AsName, Crate, Name, Source};
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Path {
-    pub kind: PathKind,
-    pub segments: Vec<PathSegment>,
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct PathSegment {
-    pub name: Name,
-    pub args_and_bindings: Option<Arc<GenericArgs>>,
-}
-/// Generic arguments to a path segment (e.g. the `i32` in `Option<i32>`). This
-/// can (in the future) also include bindings of associated types, like in
-/// `Iterator<Item = Foo>`.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct GenericArgs {
-    pub args: Vec<GenericArg>,
-    /// This specifies whether the args contain a Self type as the first
-    /// element. This is the case for path segments like `<T as Trait>`, where
-    /// `T` is actually a type parameter for the path `Trait` specifying the
-    /// Self type. Otherwise, when we have a path `Trait<X, Y>`, the Self type
-    /// is left out.
-    pub has_self_type: bool,
-    /// Associated type bindings like in `Iterator<Item = T>`.
-    pub bindings: Vec<(Name, TypeRef)>,
-}
-/// A single generic argument.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum GenericArg {
-    Type(TypeRef),
-    // or lifetime...
-}
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum PathKind {
-    Plain,
-    Self_,
-    Super,
-    Crate,
-    // Absolute path
-    Abs,
-    // Type based path like `<T>::foo`
-    Type(Box<TypeRef>),
-    // `$crate` from macro expansion
-    DollarCrate(Crate),
-}
-impl Path {
-    /// Calls `cb` with all paths, represented by this use item.
-    pub fn expand_use_item(
-        item_src: Source<ast::UseItem>,
-        db: &impl AstDatabase,
-        mut cb: impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
-    ) {
-        if let Some(tree) = item_src.ast.use_tree() {
-            expand_use_tree(None, tree, &|| item_src.file_id.macro_crate(db), &mut cb);
-        }
-    }
-    pub fn from_simple_segments(kind: PathKind, segments: impl IntoIterator<Item = Name>) -> Path {
-        Path {
-            kind,
-            segments: segments
-                .into_iter()
-                .map(|name| PathSegment { name, args_and_bindings: None })
-                .collect(),
-        }
-    }
-    /// Converts an `ast::Path` to `Path`. Works with use trees.
-    /// DEPRECATED: It does not handle `$crate` from macro call.
-    pub fn from_ast(path: ast::Path) -> Option<Path> {
-        Path::parse(path, &|| None)
-    }
-    /// Converts an `ast::Path` to `Path`. Works with use trees.
-    /// It correctly handles `$crate` based path from macro call.
-    pub fn from_src(source: Source<ast::Path>, db: &impl AstDatabase) -> Option<Path> {
-        let file_id = source.file_id;
-        Path::parse(source.ast, &|| file_id.macro_crate(db))
-    }
-    fn parse(mut path: ast::Path, macro_crate: &impl Fn() -> Option<Crate>) -> Option<Path> {
-        let mut kind = PathKind::Plain;
-        let mut segments = Vec::new();
-        loop {
-            let segment = path.segment()?;
-            if segment.has_colon_colon() {
-                kind = PathKind::Abs;
-            }
-            match segment.kind()? {
-                ast::PathSegmentKind::Name(name) => {
-                    if name.text() == "$crate" {
-                        if let Some(macro_crate) = macro_crate() {
-                            kind = PathKind::DollarCrate(macro_crate);
-                            break;
-                        }
-                    }
-                    let args = segment
-                        .type_arg_list()
-                        .and_then(GenericArgs::from_ast)
-                        .or_else(|| {
-                            GenericArgs::from_fn_like_path_ast(
-                                segment.param_list(),
-                                segment.ret_type(),
-                            )
-                        })
-                        .map(Arc::new);
-                    let segment = PathSegment { name: name.as_name(), args_and_bindings: args };
-                    segments.push(segment);
-                }
-                ast::PathSegmentKind::Type { type_ref, trait_ref } => {
-                    assert!(path.qualifier().is_none()); // this can only occur at the first segment
-                    let self_type = TypeRef::from_ast(type_ref?);
-                    match trait_ref {
-                        // <T>::foo
-                        None => {
-                            kind = PathKind::Type(Box::new(self_type));
-                        }
-                        // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
-                        Some(trait_ref) => {
-                            let path = Path::parse(trait_ref.path()?, macro_crate)?;
-                            kind = path.kind;
-                            let mut prefix_segments = path.segments;
-                            prefix_segments.reverse();
-                            segments.extend(prefix_segments);
-                            // Insert the type reference (T in the above example) as Self parameter for the trait
-                            let mut last_segment = segments.last_mut()?;
-                            if last_segment.args_and_bindings.is_none() {
-                                last_segment.args_and_bindings =
-                                    Some(Arc::new(GenericArgs::empty()));
-                            };
-                            let args = last_segment.args_and_bindings.as_mut().unwrap();
-                            let mut args_inner = Arc::make_mut(args);
-                            args_inner.has_self_type = true;
-                            args_inner.args.insert(0, GenericArg::Type(self_type));
-                        }
-                    }
-                }
-                ast::PathSegmentKind::CrateKw => {
-                    kind = PathKind::Crate;
-                    break;
-                }
-                ast::PathSegmentKind::SelfKw => {
-                    kind = PathKind::Self_;
-                    break;
-                }
-                ast::PathSegmentKind::SuperKw => {
-                    kind = PathKind::Super;
-                    break;
-                }
-            }
-            path = match qualifier(&path) {
-                Some(it) => it,
-                None => break,
-            };
-        }
-        segments.reverse();
-        return Some(Path { kind, segments });
-        fn qualifier(path: &ast::Path) -> Option<ast::Path> {
-            if let Some(q) = path.qualifier() {
-                return Some(q);
-            }
-            // FIXME: this bottom up traversal is not too precise.
-            // Should we handle do a top-down analysis, recording results?
-            let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
-            let use_tree = use_tree_list.parent_use_tree();
-            use_tree.path()
-        }
-    }
-    /// Converts an `ast::NameRef` into a single-identifier `Path`.
-    pub fn from_name_ref(name_ref: &ast::NameRef) -> Path {
-        name_ref.as_name().into()
-    }
-    /// `true` is this path is a single identifier, like `foo`
-    pub fn is_ident(&self) -> bool {
-        self.kind == PathKind::Plain && self.segments.len() == 1
-    }
-    /// `true` if this path is just a standalone `self`
-    pub fn is_self(&self) -> bool {
-        self.kind == PathKind::Self_ && self.segments.is_empty()
-    }
-    /// If this path is a single identifier, like `foo`, return its name.
-    pub fn as_ident(&self) -> Option<&Name> {
-        if self.kind != PathKind::Plain || self.segments.len() > 1 {
-            return None;
-        }
-        self.segments.first().map(|s| &s.name)
-    }
-    pub fn expand_macro_expr(&self) -> Option<Name> {
-        self.as_ident().and_then(|name| Some(name.clone()))
-    }
-    pub fn is_type_relative(&self) -> bool {
-        match self.kind {
-            PathKind::Type(_) => true,
-            _ => false,
-        }
-    }
-}
-impl GenericArgs {
-    pub(crate) fn from_ast(node: ast::TypeArgList) -> Option<GenericArgs> {
-        let mut args = Vec::new();
-        for type_arg in node.type_args() {
-            let type_ref = TypeRef::from_ast_opt(type_arg.type_ref());
-            args.push(GenericArg::Type(type_ref));
-        }
-        // lifetimes ignored for now
-        let mut bindings = Vec::new();
-        for assoc_type_arg in node.assoc_type_args() {
-            if let Some(name_ref) = assoc_type_arg.name_ref() {
-                let name = name_ref.as_name();
-                let type_ref = TypeRef::from_ast_opt(assoc_type_arg.type_ref());
-                bindings.push((name, type_ref));
-            }
-        }
-        if args.is_empty() && bindings.is_empty() {
-            None
-        } else {
-            Some(GenericArgs { args, has_self_type: false, bindings })
-        }
-    }
-    /// Collect `GenericArgs` from the parts of a fn-like path, i.e. `Fn(X, Y)
-    /// -> Z` (which desugars to `Fn<(X, Y), Output=Z>`).
-    pub(crate) fn from_fn_like_path_ast(
-        params: Option<ast::ParamList>,
-        ret_type: Option<ast::RetType>,
-    ) -> Option<GenericArgs> {
-        let mut args = Vec::new();
-        let mut bindings = Vec::new();
-        if let Some(params) = params {
-            let mut param_types = Vec::new();
-            for param in params.params() {
-                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
-                param_types.push(type_ref);
-            }
-            let arg = GenericArg::Type(TypeRef::Tuple(param_types));
-            args.push(arg);
-        }
-        if let Some(ret_type) = ret_type {
-            let type_ref = TypeRef::from_ast_opt(ret_type.type_ref());
-            bindings.push((name::OUTPUT_TYPE, type_ref))
-        }
-        if args.is_empty() && bindings.is_empty() {
-            None
-        } else {
-            Some(GenericArgs { args, has_self_type: false, bindings })
-        }
-    }
-    pub(crate) fn empty() -> GenericArgs {
-        GenericArgs { args: Vec::new(), has_self_type: false, bindings: Vec::new() }
-    }
-}
-impl From<Name> for Path {
-    fn from(name: Name) -> Path {
-        Path::from_simple_segments(PathKind::Plain, iter::once(name))
-    }
-}
-fn expand_use_tree(
-    prefix: Option<Path>,
-    tree: ast::UseTree,
-    macro_crate: &impl Fn() -> Option<Crate>,
-    cb: &mut impl FnMut(Path, &ast::UseTree, bool, Option<Name>),
-) {
-    if let Some(use_tree_list) = tree.use_tree_list() {
-        let prefix = match tree.path() {
-            // E.g. use something::{{{inner}}};
-            None => prefix,
-            // E.g. `use something::{inner}` (prefix is `None`, path is `something`)
-            // or `use something::{path::{inner::{innerer}}}` (prefix is `something::path`, path is `inner`)
-            Some(path) => match convert_path(prefix, path, macro_crate) {
-                Some(it) => Some(it),
-                None => return, // FIXME: report errors somewhere
-            },
-        };
-        for child_tree in use_tree_list.use_trees() {
-            expand_use_tree(prefix.clone(), child_tree, macro_crate, cb);
-        }
-    } else {
-        let alias = tree.alias().and_then(|a| a.name()).map(|a| a.as_name());
-        if let Some(ast_path) = tree.path() {
-            // Handle self in a path.
-            // E.g. `use something::{self, <...>}`
-            if ast_path.qualifier().is_none() {
-                if let Some(segment) = ast_path.segment() {
-                    if segment.kind() == Some(ast::PathSegmentKind::SelfKw) {
-                        if let Some(prefix) = prefix {
-                            cb(prefix, &tree, false, alias);
-                            return;
-                        }
-                    }
-                }
-            }
-            if let Some(path) = convert_path(prefix, ast_path, macro_crate) {
-                let is_glob = tree.has_star();
-                cb(path, &tree, is_glob, alias)
-            }
-            // FIXME: report errors somewhere
-            // We get here if we do
-        }
-    }
-}
-fn convert_path(
-    prefix: Option<Path>,
-    path: ast::Path,
-    macro_crate: &impl Fn() -> Option<Crate>,
-) -> Option<Path> {
-    let prefix = if let Some(qual) = path.qualifier() {
-        Some(convert_path(prefix, qual, macro_crate)?)
-    } else {
-        prefix
-    };
-    let segment = path.segment()?;
-    let res = match segment.kind()? {
-        ast::PathSegmentKind::Name(name) => {
-            if name.text() == "$crate" {
-                if let Some(krate) = macro_crate() {
-                    return Some(Path::from_simple_segments(
-                        PathKind::DollarCrate(krate),
-                        iter::empty(),
-                    ));
-                }
-            }
-            // no type args in use
-            let mut res = prefix
-                .unwrap_or_else(|| Path { kind: PathKind::Plain, segments: Vec::with_capacity(1) });
-            res.segments.push(PathSegment {
-                name: name.as_name(),
-                args_and_bindings: None, // no type args in use
-            });
-            res
-        }
-        ast::PathSegmentKind::CrateKw => {
-            if prefix.is_some() {
-                return None;
-            }
-            Path::from_simple_segments(PathKind::Crate, iter::empty())
-        }
-        ast::PathSegmentKind::SelfKw => {
-            if prefix.is_some() {
-                return None;
-            }
-            Path::from_simple_segments(PathKind::Self_, iter::empty())
-        }
-        ast::PathSegmentKind::SuperKw => {
-            if prefix.is_some() {
-                return None;
-            }
-            Path::from_simple_segments(PathKind::Super, iter::empty())
-        }
-        ast::PathSegmentKind::Type { .. } => {
-            // not allowed in imports
-            return None;
-        }
-    };
-    Some(res)
-}
-pub mod known {
-    use super::{Path, PathKind};
-    use crate::name;
-    pub fn std_iter_into_iterator() -> Path {
-        Path::from_simple_segments(
-            PathKind::Abs,
-            vec![name::STD, name::ITER, name::INTO_ITERATOR_TYPE],
-        )
-    }
-    pub fn std_ops_try() -> Path {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::TRY_TYPE])
-    }
-    pub fn std_result_result() -> Path {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::RESULT, name::RESULT_TYPE])
-    }
-    pub fn std_future_future() -> Path {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::FUTURE, name::FUTURE_TYPE])
-    }
-    pub fn std_boxed_box() -> Path {
-        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::BOXED, name::BOX_TYPE])
-    }
-}
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 3c797c0c3..75b24d386 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -1,6 +1,12 @@
 //! Name resolution.
 use std::sync::Arc;
+use hir_def::{
+    builtin_type::BuiltinType,
+    path::{Path, PathKind},
+    CrateModuleId,
+};
+use hir_expand::name::{self, Name};
 use rustc_hash::FxHashSet;
 use crate::{
@@ -12,11 +18,8 @@ use crate::{
    },
author	Seivan Heidari <[email protected]>	2019-10-31 08:43:20 +0000
committer	Seivan Heidari <[email protected]>	2019-10-31 08:43:20 +0000
commit	8edda0e7b164009d6c03bb3d4be603fb38ad2e2a (patch)
tree	744cf81075d394e2f9c06afb07642a2601800dda /crates/ra_hir
parent	49562d36b97ddde34cf7585a8c2e8f232519b657 (diff)
parent	d067afb064a7fa67b172abf561b7d80740cd6f18 (diff)