From 0e48cd0c3c712cea0267476de974012b2b05b508 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 11:41:08 +0200 Subject: Draft the module exclusion in modules --- .../completion/src/completions/unqualified_path.rs | 2 +- crates/hir_def/src/import_map.rs | 96 ++++++++++++++-------- crates/ide_db/src/imports_locator.rs | 10 ++- 3 files changed, 71 insertions(+), 37 deletions(-) (limited to 'crates') diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs index d09849752..3d72a08b4 100644 --- a/crates/completion/src/completions/unqualified_path.rs +++ b/crates/completion/src/completions/unqualified_path.rs @@ -135,7 +135,7 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<() ctx.krate?, Some(100), &potential_import_name, - true, + false, ) .filter_map(|import_candidate| { Some(match import_candidate { diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs index c0f108848..64d0ec471 100644 --- a/crates/hir_def/src/import_map.rs +++ b/crates/hir_def/src/import_map.rs @@ -156,8 +156,7 @@ impl ImportMap { let start = last_batch_start; last_batch_start = idx + 1; - let key = fst_path(&importables[start].1.path); - + let key = fst_string(&importables[start].1.path); builder.insert(key, start as u64).unwrap(); } @@ -213,15 +212,15 @@ impl fmt::Debug for ImportMap { } } -fn fst_path(path: &ImportPath) -> String { - let mut s = path.to_string(); +fn fst_string(t: &T) -> String { + let mut s = t.to_string(); s.make_ascii_lowercase(); s } fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo)) -> Ordering { - let lhs_str = fst_path(&lhs.path); - let rhs_str = fst_path(&rhs.path); + let lhs_str = fst_string(&lhs.path); + let rhs_str = fst_string(&rhs.path); lhs_str.cmp(&rhs_str) } @@ -242,7 +241,10 @@ pub enum ImportKind { pub struct Query { query: String, lowercased: String, - anchor_end: bool, + // TODO kb use enums instead? + name_only: bool, + name_end: bool, + strict_include: bool, case_sensitive: bool, limit: usize, exclude_import_kinds: FxHashSet, @@ -253,17 +255,27 @@ impl Query { Self { lowercased: query.to_lowercase(), query: query.to_string(), - anchor_end: false, + name_only: false, + name_end: false, + strict_include: false, case_sensitive: false, limit: usize::max_value(), exclude_import_kinds: FxHashSet::default(), } } - /// Only returns items whose paths end with the (case-insensitive) query string as their last - /// segment. - pub fn anchor_end(self) -> Self { - Self { anchor_end: true, ..self } + pub fn name_end(self) -> Self { + Self { name_end: true, ..self } + } + + /// todo kb + pub fn name_only(self) -> Self { + Self { name_only: true, ..self } + } + + /// todo kb + pub fn strict_include(self) -> Self { + Self { strict_include: true, ..self } } /// Limits the returned number of items to `limit`. @@ -283,6 +295,35 @@ impl Query { } } +// TODO kb: ugly with a special `return true` case and the `enforce_lowercase` one. +fn contains_query(query: &Query, input_path: &ImportPath, enforce_lowercase: bool) -> bool { + let mut input = if query.name_only { + input_path.segments.last().unwrap().to_string() + } else { + input_path.to_string() + }; + if enforce_lowercase || !query.case_sensitive { + input.make_ascii_lowercase(); + } + + let query_string = + if !enforce_lowercase && query.case_sensitive { &query.query } else { &query.lowercased }; + + if query.strict_include { + if query.name_end { + &input == query_string + } else { + input.contains(query_string) + } + } else if query.name_end { + input.ends_with(query_string) + } else { + let input_chars = input.chars().collect::>(); + // TODO kb actually check for the order and the quantity + query_string.chars().all(|query_char| input_chars.contains(&query_char)) + } +} + /// Searches dependencies of `krate` for an importable path matching `query`. /// /// This returns a list of items that could be imported from dependencies of `krate`. @@ -312,39 +353,26 @@ pub fn search_dependencies<'a>( let importables = &import_map.importables[indexed_value.value as usize..]; // Path shared by the importable items in this group. - let path = &import_map.map[&importables[0]].path; - - if query.anchor_end { - // Last segment must match query. - let last = path.segments.last().unwrap().to_string(); - if last.to_lowercase() != query.lowercased { - continue; - } + let common_importables_path = &import_map.map[&importables[0]].path; + if !contains_query(&query, common_importables_path, true) { + continue; } + let common_importables_path_fst = fst_string(common_importables_path); // Add the items from this `ModPath` group. Those are all subsequent items in // `importables` whose paths match `path`. let iter = importables .iter() .copied() .take_while(|item| { - let item_path = &import_map.map[item].path; - fst_path(item_path) == fst_path(path) + common_importables_path_fst == fst_string(&import_map.map[item].path) }) .filter(|&item| match item_import_kind(item) { Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind), None => true, - }); - - if query.case_sensitive { - // FIXME: This does not do a subsequence match. - res.extend(iter.filter(|item| { - let item_path = &import_map.map[item].path; - item_path.to_string().contains(&query.query) - })); - } else { - res.extend(iter); - } + }) + .filter(|item| contains_query(&query, &import_map.map[item].path, false)); + res.extend(iter); if res.len() >= query.limit { res.truncate(query.limit); @@ -728,7 +756,7 @@ mod tests { check_search( ra_fixture, "main", - Query::new("fmt").anchor_end(), + Query::new("fmt").name_only().strict_include(), expect![[r#" dep::fmt (t) dep::Fmt (t) diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs index b2980a5d6..0de949b9a 100644 --- a/crates/ide_db/src/imports_locator.rs +++ b/crates/ide_db/src/imports_locator.rs @@ -27,7 +27,12 @@ pub fn find_exact_imports<'a>( local_query.limit(40); local_query }, - import_map::Query::new(name_to_import).anchor_end().case_sensitive().limit(40), + import_map::Query::new(name_to_import) + .limit(40) + .name_only() + .name_end() + .strict_include() + .case_sensitive(), ) } @@ -36,11 +41,12 @@ pub fn find_similar_imports<'a>( krate: Crate, limit: Option, name_to_import: &str, + // TODO kb change it to search across the whole path or not? ignore_modules: bool, ) -> impl Iterator> { let _p = profile::span("find_similar_imports"); - let mut external_query = import_map::Query::new(name_to_import); + let mut external_query = import_map::Query::new(name_to_import).name_only(); if ignore_modules { external_query = external_query.exclude_import_kind(import_map::ImportKind::Module); } -- cgit v1.2.3 From c4995cfbd5b265c02d3038d72b8a022cde5f7040 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 14:24:13 +0200 Subject: Better query api and fuzzy search --- .../completion/src/completions/unqualified_path.rs | 2 +- crates/hir_def/src/import_map.rs | 73 ++++++++++++---------- crates/ide_db/src/imports_locator.rs | 13 ++-- 3 files changed, 47 insertions(+), 41 deletions(-) (limited to 'crates') diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs index 3d72a08b4..d09849752 100644 --- a/crates/completion/src/completions/unqualified_path.rs +++ b/crates/completion/src/completions/unqualified_path.rs @@ -135,7 +135,7 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<() ctx.krate?, Some(100), &potential_import_name, - false, + true, ) .filter_map(|import_candidate| { Some(match import_candidate { diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs index 64d0ec471..ce25e1c6e 100644 --- a/crates/hir_def/src/import_map.rs +++ b/crates/hir_def/src/import_map.rs @@ -156,7 +156,8 @@ impl ImportMap { let start = last_batch_start; last_batch_start = idx + 1; - let key = fst_string(&importables[start].1.path); + let key = fst_path(&importables[start].1.path); + builder.insert(key, start as u64).unwrap(); } @@ -212,15 +213,15 @@ impl fmt::Debug for ImportMap { } } -fn fst_string(t: &T) -> String { - let mut s = t.to_string(); +fn fst_path(path: &ImportPath) -> String { + let mut s = path.to_string(); s.make_ascii_lowercase(); s } fn cmp((_, lhs): &(&ItemInNs, &ImportInfo), (_, rhs): &(&ItemInNs, &ImportInfo)) -> Ordering { - let lhs_str = fst_string(&lhs.path); - let rhs_str = fst_string(&rhs.path); + let lhs_str = fst_path(&lhs.path); + let rhs_str = fst_path(&rhs.path); lhs_str.cmp(&rhs_str) } @@ -237,14 +238,20 @@ pub enum ImportKind { BuiltinType, } +/// todo kb +#[derive(Debug)] +pub enum SearchMode { + Equals, + Contains, + Fuzzy, +} + #[derive(Debug)] pub struct Query { query: String, lowercased: String, - // TODO kb use enums instead? name_only: bool, - name_end: bool, - strict_include: bool, + search_mode: SearchMode, case_sensitive: bool, limit: usize, exclude_import_kinds: FxHashSet, @@ -253,29 +260,23 @@ pub struct Query { impl Query { pub fn new(query: &str) -> Self { Self { - lowercased: query.to_lowercase(), query: query.to_string(), + lowercased: query.to_lowercase(), name_only: false, - name_end: false, - strict_include: false, + search_mode: SearchMode::Contains, case_sensitive: false, limit: usize::max_value(), exclude_import_kinds: FxHashSet::default(), } } - pub fn name_end(self) -> Self { - Self { name_end: true, ..self } - } - - /// todo kb pub fn name_only(self) -> Self { Self { name_only: true, ..self } } /// todo kb - pub fn strict_include(self) -> Self { - Self { strict_include: true, ..self } + pub fn search_mode(self, search_mode: SearchMode) -> Self { + Self { search_mode, ..self } } /// Limits the returned number of items to `limit`. @@ -309,18 +310,24 @@ fn contains_query(query: &Query, input_path: &ImportPath, enforce_lowercase: boo let query_string = if !enforce_lowercase && query.case_sensitive { &query.query } else { &query.lowercased }; - if query.strict_include { - if query.name_end { - &input == query_string - } else { - input.contains(query_string) + match query.search_mode { + SearchMode::Equals => &input == query_string, + SearchMode::Contains => input.contains(query_string), + SearchMode::Fuzzy => { + let mut unchecked_query_chars = query_string.chars(); + let mut mismatching_query_char = unchecked_query_chars.next(); + + for input_char in input.chars() { + match mismatching_query_char { + None => return true, + Some(matching_query_char) if matching_query_char == input_char => { + mismatching_query_char = unchecked_query_chars.next(); + } + _ => (), + } + } + mismatching_query_char.is_none() } - } else if query.name_end { - input.ends_with(query_string) - } else { - let input_chars = input.chars().collect::>(); - // TODO kb actually check for the order and the quantity - query_string.chars().all(|query_char| input_chars.contains(&query_char)) } } @@ -358,14 +365,14 @@ pub fn search_dependencies<'a>( continue; } - let common_importables_path_fst = fst_string(common_importables_path); + let common_importables_path_fst = fst_path(common_importables_path); // Add the items from this `ModPath` group. Those are all subsequent items in // `importables` whose paths match `path`. let iter = importables .iter() .copied() .take_while(|item| { - common_importables_path_fst == fst_string(&import_map.map[item].path) + common_importables_path_fst == fst_path(&import_map.map[item].path) }) .filter(|&item| match item_import_kind(item) { Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind), @@ -741,7 +748,7 @@ mod tests { check_search( ra_fixture, "main", - Query::new("fmt"), + Query::new("fmt").search_mode(SearchMode::Fuzzy), expect![[r#" dep::fmt (t) dep::Fmt (t) @@ -756,7 +763,7 @@ mod tests { check_search( ra_fixture, "main", - Query::new("fmt").name_only().strict_include(), + Query::new("fmt").name_only().search_mode(SearchMode::Equals), expect![[r#" dep::fmt (t) dep::Fmt (t) diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs index 0de949b9a..986cb5b83 100644 --- a/crates/ide_db/src/imports_locator.rs +++ b/crates/ide_db/src/imports_locator.rs @@ -30,8 +30,7 @@ pub fn find_exact_imports<'a>( import_map::Query::new(name_to_import) .limit(40) .name_only() - .name_end() - .strict_include() + .search_mode(import_map::SearchMode::Equals) .case_sensitive(), ) } @@ -41,14 +40,14 @@ pub fn find_similar_imports<'a>( krate: Crate, limit: Option, name_to_import: &str, - // TODO kb change it to search across the whole path or not? - ignore_modules: bool, + name_only: bool, ) -> impl Iterator> { let _p = profile::span("find_similar_imports"); - let mut external_query = import_map::Query::new(name_to_import).name_only(); - if ignore_modules { - external_query = external_query.exclude_import_kind(import_map::ImportKind::Module); + let mut external_query = + import_map::Query::new(name_to_import).search_mode(import_map::SearchMode::Fuzzy); + if name_only { + external_query = external_query.name_only(); } let mut local_query = symbol_index::Query::new(name_to_import.to_string()); -- cgit v1.2.3 From e4c3f753d23752a9fbb01bdf1cd92a8cb1f6681e Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 14:54:31 +0200 Subject: Add docs and optimisations --- crates/completion/src/completions/unqualified_path.rs | 4 ++-- crates/hir_def/src/import_map.rs | 17 +++++++++++++---- crates/ide_db/src/imports_locator.rs | 6 +++--- 3 files changed, 18 insertions(+), 9 deletions(-) (limited to 'crates') diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs index d09849752..aefbdb163 100644 --- a/crates/completion/src/completions/unqualified_path.rs +++ b/crates/completion/src/completions/unqualified_path.rs @@ -101,8 +101,8 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T // // .Fuzzy search details // -// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the identifiers only -// (i.e. in `HashMap` in the `std::collections::HashMap` path), also not in the module indentifiers. +// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only +// (i.e. in `HashMap` in the `std::collections::HashMap` path). // // .Merge Behavior // diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs index ce25e1c6e..34a424c60 100644 --- a/crates/hir_def/src/import_map.rs +++ b/crates/hir_def/src/import_map.rs @@ -238,11 +238,15 @@ pub enum ImportKind { BuiltinType, } -/// todo kb +/// A way to match import map contents against the search query. #[derive(Debug)] pub enum SearchMode { + /// Import map entry should strictly match the query string. Equals, + /// Import map entry should contain the query string. Contains, + /// Import map entry should contain all letters from the query string, + /// in the same order, but not necessary adjacent. Fuzzy, } @@ -270,11 +274,14 @@ impl Query { } } + /// Matches entries' names only, ignoring the rest of + /// the qualifier. + /// Example: for `std::marker::PhantomData`, the name is `PhantomData`. pub fn name_only(self) -> Self { Self { name_only: true, ..self } } - /// todo kb + /// Specifies the way to search for the entries using the query. pub fn search_mode(self, search_mode: SearchMode) -> Self { Self { search_mode, ..self } } @@ -296,7 +303,6 @@ impl Query { } } -// TODO kb: ugly with a special `return true` case and the `enforce_lowercase` one. fn contains_query(query: &Query, input_path: &ImportPath, enforce_lowercase: bool) -> bool { let mut input = if query.name_only { input_path.segments.last().unwrap().to_string() @@ -378,7 +384,10 @@ pub fn search_dependencies<'a>( Some(import_kind) => !query.exclude_import_kinds.contains(&import_kind), None => true, }) - .filter(|item| contains_query(&query, &import_map.map[item].path, false)); + .filter(|item| { + !query.case_sensitive // we've already checked the common importables path case-insensitively + || contains_query(&query, &import_map.map[item].path, false) + }); res.extend(iter); if res.len() >= query.limit { diff --git a/crates/ide_db/src/imports_locator.rs b/crates/ide_db/src/imports_locator.rs index 986cb5b83..b6355af4b 100644 --- a/crates/ide_db/src/imports_locator.rs +++ b/crates/ide_db/src/imports_locator.rs @@ -39,18 +39,18 @@ pub fn find_similar_imports<'a>( sema: &Semantics<'a, RootDatabase>, krate: Crate, limit: Option, - name_to_import: &str, + fuzzy_search_string: &str, name_only: bool, ) -> impl Iterator> { let _p = profile::span("find_similar_imports"); let mut external_query = - import_map::Query::new(name_to_import).search_mode(import_map::SearchMode::Fuzzy); + import_map::Query::new(fuzzy_search_string).search_mode(import_map::SearchMode::Fuzzy); if name_only { external_query = external_query.name_only(); } - let mut local_query = symbol_index::Query::new(name_to_import.to_string()); + let mut local_query = symbol_index::Query::new(fuzzy_search_string.to_string()); if let Some(limit) = limit { local_query.limit(limit); -- cgit v1.2.3 From 8600cf807ed25684bbbbac96badf383add43b358 Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 15:22:03 +0200 Subject: Add tests --- crates/hir_def/src/import_map.rs | 73 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 71 insertions(+), 2 deletions(-) (limited to 'crates') diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs index 34a424c60..fcbb3ac14 100644 --- a/crates/hir_def/src/import_map.rs +++ b/crates/hir_def/src/import_map.rs @@ -729,7 +729,7 @@ mod tests { } #[test] - fn search() { + fn search_mode() { let ra_fixture = r#" //- /main.rs crate:main deps:dep //- /dep.rs crate:dep deps:tdep @@ -772,7 +772,76 @@ mod tests { check_search( ra_fixture, "main", - Query::new("fmt").name_only().search_mode(SearchMode::Equals), + Query::new("fmt").search_mode(SearchMode::Equals), + expect![[r#" + dep::fmt (t) + dep::Fmt (t) + dep::Fmt (v) + dep::Fmt (m) + dep::fmt::Display (t) + "#]], + ); + + check_search( + ra_fixture, + "main", + Query::new("fmt").search_mode(SearchMode::Contains), + expect![[r#" + dep::fmt (t) + dep::Fmt (t) + dep::Fmt (v) + dep::Fmt (m) + dep::fmt::Display (t) + dep::fmt::Display (t) + "#]], + ); + } + + #[test] + fn name_only() { + let ra_fixture = r#" + //- /main.rs crate:main deps:dep + //- /dep.rs crate:dep deps:tdep + use tdep::fmt as fmt_dep; + pub mod fmt { + pub trait Display { + fn fmt(); + } + } + #[macro_export] + macro_rules! Fmt { + () => {}; + } + pub struct Fmt; + + pub fn format() {} + pub fn no() {} + + //- /tdep.rs crate:tdep + pub mod fmt { + pub struct NotImportableFromMain; + } + "#; + + check_search( + ra_fixture, + "main", + Query::new("fmt"), + expect![[r#" + dep::fmt (t) + dep::Fmt (t) + dep::Fmt (v) + dep::Fmt (m) + dep::fmt::Display (t) + dep::fmt::Display (t) + "#]], + ); + + // TODO kb where does this duplicate `dep::fmt::Display (t)` come from? + check_search( + ra_fixture, + "main", + Query::new("fmt").name_only(), expect![[r#" dep::fmt (t) dep::Fmt (t) -- cgit v1.2.3 From eecbb51cb39a9d07947e9c474d3e411265282fce Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 16:13:37 +0200 Subject: Better display methods in expect tests --- crates/hir_def/src/import_map.rs | 46 +++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 15 deletions(-) (limited to 'crates') diff --git a/crates/hir_def/src/import_map.rs b/crates/hir_def/src/import_map.rs index fcbb3ac14..fdc681d6c 100644 --- a/crates/hir_def/src/import_map.rs +++ b/crates/hir_def/src/import_map.rs @@ -432,7 +432,7 @@ mod tests { use base_db::{fixture::WithFixture, SourceDatabase, Upcast}; use expect_test::{expect, Expect}; - use crate::{test_db::TestDB, AssocContainerId, Lookup}; + use crate::{data::FunctionData, test_db::TestDB, AssocContainerId, Lookup}; use super::*; @@ -451,14 +451,31 @@ mod tests { .into_iter() .filter_map(|item| { let mark = match item { + ItemInNs::Types(ModuleDefId::FunctionId(_)) + | ItemInNs::Values(ModuleDefId::FunctionId(_)) => "f", ItemInNs::Types(_) => "t", ItemInNs::Values(_) => "v", ItemInNs::Macros(_) => "m", }; - let item = assoc_to_trait(&db, item); item.krate(db.upcast()).map(|krate| { let map = db.import_map(krate); - let path = map.path_of(item).unwrap(); + + let path = match assoc_to_trait(&db, item) { + Some(trait_) => { + let mut full_path = map.path_of(trait_).unwrap().to_string(); + if let ItemInNs::Types(ModuleDefId::FunctionId(function_id)) + | ItemInNs::Values(ModuleDefId::FunctionId(function_id)) = item + { + full_path += &format!( + "::{}", + FunctionData::fn_data_query(&db, function_id).name + ); + } + full_path + } + None => map.path_of(item).unwrap().to_string(), + }; + format!( "{}::{} ({})\n", crate_graph[krate].display_name.as_ref().unwrap(), @@ -471,15 +488,15 @@ mod tests { expect.assert_eq(&actual) } - fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> ItemInNs { + fn assoc_to_trait(db: &dyn DefDatabase, item: ItemInNs) -> Option { let assoc: AssocItemId = match item { ItemInNs::Types(it) | ItemInNs::Values(it) => match it { ModuleDefId::TypeAliasId(it) => it.into(), ModuleDefId::FunctionId(it) => it.into(), ModuleDefId::ConstId(it) => it.into(), - _ => return item, + _ => return None, }, - _ => return item, + _ => return None, }; let container = match assoc { @@ -489,8 +506,8 @@ mod tests { }; match container { - AssocContainerId::TraitId(it) => ItemInNs::Types(it.into()), - _ => item, + AssocContainerId::TraitId(it) => Some(ItemInNs::Types(it.into())), + _ => None, } } @@ -764,8 +781,8 @@ mod tests { dep::Fmt (v) dep::Fmt (m) dep::fmt::Display (t) - dep::format (v) - dep::fmt::Display (t) + dep::format (f) + dep::fmt::Display::fmt (f) "#]], ); @@ -778,7 +795,7 @@ mod tests { dep::Fmt (t) dep::Fmt (v) dep::Fmt (m) - dep::fmt::Display (t) + dep::fmt::Display::fmt (f) "#]], ); @@ -792,7 +809,7 @@ mod tests { dep::Fmt (v) dep::Fmt (m) dep::fmt::Display (t) - dep::fmt::Display (t) + dep::fmt::Display::fmt (f) "#]], ); } @@ -833,11 +850,10 @@ mod tests { dep::Fmt (v) dep::Fmt (m) dep::fmt::Display (t) - dep::fmt::Display (t) + dep::fmt::Display::fmt (f) "#]], ); - // TODO kb where does this duplicate `dep::fmt::Display (t)` come from? check_search( ra_fixture, "main", @@ -847,7 +863,7 @@ mod tests { dep::Fmt (t) dep::Fmt (v) dep::Fmt (m) - dep::fmt::Display (t) + dep::fmt::Display::fmt (f) "#]], ); } -- cgit v1.2.3 From 77b4a1c5ef594ddd78c77dd8bb05fba14b99cc9f Mon Sep 17 00:00:00 2001 From: Kirill Bulatov Date: Mon, 28 Dec 2020 16:19:51 +0200 Subject: Tweak the fuzzy search limits --- crates/completion/src/completions/unqualified_path.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'crates') diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs index aefbdb163..59f950189 100644 --- a/crates/completion/src/completions/unqualified_path.rs +++ b/crates/completion/src/completions/unqualified_path.rs @@ -103,6 +103,7 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T // // To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only // (i.e. in `HashMap` in the `std::collections::HashMap` path). +// For the same reasons, avoids searching for any imports for inputs with their length less that 2 symbols. // // .Merge Behavior // @@ -126,6 +127,10 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<() let _p = profile::span("fuzzy_completion"); let potential_import_name = ctx.token.to_string(); + if potential_import_name.len() < 2 { + return None; + } + let current_module = ctx.scope.module()?; let anchor = ctx.name_ref_syntax.as_ref()?; let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?; @@ -133,7 +138,7 @@ fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<() let mut all_mod_paths = imports_locator::find_similar_imports( &ctx.sema, ctx.krate?, - Some(100), + Some(40), &potential_import_name, true, ) -- cgit v1.2.3