Code review fixes

crates/completion/src/completions/unqualified_path.rs

@@ -3,7 +3,7 @@
 use std::iter;
 
 use either::Either;
-use hir::{Adt, AsAssocItem, ModPath, ModuleDef, ScopeDef, Type};
+use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
 use ide_db::helpers::insert_use::ImportScope;
 use ide_db::imports_locator;
 use syntax::AstNode;
@@ -142,15 +142,8 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()
         Some(40),
         potential_import_name,
         true,
+        true,
     )
-    .filter(|import_candidate| match import_candidate {
-        Either::Left(ModuleDef::Function(function)) => function.as_assoc_item(ctx.db).is_none(),
-        Either::Left(ModuleDef::Const(const_)) => const_.as_assoc_item(ctx.db).is_none(),
-        Either::Left(ModuleDef::TypeAlias(type_alias)) => {
-            type_alias.as_assoc_item(ctx.db).is_none()
-        }
-        _ => true,
-    })
     .filter_map(|import_candidate| {
         Some(match import_candidate {
             Either::Left(module_def) => {

crates/hir_def/src/import_map.rs

@@ -199,7 +199,7 @@ impl ImportMap {
                 ItemInNs::Values(module_def_id)
             };
 
-            let mut assoc_item_info = original_import_info.to_owned();
+            let mut assoc_item_info = original_import_info.clone();
             assoc_item_info.path.segments.push(assoc_item_name.to_owned());
             assoc_item_info.is_trait_assoc_item = true;
             self.map.insert(assoc_item, assoc_item_info);
@@ -325,22 +325,21 @@ impl Query {
         self.exclude_import_kinds.insert(import_kind);
         self
     }
-}
 
-fn import_matches_query(import: &ImportInfo, query: &Query, enforce_lowercase: bool) -> bool {
+    fn import_matches(&self, import: &ImportInfo, enforce_lowercase: bool) -> bool {
-    let mut input = if import.is_trait_assoc_item || query.name_only {
+        let mut input = if import.is_trait_assoc_item || self.name_only {
             import.path.segments.last().unwrap().to_string()
         } else {
             import.path.to_string()
         };
-    if enforce_lowercase || !query.case_sensitive {
+        if enforce_lowercase || !self.case_sensitive {
             input.make_ascii_lowercase();
         }
 
         let query_string =
-        if !enforce_lowercase && query.case_sensitive { &query.query } else { &query.lowercased };
+            if !enforce_lowercase && self.case_sensitive { &self.query } else { &self.lowercased };
 
-    match query.search_mode {
+        match self.search_mode {
             SearchMode::Equals => &input == query_string,
             SearchMode::Contains => input.contains(query_string),
             SearchMode::Fuzzy => {
@@ -359,6 +358,7 @@ fn import_matches_query(import: &ImportInfo, query: &Query, enforce_lowercase: b
                 mismatching_query_char.is_none()
             }
         }
+    }
 }
 
 /// Searches dependencies of `krate` for an importable path matching `query`.
@@ -390,7 +390,7 @@ pub fn search_dependencies<'a>(
             let importables = &import_map.importables[indexed_value.value as usize..];
 
             let common_importable_data = &import_map.map[&importables[0]];
-            if !import_matches_query(common_importable_data, &query, true) {
+            if !query.import_matches(common_importable_data, true) {
                 continue;
             }
 
@@ -410,7 +410,7 @@ pub fn search_dependencies<'a>(
                 })
                 .filter(|item| {
                     !query.case_sensitive // we've already checked the common importables path case-insensitively
-                        || import_matches_query(&import_map.map[item], &query, false)
+                        || query.import_matches(&import_map.map[item], false)
                 });
             res.extend(iter);
 

crates/ide_db/src/imports_locator.rs

@@ -1,7 +1,7 @@
 //! This module contains an import search funcionality that is provided to the assists module.
 //! Later, this should be moved away to a separate crate that is accessible from the assists module.
 
-use hir::{import_map, Crate, MacroDef, ModuleDef, Semantics};
+use hir::{import_map, AsAssocItem, Crate, MacroDef, ModuleDef, Semantics};
 use syntax::{ast, AstNode, SyntaxKind::NAME};
 
 use crate::{
@@ -40,8 +40,9 @@ pub fn find_similar_imports<'a>(
     krate: Crate,
     limit: Option<usize>,
     fuzzy_search_string: String,
+    ignore_assoc_items: bool,
     name_only: bool,
-) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
+) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> + 'a {
     let _p = profile::span("find_similar_imports");
 
     let mut external_query = import_map::Query::new(fuzzy_search_string.clone())
@@ -57,7 +58,21 @@ pub fn find_similar_imports<'a>(
         external_query = external_query.limit(limit);
     }
 
-    find_imports(sema, krate, local_query, external_query)
+    let db = sema.db;
+    find_imports(sema, krate, local_query, external_query).filter(move |import_candidate| {
+        if ignore_assoc_items {
+            match import_candidate {
+                Either::Left(ModuleDef::Function(function)) => function.as_assoc_item(db).is_none(),
+                Either::Left(ModuleDef::Const(const_)) => const_.as_assoc_item(db).is_none(),
+                Either::Left(ModuleDef::TypeAlias(type_alias)) => {
+                    type_alias.as_assoc_item(db).is_none()
+                }
+                _ => true,
+            }
+        } else {
+            true
+        }
+    })
 }
 
 fn find_imports<'a>(