Merge #4819

4819: Add an FST index to `ImportMap` and use it to speed up auto import r=matklad a=jonas-schievink

For the importing crate, we still use the symbol index, but I've modified it to only look at files that comprise that crate (instead of the whole workspace).

Oh, and since now the symbol query limit is respected correctly, it's possible that some results from the local crate now disappear if there are many matches.

Fixes https://github.com/rust-analyzer/rust-analyzer/issues/4763

Co-authored-by: Jonas Schievink <[email protected]>

1 files changed, 24 insertions, 22 deletions

diff --git a/crates/ra_ide_db/src/imports_locator.rs b/crates/ra_ide_db/src/imports_locator.rs
index bf0d8db60..fff112e66 100644
--- a/crates/ra_ide_db/src/imports_locator.rs
+++ b/crates/ra_ide_db/src/imports_locator.rs
@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the ra_assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the ra_assists module.
 
-use hir::{MacroDef, ModuleDef, Semantics};
+use hir::{Crate, MacroDef, ModuleDef, Semantics};
 use ra_prof::profile;
 use ra_syntax::{ast, AstNode, SyntaxKind::NAME};
 
@@ -11,44 +11,46 @@ use crate::{
     RootDatabase,
 };
 use either::Either;
+use rustc_hash::FxHashSet;
 
 pub struct ImportsLocator<'a> {
     sema: Semantics<'a, RootDatabase>,
+    krate: Crate,
 }
 
 impl<'a> ImportsLocator<'a> {
-    pub fn new(db: &'a RootDatabase) -> Self {
-        Self { sema: Semantics::new(db) }
+    pub fn new(db: &'a RootDatabase, krate: Crate) -> Self {
+        Self { sema: Semantics::new(db), krate }
     }
 
     pub fn find_imports(&mut self, name_to_import: &str) -> Vec<Either<ModuleDef, MacroDef>> {
         let _p = profile("search_for_imports");
         let db = self.sema.db;
 
-        let project_results = {
-            let mut query = Query::new(name_to_import.to_string());
-            query.exact();
-            query.limit(40);
-            symbol_index::world_symbols(db, query)
-        };
-        let lib_results = {
+        // Query dependencies first.
+        let mut candidates: FxHashSet<_> =
+            self.krate.query_external_importables(db, name_to_import).collect();
+
+        // Query the local crate using the symbol index.
+        let local_results = {
             let mut query = Query::new(name_to_import.to_string());
-            query.libs();
             query.exact();
             query.limit(40);
-            symbol_index::world_symbols(db, query)
+            symbol_index::crate_symbols(db, self.krate.into(), query)
         };
 
-        project_results
-            .into_iter()
-            .chain(lib_results.into_iter())
-            .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
-            .filter_map(|name_definition_to_import| match name_definition_to_import {
-                Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
-                Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
-                _ => None,
-            })
-            .collect()
+        candidates.extend(
+            local_results
+                .into_iter()
+                .filter_map(|import_candidate| self.get_name_definition(&import_candidate))
+                .filter_map(|name_definition_to_import| match name_definition_to_import {
+                    Definition::ModuleDef(module_def) => Some(Either::Left(module_def)),
+                    Definition::Macro(macro_def) => Some(Either::Right(macro_def)),
+                    _ => None,
+                }),
+        );
+
+        candidates.into_iter().collect()
     }
 
     fn get_name_definition(&mut self, import_candidate: &FileSymbol) -> Option<Definition> {