7 files changed, 70 insertions, 164 deletions

diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index aae3dcadf..b02364e86 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -12,19 +12,20 @@ use rustc_hash::FxHashMap;
 use test_utils::tested_by;
 
 use crate::{
-    attr::Attr,
-    db::DefDatabase2,
+    attr::Attrs,
+    db::DefDatabase,
     nameres::{
         diagnostics::DefDiagnostic, mod_resolution::ModDir, path_resolution::ReachedFixedPoint,
-        per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
+        raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
     },
     path::{Path, PathKind},
-    AdtId, AstId, AstItemDef, ConstLoc, ContainerId, CrateModuleId, EnumId, EnumVariantId,
-    FunctionLoc, ImplId, Intern, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
+    per_ns::PerNs,
+    AdtId, AstId, AstItemDef, ConstLoc, ContainerId, EnumId, EnumVariantId, FunctionLoc, ImplId,
+    Intern, LocalImportId, LocalModuleId, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
     StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
 };
 
-pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
+pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
     let crate_graph = db.crate_graph();
 
     // populate external prelude
@@ -94,10 +95,10 @@ impl MacroStackMonitor {
 struct DefCollector<'a, DB> {
     db: &'a DB,
     def_map: CrateDefMap,
-    glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>,
-    unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>,
-    unexpanded_macros: Vec<(CrateModuleId, AstId<ast::MacroCall>, Path)>,
-    mod_dirs: FxHashMap<CrateModuleId, ModDir>,
+    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
+    unresolved_imports: Vec<(LocalModuleId, LocalImportId, raw::ImportData)>,
+    unexpanded_macros: Vec<(LocalModuleId, AstId<ast::MacroCall>, Path)>,
+    mod_dirs: FxHashMap<LocalModuleId, ModDir>,
 
     /// Some macro use `$tt:tt which mean we have to handle the macro perfectly
     /// To prevent stack overflow, we add a deep counter here for prevent that.
@@ -108,7 +109,7 @@ struct DefCollector<'a, DB> {
 
 impl<DB> DefCollector<'_, DB>
 where
-    DB: DefDatabase2,
+    DB: DefDatabase,
 {
     fn collect(&mut self) {
         let crate_graph = self.db.crate_graph();
@@ -173,7 +174,7 @@ where
     /// ```
     fn define_macro(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         name: Name,
         macro_: MacroDefId,
         export: bool,
@@ -200,7 +201,7 @@ where
     /// the definition of current module.
     /// And also, `macro_use` on a module will import all legacy macros visable inside to
     /// current legacy scope, with possible shadowing.
-    fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDefId) {
+    fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, macro_: MacroDefId) {
         // Always shadowing
         self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_);
     }
@@ -208,7 +209,7 @@ where
     /// Import macros from `#[macro_use] extern crate`.
     fn import_macros_from_extern_crate(
         &mut self,
-        current_module_id: CrateModuleId,
+        current_module_id: LocalModuleId,
         import: &raw::ImportData,
     ) {
         log::debug!(
@@ -235,7 +236,7 @@ where
     /// Exported macros are just all macros in the root module scope.
     /// Note that it contains not only all `#[macro_export]` macros, but also all aliases
     /// created by `use` in the root module, ignoring the visibility of `use`.
-    fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: CrateId) {
+    fn import_all_macros_exported(&mut self, current_module_id: LocalModuleId, krate: CrateId) {
         let def_map = self.db.crate_def_map(krate);
         for (name, def) in def_map[def_map.root].scope.macros() {
             // `macro_use` only bring things into legacy scope.
@@ -265,7 +266,7 @@ where
 
     fn resolve_import(
         &self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         import: &raw::ImportData,
     ) -> (PerNs, ReachedFixedPoint) {
         log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
@@ -291,9 +292,9 @@ where
 
     fn record_resolved_import(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         def: PerNs,
-        import_id: raw::ImportId,
+        import_id: LocalImportId,
         import: &raw::ImportData,
     ) {
         if import.is_glob {
@@ -387,8 +388,8 @@ where
 
     fn update(
         &mut self,
-        module_id: CrateModuleId,
-        import: Option<raw::ImportId>,
+        module_id: LocalModuleId,
+        import: Option<LocalImportId>,
         resolutions: &[(Name, Resolution)],
     ) {
         self.update_recursive(module_id, import, resolutions, 0)
@@ -396,8 +397,8 @@ where
 
     fn update_recursive(
         &mut self,
-        module_id: CrateModuleId,
-        import: Option<raw::ImportId>,
+        module_id: LocalModuleId,
+        import: Option<LocalImportId>,
         resolutions: &[(Name, Resolution)],
         depth: usize,
     ) {
@@ -484,7 +485,7 @@ where
 
     fn collect_macro_expansion(
         &mut self,
-        module_id: CrateModuleId,
+        module_id: LocalModuleId,
         macro_call_id: MacroCallId,
         macro_def_id: MacroDefId,
     ) {
@@ -522,7 +523,7 @@ where
 /// Walks a single module, populating defs, imports and macros
 struct ModCollector<'a, D> {
     def_collector: D,
-    module_id: CrateModuleId,
+    module_id: LocalModuleId,
     file_id: HirFileId,
     raw_items: &'a raw::RawItems,
     mod_dir: ModDir,
@@ -530,7 +531,7 @@ struct ModCollector<'a, D> {
 
 impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
 where
-    DB: DefDatabase2,
+    DB: DefDatabase,
 {
     fn collect(&mut self, items: &[raw::RawItem]) {
         // Note: don't assert that inserted value is fresh: it's simply not true
@@ -549,7 +550,7 @@ where
         // `#[macro_use] extern crate` is hoisted to imports macros before collecting
         // any other items.
         for item in items {
-            if self.is_cfg_enabled(item.attrs()) {
+            if self.is_cfg_enabled(&item.attrs) {
                 if let raw::RawItemKind::Import(import_id) = item.kind {
                     let import = self.raw_items[import_id].clone();
                     if import.is_extern_crate && import.is_macro_use {
@@ -560,10 +561,10 @@ where
         }
 
         for item in items {
-            if self.is_cfg_enabled(item.attrs()) {
+            if self.is_cfg_enabled(&item.attrs) {
                 match item.kind {
                     raw::RawItemKind::Module(m) => {
-                        self.collect_module(&self.raw_items[m], item.attrs())
+                        self.collect_module(&self.raw_items[m], &item.attrs)
                     }
                     raw::RawItemKind::Import(import_id) => self
                         .def_collector
@@ -585,9 +586,9 @@ where
         }
     }
 
-    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &[Attr]) {
+    fn collect_module(&mut self, module: &raw::ModuleData, attrs: &Attrs) {
         let path_attr = self.path_attr(attrs);
-        let is_macro_use = self.is_macro_use(attrs);
+        let is_macro_use = attrs.has_atom("macro_use");
         match module {
             // inline module, just recurse
             raw::ModuleData::Definition { name, items, ast_id } => {
@@ -647,7 +648,7 @@ where
         name: Name,
         declaration: AstId<ast::Module>,
         definition: Option<FileId>,
-    ) -> CrateModuleId {
+    ) -> LocalModuleId {
         let modules = &mut self.def_collector.def_map.modules;
         let res = modules.alloc(ModuleData::default());
         modules[res].parent = Some(self.module_id);
@@ -772,24 +773,20 @@ where
         self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path));
     }
 
-    fn import_all_legacy_macros(&mut self, module_id: CrateModuleId) {
+    fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
         let macros = self.def_collector.def_map[module_id].scope.legacy_macros.clone();
         for (name, macro_) in macros {
             self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
         }
     }
 
-    fn is_cfg_enabled(&self, attrs: &[Attr]) -> bool {
+    fn is_cfg_enabled(&self, attrs: &Attrs) -> bool {
         attrs.iter().all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false))
     }
 
-    fn path_attr<'a>(&self, attrs: &'a [Attr]) -> Option<&'a SmolStr> {
+    fn path_attr<'a>(&self, attrs: &'a Attrs) -> Option<&'a SmolStr> {
         attrs.iter().find_map(|attr| attr.as_path())
     }
-
-    fn is_macro_use<'a>(&self, attrs: &'a [Attr]) -> bool {
-        attrs.iter().any(|attr| attr.is_simple_atom("macro_use"))
-    }
 }
 
 fn is_macro_rules(path: &Path) -> bool {
@@ -802,12 +799,12 @@ mod tests {
     use ra_db::{fixture::WithFixture, SourceDatabase};
     use rustc_hash::FxHashSet;
 
-    use crate::{db::DefDatabase2, test_db::TestDB};
+    use crate::{db::DefDatabase, test_db::TestDB};
 
     use super::*;
 
     fn do_collect_defs(
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         def_map: CrateDefMap,
         monitor: MacroStackMonitor,
     ) -> CrateDefMap {
@@ -831,7 +828,7 @@ mod tests {
 
         let def_map = {
             let edition = db.crate_graph().edition(krate);
-            let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+            let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
             let root = modules.alloc(ModuleData::default());
             CrateDefMap {
                 krate,
diff --git a/crates/ra_hir_def/src/nameres/mod_resolution.rs b/crates/ra_hir_def/src/nameres/mod_resolution.rs
index b3b1379d0..14fb8ba3a 100644
--- a/crates/ra_hir_def/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/mod_resolution.rs
@@ -3,7 +3,7 @@ use hir_expand::name::Name;
 use ra_db::{FileId, RelativePathBuf};
 use ra_syntax::SmolStr;
 
-use crate::{db::DefDatabase2, HirFileId};
+use crate::{db::DefDatabase, HirFileId};
 
 #[derive(Clone, Debug)]
 pub(super) struct ModDir {
@@ -40,7 +40,7 @@ impl ModDir {
 
     pub(super) fn resolve_declaration(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         file_id: HirFileId,
         name: &Name,
         attr_path: Option<&SmolStr>,
diff --git a/crates/ra_hir_def/src/nameres/path_resolution.rs b/crates/ra_hir_def/src/nameres/path_resolution.rs
index 95692f826..9455f22bb 100644
--- a/crates/ra_hir_def/src/nameres/path_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/path_resolution.rs
@@ -15,10 +15,11 @@ use ra_db::Edition;
 use test_utils::tested_by;
 
 use crate::{
-    db::DefDatabase2,
-    nameres::{per_ns::PerNs, CrateDefMap},
+    db::DefDatabase,
+    nameres::CrateDefMap,
     path::{Path, PathKind},
-    AdtId, CrateModuleId, EnumVariantId, ModuleDefId, ModuleId,
+    per_ns::PerNs,
+    AdtId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
 };
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -63,9 +64,9 @@ impl CrateDefMap {
     // the result.
     pub(super) fn resolve_path_fp_with_macro(
         &self,
-        db: &impl DefDatabase2,
+        db: &impl DefDatabase,
         mode: ResolveMode,
-        original_module: CrateModuleId,
+        original_module: LocalModuleId,
         path: &Path,
     ) -> ResolvePathResult {
         let mut segments = path.segments.iter().enumerate();
@@ -216,8 +217,8 @@ impl CrateDefMap {
 
     fn resolve_name_in_module(
         &self,
-        db: &impl DefDatabase2,
-        module: CrateModuleId,
+        db: &impl DefDatabase,
+        module: LocalModuleId,
         name: &Name,
     ) -> PerNs {
         // Resolve in:
@@ -243,7 +244,7 @@ impl CrateDefMap {
         from_crate_root.or(from_extern_prelude)
     }
 
-    fn resolve_in_prelude(&self, db: &impl DefDatabase2, name: &Name) -> PerNs {
+    fn resolve_in_prelude(&self, db: &impl DefDatabase, name: &Name) -> PerNs {
         if let Some(prelude) = self.prelude {
             let keep;
             let def_map = if prelude.krate == self.krate {
diff --git a/crates/ra_hir_def/src/nameres/per_ns.rs b/crates/ra_hir_def/src/nameres/per_ns.rs
deleted file mode 100644
index 717ed1ef9..000000000
--- a/crates/ra_hir_def/src/nameres/per_ns.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! FIXME: write short doc here
-
-use hir_expand::MacroDefId;
-
-use crate::ModuleDefId;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct PerNs {
-    pub types: Option<ModuleDefId>,
-    pub values: Option<ModuleDefId>,
-    /// Since macros has different type, many methods simply ignore it.
-    /// We can only use special method like `get_macros` to access it.
-    pub macros: Option<MacroDefId>,
-}
-
-impl Default for PerNs {
-    fn default() -> Self {
-        PerNs { types: None, values: None, macros: None }
-    }
-}
-
-impl PerNs {
-    pub fn none() -> PerNs {
-        PerNs { types: None, values: None, macros: None }
-    }
-
-    pub fn values(t: ModuleDefId) -> PerNs {
-        PerNs { types: None, values: Some(t), macros: None }
-    }
-
-    pub fn types(t: ModuleDefId) -> PerNs {
-        PerNs { types: Some(t), values: None, macros: None }
-    }
-
-    pub fn both(types: ModuleDefId, values: ModuleDefId) -> PerNs {
-        PerNs { types: Some(types), values: Some(values), macros: None }
-    }
-
-    pub fn macros(macro_: MacroDefId) -> PerNs {
-        PerNs { types: None, values: None, macros: Some(macro_) }
-    }
-
-    pub fn is_none(&self) -> bool {
-        self.types.is_none() && self.values.is_none() && self.macros.is_none()
-    }
-
-    pub fn is_all(&self) -> bool {
-        self.types.is_some() && self.values.is_some() && self.macros.is_some()
-    }
-
-    pub fn take_types(self) -> Option<ModuleDefId> {
-        self.types
-    }
-
-    pub fn take_values(self) -> Option<ModuleDefId> {
-        self.values
-    }
-
-    pub fn get_macros(&self) -> Option<MacroDefId> {
-        self.macros
-    }
-
-    pub fn only_macros(&self) -> PerNs {
-        PerNs { types: None, values: None, macros: self.macros }
-    }
-
-    pub fn or(self, other: PerNs) -> PerNs {
-        PerNs {
-            types: self.types.or(other.types),
-            values: self.values.or(other.values),
-            macros: self.macros.or(other.macros),
-        }
-    }
-}
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index 7c68fd638..552cbe544 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -12,11 +12,16 @@ use hir_expand::{
 use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
 use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr, SourceFile,
+    AstNode, AstPtr,
 };
 use test_utils::tested_by;
 
-use crate::{attr::Attr, db::DefDatabase2, path::Path, FileAstId, HirFileId, ModuleSource, Source};
+use crate::{
+    attr::{Attr, Attrs},
+    db::DefDatabase,
+    path::Path,
+    FileAstId, HirFileId, LocalImportId, Source,
+};
 
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -25,7 +30,7 @@ use crate::{attr::Attr, db::DefDatabase2, path::Path, FileAstId, HirFileId, Modu
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct RawItems {
     modules: Arena<Module, ModuleData>,
-    imports: Arena<ImportId, ImportData>,
+    imports: Arena<LocalImportId, ImportData>,
     defs: Arena<Def, DefData>,
     macros: Arena<Macro, MacroData>,
     impls: Arena<Impl, ImplData>,
@@ -35,41 +40,31 @@ pub struct RawItems {
 
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ImportSourceMap {
-    map: ArenaMap<ImportId, ImportSourcePtr>,
+    map: ArenaMap<LocalImportId, ImportSourcePtr>,
 }
 
 type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-type ImportSource = Either<ast::UseTree, ast::ExternCrateItem>;
-
-fn to_node(ptr: ImportSourcePtr, file: &SourceFile) -> ImportSource {
-    ptr.map(|ptr| ptr.to_node(file.syntax()), |ptr| ptr.to_node(file.syntax()))
-}
 
 impl ImportSourceMap {
-    fn insert(&mut self, import: ImportId, ptr: ImportSourcePtr) {
+    fn insert(&mut self, import: LocalImportId, ptr: ImportSourcePtr) {
         self.map.insert(import, ptr)
     }
 
-    pub fn get(&self, source: &ModuleSource, import: ImportId) -> ImportSource {
-        let file = match source {
-            ModuleSource::SourceFile(file) => file.clone(),
-            ModuleSource::Module(m) => m.syntax().ancestors().find_map(SourceFile::cast).unwrap(),
-        };
-
-        to_node(self.map[import], &file)
+    pub fn get(&self, import: LocalImportId) -> ImportSourcePtr {
+        self.map[import].clone()
     }
 }
 
 impl RawItems {
     pub(crate) fn raw_items_query(
-        db: &(impl DefDatabase2 + AstDatabase),
+        db: &(impl DefDatabase + AstDatabase),
         file_id: HirFileId,
     ) -> Arc<RawItems> {
         db.raw_items_with_source_map(file_id).0
     }
 
     pub(crate) fn raw_items_with_source_map_query(
-        db: &(impl DefDatabase2 + AstDatabase),
+        db: &(impl DefDatabase + AstDatabase),
         file_id: HirFileId,
     ) -> (Arc<RawItems>, Arc<ImportSourceMap>) {
         let mut collector = RawItemsCollector {
@@ -101,9 +96,9 @@ impl Index<Module> for RawItems {
     }
 }
 
-impl Index<ImportId> for RawItems {
+impl Index<LocalImportId> for RawItems {
     type Output = ImportData;
-    fn index(&self, idx: ImportId) -> &ImportData {
+    fn index(&self, idx: LocalImportId) -> &ImportData {
         &self.imports[idx]
     }
 }
@@ -129,25 +124,16 @@ impl Index<Impl> for RawItems {
     }
 }
 
-// Avoid heap allocation on items without attributes.
-type Attrs = Option<Arc<[Attr]>>;
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub(super) struct RawItem {
-    attrs: Attrs,
+    pub(super) attrs: Attrs,
     pub(super) kind: RawItemKind,
 }
 
-impl RawItem {
-    pub(super) fn attrs(&self) -> &[Attr] {
-        self.attrs.as_ref().map_or(&[], |it| &*it)
-    }
-}
-
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub(super) enum RawItemKind {
     Module(Module),
-    Import(ImportId),
+    Import(LocalImportId),
     Def(Def),
     Macro(Macro),
     Impl(Impl),
@@ -163,10 +149,6 @@ pub(super) enum ModuleData {
     Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct ImportId(RawId);
-impl_arena_id!(ImportId);
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportData {
     pub(super) path: Path,
diff --git a/crates/ra_hir_def/src/nameres/tests.rs b/crates/ra_hir_def/src/nameres/tests.rs
index 256f7d4be..f0b86af7c 100644
--- a/crates/ra_hir_def/src/nameres/tests.rs
+++ b/crates/ra_hir_def/src/nameres/tests.rs
@@ -10,7 +10,7 @@ use insta::assert_snapshot;
 use ra_db::{fixture::WithFixture, SourceDatabase};
 use test_utils::covers;
 
-use crate::{db::DefDatabase2, nameres::*, test_db::TestDB, CrateModuleId};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
 
 fn def_map(fixtute: &str) -> String {
     let dm = compute_crate_def_map(fixtute);
@@ -28,7 +28,7 @@ fn render_crate_def_map(map: &CrateDefMap) -> String {
     go(&mut buf, map, "\ncrate", map.root());
     return buf.trim().to_string();
 
-    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+    fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
         *buf += path;
         *buf += "\n";
 
diff --git a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
index eb7b85c07..e11530062 100644
--- a/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/ra_hir_def/src/nameres/tests/mod_resolution.rs
@@ -665,7 +665,7 @@ fn unresolved_module_diagnostics() {
         @r###"
     [
         UnresolvedModule {
-            module: CrateModuleId(
+            module: LocalModuleId(
                 0,
             ),
             declaration: AstId {