);
let lookup = components.join(", ");
let label = components.iter().rev().join(", ");
- let mut builder =
+ let mut item =
CompletionItem::new(CompletionKind::Attribute, ctx.source_range(), label);
- builder.lookup_by(lookup).kind(CompletionItemKind::Attribute);
- builder.add_to(acc);
+ item.lookup_by(lookup).kind(CompletionItemKind::Attribute);
+ item.add_to(acc);
}
for custom_derive_name in get_derive_names_in_scope(ctx).difference(&existing_derives) {
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Attribute,
ctx.source_range(),
custom_derive_name,
);
- builder.kind(CompletionItemKind::Attribute);
- builder.add_to(acc);
+ item.kind(CompletionItemKind::Attribute);
+ item.add_to(acc);
}
}
}
.into_iter()
.filter(|completion| !existing_lints.contains(completion.label))
{
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Attribute,
ctx.source_range(),
lint_completion.label,
);
- builder.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
- builder.add_to(acc)
+ item.kind(CompletionItemKind::Attribute).detail(lint_completion.description);
+ item.add_to(acc)
}
}
}
}
params.into_iter().for_each(|(label, lookup)| {
- let mut builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
- builder.kind(CompletionItemKind::Binding).lookup_by(lookup);
- builder.add_to(acc)
+ let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
+ item.kind(CompletionItemKind::Binding).lookup_by(lookup);
+ item.add_to(acc)
});
}
if ctx.use_item_syntax.is_some() {
if ctx.path_qual.is_none() {
- let mut crate_builder =
- CompletionItem::new(CompletionKind::Keyword, source_range, "crate::");
- crate_builder.kind(CompletionItemKind::Keyword).insert_text("crate::");
- crate_builder.add_to(acc);
+ let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "crate::");
+ item.kind(CompletionItemKind::Keyword).insert_text("crate::");
+ item.add_to(acc);
}
- let mut self_builder = CompletionItem::new(CompletionKind::Keyword, source_range, "self");
- self_builder.kind(CompletionItemKind::Keyword);
- self_builder.add_to(acc);
+ let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "self");
+ item.kind(CompletionItemKind::Keyword);
+ item.add_to(acc);
if iter::successors(ctx.path_qual.clone(), |p| p.qualifier())
.all(|p| p.segment().and_then(|s| s.super_token()).is_some())
{
- let mut super_builder =
- CompletionItem::new(CompletionKind::Keyword, source_range, "super::");
- super_builder.kind(CompletionItemKind::Keyword).insert_text("super::");
- super_builder.add_to(acc);
+ let mut item = CompletionItem::new(CompletionKind::Keyword, source_range, "super::");
+ item.kind(CompletionItemKind::Keyword).insert_text("super::");
+ item.add_to(acc);
}
}
if let Some(receiver) = &ctx.dot_receiver {
if let Some(ty) = ctx.sema.type_of_expr(receiver) {
if ty.impls_future(ctx.db) {
- let mut builder =
+ let mut item =
CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await");
- builder.kind(CompletionItemKind::Keyword).detail("expr.await").insert_text("await");
- builder.add_to(acc);
+ item.kind(CompletionItemKind::Keyword).detail("expr.await").insert_text("await");
+ item.add_to(acc);
}
};
}
}
fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
- let mut builder = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw);
- builder.kind(CompletionItemKind::Keyword);
+ let mut item = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw);
+ item.kind(CompletionItemKind::Keyword);
match ctx.config.snippet_cap {
Some(cap) => {
} else {
snippet
};
- builder.insert_snippet(cap, snippet);
+ item.insert_snippet(cap, snippet);
}
None => {
- builder.insert_text(if snippet.contains('$') { kw } else { snippet });
+ item.insert_text(if snippet.contains('$') { kw } else { snippet });
}
};
- acc.add(builder.build());
+ item.add_to(acc);
}
#[cfg(test)]
if mod_under_caret.semicolon_token().is_none() {
label.push(';');
}
- let mut builder =
- CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label);
- builder.kind(SymbolKind::Module);
- builder.add_to(acc)
+ let mut item = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), &label);
+ item.kind(SymbolKind::Module);
+ item.add_to(acc)
});
Some(())
let delete_range = TextRange::new(receiver_range.start(), ctx.source_range().end());
TextEdit::replace(delete_range, snippet.to_string())
};
- CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label)
- .detail(detail)
- .kind(CompletionItemKind::Snippet)
- .snippet_edit(cap, edit)
- .clone()
+ let mut item = CompletionItem::new(CompletionKind::Postfix, ctx.source_range(), label);
+ item.detail(detail).kind(CompletionItemKind::Snippet).snippet_edit(cap, edit);
+ item
}
#[cfg(test)]
let completion_text = completion_text
.strip_prefix(ctx.token.to_string().as_str())
.unwrap_or(completion_text);
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Snippet,
ctx.source_range(),
"..Default::default()",
);
- builder.insert_text(completion_text).kind(SymbolKind::Field);
- acc.add(builder.build());
+ item.insert_text(completion_text).kind(SymbolKind::Field);
+ item.add_to(acc);
}
missing_fields
};
fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str) -> Builder {
- let mut builder = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label);
- builder.insert_snippet(cap, snippet).kind(CompletionItemKind::Snippet).clone()
+ let mut item = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), label);
+ item.insert_snippet(cap, snippet).kind(CompletionItemKind::Snippet);
+ item
}
pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
None => return,
};
- let mut test_module_builder = snippet(
+ let mut item = snippet(
ctx,
cap,
"tmod (Test module)",
}
}",
);
- test_module_builder.lookup_by("tmod");
- test_module_builder.add_to(acc);
+ item.lookup_by("tmod");
+ item.add_to(acc);
- let mut test_function_builder = snippet(
+ let mut item = snippet(
ctx,
cap,
"tfn (Test function)",
$0
}",
);
- test_function_builder.lookup_by("tfn");
- test_function_builder.add_to(acc);
+ item.lookup_by("tfn");
+ item.add_to(acc);
- let macro_rules_builder =
- snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}");
- macro_rules_builder.add_to(acc);
+ let item = snippet(ctx, cap, "macro_rules", "macro_rules! $1 {\n\t($2) => {\n\t\t$0\n\t};\n}");
+ item.add_to(acc);
}
#[cfg(test)]
format!("fn {}(..)", fn_name)
};
- let mut builder = CompletionItem::new(CompletionKind::Magic, ctx.source_range(), label);
- builder.lookup_by(fn_name).set_documentation(func.docs(ctx.db));
+ 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
match ctx.config.snippet_cap {
Some(cap) => {
let snippet = format!("{} {{\n $0\n}}", function_decl);
- builder.snippet_edit(cap, TextEdit::replace(range, snippet));
+ item.snippet_edit(cap, TextEdit::replace(range, snippet));
}
None => {
let header = format!("{} {{", function_decl);
- builder.text_edit(TextEdit::replace(range, header));
+ item.text_edit(TextEdit::replace(range, header));
}
};
- builder.kind(completion_kind);
- builder.add_to(acc);
+ item.kind(completion_kind);
+ item.add_to(acc);
}
}
let range = TextRange::new(type_def_node.text_range().start(), ctx.source_range().end());
- let mut builder =
- CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
- builder
- .text_edit(TextEdit::replace(range, snippet))
+ let mut item = CompletionItem::new(CompletionKind::Magic, 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));
- builder.add_to(acc);
+ item.add_to(acc);
}
fn add_const_impl(
let range =
TextRange::new(const_def_node.text_range().start(), ctx.source_range().end());
- let mut builder =
+ let mut item =
CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
- builder
- .text_edit(TextEdit::replace(range, snippet))
+ item.text_edit(TextEdit::replace(range, snippet))
.lookup_by(const_name)
.kind(SymbolKind::Const)
.set_documentation(const_.docs(ctx.db));
- builder.add_to(acc);
+ item.add_to(acc);
}
}
}
fn add_field(&mut self, field: hir::Field, ty: &Type) -> CompletionItem {
let is_deprecated = self.ctx.is_deprecated(field);
let name = field.name(self.ctx.db());
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Reference,
self.ctx.source_range(),
name.to_string(),
);
- builder
- .kind(SymbolKind::Field)
+ item.kind(SymbolKind::Field)
.detail(ty.display(self.ctx.db()).to_string())
.set_documentation(field.docs(self.ctx.db()))
.set_deprecated(is_deprecated);
if let Some(relevance) = compute_relevance(&self.ctx, &ty, &name.to_string()) {
- builder.set_relevance(relevance);
+ item.set_relevance(relevance);
}
- builder.build()
+ item.build()
}
fn add_tuple_field(&mut self, field: usize, ty: &Type) -> CompletionItem {
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Reference,
self.ctx.source_range(),
field.to_string(),
);
- builder.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string());
+ item.kind(SymbolKind::Field).detail(ty.display(self.ctx.db()).to_string());
- builder.build()
+ item.build()
}
fn render_resolution(
}
fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Reference,
self.ctx.source_range(),
self.qualified_name.clone(),
);
- builder
- .kind(SymbolKind::Variant)
+ item.kind(SymbolKind::Variant)
.set_documentation(self.variant.docs(self.ctx.db()))
.set_deprecated(self.ctx.is_deprecated(self.variant))
.add_import(import_to_add)
if self.variant_kind == StructKind::Tuple {
cov_mark::hit!(inserts_parens_for_tuple_enums);
let params = Params::Anonymous(self.variant.fields(self.ctx.db()).len());
- builder.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
+ item.add_call_parens(self.ctx.completion, self.short_qualified_name, params);
} else if self.path.is_some() {
- builder.lookup_by(self.short_qualified_name);
+ item.lookup_by(self.short_qualified_name);
}
- builder.build()
+ item.build()
}
fn detail(&self) -> String {
fn render(self, import_to_add: Option<ImportEdit>) -> CompletionItem {
let params = self.params();
- let mut builder = CompletionItem::new(
+ let mut item = CompletionItem::new(
CompletionKind::Reference,
self.ctx.source_range(),
self.name.clone(),
);
- builder
- .kind(self.kind())
+ item.kind(self.kind())
.set_documentation(self.ctx.docs(self.func))
.set_deprecated(
self.ctx.is_deprecated(self.func) || self.ctx.is_deprecated_assoc_item(self.func),
.add_call_parens(self.ctx.completion, self.name, params)
.add_import(import_to_add);
- builder.build()
+ item.build()
}
fn detail(&self) -> String {
}
fn render(&self, import_to_add: Option<ImportEdit>) -> Option<CompletionItem> {
- let mut builder =
+ let mut item =
CompletionItem::new(CompletionKind::Reference, self.ctx.source_range(), &self.label());
- builder
- .kind(SymbolKind::Macro)
+ item.kind(SymbolKind::Macro)
.set_documentation(self.docs.clone())
.set_deprecated(self.ctx.is_deprecated(self.macro_))
.add_import(import_to_add)
Some(cap) if needs_bang => {
let snippet = self.snippet();
let lookup = self.lookup();
- builder.insert_snippet(cap, snippet).lookup_by(lookup);
+ item.insert_snippet(cap, snippet).lookup_by(lookup);
}
None if needs_bang => {
- builder.insert_text(self.banged_name());
+ item.insert_text(self.banged_name());
}
_ => {
cov_mark::hit!(dont_insert_macro_call_parens_unncessary);
- builder.insert_text(&self.name);
+ item.insert_text(&self.name);
}
};
- Some(builder.build())
+ Some(item.build())
}
fn needs_bang(&self) -> bool {
ctx: RenderContext<'_>,
name: String,
pat: String,
- item: impl HasAttrs + Copy,
+ def: impl HasAttrs + Copy,
) -> CompletionItem {
- let mut completion = CompletionItem::new(CompletionKind::Snippet, ctx.source_range(), name);
- completion
- .kind(CompletionItemKind::Binding)
- .set_documentation(ctx.docs(item))
- .set_deprecated(ctx.is_deprecated(item))
+ 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);
if let Some(snippet_cap) = ctx.snippet_cap() {
- completion.insert_snippet(snippet_cap, pat);
+ item.insert_snippet(snippet_cap, pat);
} else {
- completion.insert_text(pat);
+ item.insert_text(pat);
};
- completion.build()
+ item.build()
}
fn render_pat(