Only run completion functions if their corresponding context is active

Author: Veykril

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

@@ -18,7 +18,7 @@ use syntax::{
 
 use crate::{
     completions::module_or_attr,
-    context::{CompletionContext, IdentContext, PathCompletionCtx, PathKind, Qualified},
+    context::{CompletionContext, PathCompletionCtx, PathKind, Qualified},
     item::CompletionItem,
     Completions,
 };
@@ -34,11 +34,9 @@ pub(crate) use self::derive::complete_derive;
 pub(crate) fn complete_known_attribute_input(
     acc: &mut Completions,
     ctx: &CompletionContext,
+    fake_attribute_under_caret: &ast::Attr,
 ) -> Option<()> {
-    let attribute = match &ctx.ident_ctx {
-        IdentContext::UnexpandedAttrTT { fake_attribute_under_caret: Some(it) } => it,
-        _ => return None,
-    };
+    let attribute = fake_attribute_under_caret;
     let name_ref = match attribute.path() {
         Some(p) => Some(p.as_single_name_ref()?),
         None => None,
@@ -71,13 +69,17 @@ pub(crate) fn complete_known_attribute_input(
     Some(())
 }
 
-pub(crate) fn complete_attribute(acc: &mut Completions, ctx: &CompletionContext) {
-    let (qualified, is_inner, annotated_item_kind) = match ctx.path_context() {
-        Some(&PathCompletionCtx {
+pub(crate) fn complete_attribute(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx: &PathCompletionCtx,
+) {
+    let (qualified, is_inner, annotated_item_kind) = match path_ctx {
+        &PathCompletionCtx {
             kind: PathKind::Attr { kind, annotated_item_kind },
             ref qualified,
             ..
-        }) => (qualified, kind == AttrKind::Inner, annotated_item_kind),
+        } => (qualified, kind == AttrKind::Inner, annotated_item_kind),
         _ => return,
     };
 

crates/ide-completion/src/completions/attribute/derive.rs

@@ -10,11 +10,15 @@ use crate::{
     Completions,
 };
 
-pub(crate) fn complete_derive(acc: &mut Completions, ctx: &CompletionContext) {
-    let (qualified, existing_derives) = match ctx.path_context() {
-        Some(PathCompletionCtx {
-            kind: PathKind::Derive { existing_derives }, qualified, ..
-        }) => (qualified, existing_derives),
+pub(crate) fn complete_derive(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx: &PathCompletionCtx,
+) {
+    let (qualified, existing_derives) = match path_ctx {
+        PathCompletionCtx { kind: PathKind::Derive { existing_derives }, qualified, .. } => {
+            (qualified, existing_derives)
+        }
         _ => return,
     };
 

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

@@ -4,21 +4,16 @@ use ide_db::FxHashSet;
 
 use crate::{
     context::{
-        CompletionContext, DotAccess, DotAccessKind, NameRefContext, NameRefKind,
-        PathCompletionCtx, PathKind, Qualified,
+        CompletionContext, DotAccess, DotAccessKind, PathCompletionCtx, PathKind, Qualified,
     },
     CompletionItem, CompletionItemKind, Completions,
 };
 
 /// Complete dot accesses, i.e. fields or methods.
-pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
-    let (dot_access, receiver_ty) = match ctx.nameref_ctx() {
-        Some(NameRefContext {
-            kind:
-                Some(NameRefKind::DotAccess(access @ DotAccess { receiver_ty: Some(receiver_ty), .. })),
-            ..
-        }) => (access, &receiver_ty.original),
-        _ => return complete_undotted_self(acc, ctx),
+pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext, dot_access: &DotAccess) {
+    let receiver_ty = match dot_access {
+        DotAccess { receiver_ty: Some(receiver_ty), .. } => &receiver_ty.original,
+        _ => return,
     };
 
     // Suggest .await syntax for types that implement Future trait
@@ -43,18 +38,17 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     complete_methods(ctx, &receiver_ty, |func| acc.add_method(ctx, func, None, None));
 }
 
-fn complete_undotted_self(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_undotted_self(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx: &PathCompletionCtx,
+) {
     if !ctx.config.enable_self_on_the_fly {
         return;
     }
-    match ctx.path_context() {
-        Some(
-            path_ctx @ PathCompletionCtx {
-                qualified: Qualified::No,
-                kind: PathKind::Expr { .. },
-                ..
-            },
-        ) if path_ctx.is_trivial_path() && ctx.qualifier_ctx.none() => {}
+    match path_ctx {
+        PathCompletionCtx { qualified: Qualified::No, kind: PathKind::Expr { .. }, .. }
+            if path_ctx.is_trivial_path() && ctx.qualifier_ctx.none() => {}
         _ => return,
     }
 

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

@@ -8,7 +8,11 @@ use crate::{
     CompletionContext, Completions,
 };
 
-pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_expr_path(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    name_ref_ctx: &NameRefContext,
+) {
     let _p = profile::span("complete_expr_path");
 
     let (
@@ -19,8 +23,8 @@ pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext)
         after_if_expr,
         wants_mut_token,
         in_condition,
-    ) = match ctx.nameref_ctx() {
-        Some(&NameRefContext {
+    ) = match name_ref_ctx {
+        &NameRefContext {
             kind:
                 Some(NameRefKind::Path(PathCompletionCtx {
                     kind:
@@ -36,7 +40,7 @@ pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext)
                     ..
                 })),
             ..
-        }) if ctx.qualifier_ctx.none() => (
+        } if ctx.qualifier_ctx.none() => (
             qualified,
             in_block_expr,
             in_loop_body,

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

@@ -5,9 +5,7 @@ use syntax::{
 };
 
 use crate::{
-    completions::Completions,
-    context::{CompletionContext, IdentContext},
-    CompletionItem, CompletionItemKind,
+    completions::Completions, context::CompletionContext, CompletionItem, CompletionItemKind,
 };
 
 // Most of these are feature gated, we should filter/add feature gate completions once we have them.
@@ -42,15 +40,15 @@ const SUPPORTED_CALLING_CONVENTIONS: &[&str] = &[
     "unadjusted",
 ];
 
-pub(crate) fn complete_extern_abi(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let abi_str = match &ctx.ident_ctx {
-        IdentContext::String { expanded: Some(expanded), .. }
-            if expanded.syntax().parent().map_or(false, |it| ast::Abi::can_cast(it.kind())) =>
-        {
-            expanded
-        }
-        _ => return None,
-    };
+pub(crate) fn complete_extern_abi(
+    acc: &mut Completions,
+    _ctx: &CompletionContext,
+    expanded: &ast::String,
+) -> Option<()> {
+    if !expanded.syntax().parent().map_or(false, |it| ast::Abi::can_cast(it.kind())) {
+        return None;
+    }
+    let abi_str = expanded;
     let source_range = abi_str.text_range_between_quotes()?;
     for &abi in SUPPORTED_CALLING_CONVENTIONS {
         CompletionItem::new(CompletionItemKind::Keyword, source_range, abi).add_to(acc);

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

@@ -2,16 +2,19 @@
 
 use crate::{
     context::{
-        IdentContext, NameContext, NameKind, NameRefContext, NameRefKind, PathCompletionCtx,
-        PathKind, Qualified, TypeLocation,
+        NameContext, NameKind, NameRefContext, NameRefKind, PathCompletionCtx, PathKind, Qualified,
+        TypeLocation,
     },
     CompletionContext, Completions,
 };
 
-pub(crate) fn complete_field_list(acc: &mut Completions, ctx: &CompletionContext) {
-    match &ctx.ident_ctx {
-        IdentContext::Name(NameContext { kind: NameKind::RecordField, .. })
-        | IdentContext::NameRef(NameRefContext {
+pub(crate) fn complete_field_list_tuple_variant(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    name_ref_ctx: &NameRefContext,
+) {
+    match name_ref_ctx {
+        NameRefContext {
             kind:
                 Some(NameRefKind::Path(PathCompletionCtx {
                     has_macro_bang: false,
@@ -22,14 +25,29 @@ pub(crate) fn complete_field_list(acc: &mut Completions, ctx: &CompletionContext
                     ..
                 })),
             ..
-        }) => {
+        } => {
             if ctx.qualifier_ctx.vis_node.is_none() {
                 let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
                 add_keyword("pub(crate)", "pub(crate)");
                 add_keyword("pub(super)", "pub(super)");
                 add_keyword("pub", "pub");
             }
         }
-        _ => return,
+        _ => (),
+    }
+}
+
+pub(crate) fn complete_field_list_record_variant(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    name_ctx: &NameContext,
+) {
+    if let NameContext { kind: NameKind::RecordField, .. } = name_ctx {
+        if ctx.qualifier_ctx.vis_node.is_none() {
+            let mut add_keyword = |kw, snippet| acc.add_keyword_snippet(ctx, kw, snippet);
+            add_keyword("pub(crate)", "pub(crate)");
+            add_keyword("pub(super)", "pub(super)");
+            add_keyword("pub", "pub");
+        }
     }
 }

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

@@ -19,9 +19,13 @@ use crate::{
 /// `spam: &mut Spam` insert text/label will be suggested.
 ///
 /// Also complete parameters for closure or local functions from the surrounding defined locals.
-pub(crate) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let (param_list, _, param_kind) = match &ctx.pattern_ctx {
-        Some(PatternContext { param_ctx: Some(kind), .. }) => kind,
+pub(crate) fn complete_fn_param(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    pattern_ctx: &PatternContext,
+) -> Option<()> {
+    let (param_list, _, param_kind) = match pattern_ctx {
+        PatternContext { param_ctx: Some(kind), .. } => kind,
         _ => return None,
     };
 

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

@@ -2,28 +2,25 @@
 
 use ide_db::syntax_helpers::format_string::is_format_string;
 use itertools::Itertools;
-use syntax::{AstToken, TextRange, TextSize};
+use syntax::{ast, AstToken, TextRange, TextSize};
 
-use crate::{
-    context::{CompletionContext, IdentContext},
-    CompletionItem, CompletionItemKind, Completions,
-};
+use crate::{context::CompletionContext, CompletionItem, CompletionItemKind, Completions};
 
 /// Complete identifiers in format strings.
-pub(crate) fn format_string(acc: &mut Completions, ctx: &CompletionContext) {
-    let string = match &ctx.ident_ctx {
-        IdentContext::String { expanded: Some(expanded), original }
-            if is_format_string(&expanded) =>
-        {
-            original
-        }
-        _ => return,
-    };
+pub(crate) fn format_string(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    original: &ast::String,
+    expanded: &ast::String,
+) {
+    if !is_format_string(&expanded) {
+        return;
+    }
     let cursor = ctx.position.offset;
     let lit_start = ctx.original_token.text_range().start();
     let cursor_in_lit = cursor - lit_start;
 
-    let prefix = &string.text()[..cursor_in_lit.into()];
+    let prefix = &original.text()[..cursor_in_lit.into()];
     let braces = prefix.char_indices().rev().skip_while(|&(_, c)| c.is_alphanumeric()).next_tuple();
     let brace_offset = match braces {
         // escaped brace

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

@@ -2,43 +2,50 @@
 
 use crate::{
     completions::module_or_fn_macro,
-    context::{ItemListKind, PathCompletionCtx, PathKind, Qualified},
+    context::{ItemListKind, NameRefContext, NameRefKind, PathCompletionCtx, PathKind, Qualified},
     CompletionContext, Completions,
 };
 
-mod trait_impl;
+pub(crate) mod trait_impl;
 
-pub(crate) fn complete_item_list(acc: &mut Completions, ctx: &CompletionContext) {
+pub(crate) fn complete_item_list(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    name_ref_ctx: &NameRefContext,
+) {
     let _p = profile::span("complete_item_list");
 
-    if let Some(_) = ctx.name_ctx() {
-        trait_impl::complete_trait_impl(acc, ctx);
-        return;
-    }
-
-    let (qualified, kind, is_trivial_path) = match ctx.path_context() {
-        Some(ctx @ PathCompletionCtx { kind: PathKind::Item { kind }, qualified, .. }) => {
-            (qualified, Some(kind), ctx.is_trivial_path())
-        }
-        Some(
-            ctx @ PathCompletionCtx {
-                kind: PathKind::Expr { in_block_expr: true, .. },
-                qualified,
-                ..
-            },
-        ) => (qualified, None, ctx.is_trivial_path()),
+    let (qualified, item_list_kind, is_trivial_path) = match name_ref_ctx {
+        NameRefContext {
+            kind:
+                Some(NameRefKind::Path(
+                    ctx @ PathCompletionCtx { kind: PathKind::Item { kind }, qualified, .. },
+                )),
+            ..
+        } => (qualified, Some(kind), ctx.is_trivial_path()),
+        NameRefContext {
+            kind:
+                Some(NameRefKind::Path(
+                    ctx @ PathCompletionCtx {
+                        kind: PathKind::Expr { in_block_expr: true, .. },
+                        qualified,
+                        ..
+                    },
+                )),
+            ..
+        } => (qualified, None, ctx.is_trivial_path()),
         _ => return,
     };
 
-    if matches!(kind, Some(ItemListKind::TraitImpl)) {
-        trait_impl::complete_trait_impl(acc, ctx);
+    if matches!(item_list_kind, Some(ItemListKind::TraitImpl)) {
+        trait_impl::complete_trait_impl_name_ref(acc, ctx, name_ref_ctx);
     }
 
     if is_trivial_path {
-        add_keywords(acc, ctx, kind);
+        add_keywords(acc, ctx, item_list_kind);
     }
 
-    if kind.is_none() {
+    if item_list_kind.is_none() {
         // this is already handled by expression
         return;
     }