Even more completion context filtering

Author: Veykril

crates/ide-completion/src/completions.rs

@@ -27,7 +27,10 @@ use ide_db::SymbolKind;
 use syntax::ast;
 
 use crate::{
-    context::Visible,
+    context::{
+        ItemListKind, NameContext, NameKind, NameRefContext, NameRefKind, PathKind, PatternContext,
+        TypeLocation, Visible,
+    },
     item::Builder,
     render::{
         const_::render_const,
@@ -437,3 +440,120 @@ fn enum_variants_with_paths(
         }
     }
 }
+
+pub(super) fn complete_name(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    NameContext { name, kind }: &NameContext,
+) {
+    match kind {
+        NameKind::Const => {
+            item_list::trait_impl::complete_trait_impl_const(acc, ctx, name);
+        }
+        NameKind::Function => {
+            item_list::trait_impl::complete_trait_impl_fn(acc, ctx, name);
+        }
+        NameKind::IdentPat(pattern_ctx) => complete_patterns(acc, ctx, pattern_ctx),
+        NameKind::Module(mod_under_caret) => {
+            mod_::complete_mod(acc, ctx, mod_under_caret);
+        }
+        NameKind::TypeAlias => {
+            item_list::trait_impl::complete_trait_impl_type_alias(acc, ctx, name);
+        }
+        NameKind::RecordField => {
+            field::complete_field_list_record_variant(acc, ctx);
+        }
+        NameKind::ConstParam
+        | NameKind::Enum
+        | NameKind::MacroDef
+        | NameKind::MacroRules
+        | NameKind::Rename
+        | NameKind::SelfParam
+        | NameKind::Static
+        | NameKind::Struct
+        | NameKind::Trait
+        | NameKind::TypeParam
+        | NameKind::Union
+        | NameKind::Variant => (),
+    }
+}
+
+pub(super) fn complete_name_ref(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    NameRefContext { nameref, kind }: &NameRefContext,
+) {
+    match kind {
+        NameRefKind::Path(path_ctx) => {
+            flyimport::import_on_the_fly_path(acc, ctx, path_ctx);
+            match &path_ctx.kind {
+                PathKind::Expr { expr_ctx } => {
+                    dot::complete_undotted_self(acc, ctx, path_ctx, expr_ctx);
+                    expr::complete_expr_path(acc, ctx, path_ctx, expr_ctx);
+                    item_list::complete_item_list_in_expr(acc, ctx, path_ctx, expr_ctx);
+                    record::complete_record_expr_func_update(acc, ctx, path_ctx, expr_ctx);
+                    snippet::complete_expr_snippet(acc, ctx, path_ctx, expr_ctx);
+                }
+                PathKind::Type { location } => {
+                    r#type::complete_type_path(acc, ctx, path_ctx, location);
+                    match location {
+                        TypeLocation::TupleField => {
+                            field::complete_field_list_tuple_variant(acc, ctx, path_ctx);
+                        }
+                        TypeLocation::TypeAscription(ascription) => {
+                            r#type::complete_ascribed_type(acc, ctx, path_ctx, ascription);
+                        }
+                        TypeLocation::GenericArgList(_)
+                        | TypeLocation::TypeBound
+                        | TypeLocation::ImplTarget
+                        | TypeLocation::ImplTrait
+                        | TypeLocation::Other => (),
+                    }
+                }
+                PathKind::Attr { attr_ctx } => {
+                    attribute::complete_attribute(acc, ctx, path_ctx, attr_ctx);
+                }
+                PathKind::Derive { existing_derives } => {
+                    attribute::complete_derive(acc, ctx, path_ctx, existing_derives);
+                }
+                PathKind::Item { kind } => {
+                    item_list::complete_item_list(acc, ctx, path_ctx, kind);
+                    snippet::complete_item_snippet(acc, ctx, path_ctx, kind);
+                    if let ItemListKind::TraitImpl(impl_) = kind {
+                        item_list::trait_impl::complete_trait_impl_item_by_name(
+                            acc, ctx, path_ctx, nameref, impl_,
+                        );
+                    }
+                }
+                PathKind::Pat { .. } => {
+                    pattern::complete_pattern_path(acc, ctx, path_ctx);
+                }
+                PathKind::Vis { has_in_token } => {
+                    vis::complete_vis_path(acc, ctx, path_ctx, has_in_token);
+                }
+                PathKind::Use => {
+                    use_::complete_use_tree(acc, ctx, path_ctx, nameref);
+                }
+            }
+        }
+        NameRefKind::DotAccess(dot_access) => {
+            flyimport::import_on_the_fly_dot(acc, ctx, dot_access);
+            dot::complete_dot(acc, ctx, dot_access);
+            postfix::complete_postfix(acc, ctx, dot_access);
+        }
+        NameRefKind::Keyword(item) => {
+            keyword::complete_for_and_where(acc, ctx, item);
+        }
+        NameRefKind::RecordExpr(record_expr) => {
+            record::complete_record_expr_fields(acc, ctx, record_expr);
+        }
+        NameRefKind::Pattern(pattern_ctx) => complete_patterns(acc, ctx, pattern_ctx),
+    }
+}
+
+fn complete_patterns(acc: &mut Completions, ctx: &CompletionContext, pattern_ctx: &PatternContext) {
+    flyimport::import_on_the_fly_pat(acc, ctx, pattern_ctx);
+    fn_param::complete_fn_param(acc, ctx, pattern_ctx);
+    pattern::complete_pattern(acc, ctx, pattern_ctx);
+    record::complete_record_pattern_fields(acc, ctx, pattern_ctx);
+}

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

@@ -18,7 +18,7 @@ use syntax::{
 
 use crate::{
     completions::module_or_attr,
-    context::{AttrCtx, CompletionContext, PathCompletionCtx, PathKind, Qualified},
+    context::{AttrCtx, CompletionContext, PathCompletionCtx, Qualified},
     item::CompletionItem,
     Completions,
 };
@@ -72,16 +72,10 @@ pub(crate) fn complete_known_attribute_input(
 pub(crate) fn complete_attribute(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    path_ctx: &PathCompletionCtx,
+    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    &AttrCtx { kind, annotated_item_kind }: &AttrCtx,
 ) {
-    let (qualified, is_inner, annotated_item_kind) = match path_ctx {
-        &PathCompletionCtx {
-            kind: PathKind::Attr { attr_ctx: AttrCtx { kind, annotated_item_kind } },
-            ref qualified,
-            ..
-        } => (qualified, kind == AttrKind::Inner, annotated_item_kind),
-        _ => return,
-    };
+    let is_inner = kind == AttrKind::Inner;
 
     match qualified {
         Qualified::With {

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

@@ -5,23 +5,17 @@ use itertools::Itertools;
 use syntax::SmolStr;
 
 use crate::{
-    context::{CompletionContext, PathCompletionCtx, PathKind, Qualified},
+    context::{CompletionContext, ExistingDerives, PathCompletionCtx, Qualified},
     item::CompletionItem,
     Completions,
 };
 
 pub(crate) fn complete_derive(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    path_ctx: &PathCompletionCtx,
+    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    existing_derives: &ExistingDerives,
 ) {
-    let (qualified, existing_derives) = match path_ctx {
-        PathCompletionCtx { kind: PathKind::Derive { existing_derives }, qualified, .. } => {
-            (qualified, existing_derives)
-        }
-        _ => return,
-    };
-
     let core = ctx.famous_defs().core();
 
     match qualified {

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

@@ -3,10 +3,7 @@
 use ide_db::FxHashSet;
 
 use crate::{
-    context::{
-        CompletionContext, DotAccess, DotAccessKind, ExprCtx, PathCompletionCtx, PathKind,
-        Qualified,
-    },
+    context::{CompletionContext, DotAccess, DotAccessKind, ExprCtx, PathCompletionCtx, Qualified},
     CompletionItem, CompletionItemKind, Completions,
 };
 
@@ -43,16 +40,22 @@ pub(crate) fn complete_undotted_self(
     acc: &mut Completions,
     ctx: &CompletionContext,
     path_ctx: &PathCompletionCtx,
+    expr_ctx: &ExprCtx,
 ) {
     if !ctx.config.enable_self_on_the_fly {
         return;
     }
-    let self_param = match path_ctx {
-        PathCompletionCtx {
-            qualified: Qualified::No,
-            kind: PathKind::Expr { expr_ctx: ExprCtx { self_param: Some(self_param), .. } },
-            ..
-        } if path_ctx.is_trivial_path() && ctx.qualifier_ctx.none() => self_param,
+    if !path_ctx.is_trivial_path() {
+        return;
+    }
+    if !ctx.qualifier_ctx.none() {
+        return;
+    }
+    if !matches!(path_ctx.qualified, Qualified::No) {
+        return;
+    }
+    let self_param = match expr_ctx {
+        ExprCtx { self_param: Some(self_param), .. } => self_param,
         _ => return,
     };
 

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

@@ -4,39 +4,31 @@ use hir::ScopeDef;
 use ide_db::FxHashSet;
 
 use crate::{
-    context::{ExprCtx, PathCompletionCtx, PathKind, Qualified},
+    context::{ExprCtx, PathCompletionCtx, Qualified},
     CompletionContext, Completions,
 };
 
 pub(crate) fn complete_expr_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    path_ctx: &PathCompletionCtx,
+    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    &ExprCtx {
+        in_block_expr,
+        in_loop_body,
+        after_if_expr,
+        in_condition,
+        incomplete_let,
+        ref ref_expr_parent,
+        ref is_func_update,
+        ref innermost_ret_ty,
+        ref impl_,
+        ..
+    }: &ExprCtx,
 ) {
     let _p = profile::span("complete_expr_path");
     if !ctx.qualifier_ctx.none() {
         return;
     }
-    let (
-        qualified,
-        &ExprCtx {
-            in_block_expr,
-            in_loop_body,
-            after_if_expr,
-            in_condition,
-            incomplete_let,
-            ref ref_expr_parent,
-            ref is_func_update,
-            ref innermost_ret_ty,
-            ref impl_,
-            ..
-        },
-    ) = match path_ctx {
-        PathCompletionCtx { kind: PathKind::Expr { expr_ctx }, qualified, .. } => {
-            (qualified, expr_ctx)
-        }
-        _ => return,
-    };
 
     let wants_mut_token =
         ref_expr_parent.as_ref().map(|it| it.mut_token().is_none()).unwrap_or(false);

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

@@ -1,7 +1,7 @@
 //! Completion of field list position.
 
 use crate::{
-    context::{PathCompletionCtx, PathKind, Qualified, TypeLocation},
+    context::{PathCompletionCtx, Qualified},
     CompletionContext, Completions,
 };
 
@@ -10,21 +10,21 @@ pub(crate) fn complete_field_list_tuple_variant(
     ctx: &CompletionContext,
     path_ctx: &PathCompletionCtx,
 ) {
+    if ctx.qualifier_ctx.vis_node.is_some() {
+        return;
+    }
     match path_ctx {
         PathCompletionCtx {
             has_macro_bang: false,
             qualified: Qualified::No,
             parent: None,
-            kind: PathKind::Type { location: TypeLocation::TupleField },
             has_type_args: false,
             ..
         } => {
-            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");
-            }
+            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/item_list.rs

@@ -2,34 +2,37 @@
 
 use crate::{
     completions::module_or_fn_macro,
-    context::{ExprCtx, ItemListKind, PathCompletionCtx, PathKind, Qualified},
+    context::{ExprCtx, ItemListKind, PathCompletionCtx, Qualified},
     CompletionContext, Completions,
 };
 
 pub(crate) mod trait_impl;
 
-pub(crate) fn complete_item_list(
+pub(crate) fn complete_item_list_in_expr(
     acc: &mut Completions,
     ctx: &CompletionContext,
     path_ctx: &PathCompletionCtx,
+    expr_ctx: &ExprCtx,
+) {
+    if !expr_ctx.in_block_expr {
+        return;
+    }
+    if !path_ctx.is_trivial_path() {
+        return;
+    }
+    add_keywords(acc, ctx, None);
+}
+
+pub(crate) fn complete_item_list(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    kind: &ItemListKind,
 ) {
     let _p = profile::span("complete_item_list");
-    let qualified = match path_ctx {
-        PathCompletionCtx { kind: PathKind::Item { kind }, qualified, .. } => {
-            if path_ctx.is_trivial_path() {
-                add_keywords(acc, ctx, Some(kind));
-            }
-            qualified
-        }
-        PathCompletionCtx {
-            kind: PathKind::Expr { expr_ctx: ExprCtx { in_block_expr: true, .. } },
-            ..
-        } if path_ctx.is_trivial_path() => {
-            add_keywords(acc, ctx, None);
-            return;
-        }
-        _ => return,
-    };
+    if path_ctx.is_trivial_path() {
+        add_keywords(acc, ctx, Some(kind));
+    }
 
     match qualified {
         Qualified::With {