929 lines
20 KiB
Rust
929 lines
20 KiB
Rust
//! Completion of names from the current scope, e.g. locals and imported items.
|
|
|
|
use either::Either;
|
|
use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
|
|
use ide_db::helpers::insert_use::ImportScope;
|
|
use ide_db::imports_locator;
|
|
use syntax::AstNode;
|
|
use test_utils::mark;
|
|
|
|
use crate::{
|
|
render::{render_resolution_with_import, RenderContext},
|
|
CompletionContext, Completions, ImportEdit,
|
|
};
|
|
|
|
pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
|
|
if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
|
|
return;
|
|
}
|
|
if ctx.record_lit_syntax.is_some()
|
|
|| ctx.record_pat_syntax.is_some()
|
|
|| ctx.attribute_under_caret.is_some()
|
|
|| ctx.mod_declaration_under_caret.is_some()
|
|
{
|
|
return;
|
|
}
|
|
|
|
if let Some(ty) = &ctx.expected_type {
|
|
complete_enum_variants(acc, ctx, ty);
|
|
}
|
|
|
|
if ctx.is_pat_binding_or_const {
|
|
return;
|
|
}
|
|
|
|
ctx.scope.process_all_names(&mut |name, res| {
|
|
if ctx.use_item_syntax.is_some() {
|
|
if let (ScopeDef::Unknown, Some(name_ref)) = (&res, &ctx.name_ref_syntax) {
|
|
if name_ref.syntax().text() == name.to_string().as_str() {
|
|
mark::hit!(self_fulfilling_completion);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
acc.add_resolution(ctx, name.to_string(), &res)
|
|
});
|
|
|
|
if ctx.config.enable_autoimport_completions && ctx.config.resolve_additional_edits_lazily() {
|
|
fuzzy_completion(acc, ctx);
|
|
}
|
|
}
|
|
|
|
fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
|
|
if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
|
|
let variants = enum_data.variants(ctx.db);
|
|
|
|
let module = if let Some(module) = ctx.scope.module() {
|
|
// Compute path from the completion site if available.
|
|
module
|
|
} else {
|
|
// Otherwise fall back to the enum's definition site.
|
|
enum_data.module(ctx.db)
|
|
};
|
|
|
|
for variant in variants {
|
|
if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
|
|
// Variants with trivial paths are already added by the existing completion logic,
|
|
// so we should avoid adding these twice
|
|
if path.segments.len() > 1 {
|
|
acc.add_qualified_enum_variant(ctx, variant, path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Feature: Fuzzy Completion and Autoimports
|
|
//
|
|
// When completing names in the current scope, proposes additional imports from other modules or crates,
|
|
// if they can be qualified in the scope and their name contains all symbols from the completion input
|
|
// (case-insensitive, in any order or places).
|
|
//
|
|
// ```
|
|
// fn main() {
|
|
// pda<|>
|
|
// }
|
|
// # pub mod std { pub mod marker { pub struct PhantomData { } } }
|
|
// ```
|
|
// ->
|
|
// ```
|
|
// use std::marker::PhantomData;
|
|
//
|
|
// fn main() {
|
|
// PhantomData
|
|
// }
|
|
// # pub mod std { pub mod marker { pub struct PhantomData { } } }
|
|
// ```
|
|
//
|
|
// .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.
|
|
//
|
|
// .Merge Behavior
|
|
//
|
|
// It is possible to configure how use-trees are merged with the `importMergeBehavior` setting.
|
|
// Mimics the corresponding behavior of the `Auto Import` feature.
|
|
//
|
|
// .LSP and performance implications
|
|
//
|
|
// The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the `additionalTextEdits`
|
|
// (case sensitive) resolve client capability in its client capabilities.
|
|
// This way the server is able to defer the costly computations, doing them for a selected completion item only.
|
|
// For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
|
|
// which might be slow ergo the feature is automatically disabled.
|
|
//
|
|
// .Feature toggle
|
|
//
|
|
// The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.enableAutoimportCompletions` flag.
|
|
// Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
|
|
// capability enabled.
|
|
fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
|
|
let _p = profile::span("fuzzy_completion");
|
|
let potential_import_name = ctx.token.to_string();
|
|
|
|
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)?;
|
|
|
|
let mut all_mod_paths = imports_locator::find_similar_imports(
|
|
&ctx.sema,
|
|
ctx.krate?,
|
|
Some(100),
|
|
&potential_import_name,
|
|
true,
|
|
)
|
|
.filter_map(|import_candidate| {
|
|
Some(match import_candidate {
|
|
Either::Left(module_def) => {
|
|
(current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
|
|
}
|
|
Either::Right(macro_def) => {
|
|
(current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
|
|
}
|
|
})
|
|
})
|
|
.filter(|(mod_path, _)| mod_path.len() > 1)
|
|
.collect::<Vec<_>>();
|
|
|
|
let user_input_lowercased = potential_import_name.to_lowercase();
|
|
all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
|
|
compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
|
|
});
|
|
|
|
acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
|
|
render_resolution_with_import(
|
|
RenderContext::new(ctx),
|
|
ImportEdit { import_path, import_scope: import_scope.clone() },
|
|
&definition,
|
|
)
|
|
}));
|
|
Some(())
|
|
}
|
|
|
|
fn compute_fuzzy_completion_order_key(
|
|
proposed_mod_path: &ModPath,
|
|
user_input_lowercased: &str,
|
|
) -> usize {
|
|
mark::hit!(certain_fuzzy_order_test);
|
|
let proposed_import_name = match proposed_mod_path.segments.last() {
|
|
Some(name) => name.to_string().to_lowercase(),
|
|
None => return usize::MAX,
|
|
};
|
|
match proposed_import_name.match_indices(user_input_lowercased).next() {
|
|
Some((first_matching_index, _)) => first_matching_index,
|
|
None => usize::MAX,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use expect_test::{expect, Expect};
|
|
use test_utils::mark;
|
|
|
|
use crate::{
|
|
test_utils::{check_edit, check_edit_with_config, completion_list_with_config},
|
|
CompletionConfig, CompletionKind,
|
|
};
|
|
|
|
fn check(ra_fixture: &str, expect: Expect) {
|
|
check_with_config(CompletionConfig::default(), ra_fixture, expect);
|
|
}
|
|
|
|
fn check_with_config(config: CompletionConfig, ra_fixture: &str, expect: Expect) {
|
|
let actual = completion_list_with_config(config, ra_fixture, CompletionKind::Reference);
|
|
expect.assert_eq(&actual)
|
|
}
|
|
|
|
fn fuzzy_completion_config() -> CompletionConfig {
|
|
let mut completion_config = CompletionConfig::default();
|
|
completion_config
|
|
.active_resolve_capabilities
|
|
.insert(crate::CompletionResolveCapability::AdditionalTextEdits);
|
|
completion_config
|
|
}
|
|
|
|
#[test]
|
|
fn self_fulfilling_completion() {
|
|
mark::check!(self_fulfilling_completion);
|
|
check(
|
|
r#"
|
|
use foo<|>
|
|
use std::collections;
|
|
"#,
|
|
expect![[r#"
|
|
?? collections
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bind_pat_and_path_ignore_at() {
|
|
check(
|
|
r#"
|
|
enum Enum { A, B }
|
|
fn quux(x: Option<Enum>) {
|
|
match x {
|
|
None => (),
|
|
Some(en<|> @ Enum::A) => (),
|
|
}
|
|
}
|
|
"#,
|
|
expect![[""]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bind_pat_and_path_ignore_ref() {
|
|
check(
|
|
r#"
|
|
enum Enum { A, B }
|
|
fn quux(x: Option<Enum>) {
|
|
match x {
|
|
None => (),
|
|
Some(ref en<|>) => (),
|
|
}
|
|
}
|
|
"#,
|
|
expect![[""]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bind_pat_and_path() {
|
|
check(
|
|
r#"
|
|
enum Enum { A, B }
|
|
fn quux(x: Option<Enum>) {
|
|
match x {
|
|
None => (),
|
|
Some(En<|>) => (),
|
|
}
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
en Enum
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_bindings_from_let() {
|
|
check(
|
|
r#"
|
|
fn quux(x: i32) {
|
|
let y = 92;
|
|
1 + <|>;
|
|
let z = ();
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
bn y i32
|
|
bn x i32
|
|
fn quux(…) fn quux(x: i32)
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_bindings_from_if_let() {
|
|
check(
|
|
r#"
|
|
fn quux() {
|
|
if let Some(x) = foo() {
|
|
let y = 92;
|
|
};
|
|
if let Some(a) = bar() {
|
|
let b = 62;
|
|
1 + <|>
|
|
}
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
bn b i32
|
|
bn a
|
|
fn quux() fn quux()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_bindings_from_for() {
|
|
check(
|
|
r#"
|
|
fn quux() {
|
|
for x in &[1, 2, 3] { <|> }
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
bn x
|
|
fn quux() fn quux()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_if_prefix_is_keyword() {
|
|
mark::check!(completes_if_prefix_is_keyword);
|
|
check_edit(
|
|
"wherewolf",
|
|
r#"
|
|
fn main() {
|
|
let wherewolf = 92;
|
|
drop(where<|>)
|
|
}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
let wherewolf = 92;
|
|
drop(wherewolf)
|
|
}
|
|
"#,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_generic_params() {
|
|
check(
|
|
r#"fn quux<T>() { <|> }"#,
|
|
expect![[r#"
|
|
tp T
|
|
fn quux() fn quux<T>()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_generic_params_in_struct() {
|
|
check(
|
|
r#"struct S<T> { x: <|>}"#,
|
|
expect![[r#"
|
|
tp Self
|
|
tp T
|
|
st S<…>
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_self_in_enum() {
|
|
check(
|
|
r#"enum X { Y(<|>) }"#,
|
|
expect![[r#"
|
|
tp Self
|
|
en X
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_module_items() {
|
|
check(
|
|
r#"
|
|
struct S;
|
|
enum E {}
|
|
fn quux() { <|> }
|
|
"#,
|
|
expect![[r#"
|
|
st S
|
|
fn quux() fn quux()
|
|
en E
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
/// Regression test for issue #6091.
|
|
#[test]
|
|
fn correctly_completes_module_items_prefixed_with_underscore() {
|
|
check_edit(
|
|
"_alpha",
|
|
r#"
|
|
fn main() {
|
|
_<|>
|
|
}
|
|
fn _alpha() {}
|
|
"#,
|
|
r#"
|
|
fn main() {
|
|
_alpha()$0
|
|
}
|
|
fn _alpha() {}
|
|
"#,
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_extern_prelude() {
|
|
check(
|
|
r#"
|
|
//- /lib.rs crate:main deps:other_crate
|
|
use <|>;
|
|
|
|
//- /other_crate/lib.rs crate:other_crate
|
|
// nothing here
|
|
"#,
|
|
expect![[r#"
|
|
md other_crate
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_module_items_in_nested_modules() {
|
|
check(
|
|
r#"
|
|
struct Foo;
|
|
mod m {
|
|
struct Bar;
|
|
fn quux() { <|> }
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
fn quux() fn quux()
|
|
st Bar
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_return_type() {
|
|
check(
|
|
r#"
|
|
struct Foo;
|
|
fn x() -> <|>
|
|
"#,
|
|
expect![[r#"
|
|
st Foo
|
|
fn x() fn x()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn dont_show_both_completions_for_shadowing() {
|
|
check(
|
|
r#"
|
|
fn foo() {
|
|
let bar = 92;
|
|
{
|
|
let bar = 62;
|
|
drop(<|>)
|
|
}
|
|
}
|
|
"#,
|
|
// FIXME: should be only one bar here
|
|
expect![[r#"
|
|
bn bar i32
|
|
bn bar i32
|
|
fn foo() fn foo()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_self_in_methods() {
|
|
check(
|
|
r#"impl S { fn foo(&self) { <|> } }"#,
|
|
expect![[r#"
|
|
bn self &{unknown}
|
|
tp Self
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_prelude() {
|
|
check(
|
|
r#"
|
|
//- /main.rs crate:main deps:std
|
|
fn foo() { let x: <|> }
|
|
|
|
//- /std/lib.rs crate:std
|
|
#[prelude_import]
|
|
use prelude::*;
|
|
|
|
mod prelude { struct Option; }
|
|
"#,
|
|
expect![[r#"
|
|
fn foo() fn foo()
|
|
md std
|
|
st Option
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_std_prelude_if_core_is_defined() {
|
|
check(
|
|
r#"
|
|
//- /main.rs crate:main deps:core,std
|
|
fn foo() { let x: <|> }
|
|
|
|
//- /core/lib.rs crate:core
|
|
#[prelude_import]
|
|
use prelude::*;
|
|
|
|
mod prelude { struct Option; }
|
|
|
|
//- /std/lib.rs crate:std deps:core
|
|
#[prelude_import]
|
|
use prelude::*;
|
|
|
|
mod prelude { struct String; }
|
|
"#,
|
|
expect![[r#"
|
|
fn foo() fn foo()
|
|
md std
|
|
md core
|
|
st String
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_macros_as_value() {
|
|
check(
|
|
r#"
|
|
macro_rules! foo { () => {} }
|
|
|
|
#[macro_use]
|
|
mod m1 {
|
|
macro_rules! bar { () => {} }
|
|
}
|
|
|
|
mod m2 {
|
|
macro_rules! nope { () => {} }
|
|
|
|
#[macro_export]
|
|
macro_rules! baz { () => {} }
|
|
}
|
|
|
|
fn main() { let v = <|> }
|
|
"#,
|
|
expect![[r##"
|
|
md m1
|
|
ma baz!(…) #[macro_export]
|
|
macro_rules! baz
|
|
fn main() fn main()
|
|
md m2
|
|
ma bar!(…) macro_rules! bar
|
|
ma foo!(…) macro_rules! foo
|
|
"##]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_both_macro_and_value() {
|
|
check(
|
|
r#"
|
|
macro_rules! foo { () => {} }
|
|
fn foo() { <|> }
|
|
"#,
|
|
expect![[r#"
|
|
fn foo() fn foo()
|
|
ma foo!(…) macro_rules! foo
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_macros_as_type() {
|
|
check(
|
|
r#"
|
|
macro_rules! foo { () => {} }
|
|
fn main() { let x: <|> }
|
|
"#,
|
|
expect![[r#"
|
|
fn main() fn main()
|
|
ma foo!(…) macro_rules! foo
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_macros_as_stmt() {
|
|
check(
|
|
r#"
|
|
macro_rules! foo { () => {} }
|
|
fn main() { <|> }
|
|
"#,
|
|
expect![[r#"
|
|
fn main() fn main()
|
|
ma foo!(…) macro_rules! foo
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_local_item() {
|
|
check(
|
|
r#"
|
|
fn main() {
|
|
return f<|>;
|
|
fn frobnicate() {}
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
fn frobnicate() fn frobnicate()
|
|
fn main() fn main()
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_in_simple_macro_1() {
|
|
check(
|
|
r#"
|
|
macro_rules! m { ($e:expr) => { $e } }
|
|
fn quux(x: i32) {
|
|
let y = 92;
|
|
m!(<|>);
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
bn y i32
|
|
bn x i32
|
|
fn quux(…) fn quux(x: i32)
|
|
ma m!(…) macro_rules! m
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_in_simple_macro_2() {
|
|
check(
|
|
r"
|
|
macro_rules! m { ($e:expr) => { $e } }
|
|
fn quux(x: i32) {
|
|
let y = 92;
|
|
m!(x<|>);
|
|
}
|
|
",
|
|
expect![[r#"
|
|
bn y i32
|
|
bn x i32
|
|
fn quux(…) fn quux(x: i32)
|
|
ma m!(…) macro_rules! m
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_in_simple_macro_without_closing_parens() {
|
|
check(
|
|
r#"
|
|
macro_rules! m { ($e:expr) => { $e } }
|
|
fn quux(x: i32) {
|
|
let y = 92;
|
|
m!(x<|>
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
bn y i32
|
|
bn x i32
|
|
fn quux(…) fn quux(x: i32)
|
|
ma m!(…) macro_rules! m
|
|
"#]],
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn completes_unresolved_uses() {
|
|
check(
|
|
r#"
|
|
use spam::Quux;
|
|
|
|
fn main() { <|> }
|
|
"#,
|
|
expect![[r#"
|
|
fn main() fn main()
|
|
?? Quux
|
|
"#]],
|
|
);
|
|
}
|
|
#[test]
|
|
fn completes_enum_variant_matcharm() {
|
|
check(
|
|
r#"
|
|
enum Foo { Bar, Baz, Quux }
|
|
|
|
fn main() {
|
|
let foo = Foo::Quux;
|
|
match foo { Qu<|> }
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
ev Foo::Bar ()
|
|
ev Foo::Baz ()
|
|
ev Foo::Quux ()
|
|
en Foo
|
|
"#]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_enum_variant_iflet() {
|
|
check(
|
|
r#"
|
|
enum Foo { Bar, Baz, Quux }
|
|
|
|
fn main() {
|
|
let foo = Foo::Quux;
|
|
if let Qu<|> = foo { }
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
ev Foo::Bar ()
|
|
ev Foo::Baz ()
|
|
ev Foo::Quux ()
|
|
en Foo
|
|
"#]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_enum_variant_basic_expr() {
|
|
check(
|
|
r#"
|
|
enum Foo { Bar, Baz, Quux }
|
|
fn main() { let foo: Foo = Q<|> }
|
|
"#,
|
|
expect![[r#"
|
|
ev Foo::Bar ()
|
|
ev Foo::Baz ()
|
|
ev Foo::Quux ()
|
|
en Foo
|
|
fn main() fn main()
|
|
"#]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_enum_variant_from_module() {
|
|
check(
|
|
r#"
|
|
mod m { pub enum E { V } }
|
|
fn f() -> m::E { V<|> }
|
|
"#,
|
|
expect![[r#"
|
|
ev m::E::V ()
|
|
md m
|
|
fn f() fn f() -> m::E
|
|
"#]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn dont_complete_attr() {
|
|
check(
|
|
r#"
|
|
struct Foo;
|
|
#[<|>]
|
|
fn f() {}
|
|
"#,
|
|
expect![[""]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn completes_type_or_trait_in_impl_block() {
|
|
check(
|
|
r#"
|
|
trait MyTrait {}
|
|
struct MyStruct {}
|
|
|
|
impl My<|>
|
|
"#,
|
|
expect![[r#"
|
|
tp Self
|
|
tt MyTrait
|
|
st MyStruct
|
|
"#]],
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn function_fuzzy_completion() {
|
|
check_edit_with_config(
|
|
fuzzy_completion_config(),
|
|
"stdin",
|
|
r#"
|
|
//- /lib.rs crate:dep
|
|
pub mod io {
|
|
pub fn stdin() {}
|
|
};
|
|
|
|
//- /main.rs crate:main deps:dep
|
|
fn main() {
|
|
stdi<|>
|
|
}
|
|
"#,
|
|
r#"
|
|
use dep::io::stdin;
|
|
|
|
fn main() {
|
|
stdin()$0
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn macro_fuzzy_completion() {
|
|
check_edit_with_config(
|
|
fuzzy_completion_config(),
|
|
"macro_with_curlies!",
|
|
r#"
|
|
//- /lib.rs crate:dep
|
|
/// Please call me as macro_with_curlies! {}
|
|
#[macro_export]
|
|
macro_rules! macro_with_curlies {
|
|
() => {}
|
|
}
|
|
|
|
//- /main.rs crate:main deps:dep
|
|
fn main() {
|
|
curli<|>
|
|
}
|
|
"#,
|
|
r#"
|
|
use dep::macro_with_curlies;
|
|
|
|
fn main() {
|
|
macro_with_curlies! {$0}
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn struct_fuzzy_completion() {
|
|
check_edit_with_config(
|
|
fuzzy_completion_config(),
|
|
"ThirdStruct",
|
|
r#"
|
|
//- /lib.rs crate:dep
|
|
pub struct FirstStruct;
|
|
pub mod some_module {
|
|
pub struct SecondStruct;
|
|
pub struct ThirdStruct;
|
|
}
|
|
|
|
//- /main.rs crate:main deps:dep
|
|
use dep::{FirstStruct, some_module::SecondStruct};
|
|
|
|
fn main() {
|
|
this<|>
|
|
}
|
|
"#,
|
|
r#"
|
|
use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
|
|
|
|
fn main() {
|
|
ThirdStruct
|
|
}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn fuzzy_completions_come_in_specific_order() {
|
|
mark::check!(certain_fuzzy_order_test);
|
|
check_with_config(
|
|
fuzzy_completion_config(),
|
|
r#"
|
|
//- /lib.rs crate:dep
|
|
pub struct FirstStruct;
|
|
pub mod some_module {
|
|
// already imported, omitted
|
|
pub struct SecondStruct;
|
|
// does not contain all letters from the query, omitted
|
|
pub struct UnrelatedOne;
|
|
// contains all letters from the query, but not in sequence, displayed last
|
|
pub struct ThiiiiiirdStruct;
|
|
// contains all letters from the query, but not in the beginning, displayed second
|
|
pub struct AfterThirdStruct;
|
|
// contains all letters from the query in the begginning, displayed first
|
|
pub struct ThirdStruct;
|
|
}
|
|
|
|
//- /main.rs crate:main deps:dep
|
|
use dep::{FirstStruct, some_module::SecondStruct};
|
|
|
|
fn main() {
|
|
hir<|>
|
|
}
|
|
"#,
|
|
expect![[r#"
|
|
fn main() fn main()
|
|
st SecondStruct
|
|
st FirstStruct
|
|
md dep
|
|
st dep::some_module::ThirdStruct
|
|
st dep::some_module::AfterThirdStruct
|
|
st dep::some_module::ThiiiiiirdStruct
|
|
"#]],
|
|
);
|
|
}
|
|
}
|