Move trait_impl completion analysis into CompletionContext

Author: Veykril

crates/ide-completion/src/completions.rs

@@ -16,7 +16,6 @@ pub(crate) mod pattern;
 pub(crate) mod postfix;
 pub(crate) mod record;
 pub(crate) mod snippet;
-pub(crate) mod trait_impl;
 pub(crate) mod r#type;
 pub(crate) mod use_;
 pub(crate) mod vis;

crates/ide-completion/src/completions/item_list.rs

@@ -6,9 +6,16 @@ use crate::{
     CompletionContext, Completions,
 };
 
+mod trait_impl;
+
 pub(crate) fn complete_item_list(acc: &mut Completions, ctx: &CompletionContext) {
     let _p = profile::span("complete_item_list");
 
+    if let Some(_) = ctx.name_ctx() {
+        trait_impl::complete_trait_impl(acc, ctx);
+        return;
+    }
+
     let (&is_absolute_path, path_qualifier, kind) = match ctx.path_context() {
         Some(PathCompletionCtx {
             kind: PathKind::Item { kind },
@@ -24,7 +31,6 @@ pub(crate) fn complete_item_list(acc: &mut Completions, ctx: &CompletionContext)
         }) => (is_absolute_path, qualifier, None),
         _ => return,
     };
-    let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
 
     let in_item_list = matches!(kind, Some(ItemListKind::SourceFile | ItemListKind::Module) | None);
     let in_assoc_non_trait_impl = matches!(kind, Some(ItemListKind::Impl | ItemListKind::Trait));
@@ -35,6 +41,11 @@ pub(crate) fn complete_item_list(acc: &mut Completions, ctx: &CompletionContext)
     let no_qualifiers = ctx.qualifier_ctx.vis_node.is_none();
     let in_block = matches!(kind, None);
 
+    if in_trait_impl {
+        trait_impl::complete_trait_impl(acc, ctx);
+    }
+    let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
+
     'block: loop {
         if ctx.is_non_trivial_path() {
             break 'block;

crates/ide-completion/src/completions/trait_impl.rs renamed to crates/ide-completion/src/completions/item_list/trait_impl.rs

@@ -43,6 +43,7 @@ use syntax::{
 use text_edit::TextEdit;
 
 use crate::{
+    context::{ItemListKind, NameContext, NameKind, NameRefContext, PathCompletionCtx, PathKind},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionRelevance, Completions,
 };
 
@@ -54,7 +55,6 @@ enum ImplCompletionKind {
     Const,
 }
 
-// FIXME: Make this a submodule of [`item_list`]
 pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext) {
     if let Some((kind, replacement_range, impl_def)) = completion_match(ctx) {
         if let Some(hir_impl) = ctx.sema.to_def(&impl_def) {
@@ -77,74 +77,48 @@ pub(crate) fn complete_trait_impl(acc: &mut Completions, ctx: &CompletionContext
     }
 }
 
-// FIXME: This should be lifted out so that we can do proper smart item keyword completions
 fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, TextRange, ast::Impl)> {
     let token = ctx.token.clone();
 
-    // For keyword without name like `impl .. { fn $0 }`, the current position is inside
-    // the whitespace token, which is outside `FN` syntax node.
-    // We need to follow the previous token in this case.
-    let mut token_before_ws = token.clone();
-    if token.kind() == SyntaxKind::WHITESPACE {
-        token_before_ws = token.prev_token()?;
-    }
-
-    let parent_kind = token_before_ws.parent().map_or(SyntaxKind::EOF, |it| it.kind());
-    if token.parent().map(|n| n.kind()) == Some(SyntaxKind::ASSOC_ITEM_LIST)
-        && matches!(
-            token_before_ws.kind(),
-            SyntaxKind::SEMICOLON | SyntaxKind::R_CURLY | SyntaxKind::L_CURLY
-        )
-    {
-        let impl_def = ast::Impl::cast(token.parent()?.parent()?)?;
-        let kind = ImplCompletionKind::All;
-        let replacement_range = TextRange::empty(ctx.position.offset);
-        Some((kind, replacement_range, impl_def))
-    } else {
-        let impl_item_offset = match token_before_ws.kind() {
-            // `impl .. { const $0 }`
-            // ERROR      0
-            //   CONST_KW <- *
-            T![const] => 0,
-            // `impl .. { fn/type $0 }`
-            // FN/TYPE_ALIAS  0
-            //   FN_KW        <- *
-            T![fn] | T![type] => 0,
-            // `impl .. { fn/type/const foo$0 }`
-            // FN/TYPE_ALIAS/CONST  1
-            //  NAME                0
-            //    IDENT             <- *
-            SyntaxKind::IDENT if parent_kind == SyntaxKind::NAME => 1,
-            // `impl .. { foo$0 }`
-            // MACRO_CALL       3
-            //  PATH            2
-            //    PATH_SEGMENT  1
-            //      NAME_REF    0
-            //        IDENT     <- *
-            SyntaxKind::IDENT if parent_kind == SyntaxKind::NAME_REF => 3,
+    if let Some(NameContext { name, kind, .. }) = ctx.name_ctx() {
+        let kind = match kind {
+            NameKind::Const => ImplCompletionKind::Const,
+            NameKind::Function => ImplCompletionKind::Fn,
+            NameKind::TypeAlias => ImplCompletionKind::TypeAlias,
             _ => return None,
         };
-
-        let impl_item = token_before_ws.ancestors().nth(impl_item_offset)?;
-        // Must directly belong to an impl block.
-        // IMPL
-        //   ASSOC_ITEM_LIST
-        //     <item>
-        let impl_def = ast::Impl::cast(impl_item.parent()?.parent()?)?;
-        let kind = match impl_item.kind() {
-            // `impl ... { const $0 fn/type/const }`
-            _ if token_before_ws.kind() == T![const] => ImplCompletionKind::Const,
-            SyntaxKind::CONST | SyntaxKind::ERROR => ImplCompletionKind::Const,
-            SyntaxKind::TYPE_ALIAS => ImplCompletionKind::TypeAlias,
-            SyntaxKind::FN => ImplCompletionKind::Fn,
-            SyntaxKind::MACRO_CALL => ImplCompletionKind::All,
-            _ => return None,
-        };
-
-        let replacement_range = replacement_range(ctx, &impl_item);
-
-        Some((kind, replacement_range, impl_def))
+        let item = match name {
+            Some(name) => name.syntax().parent(),
+            None => {
+                if token.kind() == SyntaxKind::WHITESPACE { token.prev_token()? } else { token }
+                    .parent()
+            }
+        }?;
+        return Some((
+            kind,
+            replacement_range(ctx, &item),
+            // item -> ASSOC_ITEM_LIST -> IMPL
+            ast::Impl::cast(item.parent()?.parent()?)?,
+        ));
+    } else if let Some(NameRefContext {
+        nameref,
+        path_ctx:
+            Some(PathCompletionCtx { kind: PathKind::Item { kind: ItemListKind::TraitImpl }, .. }),
+        ..
+    }) = ctx.nameref_ctx()
+    {
+        if !ctx.is_non_trivial_path() {
+            return Some((
+                ImplCompletionKind::All,
+                match nameref {
+                    Some(name) => name.syntax().text_range(),
+                    None => TextRange::empty(ctx.position.offset),
+                },
+                ctx.impl_def.clone()?,
+            ));
+        }
     }
+    None
 }
 
 fn add_function_impl(