X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=crates%2Fide_completion%2Fsrc%2Fcompletions%2Ftrait_impl.rs;h=0d59f77a55c975d4ac5b4534d91e201feae904c7;hb=7b89d5ede23cbbbf4bef37b43e0d2d99752ddb51;hp=dc1d198cc23825c92ca77b91b2c4761cc9c18eae;hpb=d6b8af44829521a9f925c4d87599efa3fef38edc;p=rust.git diff --git a/crates/ide_completion/src/completions/trait_impl.rs b/crates/ide_completion/src/completions/trait_impl.rs index dc1d198cc23..0d59f77a55c 100644 --- a/crates/ide_completion/src/completions/trait_impl.rs +++ b/crates/ide_completion/src/completions/trait_impl.rs @@ -1,7 +1,7 @@ //! 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`. //! @@ -31,18 +31,18 @@ //! } //! ``` -use hir::{self, HasAttrs, HasSource}; -use ide_db::{traits::get_missing_assoc_items, SymbolKind}; +use hir::{self, HasAttrs}; +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)] +#[derive(Copy, Clone, Debug, PartialEq, Eq)] enum ImplCompletionKind { All, Fn, @@ -52,24 +52,25 @@ enum ImplCompletionKind { pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) { if let Some((kind, trigger, impl_def)) = completion_match(ctx.token.clone()) { - get_missing_assoc_items(&ctx.sema, &impl_def).into_iter().for_each(|item| match item { - hir::AssocItem::Function(fn_item) - if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Fn => - { - add_function_impl(&trigger, acc, ctx, fn_item) - } - hir::AssocItem::TypeAlias(type_item) - if kind == ImplCompletionKind::All || kind == ImplCompletionKind::TypeAlias => - { - add_type_alias_impl(&trigger, acc, ctx, type_item) - } - hir::AssocItem::Const(const_item) - if kind == ImplCompletionKind::All || kind == ImplCompletionKind::Const => - { - add_const_impl(&trigger, acc, ctx, const_item) - } - _ => {} - }); + if let Some(hir_impl) = ctx.sema.to_def(&impl_def) { + get_missing_assoc_items(&ctx.sema, &impl_def).into_iter().for_each(|item| { + match (item, kind) { + ( + hir::AssocItem::Function(fn_item), + ImplCompletionKind::All | ImplCompletionKind::Fn, + ) => add_function_impl(acc, ctx, &trigger, fn_item, hir_impl), + ( + hir::AssocItem::TypeAlias(type_item), + ImplCompletionKind::All | ImplCompletionKind::TypeAlias, + ) => add_type_alias_impl(acc, ctx, &trigger, type_item), + ( + hir::AssocItem::Const(const_item), + ImplCompletionKind::All | ImplCompletionKind::Const, + ) => add_const_impl(acc, ctx, &trigger, const_item, hir_impl), + _ => {} + } + }); + } } } @@ -125,12 +126,13 @@ fn completion_match(mut token: SyntaxToken) -> Option<(ImplCompletionKind, Synta } fn add_function_impl( - fn_def_node: &SyntaxNode, acc: &mut Completions, ctx: &CompletionContext, + fn_def_node: &SyntaxNode, 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) @@ -138,77 +140,115 @@ 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 range = replacement_range(ctx, fn_def_node); - if let Some(src) = func.source(ctx.db) { - let function_decl = function_declaration(&src.value); - match ctx.config.snippet_cap { - Some(cap) => { - let snippet = format!("{} {{\n $0\n}}", function_decl); - item.snippet_edit(cap, TextEdit::replace(range, snippet)); - } - None => { - let header = format!("{} {{", function_decl); - item.text_edit(TextEdit::replace(range, header)); - } - }; - item.kind(completion_kind); - item.add_to(acc); + let mut item = CompletionItem::new(completion_kind, range, label); + item.lookup_by(fn_name).set_documentation(func.docs(ctx.db)); + + if let Some(source) = ctx.sema.source(func) { + let assoc_item = ast::AssocItem::Fn(source.value); + if let Some(transformed_item) = get_transformed_assoc_item(ctx, assoc_item, impl_def) { + let transformed_fn = match transformed_item { + ast::AssocItem::Fn(func) => func, + _ => unreachable!(), + }; + + let function_decl = function_declaration(&transformed_fn); + match ctx.config.snippet_cap { + Some(cap) => { + let snippet = format!("{} {{\n $0\n}}", function_decl); + item.snippet_edit(cap, TextEdit::replace(range, snippet)); + } + None => { + let header = format!("{} {{", function_decl); + item.text_edit(TextEdit::replace(range, header)); + } + }; + item.add_to(acc); + } + } +} + +/// Transform a relevant associated item to inline generics from the impl, remove attrs and docs, etc. +fn get_transformed_assoc_item( + ctx: &CompletionContext, + assoc_item: ast::AssocItem, + impl_def: hir::Impl, +) -> Option { + 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(ctx.sema.source(impl_def)?.syntax().value); + let transform = PathTransform::trait_impl( + target_scope, + source_scope, + trait_, + ctx.sema.source(impl_def)?.value, + ); + + 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( - type_def_node: &SyntaxNode, acc: &mut Completions, ctx: &CompletionContext, + type_def_node: &SyntaxNode, 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, 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); } fn add_const_impl( - const_def_node: &SyntaxNode, acc: &mut Completions, ctx: &CompletionContext, + const_def_node: &SyntaxNode, 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(&source.value); - - let range = replacement_range(ctx, const_def_node); - let mut item = - CompletionItem::new(CompletionKind::Magic, 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); + if let Some(source) = ctx.sema.source(const_) { + let assoc_item = ast::AssocItem::Const(source.value); + if let Some(transformed_item) = get_transformed_assoc_item(ctx, assoc_item, impl_def) { + let transformed_const = match transformed_item { + ast::AssocItem::Const(const_) => const_, + _ => unreachable!(), + }; + + let snippet = make_const_compl_syntax(&transformed_const); + + let range = replacement_range(ctx, const_def_node); + let mut item = CompletionItem::new(SymbolKind::Const, range, &snippet); + item.text_edit(TextEdit::replace(range, snippet)) + .lookup_by(const_name) + .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(); @@ -245,39 +285,13 @@ fn replacement_range(ctx: &CompletionContext, item: &SyntaxNode) -> TextRange { 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( @@ -291,7 +305,12 @@ fn test() { } } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); check( @@ -334,7 +353,7 @@ fn test() { } } ", - expect![[""]], + expect![[r#""#]], ); check( @@ -346,7 +365,10 @@ impl Test for T { fn test(t$0) } ", - expect![[""]], + expect![[r#" + sp Self + st T + "#]], ); check( @@ -358,7 +380,10 @@ impl Test for T { fn test(f: fn $0) } ", - expect![[""]], + expect![[r#" + sp Self + st T + "#]], ); } @@ -373,7 +398,7 @@ impl Test for T { const TEST: fn $0 } ", - expect![[""]], + expect![[r#""#]], ); check( @@ -385,7 +410,12 @@ impl Test for T { const TEST: T$0 } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); check( @@ -397,7 +427,12 @@ impl Test for T { const TEST: u32 = f$0 } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); check( @@ -411,7 +446,12 @@ impl Test for T { }; } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); check( @@ -454,7 +494,12 @@ impl Test for T { type Test = T$0; } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); check( @@ -466,7 +511,12 @@ impl Test for T { type Test = fn $0; } ", - expect![[""]], + expect![[r#" + sp Self + tt Test + st T + bt u32 + "#]], ); } @@ -528,27 +578,6 @@ fn test() { ); } - #[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( @@ -779,4 +808,183 @@ impl Foo for T {{ test("Type", "type T$0", "type Type = "); test("CONST", "const C$0", "const CONST: i32 = "); } + + #[test] + fn generics_are_inlined_in_return_type() { + check_edit( + "function", + r#" +trait Foo { + fn function() -> T; +} +struct Bar; + +impl Foo for Bar { + fn f$0 +} +"#, + r#" +trait Foo { + fn function() -> T; +} +struct Bar; + +impl Foo for Bar { + fn function() -> u32 { + $0 +} +} +"#, + ) + } + + #[test] + fn generics_are_inlined_in_parameter() { + check_edit( + "function", + r#" +trait Foo { + fn function(bar: T); +} +struct Bar; + +impl Foo for Bar { + fn f$0 +} +"#, + r#" +trait Foo { + fn function(bar: T); +} +struct Bar; + +impl Foo for Bar { + fn function(bar: u32) { + $0 +} +} +"#, + ) + } + + #[test] + fn generics_are_inlined_when_part_of_other_types() { + check_edit( + "function", + r#" +trait Foo { + fn function(bar: Vec); +} +struct Bar; + +impl Foo for Bar { + fn f$0 +} +"#, + r#" +trait Foo { + fn function(bar: Vec); +} +struct Bar; + +impl Foo for Bar { + fn function(bar: Vec) { + $0 +} +} +"#, + ) + } + + #[test] + fn generics_are_inlined_complex() { + check_edit( + "function", + r#" +trait Foo { + fn function(bar: Vec, baz: U) -> Arc>; +} +struct Bar; + +impl Foo, u8> for Bar { + fn f$0 +} +"#, + r#" +trait Foo { + fn function(bar: Vec, baz: U) -> Arc>; +} +struct Bar; + +impl Foo, u8> for Bar { + fn function(bar: Vec, baz: Vec) -> Arc> { + $0 +} +} +"#, + ) + } + + #[test] + fn generics_are_inlined_in_associated_const() { + check_edit( + "BAR", + r#" +trait Foo { + const BAR: T; +} +struct Bar; + +impl Foo for Bar { + const B$0; +} +"#, + r#" +trait Foo { + const BAR: T; +} +struct Bar; + +impl Foo for Bar { + const BAR: u32 = ; +} +"#, + ) + } + + #[test] + fn generics_are_inlined_in_where_clause() { + check_edit( + "function", + r#" +trait SomeTrait {} + +trait Foo { + fn function() + where Self: SomeTrait; +} +struct Bar; + +impl Foo for Bar { + fn f$0 +} +"#, + r#" +trait SomeTrait {} + +trait Foo { + fn function() + where Self: SomeTrait; +} +struct Bar; + +impl Foo for Bar { + fn function() +where Self: SomeTrait { + $0 +} +} +"#, + ) + } }