Merge #2629

2629: Remove imports from hir r=matklad a=matklad

We only used them to avoid self-confirming completions (`use self::foo`), but that can be handled more locally.

bors r+

Co-authored-by: Aleksey Kladov <[email protected]>

2 files changed, 35 insertions, 79 deletions

diff --git a/crates/ra_hir_def/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index 45199fa11..9419461a8 100644
--- a/crates/ra_hir_def/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -26,8 +26,7 @@ use crate::{
     path::{ModPath, PathKind},
     per_ns::PerNs,
     AdtId, AstId, ConstLoc, ContainerId, EnumLoc, EnumVariantId, FunctionLoc, ImplLoc, Intern,
-    LocalImportId, LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc,
-    TypeAliasLoc, UnionLoc,
+    LocalModuleId, ModuleDefId, ModuleId, StaticLoc, StructLoc, TraitLoc, TypeAliasLoc, UnionLoc,
 };
 
 pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
@@ -93,7 +92,7 @@ impl PartialResolvedImport {
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct ImportDirective {
     module_id: LocalModuleId,
-    import_id: LocalImportId,
+    import_id: raw::LocalImportId,
     import: raw::ImportData,
     status: PartialResolvedImport,
 }
@@ -110,7 +109,7 @@ struct MacroDirective {
 struct DefCollector<'a, DB> {
     db: &'a DB,
     def_map: CrateDefMap,
-    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
+    glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, raw::LocalImportId)>>,
     unresolved_imports: Vec<ImportDirective>,
     resolved_imports: Vec<ImportDirective>,
     unexpanded_macros: Vec<MacroDirective>,
@@ -218,8 +217,7 @@ where
         if export {
             self.update(
                 self.def_map.root,
-                None,
-                &[(name, Resolution { def: PerNs::macros(macro_), import: None })],
+                &[(name, Resolution { def: PerNs::macros(macro_), declaration: false })],
             );
         }
     }
@@ -374,7 +372,7 @@ where
                         // Module scoped macros is included
                         let items = scope.collect_resolutions();
 
-                        self.update(module_id, Some(import_id), &items);
+                        self.update(module_id, &items);
                     } else {
                         // glob import from same crate => we do an initial
                         // import, and then need to propagate any further
@@ -384,7 +382,7 @@ where
                         // Module scoped macros is included
                         let items = scope.collect_resolutions();
 
-                        self.update(module_id, Some(import_id), &items);
+                        self.update(module_id, &items);
                         // record the glob import in case we add further items
                         let glob = self.glob_imports.entry(m.local_id).or_default();
                         if !glob.iter().any(|it| *it == (module_id, import_id)) {
@@ -404,12 +402,12 @@ where
                             let variant = EnumVariantId { parent: e, local_id };
                             let res = Resolution {
                                 def: PerNs::both(variant.into(), variant.into()),
-                                import: Some(import_id),
+                                declaration: false,
                             };
                             (name, res)
                         })
                         .collect::<Vec<_>>();
-                    self.update(module_id, Some(import_id), &resolutions);
+                    self.update(module_id, &resolutions);
                 }
                 Some(d) => {
                     log::debug!("glob import {:?} from non-module/enum {:?}", import, d);
@@ -431,27 +429,21 @@ where
                         }
                     }
 
-                    let resolution = Resolution { def, import: Some(import_id) };
-                    self.update(module_id, Some(import_id), &[(name, resolution)]);
+                    let resolution = Resolution { def, declaration: false };
+                    self.update(module_id, &[(name, resolution)]);
                 }
                 None => tested_by!(bogus_paths),
             }
         }
     }
 
-    fn update(
-        &mut self,
-        module_id: LocalModuleId,
-        import: Option<LocalImportId>,
-        resolutions: &[(Name, Resolution)],
-    ) {
-        self.update_recursive(module_id, import, resolutions, 0)
+    fn update(&mut self, module_id: LocalModuleId, resolutions: &[(Name, Resolution)]) {
+        self.update_recursive(module_id, resolutions, 0)
     }
 
     fn update_recursive(
         &mut self,
         module_id: LocalModuleId,
-        import: Option<LocalImportId>,
         resolutions: &[(Name, Resolution)],
         depth: usize,
     ) {
@@ -462,7 +454,7 @@ where
         let scope = &mut self.def_map.modules[module_id].scope;
         let mut changed = false;
         for (name, res) in resolutions {
-            changed |= scope.push_res(name.clone(), res, import);
+            changed |= scope.push_res(name.clone(), res, depth == 0 && res.declaration);
         }
 
         if !changed {
@@ -475,9 +467,9 @@ where
             .flat_map(|v| v.iter())
             .cloned()
             .collect::<Vec<_>>();
-        for (glob_importing_module, glob_import) in glob_imports {
+        for (glob_importing_module, _glob_import) in glob_imports {
             // We pass the glob import so that the tracked import in those modules is that glob import
-            self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1);
+            self.update_recursive(glob_importing_module, resolutions, depth + 1);
         }
     }
 
@@ -719,9 +711,9 @@ where
             def: PerNs::types(
                 ModuleId { krate: self.def_collector.def_map.krate, local_id: res }.into(),
             ),
-            import: None,
+            declaration: true,
         };
-        self.def_collector.update(self.module_id, None, &[(name, resolution)]);
+        self.def_collector.update(self.module_id, &[(name, resolution)]);
         res
     }
 
@@ -791,8 +783,8 @@ where
                 PerNs::types(def.into())
             }
         };
-        let resolution = Resolution { def, import: None };
-        self.def_collector.update(self.module_id, None, &[(name, resolution)])
+        let resolution = Resolution { def, declaration: true };
+        self.def_collector.update(self.module_id, &[(name, resolution)])
     }
 
     fn collect_derives(&mut self, attrs: &Attrs, def: &raw::DefData) {
diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs
index ecb4d7c03..b10e458a2 100644
--- a/crates/ra_hir_def/src/nameres/raw.rs
+++ b/crates/ra_hir_def/src/nameres/raw.rs
@@ -7,24 +7,24 @@
 
 use std::{ops::Index, sync::Arc};
 
-use either::Either;
 use hir_expand::{
     ast_id_map::AstIdMap,
     db::AstDatabase,
     hygiene::Hygiene,
     name::{AsName, Name},
 };
-use ra_arena::{impl_arena_id, map::ArenaMap, Arena, RawId};
+use ra_arena::{impl_arena_id, Arena, RawId};
 use ra_syntax::{
     ast::{self, AttrsOwner, NameOwner},
-    AstNode, AstPtr,
+    AstNode,
 };
 use test_utils::tested_by;
 
-use crate::{
-    attr::Attrs, db::DefDatabase, path::ModPath, trace::Trace, FileAstId, HirFileId, InFile,
-    LocalImportId,
-};
+use crate::{attr::Attrs, db::DefDatabase, path::ModPath, FileAstId, HirFileId, InFile};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub(super) struct LocalImportId(RawId);
+impl_arena_id!(LocalImportId);
 
 /// `RawItems` is a set of top-level items in a file (except for impls).
 ///
@@ -41,35 +41,14 @@ pub struct RawItems {
     items: Vec<RawItem>,
 }
 
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct ImportSourceMap {
-    map: ArenaMap<LocalImportId, ImportSourcePtr>,
-}
-
-type ImportSourcePtr = Either<AstPtr<ast::UseTree>, AstPtr<ast::ExternCrateItem>>;
-
-impl ImportSourceMap {
-    pub fn get(&self, import: LocalImportId) -> ImportSourcePtr {
-        self.map[import].clone()
-    }
-}
-
 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),
-            imports: Trace::new(),
             file_id,
             hygiene: Hygiene::new(db, file_id),
         };
@@ -80,11 +59,8 @@ impl RawItems {
                 collector.process_module(None, item_list);
             }
         }
-        let mut raw_items = collector.raw_items;
-        let (arena, map) = collector.imports.into_arena_and_map();
-        raw_items.imports = arena;
-        let source_map = ImportSourceMap { map };
-        (Arc::new(raw_items), Arc::new(source_map))
+        let raw_items = collector.raw_items;
+        Arc::new(raw_items)
     }
 
     pub(super) fn items(&self) -> &[RawItem] {
@@ -223,7 +199,6 @@ pub(super) struct ImplData {
 
 struct RawItemsCollector {
     raw_items: RawItems,
-    imports: Trace<LocalImportId, ImportData, ImportSourcePtr>,
     source_ast_id_map: Arc<AstIdMap>,
     file_id: HirFileId,
     hygiene: Hygiene,
@@ -330,7 +305,7 @@ impl RawItemsCollector {
         ModPath::expand_use_item(
             InFile { value: use_item, file_id: self.file_id },
             &self.hygiene,
-            |path, use_tree, is_glob, alias| {
+            |path, _use_tree, is_glob, alias| {
                 let import_data = ImportData {
                     path,
                     alias,
@@ -339,11 +314,11 @@ impl RawItemsCollector {
                     is_extern_crate: false,
                     is_macro_use: false,
                 };
-                buf.push((import_data, Either::Left(AstPtr::new(use_tree))));
+                buf.push(import_data);
             },
         );
-        for (import_data, ptr) in buf {
-            self.push_import(current_module, attrs.clone(), import_data, ptr);
+        for import_data in buf {
+            self.push_import(current_module, attrs.clone(), import_data);
         }
     }
 
@@ -366,12 +341,7 @@ impl RawItemsCollector {
                 is_extern_crate: true,
                 is_macro_use,
             };
-            self.push_import(
-                current_module,
-                attrs,
-                import_data,
-                Either::Right(AstPtr::new(&extern_crate)),
-            );
+            self.push_import(current_module, attrs, import_data);
         }
     }
 
@@ -402,14 +372,8 @@ impl RawItemsCollector {
         self.push_item(current_module, attrs, RawItemKind::Impl(imp))
     }
 
-    fn push_import(
-        &mut self,
-        current_module: Option<Module>,
-        attrs: Attrs,
-        data: ImportData,
-        source: ImportSourcePtr,
-    ) {
-        let import = self.imports.alloc(|| source, || data);
+    fn push_import(&mut self, current_module: Option<Module>, attrs: Attrs, data: ImportData) {
+        let import = self.raw_items.imports.alloc(data);
         self.push_item(current_module, attrs, RawItemKind::Import(import))
     }