mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove CompletionKind in favor of CompletionItemKind

Browse Source
This commit is contained in:
Lukas Wirth 2021-10-27 17:18:42 +02:00
parent 722489e3ff
commit 0468b11de7
26 changed files with 191 additions and 596 deletions

9
crates/ide_completion/src/completions.rs

@ -21,7 +21,7 @@ use hir::known;
use ide_db::SymbolKind;
use crate::{
item::{Builder, CompletionKind},
item::Builder,
render::{
const_::render_const,
enum_variant::render_variant,
@ -76,8 +76,7 @@ impl Completions {
}
pub(crate) fn add_keyword(&mut self, ctx: &CompletionContext, keyword: &'static str) {
let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), keyword);
item.kind(CompletionItemKind::Keyword);
let item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), keyword);
item.add_to(self);
}
@ -191,9 +190,7 @@ impl Completions {
}
pub(crate) fn add_static_lifetime(&mut self, ctx: &CompletionContext) {
let mut item =
CompletionItem::new(CompletionKind::Reference, ctx.source_range(), "'static");
item.kind(CompletionItemKind::SymbolKind(SymbolKind::LifetimeParam));
let item = CompletionItem::new(SymbolKind::LifetimeParam, ctx.source_range(), "'static");
self.add(item.build());
}

8
crates/ide_completion/src/completions/attribute.rs

@ -12,7 +12,7 @@ use syntax::{algo::non_trivia_sibling, ast, AstNode, Direction, SyntaxKind, T};
use crate::{
context::CompletionContext,
item::{CompletionItem, CompletionItemKind, CompletionKind},
item::{CompletionItem, CompletionItemKind},
Completions,
};
@ -69,11 +69,10 @@ fn complete_new_attribute(acc: &mut Completions, ctx: &CompletionContext, attrib
let add_completion = |attr_completion: &AttrCompletion| {
let mut item = CompletionItem::new(
CompletionKind::Attribute,
CompletionItemKind::Attribute,
ctx.source_range(),
attr_completion.label,
);
item.kind(CompletionItemKind::Attribute);
if let Some(lookup) = attr_completion.lookup {
item.lookup_by(lookup);
@ -103,11 +102,10 @@ fn complete_new_attribute(acc: &mut Completions, ctx: &CompletionContext, attrib
if let hir::ScopeDef::MacroDef(mac) = scope_def {
if mac.kind() == hir::MacroKind::Attr {
let mut item = CompletionItem::new(
CompletionKind::Attribute,
CompletionItemKind::Attribute,
ctx.source_range(),
name.to_string(),
);
item.kind(CompletionItemKind::Attribute);
if let Some(docs) = mac.docs(ctx.sema.db) {
item.documentation(docs);
}

10
crates/ide_completion/src/completions/attribute/cfg.rs

@ -5,16 +5,14 @@ use std::iter;
use syntax::SyntaxKind;
use crate::{
completions::Completions, context::CompletionContext, item::CompletionKind, CompletionItem,
CompletionItemKind,
completions::Completions, context::CompletionContext, CompletionItem, CompletionItemKind,
};
pub(crate) fn complete_cfg(acc: &mut Completions, ctx: &CompletionContext) {
let add_completion = |item: &str| {
let mut completion =
CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), item);
CompletionItem::new(CompletionItemKind::Attribute, ctx.source_range(), item);
completion.insert_text(format!(r#""{}""#, item));
completion.kind(CompletionItemKind::Attribute);
acc.add(completion.build());
};
@ -35,7 +33,7 @@ pub(crate) fn complete_cfg(acc: &mut Completions, ctx: &CompletionContext) {
if let Some(krate) = ctx.krate {
krate.potential_cfg(ctx.db).get_cfg_values(&name).iter().for_each(|s| {
let mut item = CompletionItem::new(
CompletionKind::Attribute,
CompletionItemKind::Attribute,
ctx.source_range(),
s.as_str(),
);
@ -49,7 +47,7 @@ pub(crate) fn complete_cfg(acc: &mut Completions, ctx: &CompletionContext) {
if let Some(krate) = ctx.krate {
krate.potential_cfg(ctx.db).get_cfg_keys().iter().for_each(|s| {
let item = CompletionItem::new(
CompletionKind::Attribute,
CompletionItemKind::Attribute,
ctx.source_range(),
s.as_str(),
);

6
crates/ide_completion/src/completions/attribute/derive.rs

@ -7,7 +7,7 @@ use syntax::ast;
use crate::{
context::CompletionContext,
item::{CompletionItem, CompletionItemKind, CompletionKind},
item::{CompletionItem, CompletionItemKind},
Completions,
};
@ -56,8 +56,8 @@ pub(super) fn complete_derive(
_ => (&*name, None),
};
let mut item = CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
item.kind(CompletionItemKind::Attribute);
let mut item =
CompletionItem::new(CompletionItemKind::Attribute, ctx.source_range(), label);
if let Some(docs) = mac.docs(ctx.db) {
item.documentation(docs);
}

8
crates/ide_completion/src/completions/attribute/lint.rs

@ -4,7 +4,7 @@ use syntax::{ast, T};
use crate::{
context::CompletionContext,
item::{CompletionItem, CompletionItemKind, CompletionKind},
item::{CompletionItem, CompletionItemKind},
Completions,
};
@ -58,9 +58,9 @@ pub(super) fn complete_lint(
Some(qual) if !is_qualified => format!("{}::{}", qual, name),
_ => name.to_owned(),
};
let mut item = CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
item.kind(CompletionItemKind::Attribute)
.documentation(hir::Documentation::new(description.to_owned()));
let mut item =
CompletionItem::new(CompletionItemKind::Attribute, ctx.source_range(), label);
item.documentation(hir::Documentation::new(description.to_owned()));
item.add_to(acc)
}
}

5
crates/ide_completion/src/completions/attribute/repr.rs

@ -4,7 +4,7 @@ use syntax::ast;
use crate::{
context::CompletionContext,
item::{CompletionItem, CompletionItemKind, CompletionKind},
item::{CompletionItem, CompletionItemKind},
Completions,
};
@ -30,8 +30,7 @@ pub(super) fn complete_repr(acc: &mut Completions, ctx: &CompletionContext, inpu
}
let mut item =
CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
item.kind(CompletionItemKind::Attribute);
CompletionItem::new(CompletionItemKind::Attribute, ctx.source_range(), label);
if let Some(lookup) = lookup {
item.lookup_by(lookup);
}

362
crates/ide_completion/src/completions/dot.rs

@ -119,18 +119,6 @@ fn foo(s: S) { s.$0 }
expect![[r#"
fd foo u32
me bar() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -147,18 +135,6 @@ impl S {
expect![[r#"
fd the_field (u32,)
me foo() fn(self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}
@ -175,18 +151,6 @@ impl A {
expect![[r#"
fd the_field (u32, i32)
me foo() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}
@ -199,18 +163,7 @@ impl A {
struct A { the_field: u32 }
fn foo(a: A) { a.$0() }
"#,
expect![[r#"
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
expect![[r#""#]],
);
}
@ -235,18 +188,6 @@ fn foo(a: lib::m::A) { a.$0 }
fd pub_field u32
fd crate_field u32
fd super_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
@ -266,18 +207,6 @@ fn foo(a: lib::m::A) { a.$0 }
"#,
expect![[r#"
fd pub_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
@ -294,19 +223,7 @@ pub mod m {
fn foo(a: lib::m::A) { a.$0 }
"#,
expect![[r#"
fd 1 f64
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
fd 1 f64
"#]],
);
@ -328,18 +245,6 @@ fn foo(a: lib::A) { a.$0 }
me private_method() fn(&self)
me crate_method() fn(&self)
me pub_method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
check(
@ -358,18 +263,6 @@ fn foo(a: lib::A) { a.$0 }
"#,
expect![[r#"
me pub_method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -397,18 +290,6 @@ impl A {
expect![[r#"
fd pub_field u32
me pub_method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}
@ -423,18 +304,6 @@ fn foo(u: U) { u.$0 }
expect![[r#"
fd field u8
fd other u16
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -454,18 +323,6 @@ fn foo(a: A<u32>) { a.$0 }
"#,
expect![[r#"
me the_method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}
@ -481,18 +338,6 @@ fn foo(a: A) { a.$0 }
"#,
expect![[r#"
me the_method() (as Trait) fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
check_edit(
@ -523,18 +368,6 @@ fn foo(a: &A) { a.$0 }
",
expect![[r#"
me the_method() (as Trait) fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -553,18 +386,6 @@ fn foo(a: A) { a.$0 }
",
expect![[r#"
me the_method() (as Trait) fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -581,20 +402,7 @@ fn foo(a: A) {
a.$0
}
"#,
expect![[r#"
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
expect![[r#""#]],
);
}
@ -608,20 +416,8 @@ fn foo() {
}
"#,
expect![[r#"
fd 0 i32
fd 1 f64
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
fd 0 i32
fd 1 f64
"#]],
);
}
@ -637,20 +433,8 @@ fn foo() {
}
"#,
expect![[r#"
fd 0 i32
fd 1 f64
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
fd 0 i32
fd 1 f64
"#]],
);
}
@ -673,18 +457,6 @@ impl T {
"#,
expect![[r#"
me blah() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -700,18 +472,6 @@ const X: u32 = {
"#,
expect![[r#"
fd the_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -728,16 +488,6 @@ fn foo(a: A) {
"#,
expect![[r#"
fd the_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -755,16 +505,6 @@ fn foo(a: A) {
"#,
expect![[r#"
fd the_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -781,16 +521,6 @@ fn foo(a: A) {
"#,
expect![[r#"
fd the_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -817,16 +547,6 @@ fn foo(a: A) {
"#,
expect![[r#"
fd the_field u32
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -846,18 +566,6 @@ fn foo() {
"#,
expect![[r#"
me the_method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -873,18 +581,6 @@ fn main() { make_s!().f$0; }
"#,
expect![[r#"
me foo() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}
@ -913,18 +609,6 @@ mod foo {
"#,
expect![[r#"
me private() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
);
}
@ -952,16 +636,6 @@ impl S {
"#,
expect![[r#"
me foo() fn(&self) -> &[u8]
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -1019,16 +693,6 @@ fn f() {
"#,
expect![[r#"
me method() fn(&self)
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
"#]],
);
}
@ -1051,18 +715,6 @@ fn main() {
"#,
expect![[r#"
me into_iter() (as IntoIterator) fn(self) -> <Self as IntoIterator>::IntoIter
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
)
}

6
crates/ide_completion/src/completions/fn_param.rs

@ -8,7 +8,7 @@ use syntax::{
use crate::{
context::{ParamKind, PatternContext},
CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions,
CompletionContext, CompletionItem, CompletionItemKind, Completions,
};
/// Complete repeated parameters, both name and type. For example, if all
@ -75,7 +75,7 @@ fn add_new_item_to_acc(
label: String,
lookup: String,
) {
let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
item.kind(CompletionItemKind::Binding).lookup_by(lookup);
let mut item = CompletionItem::new(CompletionItemKind::Binding, ctx.source_range(), label);
item.lookup_by(lookup);
item.add_to(acc)
}

5
crates/ide_completion/src/completions/keyword.rs

@ -6,7 +6,7 @@ use syntax::{SyntaxKind, T};
use crate::{
context::PathCompletionContext, patterns::ImmediateLocation, CompletionContext, CompletionItem,
CompletionItemKind, CompletionKind, Completions,
CompletionItemKind, Completions,
};
pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
@ -158,8 +158,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
}
fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw);
item.kind(CompletionItemKind::Keyword);
let mut item = CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), kw);
match ctx.config.snippet_cap {
Some(cap) => {

5
crates/ide_completion/src/completions/mod_.rs

@ -11,7 +11,7 @@ use rustc_hash::FxHashSet;
use crate::{patterns::ImmediateLocation, CompletionItem};
use crate::{context::CompletionContext, item::CompletionKind, Completions};
use crate::{context::CompletionContext, Completions};
/// Complete mod declaration, i.e. `mod $0 ;`
pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
@ -80,8 +80,7 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
if mod_under_caret.semicolon_token().is_none() {
label.push(';');
}
let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label);
item.kind(SymbolKind::Module);
let item = CompletionItem::new(SymbolKind::Module, ctx.source_range(), &label);
item.add_to(acc)
});

18
crates/ide_completion/src/completions/postfix.rs

@ -15,11 +15,9 @@ use syntax::{
use text_edit::TextEdit;
use crate::{
completions::postfix::format_like::add_format_like_completions,
context::CompletionContext,
item::{Builder, CompletionKind},
patterns::ImmediateLocation,
CompletionItem, CompletionItemKind, CompletionRelevance, Completions, SnippetScope,
completions::postfix::format_like::add_format_like_completions, context::CompletionContext,
item::Builder, patterns::ImmediateLocation, CompletionItem, CompletionItemKind,
CompletionRelevance, Completions, SnippetScope,
};
pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
@ -45,8 +43,9 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
// Suggest .await syntax for types that implement Future trait
if receiver_ty.impls_future(ctx.db) {
let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await");
item.kind(CompletionItemKind::Keyword).detail("expr.await");
let mut item =
CompletionItem::new(CompletionItemKind::Keyword, ctx.source_range(), "await");
item.detail("expr.await");
item.add_to(acc);
}
@ -224,8 +223,9 @@ fn build_postfix_snippet_builder<'ctx>(
) -> impl Fn(&str, &str, &str) -> Builder + 'ctx {
move |label, detail, snippet| {
let edit = TextEdit::replace(delete_range, snippet.to_string());
let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
let mut item =
CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), label);
item.detail(detail).snippet_edit(cap, edit);
if ctx.original_token.text() == label {
let relevance =
CompletionRelevance { exact_postfix_snippet_match: true, ..Default::default() };

16
crates/ide_completion/src/completions/record.rs

@ -3,8 +3,7 @@ use ide_db::{helpers::FamousDefs, SymbolKind};
use syntax::{ast::Expr, T};
use crate::{
item::CompletionKind, patterns::ImmediateLocation, CompletionContext, CompletionItem,
CompletionItemKind, Completions,
patterns::ImmediateLocation, CompletionContext, CompletionItem, CompletionItemKind, Completions,
};
pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
@ -22,20 +21,17 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
let missing_fields = ctx.sema.record_literal_missing_fields(record_expr);
if impl_default_trait && !missing_fields.is_empty() && ctx.path_qual().is_none() {
let completion_text = "..Default::default()";
let mut item = CompletionItem::new(
CompletionKind::Snippet,
ctx.source_range(),
completion_text,
);
let mut item =
CompletionItem::new(SymbolKind::Field, ctx.source_range(), completion_text);
let completion_text =
completion_text.strip_prefix(ctx.token.text()).unwrap_or(completion_text);
item.insert_text(completion_text).kind(SymbolKind::Field);
item.insert_text(completion_text);
item.add_to(acc);
}
if ctx.previous_token_is(T![.]) {
let mut item =
CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), "..");
item.insert_text(".").kind(CompletionItemKind::Snippet);
CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), "..");
item.insert_text(".");
item.add_to(acc);
return None;
}

6
crates/ide_completion/src/completions/snippet.rs

@ -6,12 +6,12 @@ use syntax::T;
use crate::{
context::PathCompletionContext, item::Builder, CompletionContext, CompletionItem,
CompletionItemKind, CompletionKind, Completions, SnippetScope,
CompletionItemKind, Completions, SnippetScope,
};
fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label);
item.insert_snippet(cap, snippet).kind(CompletionItemKind::Snippet);
let mut item = CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), label);
item.insert_snippet(cap, snippet);
item
}

33
crates/ide_completion/src/completions/trait_impl.rs

@ -40,7 +40,7 @@ use syntax::{
};
use text_edit::TextEdit;
use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
use crate::{CompletionContext, CompletionItem, CompletionItemKind, Completions};
#[derive(Debug, PartialEq, Eq)]
enum ImplCompletionKind {
@ -141,14 +141,14 @@ fn add_function_impl(
format!("fn {}(..)", fn_name)
};
let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
item.lookup_by(fn_name).set_documentation(func.docs(ctx.db));
let completion_kind = if func.self_param(ctx.db).is_some() {
CompletionItemKind::Method
} else {
CompletionItemKind::SymbolKind(SymbolKind::Function)
};
let mut item = CompletionItem::new(completion_kind, ctx.source_range(), label);
item.lookup_by(fn_name).set_documentation(func.docs(ctx.db));
let range = replacement_range(ctx, fn_def_node);
if let Some(source) = func.source(ctx.db) {
@ -170,7 +170,6 @@ fn add_function_impl(
item.text_edit(TextEdit::replace(range, header));
}
};
item.kind(completion_kind);
item.add_to(acc);
}
}
@ -211,10 +210,9 @@ fn add_type_alias_impl(
let snippet = format!("type {} = ", alias_name);
let range = replacement_range(ctx, type_def_node);
let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
let mut item = CompletionItem::new(SymbolKind::TypeAlias, ctx.source_range(), snippet.clone());
item.text_edit(TextEdit::replace(range, snippet))
.lookup_by(alias_name)
.kind(SymbolKind::TypeAlias)
.set_documentation(type_alias.docs(ctx.db));
item.add_to(acc);
}
@ -241,10 +239,9 @@ fn add_const_impl(
let range = replacement_range(ctx, const_def_node);
let mut item =
CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
CompletionItem::new(SymbolKind::Const, ctx.source_range(), snippet.clone());
item.text_edit(TextEdit::replace(range, snippet))
.lookup_by(const_name)
.kind(SymbolKind::Const)
.set_documentation(const_.docs(ctx.db));
item.add_to(acc);
}
@ -358,23 +355,7 @@ impl Test for T {
}
}
",
expect![[r#"
sn if if expr {}
sn while while expr {}
sn not !expr
sn ref &expr
sn refm &mut expr
sn match match expr {}
sn box Box::new(expr)
sn ok Ok(expr)
sn err Err(expr)
sn some Some(expr)
sn dbg dbg!(expr)
sn dbgr dbg!(&expr)
sn call function(expr)
sn let let
sn letm let mut
"#]],
expect![[r#""#]],
);
check(

41
crates/ide_completion/src/item.rs

@ -21,10 +21,6 @@ use text_edit::TextEdit;
/// `CompletionItem`, use `new` method and the `Builder` struct.
#[derive(Clone)]
pub struct CompletionItem {
/// Used only internally in tests, to check only specific kind of
/// completion (postfix, keyword, reference, etc).
#[allow(unused)]
pub(crate) completion_kind: CompletionKind,
/// Label in the completion pop up which identifies completion.
label: String,
/// Range of identifier that is being completed.
@ -43,7 +39,7 @@ pub struct CompletionItem {
is_snippet: bool,
/// What item (struct, function, etc) are we completing.
kind: Option<CompletionItemKind>,
kind: CompletionItemKind,
/// Lookup is used to check if completion item indeed can complete current
/// ident.
@ -92,9 +88,7 @@ impl fmt::Debug for CompletionItem {
} else {
s.field("text_edit", &self.text_edit);
}
if let Some(kind) = self.kind().as_ref() {
s.field("kind", kind);
}
s.field("kind", &self.kind());
if self.lookup() != self.label() {
s.field("lookup", &self.lookup());
}
@ -270,32 +264,15 @@ impl CompletionItemKind {
}
}
// FIXME remove this?
/// Like [`CompletionItemKind`] but solely used for filtering test results.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub(crate) enum CompletionKind {
/// Parser-based keyword completion.
Keyword,
/// Your usual "complete all valid identifiers".
Reference,
/// "Secret sauce" completions.
Magic,
Snippet,
Postfix,
BuiltinType,
Attribute,
}
impl CompletionItem {
pub(crate) fn new(
completion_kind: CompletionKind,
kind: impl Into<CompletionItemKind>,
source_range: TextRange,
label: impl Into<String>,
) -> Builder {
let label = label.into();
Builder {
source_range,
completion_kind,
label,
insert_text: None,
is_snippet: false,
@ -303,7 +280,7 @@ impl CompletionItem {
detail: None,
documentation: None,
lookup: None,
kind: None,
kind: kind.into(),
text_edit: None,
deprecated: false,
trigger_call_info: None,
@ -342,7 +319,7 @@ impl CompletionItem {
self.lookup.as_deref().unwrap_or(&self.label)
}
pub fn kind(&self) -> Option<CompletionItemKind> {
pub fn kind(&self) -> CompletionItemKind {
self.kind
}
@ -401,7 +378,6 @@ impl ImportEdit {
#[derive(Clone)]
pub(crate) struct Builder {
source_range: TextRange,
completion_kind: CompletionKind,
imports_to_add: SmallVec<[ImportEdit; 1]>,
trait_name: Option<String>,
label: String,
@ -410,7 +386,7 @@ pub(crate) struct Builder {
detail: Option<String>,
documentation: Option<Documentation>,
lookup: Option<String>,
kind: Option<CompletionItemKind>,
kind: CompletionItemKind,
text_edit: Option<TextEdit>,
deprecated: bool,
trigger_call_info: Option<bool>,
@ -454,7 +430,6 @@ impl Builder {
documentation: self.documentation,
lookup,
kind: self.kind,
completion_kind: self.completion_kind,
deprecated: self.deprecated,
trigger_call_info: self.trigger_call_info.unwrap_or(false),
relevance: self.relevance,
@ -487,10 +462,6 @@ impl Builder {
self.is_snippet = true;
self.insert_text(snippet)
}
pub(crate) fn kind(&mut self, kind: impl Into<CompletionItemKind>) -> &mut Builder {
self.kind = Some(kind.into());
self
}
pub(crate) fn text_edit(&mut self, edit: TextEdit) -> &mut Builder {
self.text_edit = Some(edit);
self

2
crates/ide_completion/src/lib.rs

@ -24,7 +24,7 @@ use ide_db::{
use syntax::algo;
use text_edit::TextEdit;
use crate::{completions::Completions, context::CompletionContext, item::CompletionKind};
use crate::{completions::Completions, context::CompletionContext};
pub use crate::{
config::CompletionConfig,

169
crates/ide_completion/src/render.rs

@ -22,7 +22,7 @@ use crate::{
context::{PathCompletionContext, PathKind},
item::{CompletionRelevanceTypeMatch, ImportEdit},
render::{enum_variant::render_variant, function::render_fn, macro_::render_macro},
CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
CompletionContext, CompletionItem, CompletionItemKind, CompletionRelevance,
};
/// Interface for data and methods required for items rendering.
#[derive(Debug)]
@ -85,7 +85,7 @@ pub(crate) fn render_field(
let is_deprecated = ctx.is_deprecated(field);
let name = field.name(ctx.db()).to_string();
let mut item = CompletionItem::new(
CompletionKind::Reference,
SymbolKind::Field,
ctx.source_range(),
receiver.map_or_else(|| name.clone(), |receiver| format!("{}.{}", receiver, name)),
);
@ -94,8 +94,7 @@ pub(crate) fn render_field(
exact_name_match: compute_exact_name_match(ctx.completion, name.as_str()),
..CompletionRelevance::default()
});
item.kind(SymbolKind::Field)
.detail(ty.display(ctx.db()).to_string())
item.detail(ty.display(ctx.db()).to_string())
.set_documentation(field.docs(ctx.db()))
.set_deprecated(is_deprecated)
.lookup_by(name.as_str());
@ -118,13 +117,11 @@ pub(crate) fn render_tuple_field(
ty: &hir::Type,
) -> CompletionItem {
let mut item = CompletionItem::new(
CompletionKind::Reference,
SymbolKind::Field,
ctx.source_range(),
receiver.map_or_else(|| field.to_string(), |receiver| format!("{}.{}", receiver, field)),
);
item.kind(SymbolKind::Field)
.detail(ty.display(ctx.db()).to_string())
.lookup_by(field.to_string());
item.detail(ty.display(ctx.db()).to_string()).lookup_by(field.to_string());
item.build()
}
@ -147,10 +144,7 @@ pub(crate) fn render_resolution_with_import(
hir::ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
_ => item_name(ctx.db(), import_edit.import.original_item)?,
};
render_resolution_(ctx, local_name, Some(import_edit), &resolution).map(|mut item| {
item.completion_kind = CompletionKind::Magic;
item
})
render_resolution_(ctx, local_name, Some(import_edit), &resolution)
}
fn render_resolution_(
@ -162,11 +156,6 @@ fn render_resolution_(
let _p = profile::span("render_resolution");
use hir::ModuleDef::*;
let completion_kind = match resolution {
hir::ScopeDef::ModuleDef(BuiltinType(..)) => CompletionKind::BuiltinType,
_ => CompletionKind::Reference,
};
let kind = match resolution {
hir::ScopeDef::ModuleDef(Function(func)) => {
return render_fn(ctx, import_to_add, Some(local_name), *func);
@ -208,11 +197,10 @@ fn render_resolution_(
}
hir::ScopeDef::Unknown => {
let mut item = CompletionItem::new(
CompletionKind::Reference,
CompletionItemKind::UnresolvedReference,
ctx.source_range(),
local_name.to_string(),
);
item.kind(CompletionItemKind::UnresolvedReference);
if let Some(import_to_add) = import_to_add {
item.add_import(import_to_add);
}
@ -221,7 +209,7 @@ fn render_resolution_(
};
let local_name = local_name.to_string();
let mut item = CompletionItem::new(completion_kind, ctx.source_range(), local_name.clone());
let mut item = CompletionItem::new(kind, ctx.source_range(), local_name.clone());
if let hir::ScopeDef::Local(local) = resolution {
let ty = local.ty(ctx.db());
if !ty.is_unknown() {
@ -260,8 +248,7 @@ fn render_resolution_(
}
}
}
item.kind(kind)
.set_documentation(scope_def_docs(ctx.db(), resolution))
item.set_documentation(scope_def_docs(ctx.db(), resolution))
.set_deprecated(scope_def_is_deprecated(&ctx, resolution));
if let Some(import_to_add) = import_to_add {
@ -344,37 +331,54 @@ mod tests {
use std::cmp;
use expect_test::{expect, Expect};
use ide_db::SymbolKind;
use itertools::Itertools;
use crate::{
item::CompletionRelevanceTypeMatch,
tests::{check_edit, do_completion, get_all_items, TEST_CONFIG},
CompletionKind, CompletionRelevance,
CompletionItem, CompletionItemKind, CompletionRelevance,
};
#[track_caller]
fn check(ra_fixture: &str, expect: Expect) {
let actual = do_completion(ra_fixture, CompletionKind::Reference);
fn check(ra_fixture: &str, kind: impl Into<CompletionItemKind>, expect: Expect) {
let actual = do_completion(ra_fixture, kind.into());
expect.assert_debug_eq(&actual);
}
#[track_caller]
fn check_relevance(ra_fixture: &str, expect: Expect) {
check_relevance_for_kinds(&[CompletionKind::Reference], ra_fixture, expect)
fn check_kinds(ra_fixture: &str, kinds: &[CompletionItemKind], expect: Expect) {
let actual: Vec<_> =
kinds.iter().flat_map(|&kind| do_completion(ra_fixture, kind)).collect();
expect.assert_debug_eq(&actual);
}
#[track_caller]
fn check_relevance_for_kinds(kinds: &[CompletionKind], ra_fixture: &str, expect: Expect) {
fn check_relevance_for_kinds(ra_fixture: &str, kinds: &[CompletionItemKind], expect: Expect) {
let mut actual = get_all_items(TEST_CONFIG, ra_fixture);
actual.retain(|it| kinds.contains(&it.completion_kind));
actual.retain(|it| kinds.contains(&it.kind()));
actual.sort_by_key(|it| cmp::Reverse(it.relevance().score()));
check_relevance_(actual, expect);
}
#[track_caller]
fn check_relevance(ra_fixture: &str, expect: Expect) {
let mut actual = get_all_items(TEST_CONFIG, ra_fixture);
actual.retain(|it| it.kind() != CompletionItemKind::Snippet);
actual.retain(|it| it.kind() != CompletionItemKind::Keyword);
actual.retain(|it| it.kind() != CompletionItemKind::BuiltinType);
actual.sort_by_key(|it| cmp::Reverse(it.relevance().score()));
check_relevance_(actual, expect);
}
#[track_caller]
fn check_relevance_(actual: Vec<CompletionItem>, expect: Expect) {
let actual = actual
.into_iter()
.flat_map(|it| {
let mut items = vec![];
let tag = it.kind().unwrap().tag();
let tag = it.kind().tag();
let relevance = display_relevance(it.relevance());
items.push(format!("{} {} {}\n", tag, it.label(), relevance));
@ -418,6 +422,7 @@ enum Foo { Foo { x: i32, y: i32 } }
fn main() { Foo::Fo$0 }
"#,
SymbolKind::Variant,
expect![[r#"
[
CompletionItem {
@ -443,6 +448,7 @@ enum Foo { Foo (i32, i32) }
fn main() { Foo::Fo$0 }
"#,
SymbolKind::Variant,
expect![[r#"
[
CompletionItem {
@ -470,6 +476,7 @@ fn foo<T>(a: u32, b: u32, t: T) -> (u32, T) { (a, t) }
fn main() { fo$0 }
"#,
SymbolKind::Function,
expect![[r#"
[
CompletionItem {
@ -508,6 +515,7 @@ enum Foo { Foo }
fn main() { Foo::Fo$0 }
"#,
SymbolKind::Variant,
expect![[r#"
[
CompletionItem {
@ -527,15 +535,40 @@ fn main() { Foo::Fo$0 }
#[test]
fn lookup_enums_by_two_qualifiers() {
check(
check_kinds(
r#"
mod m {
pub enum Spam { Foo, Bar(i32) }
}
fn main() { let _: m::Spam = S$0 }
"#,
&[
CompletionItemKind::SymbolKind(SymbolKind::Function),
CompletionItemKind::SymbolKind(SymbolKind::Module),
CompletionItemKind::SymbolKind(SymbolKind::Variant),
],
expect![[r#"
[
CompletionItem {
label: "main()",
source_range: 75..76,
delete: 75..76,
insert: "main()$0",
kind: SymbolKind(
Function,
),
lookup: "main",
detail: "fn()",
},
CompletionItem {
label: "m",
source_range: 75..76,
delete: 75..76,
insert: "m",
kind: SymbolKind(
Module,
),
},
CompletionItem {
label: "Spam::Bar(…)",
source_range: 75..76,
@ -556,15 +589,6 @@ fn main() { let _: m::Spam = S$0 }
},
trigger_call_info: true,
},
CompletionItem {
label: "m",
source_range: 75..76,
delete: 75..76,
insert: "m",
kind: SymbolKind(
Module,
),
},
CompletionItem {
label: "m::Spam::Foo",
source_range: 75..76,
@ -584,17 +608,6 @@ fn main() { let _: m::Spam = S$0 }
exact_postfix_snippet_match: false,
},
},
CompletionItem {
label: "main()",
source_range: 75..76,
delete: 75..76,
insert: "main()$0",
kind: SymbolKind(
Function,
),
lookup: "main",
detail: "fn()",
},
]
"#]],
)
@ -611,6 +624,7 @@ fn something_else_deprecated() {}
fn main() { som$0 }
"#,
SymbolKind::Function,
expect![[r#"
[
CompletionItem {
@ -657,6 +671,7 @@ fn main() { som$0 }
struct A { #[deprecated] the_field: u32 }
fn foo() { A { the$0 } }
"#,
SymbolKind::Field,
expect![[r#"
[
CompletionItem {
@ -685,7 +700,7 @@ fn foo() { A { the$0 } }
#[test]
fn renders_docs() {
check(
check_kinds(
r#"
struct S {
/// Field docs
@ -695,6 +710,7 @@ impl S {
/// Method docs
fn bar(self) { self.$0 }
}"#,
&[CompletionItemKind::Method, CompletionItemKind::SymbolKind(SymbolKind::Field)],
expect![[r#"
[
CompletionItem {
@ -726,7 +742,7 @@ impl S {
"#]],
);
check(
check_kinds(
r#"
use self::my$0;
@ -740,18 +756,23 @@ enum E {
}
use self::E::*;
"#,
&[
CompletionItemKind::SymbolKind(SymbolKind::Module),
CompletionItemKind::SymbolKind(SymbolKind::Variant),
CompletionItemKind::SymbolKind(SymbolKind::Enum),
],
expect![[r#"
[
CompletionItem {
label: "E",
label: "my",
source_range: 10..12,
delete: 10..12,
insert: "E",
insert: "my",
kind: SymbolKind(
Enum,
Module,
),
documentation: Documentation(
"enum docs",
"mod docs",
),
},
CompletionItem {
@ -768,15 +789,15 @@ use self::E::*;
),
},
CompletionItem {
label: "my",
label: "E",
source_range: 10..12,
delete: 10..12,
insert: "my",
insert: "E",
kind: SymbolKind(
Module,
Enum,
),
documentation: Documentation(
"mod docs",
"enum docs",
),
},
]
@ -795,6 +816,7 @@ impl S {
}
fn foo(s: S) { s.$0 }
"#,
CompletionItemKind::Method,
expect![[r#"
[
CompletionItem {
@ -1318,18 +1340,28 @@ fn main() {
#[test]
fn struct_field_method_ref() {
check(
check_kinds(
r#"
struct Foo { bar: u32 }
impl Foo { fn baz(&self) -> u32 { 0 } }
fn foo(f: Foo) { let _: &u32 = f.b$0 }
"#,
&[CompletionItemKind::Method, CompletionItemKind::SymbolKind(SymbolKind::Field)],
// FIXME
// Ideally we'd also suggest &f.bar and &f.baz() as exact
// type matches. See #8058.
expect![[r#"
[
CompletionItem {
label: "baz()",
source_range: 98..99,
delete: 98..99,
insert: "baz()$0",
kind: Method,
lookup: "baz",
detail: "fn(&self) -> u32",
},
CompletionItem {
label: "bar",
source_range: 98..99,
@ -1340,15 +1372,6 @@ fn foo(f: Foo) { let _: &u32 = f.b$0 }
),
detail: "u32",
},
CompletionItem {
label: "baz()",
source_range: 98..99,
delete: 98..99,
insert: "baz()$0",
kind: Method,
lookup: "baz",
detail: "fn(&self) -> u32",
},
]
"#]],
);
@ -1387,7 +1410,6 @@ fn foo() {
#[test]
fn postfix_completion_relevance() {
check_relevance_for_kinds(
&[CompletionKind::Postfix, CompletionKind::Magic],
r#"
mod ops {
pub trait Not {
@ -1404,7 +1426,8 @@ mod ops {
fn main() {
let _: bool = (9 > 2).not$0;
}
"#,
"#,
&[CompletionItemKind::Snippet, CompletionItemKind::Method],
expect![[r#"
sn not [snippet]
me not() (use ops::Not) [type_could_unify]

10
crates/ide_completion/src/render/const_.rs

@ -7,10 +7,7 @@ use syntax::{
display::const_label,
};
use crate::{
item::{CompletionItem, CompletionKind},
render::RenderContext,
};
use crate::{item::CompletionItem, render::RenderContext};
pub(crate) fn render_const(ctx: RenderContext<'_>, const_: hir::Const) -> Option<CompletionItem> {
ConstRender::new(ctx, const_)?.render()
@ -34,9 +31,8 @@ impl<'a> ConstRender<'a> {
let detail = self.detail();
let mut item =
CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name.clone());
item.kind(SymbolKind::Const)
.set_documentation(self.ctx.docs(self.const_))
CompletionItem::new(SymbolKind::Const, self.ctx.source_range(), name.clone());
item.set_documentation(self.ctx.docs(self.const_))
.set_deprecated(
self.ctx.is_deprecated(self.const_)
|| self.ctx.is_deprecated_assoc_item(self.const_),

7
crates/ide_completion/src/render/enum_variant.rs

@ -7,7 +7,7 @@ use ide_db::SymbolKind;
use itertools::Itertools;
use crate::{
item::{CompletionItem, CompletionKind, ImportEdit},
item::{CompletionItem, ImportEdit},
render::{builder_ext::Params, compute_ref_match, compute_type_match, RenderContext},
CompletionRelevance,
};
@ -61,12 +61,11 @@ impl<'a> EnumRender<'a> {
}
fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
let mut item = CompletionItem::new(
CompletionKind::Reference,
SymbolKind::Variant,
self.ctx.source_range(),
self.qualified_name.to_string(),
);
item.kind(SymbolKind::Variant)
.set_documentation(self.variant.docs(self.ctx.db()))
item.set_documentation(self.variant.docs(self.ctx.db()))
.set_deprecated(self.ctx.is_deprecated(self.variant))
.detail(self.detail());

8
crates/ide_completion/src/render/function.rs

@ -7,7 +7,7 @@ use itertools::Itertools;
use syntax::ast;
use crate::{
item::{CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance, ImportEdit},
item::{CompletionItem, CompletionItemKind, CompletionRelevance, ImportEdit},
render::{
builder_ext::Params, compute_exact_name_match, compute_ref_match, compute_type_match,
RenderContext,
@ -79,10 +79,8 @@ impl<'a> FunctionRender<'a> {
Some(receiver) => format!("{}.{}", receiver, &self.name),
None => self.name.clone(),
};
let mut item =
CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), call.clone());
item.kind(self.kind())
.set_documentation(self.ctx.docs(self.func))
let mut item = CompletionItem::new(self.kind(), self.ctx.source_range(), call.clone());
item.set_documentation(self.ctx.docs(self.func))
.set_deprecated(
self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
)

7
crates/ide_completion/src/render/macro_.rs

@ -6,7 +6,7 @@ use syntax::display::macro_label;
use crate::{
context::CallKind,
item::{CompletionItem, CompletionKind, ImportEdit},
item::{CompletionItem, ImportEdit},
render::RenderContext,
};
@ -47,9 +47,8 @@ impl<'a> MacroRender<'a> {
} else {
Some(self.ctx.source_range())
}?;
let mut item = CompletionItem::new(CompletionKind::Reference, source_range, &self.label());
item.kind(SymbolKind::Macro)
.set_documentation(self.docs.clone())
let mut item = CompletionItem::new(SymbolKind::Macro, source_range, &self.label());
item.set_documentation(self.docs.clone())
.set_deprecated(self.ctx.is_deprecated(self.macro_))
.set_detail(self.detail());

8
crates/ide_completion/src/render/pattern.rs

@ -6,7 +6,6 @@ use itertools::Itertools;
use crate::{
context::{ParamKind, PatternContext},
item::CompletionKind,
render::RenderContext,
CompletionItem, CompletionItemKind,
};
@ -58,11 +57,8 @@ fn build_completion(
pat: String,
def: impl HasAttrs + Copy,
) -> CompletionItem {
let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name);
item.kind(CompletionItemKind::Binding)
.set_documentation(ctx.docs(def))
.set_deprecated(ctx.is_deprecated(def))
.detail(&pat);
let mut item = CompletionItem::new(CompletionItemKind::Binding, ctx.source_range(), name);
item.set_documentation(ctx.docs(def)).set_deprecated(ctx.is_deprecated(def)).detail(&pat);
match ctx.snippet_cap() {
Some(snippet_cap) => item.insert_snippet(snippet_cap, pat),
None => item.insert_text(pat),

10
crates/ide_completion/src/render/struct_literal.rs

@ -4,7 +4,7 @@ use hir::{db::HirDatabase, HasAttrs, HasVisibility, Name, StructKind};
use ide_db::helpers::SnippetCap;
use itertools::Itertools;
use crate::{item::CompletionKind, render::RenderContext, CompletionItem, CompletionItemKind};
use crate::{render::RenderContext, CompletionItem, CompletionItemKind};
pub(crate) fn render_struct_literal(
ctx: RenderContext<'_>,
@ -33,11 +33,9 @@ fn build_completion(
literal: String,
def: impl HasAttrs + Copy,
) -> CompletionItem {
let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name + " {…}");
item.kind(CompletionItemKind::Snippet)
.set_documentation(ctx.docs(def))
.set_deprecated(ctx.is_deprecated(def))
.detail(&literal);
let mut item =
CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), name + " {…}");
item.set_documentation(ctx.docs(def)).set_deprecated(ctx.is_deprecated(def)).detail(&literal);
match ctx.snippet_cap() {
Some(snippet_cap) => item.insert_snippet(snippet_cap, literal),
None => item.insert_text(literal),

10
crates/ide_completion/src/render/type_alias.rs

@ -7,10 +7,7 @@ use syntax::{
display::type_label,
};
use crate::{
item::{CompletionItem, CompletionKind},
render::RenderContext,
};
use crate::{item::CompletionItem, render::RenderContext};
pub(crate) fn render_type_alias(
ctx: RenderContext<'_>,
@ -50,9 +47,8 @@ impl<'a> TypeAliasRender<'a> {
let detail = self.detail();
let mut item =
CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), name.clone());
item.kind(SymbolKind::TypeAlias)
.set_documentation(self.ctx.docs(self.type_alias))
CompletionItem::new(SymbolKind::TypeAlias, self.ctx.source_range(), name.clone());
item.set_documentation(self.ctx.docs(self.type_alias))
.set_deprecated(
self.ctx.is_deprecated(self.type_alias)
|| self.ctx.is_deprecated_assoc_item(self.type_alias),

16
crates/ide_completion/src/tests.rs

@ -38,7 +38,7 @@ use stdx::{format_to, trim_indent};
use syntax::{AstNode, NodeOrToken, SyntaxElement};
use test_utils::assert_eq_text;
use crate::{item::CompletionKind, CompletionConfig, CompletionItem};
use crate::{CompletionConfig, CompletionItem, CompletionItemKind};
/// Lots of basic item definitions
const BASE_ITEMS_FIXTURE: &str = r#"
@ -96,10 +96,10 @@ fn completion_list_with_config(
let items = items
.into_iter()
.filter(|it| {
it.completion_kind != CompletionKind::BuiltinType || !mem::replace(&mut bt_seen, true)
it.kind() != CompletionItemKind::BuiltinType || !mem::replace(&mut bt_seen, true)
})
.filter(|it| include_keywords || it.completion_kind != CompletionKind::Keyword)
.filter(|it| include_keywords || it.completion_kind != CompletionKind::Snippet)
.filter(|it| include_keywords || it.kind() != CompletionItemKind::Keyword)
.filter(|it| include_keywords || it.kind() != CompletionItemKind::Snippet)
.collect();
render_completion_list(items)
}
@ -115,18 +115,18 @@ pub(crate) fn position(ra_fixture: &str) -> (RootDatabase, FilePosition) {
(database, FilePosition { file_id, offset })
}
pub(crate) fn do_completion(code: &str, kind: CompletionKind) -> Vec<CompletionItem> {
pub(crate) fn do_completion(code: &str, kind: CompletionItemKind) -> Vec<CompletionItem> {
do_completion_with_config(TEST_CONFIG, code, kind)
}
pub(crate) fn do_completion_with_config(
config: CompletionConfig,
code: &str,
kind: CompletionKind,
kind: CompletionItemKind,
) -> Vec<CompletionItem> {
get_all_items(config, code)
.into_iter()
.filter(|c| c.completion_kind == kind)
.filter(|c| c.kind() == kind)
.sorted_by(|l, r| l.label().cmp(r.label()))
.collect()
}
@ -140,7 +140,7 @@ fn render_completion_list(completions: Vec<CompletionItem>) -> String {
completions
.into_iter()
.map(|it| {
let tag = it.kind().unwrap().tag();
let tag = it.kind().tag();
let var_name = format!("{} {}", tag, it.label());
let mut buf = var_name;
if let Some(detail) = it.detail() {

2
crates/rust-analyzer/src/to_proto.rs

@ -248,7 +248,7 @@ fn completion_item(
label: item.label().to_string(),
detail: item.detail().map(|it| it.to_string()),
filter_text: Some(item.lookup().to_string()),
kind: item.kind().map(completion_item_kind),
kind: Some(completion_item_kind(item.kind())),
text_edit: Some(text_edit),
additional_text_edits: Some(additional_text_edits),
documentation: item.documentation().map(documentation),