Split namelike into the corresponding completion contexts

Author: Veykril

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

@@ -9,8 +9,15 @@ use crate::{
 
 /// Complete dot accesses, i.e. fields or methods.
 pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
-    let dot_receiver = match ctx.dot_receiver() {
-        Some(expr) => expr,
+    let (dot_access, dot_receiver) = match &ctx.nameref_ctx {
+        Some(NameRefContext {
+            dot_access:
+                Some(
+                    access @ (DotAccess::Method { receiver: Some(receiver), .. }
+                    | DotAccess::Field { receiver: Some(receiver), .. }),
+                ),
+            ..
+        }) => (access, receiver),
         _ => return complete_undotted_self(acc, ctx),
     };
 
@@ -19,10 +26,7 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
         _ => return,
     };
 
-    if matches!(
-        ctx.nameref_ctx,
-        Some(NameRefContext { dot_access: Some(DotAccess::Method { .. }), .. }),
-    ) {
+    if let DotAccess::Method { .. } = dot_access {
         cov_mark::hit!(test_no_struct_field_completion_for_method_call);
     } else {
         complete_fields(

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

@@ -217,10 +217,9 @@ pub(crate) fn position_for_import(
 ) -> Option<SyntaxNode> {
     Some(
         match import_candidate {
-            Some(ImportCandidate::Path(_)) => ctx.name_syntax.as_ref()?.syntax(),
             Some(ImportCandidate::TraitAssocItem(_)) => ctx.path_qual()?.syntax(),
             Some(ImportCandidate::TraitMethod(_)) => ctx.dot_receiver()?.syntax(),
-            None => return ctx.original_token.parent(),
+            Some(ImportCandidate::Path(_)) | None => return ctx.original_token.parent(),
         }
         .clone(),
     )

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

@@ -12,17 +12,20 @@ use syntax::{ast, TokenText};
 
 use crate::{
     completions::Completions,
-    context::{CompletionContext, LifetimeContext},
+    context::{CompletionContext, LifetimeContext, LifetimeKind},
 };
 
 /// Completes lifetimes.
 pub(crate) fn complete_lifetime(acc: &mut Completions, ctx: &CompletionContext) {
-    let lp = match &ctx.lifetime_ctx {
-        Some(LifetimeContext::Lifetime) => None,
-        Some(LifetimeContext::LifetimeParam { is_decl: false, param }) => Some(param),
+    let (lp, lifetime) = match &ctx.lifetime_ctx {
+        Some(LifetimeContext { kind: LifetimeKind::Lifetime, lifetime }) => (None, lifetime),
+        Some(LifetimeContext {
+            kind: LifetimeKind::LifetimeParam { is_decl: false, param },
+            lifetime,
+        }) => (Some(param), lifetime),
         _ => return,
     };
-    let param_lifetime = match (ctx.lifetime(), lp.and_then(|lp| lp.lifetime())) {
+    let param_lifetime = match (lifetime, lp.and_then(|lp| lp.lifetime())) {
         (Some(lt), Some(lp)) if lp == lt.clone() => return,
         (Some(_), Some(lp)) => Some(lp),
         _ => None,
@@ -46,7 +49,7 @@ pub(crate) fn complete_lifetime(acc: &mut Completions, ctx: &CompletionContext)
 
 /// Completes labels.
 pub(crate) fn complete_label(acc: &mut Completions, ctx: &CompletionContext) {
-    if !matches!(ctx.lifetime_ctx, Some(LifetimeContext::LabelRef)) {
+    if !matches!(ctx.lifetime_ctx, Some(LifetimeContext { kind: LifetimeKind::LabelRef, .. })) {
         return;
     }
     ctx.process_all_names_raw(&mut |name, res| {

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

@@ -3,21 +3,23 @@
 use std::iter;
 
 use hir::{Module, ModuleSource};
-use ide_db::FxHashSet;
 use ide_db::{
     base_db::{SourceDatabaseExt, VfsPath},
-    RootDatabase, SymbolKind,
+    FxHashSet, RootDatabase, SymbolKind,
 };
 use syntax::{ast, AstNode, SyntaxKind};
 
-use crate::{context::NameContext, CompletionItem};
-
-use crate::{context::CompletionContext, Completions};
+use crate::{
+    context::{CompletionContext, NameContext, NameKind},
+    CompletionItem, Completions,
+};
 
-/// Complete mod declaration, i.e. `mod $0;`
+/// Complete mod declaration, i.e. `mod ;`
 pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
     let mod_under_caret = match &ctx.name_ctx {
-        Some(NameContext::Module(mod_under_caret)) if mod_under_caret.item_list().is_none() => {
+        Some(NameContext { kind: NameKind::Module(mod_under_caret), .. })
+            if mod_under_caret.item_list().is_none() =>
+        {
             mod_under_caret
         }
         _ => return None,
@@ -26,7 +28,7 @@ pub(crate) fn complete_mod(acc: &mut Completions, ctx: &CompletionContext) -> Op
     let _p = profile::span("completion::complete_mod");
 
     let mut current_module = ctx.module;
-    // For `mod $0`, `ctx.module` is its parent, but for `mod f$0`, it's `mod f` itself, but we're
+    // For `mod `, `ctx.module` is its parent, but for `mod f`, it's `mod f` itself, but we're
     // interested in its parent.
     if ctx.original_token.kind() == SyntaxKind::IDENT {
         if let Some(module) = ctx.original_token.ancestors().nth(1).and_then(ast::Module::cast) {

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

@@ -5,16 +5,19 @@ use ide_db::FxHashSet;
 use syntax::{ast, AstNode};
 
 use crate::{
-    context::{CompletionContext, PathCompletionCtx, PathKind, PathQualifierCtx},
+    context::{CompletionContext, NameRefContext, PathCompletionCtx, PathKind, PathQualifierCtx},
     item::Builder,
     CompletionRelevance, Completions,
 };
 
 pub(crate) fn complete_use_tree(acc: &mut Completions, ctx: &CompletionContext) {
-    let (&is_absolute_path, qualifier) = match ctx.path_context() {
-        Some(PathCompletionCtx { kind: PathKind::Use, is_absolute_path, qualifier, .. }) => {
-            (is_absolute_path, qualifier)
-        }
+    let (&is_absolute_path, qualifier, name_ref) = match &ctx.nameref_ctx {
+        Some(NameRefContext {
+            path_ctx:
+                Some(PathCompletionCtx { kind: PathKind::Use, is_absolute_path, qualifier, .. }),
+            nameref,
+            ..
+        }) => (is_absolute_path, qualifier, nameref),
         _ => return,
     };
 
@@ -55,7 +58,7 @@ pub(crate) fn complete_use_tree(acc: &mut Completions, ctx: &CompletionContext)
                     let module_scope = module.scope(ctx.db, Some(ctx.module));
                     let unknown_is_current = |name: &hir::Name| {
                         matches!(
-                            ctx.name_ref(),
+                            name_ref,
                             Some(name_ref) if name_ref.syntax().text() == name.to_smol_str().as_str()
                         )
                     };