Auto merge of rust-lang#12560 - Veykril:completion, r=Veykril

internal: More completions refactoring

This gets rid of the remaining `ImmediateLocation` bits

Author: bors

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

@@ -4,7 +4,8 @@ use ide_db::FxHashSet;
 
 use crate::{
     context::{
-        CompletionContext, DotAccess, DotAccessKind, NameRefContext, PathCompletionCtx, PathKind,
+        CompletionContext, DotAccess, DotAccessKind, NameRefContext, NameRefKind,
+        PathCompletionCtx, PathKind,
     },
     CompletionItem, CompletionItemKind, Completions,
 };
@@ -13,7 +14,8 @@ use crate::{
 pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     let (dot_access, receiver_ty) = match ctx.nameref_ctx() {
         Some(NameRefContext {
-            dot_access: Some(access @ DotAccess { receiver_ty: Some(receiver_ty), .. }),
+            kind:
+                Some(NameRefKind::DotAccess(access @ DotAccess { receiver_ty: Some(receiver_ty), .. })),
             ..
         }) => (access, &receiver_ty.original),
         _ => return complete_undotted_self(acc, ctx),

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

@@ -5,7 +5,7 @@ use ide_db::FxHashSet;
 use syntax::T;
 
 use crate::{
-    context::{NameRefContext, PathCompletionCtx, PathKind, PathQualifierCtx},
+    context::{NameRefContext, NameRefKind, PathCompletionCtx, PathKind, PathQualifierCtx},
     CompletionContext, Completions,
 };
 
@@ -21,24 +21,29 @@ pub(crate) fn complete_expr_path(acc: &mut Completions, ctx: &CompletionContext)
         after_if_expr,
         wants_mut_token,
     ) = match ctx.nameref_ctx() {
-        Some(NameRefContext {
-            path_ctx:
-                Some(PathCompletionCtx {
+        Some(&NameRefContext {
+            kind:
+                Some(NameRefKind::Path(PathCompletionCtx {
                     kind:
-                        PathKind::Expr { in_block_expr, in_loop_body, after_if_expr, ref_expr_parent },
+                        PathKind::Expr {
+                            in_block_expr,
+                            in_loop_body,
+                            after_if_expr,
+                            ref ref_expr_parent,
+                            ref is_func_update,
+                        },
                     is_absolute_path,
-                    qualifier,
+                    ref qualifier,
                     ..
-                }),
-            record_expr,
+                })),
             ..
         }) if ctx.qualifier_ctx.none() => (
-            *is_absolute_path,
+            is_absolute_path,
             qualifier,
-            *in_block_expr,
-            *in_loop_body,
-            record_expr.as_ref().map_or(false, |&(_, it)| it),
-            *after_if_expr,
+            in_block_expr,
+            in_loop_body,
+            is_func_update.is_some(),
+            after_if_expr,
             ref_expr_parent.as_ref().map(|it| it.mut_token().is_none()).unwrap_or(false),
         ),
         _ => return,

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

@@ -1,24 +1,27 @@
 //! Completion of field list position.
 
 use crate::{
-    context::{IdentContext, NameContext, NameKind, NameRefContext, PathCompletionCtx, PathKind},
+    context::{
+        IdentContext, NameContext, NameKind, NameRefContext, NameRefKind, PathCompletionCtx,
+        PathKind, 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 {
-            path_ctx:
-                Some(PathCompletionCtx {
+            kind:
+                Some(NameRefKind::Path(PathCompletionCtx {
                     has_macro_bang: false,
                     is_absolute_path: false,
                     qualifier: None,
                     parent: None,
-                    kind: PathKind::Type { in_tuple_struct: true },
+                    kind: PathKind::Type { location: TypeLocation::TupleField },
                     has_type_args: false,
                     ..
-                }),
+                })),
             ..
         }) => {
             if ctx.qualifier_ctx.vis_node.is_none() {

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

@@ -8,8 +8,10 @@ use itertools::Itertools;
 use syntax::{AstNode, SyntaxNode, T};
 
 use crate::{
-    context::{CompletionContext, NameRefContext, PathCompletionCtx, PathKind, PatternContext},
-    patterns::ImmediateLocation,
+    context::{
+        CompletionContext, NameRefContext, NameRefKind, PathCompletionCtx, PathKind,
+        PatternContext, TypeLocation,
+    },
     render::{render_resolution_with_import, RenderContext},
 };
 
@@ -111,19 +113,20 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
         return None;
     }
     let path_kind = match ctx.nameref_ctx() {
-        Some(NameRefContext { path_ctx: Some(PathCompletionCtx { kind, .. }), .. })
-            if matches!(
-                kind,
-                PathKind::Expr { .. }
-                    | PathKind::Type { .. }
-                    | PathKind::Attr { .. }
-                    | PathKind::Derive
-                    | PathKind::Pat
-            ) =>
-        {
-            Some(kind)
-        }
-        Some(NameRefContext { dot_access: Some(_), .. }) => None,
+        Some(NameRefContext {
+            kind:
+                Some(NameRefKind::Path(PathCompletionCtx {
+                    kind:
+                        kind @ (PathKind::Expr { .. }
+                        | PathKind::Type { .. }
+                        | PathKind::Attr { .. }
+                        | PathKind::Derive
+                        | PathKind::Pat),
+                    ..
+                })),
+            ..
+        }) => Some(kind),
+        Some(NameRefContext { kind: Some(NameRefKind::DotAccess(_)), .. }) => None,
         None if matches!(ctx.pattern_ctx, Some(PatternContext { record_pat: None, .. })) => {
             Some(&PathKind::Pat)
         }
@@ -173,8 +176,8 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
             (PathKind::Pat, ItemInNs::Types(_)) => true,
             (PathKind::Pat, ItemInNs::Values(def)) => matches!(def, hir::ModuleDef::Const(_)),
 
-            (PathKind::Type { .. }, ItemInNs::Types(ty)) => {
-                if matches!(ctx.completion_location, Some(ImmediateLocation::TypeBound)) {
+            (PathKind::Type { location }, ItemInNs::Types(ty)) => {
+                if matches!(location, TypeLocation::TypeBound) {
                     matches!(ty, ModuleDef::Trait(_))
                 } else {
                     true

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

@@ -44,8 +44,8 @@ use text_edit::TextEdit;
 
 use crate::{
     context::{
-        IdentContext, ItemListKind, NameContext, NameKind, NameRefContext, PathCompletionCtx,
-        PathKind,
+        IdentContext, ItemListKind, NameContext, NameKind, NameRefContext, NameRefKind,
+        PathCompletionCtx, PathKind,
     },
     CompletionContext, CompletionItem, CompletionItemKind, CompletionRelevance, Completions,
 };
@@ -106,14 +106,13 @@ fn completion_match(ctx: &CompletionContext) -> Option<(ImplCompletionKind, Text
         }
         IdentContext::NameRef(NameRefContext {
             nameref,
-            path_ctx:
-                Some(
+            kind:
+                Some(NameRefKind::Path(
                     path_ctx @ PathCompletionCtx {
                         kind: PathKind::Item { kind: ItemListKind::TraitImpl },
                         ..
                     },
-                ),
-            ..
+                )),
         }) if path_ctx.is_trivial_path() => Some((
             ImplCompletionKind::All,
             match nameref {

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

@@ -4,11 +4,14 @@
 
 use syntax::ast::Item;
 
-use crate::{context::NameRefContext, CompletionContext, Completions};
+use crate::{
+    context::{NameRefContext, NameRefKind},
+    CompletionContext, Completions,
+};
 
 pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionContext) {
     let item = match ctx.nameref_ctx() {
-        Some(NameRefContext { keyword: Some(item), record_expr: None, .. }) => item,
+        Some(NameRefContext { kind: Some(NameRefKind::Keyword(item)), .. }) => item,
         _ => return,
     };
 

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

@@ -13,7 +13,7 @@ use text_edit::TextEdit;
 
 use crate::{
     completions::postfix::format_like::add_format_like_completions,
-    context::{CompletionContext, DotAccess, DotAccessKind, NameRefContext},
+    context::{CompletionContext, DotAccess, DotAccessKind, NameRefContext, NameRefKind},
     item::{Builder, CompletionRelevancePostfixMatch},
     CompletionItem, CompletionItemKind, CompletionRelevance, Completions, SnippetScope,
 };
@@ -25,7 +25,13 @@ pub(crate) fn complete_postfix(acc: &mut Completions, ctx: &CompletionContext) {
 
     let (dot_receiver, receiver_ty, receiver_is_ambiguous_float_literal) = match ctx.nameref_ctx() {
         Some(NameRefContext {
-            dot_access: Some(DotAccess { receiver_ty: Some(ty), receiver: Some(it), kind, .. }),
+            kind:
+                Some(NameRefKind::DotAccess(DotAccess {
+                    receiver_ty: Some(ty),
+                    receiver: Some(it),
+                    kind,
+                    ..
+                })),
             ..
         }) => (
             it,

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

@@ -3,7 +3,7 @@ use ide_db::SymbolKind;
 use syntax::{ast::Expr, T};
 
 use crate::{
-    context::{NameRefContext, PatternContext},
+    context::{NameRefContext, NameRefKind, PathCompletionCtx, PathKind, PatternContext},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionRelevance,
     CompletionRelevancePostfixMatch, Completions,
 };
@@ -13,8 +13,18 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
         &ctx.pattern_ctx
     {
         ctx.sema.record_pattern_missing_fields(record_pat)
-    } else if let Some(NameRefContext { record_expr: Some((record_expr, _)), .. }) =
-        ctx.nameref_ctx()
+    } else if let Some(NameRefContext {
+        kind:
+            Some(
+                NameRefKind::RecordExpr(record_expr)
+                | NameRefKind::Path(PathCompletionCtx {
+                    kind: PathKind::Expr { is_func_update: Some(record_expr), .. },
+                    qualifier: None,
+                    ..
+                }),
+            ),
+        ..
+    }) = ctx.nameref_ctx()
     {
         let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_expr.clone()));
 
@@ -39,7 +49,7 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
                     ty.original.impls_trait(ctx.db, default_trait, &[])
                 });
 
-            if impl_default_trait && !missing_fields.is_empty() && ctx.path_qual().is_none() {
+            if impl_default_trait && !missing_fields.is_empty() {
                 let completion_text = "..Default::default()";
                 let mut item =
                     CompletionItem::new(SymbolKind::Field, ctx.source_range(), completion_text);