internal: completion: split out more PathKinds from ImmediateLocation

Author: Veykril

crates/ide_completion/src/completions/flyimport.rs

@@ -110,14 +110,19 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    if ctx.in_use_tree()
+    if matches!(ctx.path_kind(), Some(PathKind::Vis { .. } | PathKind::Use))
         || ctx.is_path_disallowed()
         || ctx.expects_item()
         || ctx.expects_assoc_item()
         || ctx.expects_variant()
     {
         return None;
     }
+    // FIXME: This should be encoded in a different way
+    if ctx.pattern_ctx.is_none() && ctx.path_context.is_none() && !ctx.has_dot_receiver() {
+        // completion inside `ast::Name` of a item declaration
+        return None;
+    }
     let potential_import_name = {
         let token_kind = ctx.token.kind();
         if matches!(token_kind, T![.] | T![::]) {
@@ -147,14 +152,25 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
             }
         };
         match (kind, import.original_item) {
+            // Aren't handled in flyimport
+            (PathKind::Vis { .. } | PathKind::Use, _) => false,
+            // modules are always fair game
+            (_, ItemInNs::Types(hir::ModuleDef::Module(_))) => true,
+            // and so are macros(except for attributes)
+            (
+                PathKind::Expr | PathKind::Type | PathKind::Mac | PathKind::Pat,
+                ItemInNs::Macros(mac),
+            ) => mac.is_fn_like(),
+            (PathKind::Mac, _) => true,
+
             (PathKind::Expr, ItemInNs::Types(_) | ItemInNs::Values(_)) => true,
 
+            (PathKind::Pat, ItemInNs::Types(_)) => true,
+            (PathKind::Pat, ItemInNs::Values(def)) => matches!(def, hir::ModuleDef::Const(_)),
+
             (PathKind::Type, ItemInNs::Types(_)) => true,
             (PathKind::Type, ItemInNs::Values(_)) => false,
 
-            (PathKind::Expr | PathKind::Type, ItemInNs::Macros(mac)) => mac.is_fn_like(),
-
-            (PathKind::Attr, ItemInNs::Types(hir::ModuleDef::Module(_))) => true,
             (PathKind::Attr, ItemInNs::Macros(mac)) => mac.is_attr(),
             (PathKind::Attr, _) => false,
         }

crates/ide_completion/src/completions/keyword.rs

@@ -5,8 +5,9 @@
 use syntax::{SyntaxKind, T};
 
 use crate::{
-    context::PathCompletionContext, patterns::ImmediateLocation, CompletionContext, CompletionItem,
-    CompletionItemKind, Completions,
+    context::{PathCompletionContext, PathKind},
+    patterns::ImmediateLocation,
+    CompletionContext, CompletionItem, CompletionItemKind, Completions,
 };
 
 pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
@@ -33,8 +34,8 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     let has_block_expr_parent = ctx.has_block_expr_parent();
     let expects_item = ctx.expects_item();
 
-    if let Some(ImmediateLocation::Visibility(vis)) = &ctx.completion_location {
-        if vis.in_token().is_none() {
+    if let Some(PathKind::Vis { has_in_token }) = ctx.path_kind() {
+        if !has_in_token {
             cov_mark::hit!(kw_completion_in);
             add_keyword("in", "in");
         }

crates/ide_completion/src/completions/pattern.rs

@@ -1,15 +1,17 @@
-//! Completes constants and paths in patterns.
+//! Completes constants and paths in unqualified patterns.
 
 use crate::{
     context::{PatternContext, PatternRefutability},
     CompletionContext, Completions,
 };
 
-/// Completes constants and paths in patterns.
+/// Completes constants and paths in unqualified patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
     let refutable = match ctx.pattern_ctx {
-        Some(PatternContext { refutability, .. }) => refutability == PatternRefutability::Refutable,
-        None => return,
+        Some(PatternContext { refutability, .. }) if ctx.path_context.is_none() => {
+            refutability == PatternRefutability::Refutable
+        }
+        _ => return,
     };
 
     if refutable {

crates/ide_completion/src/completions/qualified_path.rs

@@ -7,17 +7,23 @@ use rustc_hash::FxHashSet;
 use syntax::{ast, AstNode};
 
 use crate::{
-    context::PathCompletionContext, patterns::ImmediateLocation, CompletionContext, Completions,
+    context::{PathCompletionContext, PathKind},
+    patterns::ImmediateLocation,
+    CompletionContext, Completions,
 };
 
 pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     if ctx.is_path_disallowed() || ctx.has_impl_or_trait_prev_sibling() {
         return;
     }
-    let (path, use_tree_parent) = match &ctx.path_context {
-        Some(PathCompletionContext { qualifier: Some(qualifier), use_tree_parent, .. }) => {
-            (qualifier, *use_tree_parent)
-        }
+    let (path, use_tree_parent, kind) = match ctx.path_context {
+        // let ... else, syntax would come in really handy here right now
+        Some(PathCompletionContext {
+            qualifier: Some(ref qualifier),
+            use_tree_parent,
+            kind,
+            ..
+        }) => (qualifier, use_tree_parent, kind),
         _ => return,
     };
 
@@ -44,7 +50,11 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
             }
             return;
         }
-        Some(ImmediateLocation::Visibility(_)) => {
+        _ => (),
+    }
+
+    match kind {
+        Some(PathKind::Vis { .. }) => {
             if let hir::PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
                 if let Some(current_module) = ctx.scope.module() {
                     if let Some(next) = current_module
@@ -61,7 +71,7 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
             }
             return;
         }
-        Some(ImmediateLocation::Attribute(_)) => {
+        Some(PathKind::Attr) => {
             if let hir::PathResolution::Def(hir::ModuleDef::Module(module)) = resolution {
                 for (name, def) in module.scope(ctx.db, context_module) {
                     let add_resolution = match def {
@@ -76,37 +86,38 @@ pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionCon
             }
             return;
         }
+        Some(PathKind::Use) => {
+            if iter::successors(Some(path.clone()), |p| p.qualifier())
+                .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
+            {
+                acc.add_keyword(ctx, "super::");
+            }
+            // only show `self` in a new use-tree when the qualifier doesn't end in self
+            if use_tree_parent
+                && !matches!(
+                    path.segment().and_then(|it| it.kind()),
+                    Some(ast::PathSegmentKind::SelfKw)
+                )
+            {
+                acc.add_keyword(ctx, "self");
+            }
+        }
         _ => (),
     }
 
-    if ctx.in_use_tree() {
-        if iter::successors(Some(path.clone()), |p| p.qualifier())
-            .all(|p| p.segment().and_then(|s| s.super_token()).is_some())
-        {
-            acc.add_keyword(ctx, "super::");
-        }
-        // only show `self` in a new use-tree when the qualifier doesn't end in self
-        if use_tree_parent
-            && !matches!(
-                path.segment().and_then(|it| it.kind()),
-                Some(ast::PathSegmentKind::SelfKw)
-            )
-        {
-            acc.add_keyword(ctx, "self");
-        }
+    if !matches!(kind, Some(PathKind::Pat)) {
+        // Add associated types on type parameters and `Self`.
+        resolution.assoc_type_shorthand_candidates(ctx.db, |_, alias| {
+            acc.add_type_alias(ctx, alias);
+            None::<()>
+        });
     }
 
-    // Add associated types on type parameters and `Self`.
-    resolution.assoc_type_shorthand_candidates(ctx.db, |_, alias| {
-        acc.add_type_alias(ctx, alias);
-        None::<()>
-    });
-
     match resolution {
         hir::PathResolution::Def(hir::ModuleDef::Module(module)) => {
             let module_scope = module.scope(ctx.db, context_module);
             for (name, def) in module_scope {
-                if ctx.in_use_tree() {
+                if let Some(PathKind::Use) = kind {
                     if let ScopeDef::Unknown = def {
                         if let Some(ast::NameLike::NameRef(name_ref)) = ctx.name_syntax.as_ref() {
                             if name_ref.syntax().text() == name.to_smol_str().as_str() {

crates/ide_completion/src/completions/unqualified_path.rs

@@ -3,15 +3,23 @@
 use hir::ScopeDef;
 use syntax::{ast, AstNode};
 
-use crate::{patterns::ImmediateLocation, CompletionContext, Completions};
+use crate::{
+    context::{PathCompletionContext, PathKind},
+    patterns::ImmediateLocation,
+    CompletionContext, Completions,
+};
 
 pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
     let _p = profile::span("complete_unqualified_path");
-    if ctx.is_path_disallowed() || !ctx.is_trivial_path() || ctx.has_impl_or_trait_prev_sibling() {
+    if ctx.is_path_disallowed() || ctx.has_impl_or_trait_prev_sibling() {
         return;
     }
+    let kind = match ctx.path_context {
+        Some(PathCompletionContext { is_trivial_path: true, kind, .. }) => kind,
+        _ => return,
+    };
 
-    if ctx.in_use_tree() {
+    if let Some(PathKind::Use) = kind {
         // only show modules in a fresh UseTree
         cov_mark::hit!(unqualified_path_only_modules_in_import);
         ctx.process_all_names(&mut |name, res| {
@@ -25,8 +33,25 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     }
     ["self", "super", "crate"].into_iter().for_each(|kw| acc.add_keyword(ctx, kw));
 
+    match kind {
+        Some(PathKind::Vis { .. }) => return,
+        Some(PathKind::Attr) => {
+            ctx.process_all_names(&mut |name, res| {
+                let add_resolution = match res {
+                    ScopeDef::MacroDef(mac) => mac.is_attr(),
+                    ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) => true,
+                    _ => false,
+                };
+                if add_resolution {
+                    acc.add_resolution(ctx, name, &res);
+                }
+            });
+            return;
+        }
+        _ => (),
+    }
+
     match &ctx.completion_location {
-        Some(ImmediateLocation::Visibility(_)) => return,
         Some(ImmediateLocation::ItemList | ImmediateLocation::Trait | ImmediateLocation::Impl) => {
             // only show macros in {Assoc}ItemList
             ctx.process_all_names(&mut |name, res| {
@@ -56,19 +81,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
             });
             return;
         }
-        Some(ImmediateLocation::Attribute(_)) => {
-            ctx.process_all_names(&mut |name, res| {
-                let add_resolution = match res {
-                    ScopeDef::MacroDef(mac) => mac.is_attr(),
-                    ScopeDef::ModuleDef(hir::ModuleDef::Module(_)) => true,
-                    _ => false,
-                };
-                if add_resolution {
-                    acc.add_resolution(ctx, name, &res);
-                }
-            });
-            return;
-        }
         _ => (),
     }