//! Completion for associated items in a trait implementation.
//!
//! This module adds the completion items related to implementing associated
-//! items within a `impl Trait for Struct` block. The current context node
+//! items within an `impl Trait for Struct` block. The current context node
//! must be within either a `FN`, `TYPE_ALIAS`, or `CONST` node
//! and an direct child of an `IMPL`.
//!
use hir::{self, HasAttrs, HasSource};
use ide_db::{path_transform::PathTransform, traits::get_missing_assoc_items, SymbolKind};
use syntax::{
- ast::{self, edit},
+ ast::{self, edit_in_place::AttrsOwnerEdit},
display::function_declaration,
AstNode, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, T,
};
use text_edit::TextEdit;
-use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
+use crate::{CompletionContext, CompletionItem, CompletionItemKind, Completions};
#[derive(Debug, PartialEq, Eq)]
enum ImplCompletionKind {
func: hir::Function,
impl_def: hir::Impl,
) {
- let fn_name = func.name(ctx.db).to_string();
+ let fn_name = func.name(ctx.db).to_smol_str();
let label = if func.assoc_fn_params(ctx.db).is_empty() {
format!("fn {}()", fn_name)
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) {
item.text_edit(TextEdit::replace(range, header));
}
};
- item.kind(completion_kind);
item.add_to(acc);
}
}
let assoc_item = assoc_item.clone_for_update();
let trait_ = impl_def.trait_(ctx.db)?;
let source_scope = &ctx.sema.scope_for_def(trait_);
- let target_scope = &ctx.sema.scope(impl_def.source(ctx.db)?.syntax().value);
- let transform = PathTransform {
- subst: (trait_, impl_def.source(ctx.db)?.value),
- source_scope,
+ let target_scope = &ctx.sema.scope(ctx.sema.source(impl_def)?.syntax().value);
+ let transform = PathTransform::trait_impl(
target_scope,
- };
+ source_scope,
+ trait_,
+ impl_def.source(ctx.db)?.value,
+ );
- transform.apply(assoc_item.clone());
- Some(match assoc_item {
- ast::AssocItem::Fn(func) => ast::AssocItem::Fn(edit::remove_attrs_and_docs(&func)),
- _ => assoc_item,
- })
+ transform.apply(assoc_item.syntax());
+ if let ast::AssocItem::Fn(func) = &assoc_item {
+ func.remove_attrs_and_docs()
+ }
+ Some(assoc_item)
}
fn add_type_alias_impl(
ctx: &CompletionContext,
type_alias: hir::TypeAlias,
) {
- let alias_name = type_alias.name(ctx.db).to_string();
+ let alias_name = type_alias.name(ctx.db).to_smol_str();
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);
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);
}
const_: hir::Const,
impl_def: hir::Impl,
) {
- let const_name = const_.name(ctx.db).map(|n| n.to_string());
+ let const_name = const_.name(ctx.db).map(|n| n.to_smol_str());
if let Some(const_name) = const_name {
if let Some(source) = const_.source(ctx.db) {
let snippet = make_const_compl_syntax(&transformed_const);
let range = replacement_range(ctx, const_def_node);
- let mut item =
- CompletionItem::new(CompletionKind::Magic, ctx.source_range(), snippet.clone());
+ let mut item = CompletionItem::new(SymbolKind::Const, ctx.source_range(), &snippet);
item.text_edit(TextEdit::replace(range, snippet))
.lookup_by(const_name)
- .kind(SymbolKind::Const)
.set_documentation(const_.docs(ctx.db));
item.add_to(acc);
}
}
fn make_const_compl_syntax(const_: &ast::Const) -> String {
- let const_ = edit::remove_attrs_and_docs(const_);
+ const_.remove_attrs_and_docs();
let const_start = const_.syntax().text_range().start();
let const_end = const_.syntax().text_range().end();
mod tests {
use expect_test::{expect, Expect};
- use crate::{
- tests::{check_edit, filtered_completion_list},
- CompletionKind,
- };
+ use crate::tests::{check_edit, completion_list_no_kw};
fn check(ra_fixture: &str, expect: Expect) {
- let actual = filtered_completion_list(ra_fixture, CompletionKind::Magic);
+ let actual = completion_list_no_kw(ra_fixture);
expect.assert_eq(&actual)
}
- #[test]
- fn name_ref_function_type_const() {
- check(
- r#"
-trait Test {
- type TestType;
- const TEST_CONST: u16;
- fn test();
-}
-struct T;
-
-impl Test for T {
- t$0
-}
-"#,
- expect![["
-ta type TestType = \n\
-ct const TEST_CONST: u16 = \n\
-fn fn test()
-"]],
- );
- }
-
#[test]
fn no_completion_inside_fn() {
check(
}
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
check(
}
}
",
- expect![[""]],
+ expect![[r#""#]],
);
check(
fn test(t$0)
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ st T
+ "#]],
);
check(
fn test(f: fn $0)
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ st T
+ "#]],
);
}
const TEST: fn $0
}
",
- expect![[""]],
+ expect![[r#""#]],
);
check(
const TEST: T$0
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
check(
const TEST: u32 = f$0
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
check(
};
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
check(
type Test = T$0;
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
check(
type Test = fn $0;
}
",
- expect![[""]],
+ expect![[r#"
+ sp Self
+ tt Test
+ st T
+ bt u32
+ "#]],
);
}
);
}
- #[test]
- fn hide_implemented_fn() {
- check(
- r#"
-trait Test {
- fn foo();
- fn foo_bar();
-}
-struct T;
-
-impl Test for T {
- fn foo() {}
- fn f$0
-}
-"#,
- expect![[r#"
- fn fn foo_bar()
- "#]],
- );
- }
-
#[test]
fn generic_fn() {
check_edit(
projects / rust.git / blobdiff