Auto merge of #12594 - Veykril:completions, r=Veykril

internal: Lift out IdentContext from CompletionContext

Makes things a bit messy overall, but with this I can start cleaning up the render functions properly now.
cc https://github.com/rust-lang/rust-analyzer/issues/12571

23 files changed, 490 insertions, 372 deletions

diff --git a/crates/ide-completion/src/completions.rs b/crates/ide-completion/src/completions.rs
index c1081dbde32..a0725198f73 100644
--- a/crates/ide-completion/src/completions.rs
+++ b/crates/ide-completion/src/completions.rs
@@ -23,13 +23,13 @@ pub(crate) mod vis;
 use std::iter;
 
 use hir::{known, ScopeDef};
-use ide_db::SymbolKind;
+use ide_db::{imports::import_assets::LocatedImport, SymbolKind};
 use syntax::ast;
 
 use crate::{
     context::{
-        ItemListKind, NameContext, NameKind, NameRefContext, NameRefKind, PathKind, PatternContext,
-        TypeLocation, Visible,
+        DotAccess, ItemListKind, NameContext, NameKind, NameRefContext, NameRefKind,
+        PathCompletionCtx, PathKind, PatternContext, TypeLocation, Visible,
     },
     item::Builder,
     render::{
@@ -38,7 +38,7 @@ use crate::{
         literal::{render_struct_literal, render_variant_lit},
         macro_::render_macro,
         pattern::{render_struct_pat, render_variant_pat},
-        render_field, render_resolution, render_resolution_simple, render_tuple_field,
+        render_field, render_path_resolution, render_resolution_simple, render_tuple_field,
         type_alias::{render_type_alias, render_type_alias_with_eq},
         union_literal::render_union_literal,
         RenderContext,
@@ -137,15 +137,16 @@ impl Completions {
     pub(crate) fn add_crate_roots(&mut self, ctx: &CompletionContext) {
         ctx.process_all_names(&mut |name, res| match res {
             ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) if m.is_crate_root(ctx.db) => {
-                self.add_resolution(ctx, name, res);
+                self.add_module(ctx, m, name);
             }
             _ => (),
         });
     }
 
-    pub(crate) fn add_resolution(
+    pub(crate) fn add_path_resolution(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         local_name: hir::Name,
         resolution: hir::ScopeDef,
     ) {
@@ -153,7 +154,10 @@ impl Completions {
             cov_mark::hit!(qualified_path_doc_hidden);
             return;
         }
-        self.add(render_resolution(RenderContext::new(ctx), local_name, resolution).build());
+        self.add(
+            render_path_resolution(RenderContext::new(ctx), path_ctx, local_name, resolution)
+                .build(),
+        );
     }
 
     pub(crate) fn add_resolution_simple(
@@ -174,12 +178,13 @@ impl Completions {
         module: hir::Module,
         local_name: hir::Name,
     ) {
-        self.add_resolution(ctx, local_name, hir::ScopeDef::ModuleDef(module.into()));
+        self.add_resolution_simple(ctx, local_name, hir::ScopeDef::ModuleDef(module.into()));
     }
 
     pub(crate) fn add_macro(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         mac: hir::Macro,
         local_name: hir::Name,
     ) {
@@ -191,6 +196,7 @@ impl Completions {
         self.add(
             render_macro(
                 RenderContext::new(ctx).private_editable(is_private_editable),
+                path_ctx,
                 local_name,
                 mac,
             )
@@ -201,6 +207,7 @@ impl Completions {
     pub(crate) fn add_function(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         func: hir::Function,
         local_name: Option<hir::Name>,
     ) {
@@ -212,6 +219,7 @@ impl Completions {
         self.add(
             render_fn(
                 RenderContext::new(ctx).private_editable(is_private_editable),
+                path_ctx,
                 local_name,
                 func,
             )
@@ -222,6 +230,7 @@ impl Completions {
     pub(crate) fn add_method(
         &mut self,
         ctx: &CompletionContext,
+        dot_access: &DotAccess,
         func: hir::Function,
         receiver: Option<hir::Name>,
         local_name: Option<hir::Name>,
@@ -234,6 +243,7 @@ impl Completions {
         self.add(
             render_method(
                 RenderContext::new(ctx).private_editable(is_private_editable),
+                dot_access,
                 receiver,
                 local_name,
                 func,
@@ -242,6 +252,32 @@ impl Completions {
         );
     }
 
+    pub(crate) fn add_method_with_import(
+        &mut self,
+        ctx: &CompletionContext,
+        dot_access: &DotAccess,
+        func: hir::Function,
+        import: LocatedImport,
+    ) {
+        let is_private_editable = match ctx.is_visible(&func) {
+            Visible::Yes => false,
+            Visible::Editable => true,
+            Visible::No => return,
+        };
+        self.add(
+            render_method(
+                RenderContext::new(ctx)
+                    .private_editable(is_private_editable)
+                    .import_to_add(Some(import)),
+                dot_access,
+                None,
+                None,
+                func,
+            )
+            .build(),
+        );
+    }
+
     pub(crate) fn add_const(&mut self, ctx: &CompletionContext, konst: hir::Const) {
         let is_private_editable = match ctx.is_visible(&konst) {
             Visible::Yes => false,
@@ -277,11 +313,12 @@ impl Completions {
     pub(crate) fn add_qualified_enum_variant(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         variant: hir::Variant,
         path: hir::ModPath,
     ) {
         if let Some(builder) =
-            render_variant_lit(RenderContext::new(ctx), None, variant, Some(path))
+            render_variant_lit(RenderContext::new(ctx), path_ctx, None, variant, Some(path))
         {
             self.add(builder.build());
         }
@@ -290,11 +327,12 @@ impl Completions {
     pub(crate) fn add_enum_variant(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         variant: hir::Variant,
         local_name: Option<hir::Name>,
     ) {
         if let Some(builder) =
-            render_variant_lit(RenderContext::new(ctx), local_name, variant, None)
+            render_variant_lit(RenderContext::new(ctx), path_ctx, local_name, variant, None)
         {
             self.add(builder.build());
         }
@@ -324,12 +362,13 @@ impl Completions {
     pub(crate) fn add_struct_literal(
         &mut self,
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         strukt: hir::Struct,
         path: Option<hir::ModPath>,
         local_name: Option<hir::Name>,
     ) {
         if let Some(builder) =
-            render_struct_literal(RenderContext::new(ctx), strukt, path, local_name)
+            render_struct_literal(RenderContext::new(ctx), path_ctx, strukt, path, local_name)
         {
             self.add(builder.build());
         }
@@ -369,11 +408,13 @@ impl Completions {
     pub(crate) fn add_variant_pat(
         &mut self,
         ctx: &CompletionContext,
+        pattern_ctx: &PatternContext,
         variant: hir::Variant,
         local_name: Option<hir::Name>,
     ) {
         self.add_opt(render_variant_pat(
             RenderContext::new(ctx),
+            pattern_ctx,
             variant,
             local_name.clone(),
             None,
@@ -383,20 +424,22 @@ impl Completions {
     pub(crate) fn add_qualified_variant_pat(
         &mut self,
         ctx: &CompletionContext,
+        pattern_ctx: &PatternContext,
         variant: hir::Variant,
         path: hir::ModPath,
     ) {
         let path = Some(&path);
-        self.add_opt(render_variant_pat(RenderContext::new(ctx), variant, None, path));
+        self.add_opt(render_variant_pat(RenderContext::new(ctx), pattern_ctx, variant, None, path));
     }
 
     pub(crate) fn add_struct_pat(
         &mut self,
         ctx: &CompletionContext,
+        pattern_ctx: &PatternContext,
         strukt: hir::Struct,
         local_name: Option<hir::Name>,
     ) {
-        self.add_opt(render_struct_pat(RenderContext::new(ctx), strukt, local_name));
+        self.add_opt(render_struct_pat(RenderContext::new(ctx), pattern_ctx, strukt, local_name));
     }
 }
 
@@ -541,8 +584,8 @@ pub(super) fn complete_name_ref(
         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::RecordExpr { dot_prefix, expr } => {
+            record::complete_record_expr_fields(acc, ctx, expr, dot_prefix);
         }
         NameRefKind::Pattern(pattern_ctx) => complete_patterns(acc, ctx, pattern_ctx),
     }
diff --git a/crates/ide-completion/src/completions/attribute.rs b/crates/ide-completion/src/completions/attribute.rs
index 37e042a1609..1c4f9a3113d 100644
--- a/crates/ide-completion/src/completions/attribute.rs
+++ b/crates/ide-completion/src/completions/attribute.rs
@@ -33,6 +33,7 @@ pub(crate) use self::derive::complete_derive_path;
 pub(crate) fn complete_known_attribute_input(
     acc: &mut Completions,
     ctx: &CompletionContext,
+    &colon_prefix: &bool,
     fake_attribute_under_caret: &ast::Attr,
 ) -> Option<()> {
     let attribute = fake_attribute_under_caret;
@@ -47,7 +48,9 @@ pub(crate) fn complete_known_attribute_input(
 
     match path.text().as_str() {
         "repr" => repr::complete_repr(acc, ctx, tt),
-        "feature" => lint::complete_lint(acc, ctx, &parse_tt_as_comma_sep_paths(tt)?, FEATURES),
+        "feature" => {
+            lint::complete_lint(acc, ctx, colon_prefix, &parse_tt_as_comma_sep_paths(tt)?, FEATURES)
+        }
         "allow" | "warn" | "deny" | "forbid" => {
             let existing_lints = parse_tt_as_comma_sep_paths(tt)?;
 
@@ -60,7 +63,7 @@ pub(crate) fn complete_known_attribute_input(
                 .cloned()
                 .collect();
 
-            lint::complete_lint(acc, ctx, &existing_lints, &lints);
+            lint::complete_lint(acc, ctx, colon_prefix, &existing_lints, &lints);
         }
         "cfg" => cfg::complete_cfg(acc, ctx),
         _ => (),
@@ -71,7 +74,7 @@ pub(crate) fn complete_known_attribute_input(
 pub(crate) fn complete_attribute_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
     &AttrCtx { kind, annotated_item_kind }: &AttrCtx,
 ) {
     let is_inner = kind == AttrKind::Inner;
@@ -89,7 +92,7 @@ pub(crate) fn complete_attribute_path(
             for (name, def) in module.scope(ctx.db, Some(ctx.module)) {
                 match def {
                     hir::ScopeDef::ModuleDef(hir::ModuleDef::Macro(m)) if m.is_attr(ctx.db) => {
-                        acc.add_macro(ctx, m, name)
+                        acc.add_macro(ctx, path_ctx, m, name)
                     }
                     hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) => {
                         acc.add_module(ctx, m, name)
@@ -105,7 +108,7 @@ pub(crate) fn complete_attribute_path(
         Qualified::No => {
             ctx.process_all_names(&mut |name, def| match def {
                 hir::ScopeDef::ModuleDef(hir::ModuleDef::Macro(m)) if m.is_attr(ctx.db) => {
-                    acc.add_macro(ctx, m, name)
+                    acc.add_macro(ctx, path_ctx, m, name)
                 }
                 hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) => acc.add_module(ctx, m, name),
                 _ => (),
diff --git a/crates/ide-completion/src/completions/attribute/derive.rs b/crates/ide-completion/src/completions/attribute/derive.rs
index 0e10f381532..21298b6ca5d 100644
--- a/crates/ide-completion/src/completions/attribute/derive.rs
+++ b/crates/ide-completion/src/completions/attribute/derive.rs
@@ -13,7 +13,7 @@ use crate::{
 pub(crate) fn complete_derive_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
     existing_derives: &ExistingDerives,
 ) {
     let core = ctx.famous_defs().core();
@@ -33,7 +33,7 @@ pub(crate) fn complete_derive_path(
                     ScopeDef::ModuleDef(hir::ModuleDef::Macro(mac))
                         if !existing_derives.contains(&mac) && mac.is_derive(ctx.db) =>
                     {
-                        acc.add_macro(ctx, mac, name)
+                        acc.add_macro(ctx, path_ctx, mac, name)
                     }
                     ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) => acc.add_module(ctx, m, name),
                     _ => (),
@@ -59,7 +59,7 @@ pub(crate) fn complete_derive_path(
                 match (core, mac.module(ctx.db).krate()) {
                     // show derive dependencies for `core`/`std` derives
                     (Some(core), mac_krate) if core == mac_krate => {}
-                    _ => return acc.add_macro(ctx, mac, name),
+                    _ => return acc.add_macro(ctx, path_ctx, mac, name),
                 };
 
                 let name_ = name.to_smol_str();
@@ -92,7 +92,7 @@ pub(crate) fn complete_derive_path(
                         item.lookup_by(lookup);
                         item.add_to(acc);
                     }
-                    None => acc.add_macro(ctx, mac, name),
+                    None => acc.add_macro(ctx, path_ctx, mac, name),
                 }
             });
             acc.add_nameref_keywords_with_colon(ctx);
diff --git a/crates/ide-completion/src/completions/attribute/lint.rs b/crates/ide-completion/src/completions/attribute/lint.rs
index 8991d657e85..5c048103187 100644
--- a/crates/ide-completion/src/completions/attribute/lint.rs
+++ b/crates/ide-completion/src/completions/attribute/lint.rs
@@ -1,16 +1,16 @@
 //! Completion for lints
 use ide_db::{generated::lints::Lint, SymbolKind};
-use syntax::{ast, T};
+use syntax::ast;
 
 use crate::{context::CompletionContext, item::CompletionItem, Completions};
 
 pub(super) fn complete_lint(
     acc: &mut Completions,
     ctx: &CompletionContext,
+    is_qualified: bool,
     existing_lints: &[ast::Path],
     lints_completions: &[Lint],
 ) {
-    let is_qualified = ctx.previous_token_is(T![:]);
     for &Lint { label, description } in lints_completions {
         let (qual, name) = {
             // FIXME: change `Lint`'s label to not store a path in it but split the prefix off instead?
diff --git a/crates/ide-completion/src/completions/dot.rs b/crates/ide-completion/src/completions/dot.rs
index a8a57c0c7dd..b58a9f39f2e 100644
--- a/crates/ide-completion/src/completions/dot.rs
+++ b/crates/ide-completion/src/completions/dot.rs
@@ -33,7 +33,7 @@ pub(crate) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext, dot_a
             |acc, field, ty| acc.add_tuple_field(ctx, None, field, &ty),
         );
     }
-    complete_methods(ctx, &receiver_ty, |func| acc.add_method(ctx, func, None, None));
+    complete_methods(ctx, &receiver_ty, |func| acc.add_method(ctx, dot_access, func, None, None));
 }
 
 pub(crate) fn complete_undotted_self(
@@ -68,7 +68,17 @@ pub(crate) fn complete_undotted_self(
         |acc, field, ty| acc.add_tuple_field(ctx, Some(hir::known::SELF_PARAM), field, &ty),
     );
     complete_methods(ctx, &ty, |func| {
-        acc.add_method(ctx, func, Some(hir::known::SELF_PARAM), None)
+        acc.add_method(
+            ctx,
+            &DotAccess {
+                receiver: None,
+                receiver_ty: None,
+                kind: DotAccessKind::Method { has_parens: false },
+            },
+            func,
+            Some(hir::known::SELF_PARAM),
+            None,
+        )
     });
 }
 
diff --git a/crates/ide-completion/src/completions/expr.rs b/crates/ide-completion/src/completions/expr.rs
index 84ae596a8d0..9c003be6af4 100644
--- a/crates/ide-completion/src/completions/expr.rs
+++ b/crates/ide-completion/src/completions/expr.rs
@@ -11,7 +11,7 @@ use crate::{
 pub(crate) fn complete_expr_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
     &ExprCtx {
         in_block_expr,
         in_loop_body,
@@ -34,11 +34,12 @@ pub(crate) fn complete_expr_path(
         ref_expr_parent.as_ref().map(|it| it.mut_token().is_none()).unwrap_or(false);
 
     let scope_def_applicable = |def| {
-        use hir::{GenericParam::*, ModuleDef::*};
         match def {
-            ScopeDef::GenericParam(LifetimeParam(_)) | ScopeDef::Label(_) => false,
+            ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) | ScopeDef::Label(_) => {
+                false
+            }
             // Don't suggest attribute macros and derives.
-            ScopeDef::ModuleDef(Macro(mac)) => mac.is_fn_like(ctx.db),
+            ScopeDef::ModuleDef(hir::ModuleDef::Macro(mac)) => mac.is_fn_like(ctx.db),
             _ => true,
         }
     };
@@ -49,7 +50,7 @@ pub(crate) fn complete_expr_path(
             .0
             .into_iter()
             .flat_map(|it| hir::Trait::from(it).items(ctx.sema.db))
-            .for_each(|item| add_assoc_item(acc, ctx, item)),
+            .for_each(|item| add_assoc_item(acc, ctx, path_ctx, item)),
         Qualified::With { resolution: None, .. } => {}
         Qualified::With { resolution: Some(resolution), .. } => {
             // Add associated types on type parameters and `Self`.
@@ -62,7 +63,7 @@ pub(crate) fn complete_expr_path(
                     let module_scope = module.scope(ctx.db, Some(ctx.module));
                     for (name, def) in module_scope {
                         if scope_def_applicable(def) {
-                            acc.add_resolution(ctx, name, def);
+                            acc.add_path_resolution(ctx, path_ctx, name, def);
                         }
                     }
                 }
@@ -73,7 +74,7 @@ pub(crate) fn complete_expr_path(
                     | hir::ModuleDef::BuiltinType(_)),
                 ) => {
                     if let &hir::ModuleDef::Adt(hir::Adt::Enum(e)) = def {
-                        add_enum_variants(acc, ctx, e);
+                        add_enum_variants(acc, ctx, path_ctx, e);
                     }
                     let ty = match def {
                         hir::ModuleDef::Adt(adt) => adt.ty(ctx.db),
@@ -81,7 +82,7 @@ pub(crate) fn complete_expr_path(
                             let ty = a.ty(ctx.db);
                             if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
                                 cov_mark::hit!(completes_variant_through_alias);
-                                add_enum_variants(acc, ctx, e);
+                                add_enum_variants(acc, ctx, path_ctx, e);
                             }
                             ty
                         }
@@ -102,7 +103,7 @@ pub(crate) fn complete_expr_path(
                         Some(ctx.module),
                         None,
                         |item| {
-                            add_assoc_item(acc, ctx, item);
+                            add_assoc_item(acc, ctx, path_ctx, item);
                             None::<()>
                         },
                     );
@@ -118,7 +119,7 @@ pub(crate) fn complete_expr_path(
                 hir::PathResolution::Def(hir::ModuleDef::Trait(t)) => {
                     // Handles `Trait::assoc` as well as `<Ty as Trait>::assoc`.
                     for item in t.items(ctx.db) {
-                        add_assoc_item(acc, ctx, item);
+                        add_assoc_item(acc, ctx, path_ctx, item);
                     }
                 }
                 hir::PathResolution::TypeParam(_) | hir::PathResolution::SelfType(_) => {
@@ -129,7 +130,7 @@ pub(crate) fn complete_expr_path(
                     };
 
                     if let Some(hir::Adt::Enum(e)) = ty.as_adt() {
-                        add_enum_variants(acc, ctx, e);
+                        add_enum_variants(acc, ctx, path_ctx, e);
                     }
                     let mut seen = FxHashSet::default();
                     ty.iterate_path_candidates(
@@ -142,7 +143,7 @@ pub(crate) fn complete_expr_path(
                             // We might iterate candidates of a trait multiple times here, so deduplicate
                             // them.
                             if seen.insert(item) {
-                                add_assoc_item(acc, ctx, item);
+                                add_assoc_item(acc, ctx, path_ctx, item);
                             }
                             None::<()>
                         },
@@ -167,10 +168,16 @@ pub(crate) fn complete_expr_path(
                             .find_use_path(ctx.db, hir::ModuleDef::from(strukt))
                             .filter(|it| it.len() > 1);
 
-                        acc.add_struct_literal(ctx, strukt, path, None);
+                        acc.add_struct_literal(ctx, path_ctx, strukt, path, None);
 
                         if complete_self {
-                            acc.add_struct_literal(ctx, strukt, None, Some(hir::known::SELF_TYPE));
+                            acc.add_struct_literal(
+                                ctx,
+                                path_ctx,
+                                strukt,
+                                None,
+                                Some(hir::known::SELF_TYPE),
+                            );
                         }
                     }
                     hir::Adt::Union(un) => {
@@ -191,7 +198,7 @@ pub(crate) fn complete_expr_path(
                             e,
                             impl_,
                             |acc, ctx, variant, path| {
-                                acc.add_qualified_enum_variant(ctx, variant, path)
+                                acc.add_qualified_enum_variant(ctx, path_ctx, variant, path)
                             },
                         );
                     }
@@ -199,7 +206,7 @@ pub(crate) fn complete_expr_path(
             }
             ctx.process_all_names(&mut |name, def| {
                 if scope_def_applicable(def) {
-                    acc.add_resolution(ctx, name, def);
+                    acc.add_path_resolution(ctx, path_ctx, name, def);
                 }
             });
 
@@ -259,14 +266,26 @@ pub(crate) fn complete_expr_path(
     }
 }
 
-fn add_assoc_item(acc: &mut Completions, ctx: &CompletionContext, item: hir::AssocItem) {
+fn add_assoc_item(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx: &PathCompletionCtx,
+    item: hir::AssocItem,
+) {
     match item {
-        hir::AssocItem::Function(func) => acc.add_function(ctx, func, None),
+        hir::AssocItem::Function(func) => acc.add_function(ctx, path_ctx, func, None),
         hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
         hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
     }
 }
 
-fn add_enum_variants(acc: &mut Completions, ctx: &CompletionContext, e: hir::Enum) {
-    e.variants(ctx.db).into_iter().for_each(|variant| acc.add_enum_variant(ctx, variant, None));
+fn add_enum_variants(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    path_ctx: &PathCompletionCtx,
+    e: hir::Enum,
+) {
+    e.variants(ctx.db)
+        .into_iter()
+        .for_each(|variant| acc.add_enum_variant(ctx, path_ctx, variant, None));
 }
diff --git a/crates/ide-completion/src/completions/flyimport.rs b/crates/ide-completion/src/completions/flyimport.rs
index 608a74dc152..129910465c2 100644
--- a/crates/ide-completion/src/completions/flyimport.rs
+++ b/crates/ide-completion/src/completions/flyimport.rs
@@ -116,17 +116,17 @@ pub(crate) fn import_on_the_fly_path(
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    let (kind, qualified) = match path_ctx {
+    let qualified = match path_ctx {
         PathCompletionCtx {
             kind:
-                kind @ (PathKind::Expr { .. }
+                PathKind::Expr { .. }
                 | PathKind::Type { .. }
                 | PathKind::Attr { .. }
                 | PathKind::Derive { .. }
-                | PathKind::Pat { .. }),
+                | PathKind::Pat { .. },
             qualified,
             ..
-        } => (Some(kind), qualified),
+        } => qualified,
         _ => return None,
     };
     let potential_import_name = import_name(ctx);
@@ -139,63 +139,70 @@ pub(crate) fn import_on_the_fly_path(
     import_on_the_fly(
         acc,
         ctx,
-        kind,
+        path_ctx,
         import_assets,
         qualifier.map(|it| it.syntax().clone()).or_else(|| ctx.original_token.parent())?,
         potential_import_name,
     )
 }
 
-pub(crate) fn import_on_the_fly_dot(
+pub(crate) fn import_on_the_fly_pat(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    dot_access: &DotAccess,
+    pat_ctx: &PatternContext,
 ) -> Option<()> {
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    let receiver = dot_access.receiver.as_ref()?;
-    let ty = dot_access.receiver_ty.as_ref()?;
+    if let PatternContext { record_pat: Some(_), .. } = pat_ctx {
+        return None;
+    }
+
     let potential_import_name = import_name(ctx);
-    let import_assets = ImportAssets::for_fuzzy_method_call(
-        ctx.module,
-        ty.original.clone(),
-        potential_import_name.clone(),
-        receiver.syntax().clone(),
-    )?;
+    let import_assets = import_assets_for_path(ctx, &potential_import_name, None)?;
 
     import_on_the_fly(
         acc,
         ctx,
-        None,
+        &PathCompletionCtx {
+            has_call_parens: false,
+            has_macro_bang: false,
+            qualified: Qualified::No,
+            parent: None,
+            kind: crate::context::PathKind::Pat { pat_ctx: pat_ctx.clone() },
+            has_type_args: false,
+            use_tree_parent: false,
+        },
         import_assets,
-        receiver.syntax().clone(),
+        ctx.original_token.parent()?,
         potential_import_name,
     )
 }
 
-pub(crate) fn import_on_the_fly_pat(
+pub(crate) fn import_on_the_fly_dot(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    pat_ctx: &PatternContext,
+    dot_access: &DotAccess,
 ) -> Option<()> {
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    let kind = match pat_ctx {
-        PatternContext { record_pat: None, .. } => PathKind::Pat { pat_ctx: pat_ctx.clone() },
-        _ => return None,
-    };
-
+    let receiver = dot_access.receiver.as_ref()?;
+    let ty = dot_access.receiver_ty.as_ref()?;
     let potential_import_name = import_name(ctx);
-    let import_assets = import_assets_for_path(ctx, &potential_import_name, None)?;
+    let import_assets = ImportAssets::for_fuzzy_method_call(
+        ctx.module,
+        ty.original.clone(),
+        potential_import_name.clone(),
+        receiver.syntax().clone(),
+    )?;
 
-    import_on_the_fly(
+    import_on_the_fly_method(
         acc,
         ctx,
-        Some(&kind),
+        dot_access,
         import_assets,
-        ctx.original_token.parent()?,
+        receiver.syntax().clone(),
         potential_import_name,
     )
 }
@@ -203,7 +210,7 @@ pub(crate) fn import_on_the_fly_pat(
 fn import_on_the_fly(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    path_kind: Option<&PathKind>,
+    path_ctx @ PathCompletionCtx { kind, .. }: &PathCompletionCtx,
     import_assets: ImportAssets,
     position: SyntaxNode,
     potential_import_name: String,
@@ -215,11 +222,7 @@ fn import_on_the_fly(
     }
 
     let ns_filter = |import: &LocatedImport| {
-        let path_kind = match path_kind {
-            Some(it) => it,
-            None => return true,
-        };
-        match (path_kind, import.original_item) {
+        match (kind, import.original_item) {
             // Aren't handled in flyimport
             (PathKind::Vis { .. } | PathKind::Use, _) => false,
             // modules are always fair game
@@ -276,12 +279,49 @@ fn import_on_the_fly(
                     &user_input_lowercased,
                 )
             })
-            .filter_map(|import| render_resolution_with_import(RenderContext::new(ctx), import))
+            .filter_map(|import| {
+                render_resolution_with_import(RenderContext::new(ctx), path_ctx, import)
+            })
             .map(|builder| builder.build()),
     );
     Some(())
 }
 
+fn import_on_the_fly_method(
+    acc: &mut Completions,
+    ctx: &CompletionContext,
+    dot_access: &DotAccess,
+    import_assets: ImportAssets,
+    position: SyntaxNode,
+    potential_import_name: String,
+) -> Option<()> {
+    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.clone());
+
+    if ImportScope::find_insert_use_container(&position, &ctx.sema).is_none() {
+        return None;
+    }
+
+    let user_input_lowercased = potential_import_name.to_lowercase();
+
+    import_assets
+        .search_for_imports(&ctx.sema, ctx.config.insert_use.prefix_kind)
+        .into_iter()
+        .filter(|import| {
+            !ctx.is_item_hidden(&import.item_to_import)
+                && !ctx.is_item_hidden(&import.original_item)
+        })
+        .sorted_by_key(|located_import| {
+            compute_fuzzy_completion_order_key(&located_import.import_path, &user_input_lowercased)
+        })
+        .for_each(|import| match import.original_item {
+            ItemInNs::Values(hir::ModuleDef::Function(f)) => {
+                acc.add_method_with_import(ctx, dot_access, f, import);
+            }
+            _ => (),
+        });
+    Some(())
+}
+
 fn import_name(ctx: &CompletionContext) -> String {
     let token_kind = ctx.token.kind();
     if matches!(token_kind, T![.] | T![::]) {
diff --git a/crates/ide-completion/src/completions/item_list.rs b/crates/ide-completion/src/completions/item_list.rs
index e697e1971ea..329d08a9e76 100644
--- a/crates/ide-completion/src/completions/item_list.rs
+++ b/crates/ide-completion/src/completions/item_list.rs
@@ -42,7 +42,7 @@ pub(crate) fn complete_item_list(
             for (name, def) in module.scope(ctx.db, Some(ctx.module)) {
                 match def {
                     hir::ScopeDef::ModuleDef(hir::ModuleDef::Macro(m)) if m.is_fn_like(ctx.db) => {
-                        acc.add_macro(ctx, m, name)
+                        acc.add_macro(ctx, path_ctx, m, name)
                     }
                     hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) => {
                         acc.add_module(ctx, m, name)
@@ -59,7 +59,7 @@ pub(crate) fn complete_item_list(
         Qualified::No if ctx.qualifier_ctx.none() => {
             ctx.process_all_names(&mut |name, def| match def {
                 hir::ScopeDef::ModuleDef(hir::ModuleDef::Macro(m)) if m.is_fn_like(ctx.db) => {
-                    acc.add_macro(ctx, m, name)
+                    acc.add_macro(ctx, path_ctx, m, name)
                 }
                 hir::ScopeDef::ModuleDef(hir::ModuleDef::Module(m)) => acc.add_module(ctx, m, name),
                 _ => (),
diff --git a/crates/ide-completion/src/completions/pattern.rs b/crates/ide-completion/src/completions/pattern.rs
index e2e8d3f205a..91d53565410 100644
--- a/crates/ide-completion/src/completions/pattern.rs
+++ b/crates/ide-completion/src/completions/pattern.rs
@@ -13,9 +13,9 @@ use crate::{
 pub(crate) fn complete_pattern(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    patctx: &PatternContext,
+    pattern_ctx: &PatternContext,
 ) {
-    match patctx.parent_pat.as_ref() {
+    match pattern_ctx.parent_pat.as_ref() {
         Some(Pat::RangePat(_) | Pat::BoxPat(_)) => (),
         Some(Pat::RefPat(r)) => {
             if r.mut_token().is_none() {
@@ -24,7 +24,7 @@ pub(crate) fn complete_pattern(
         }
         _ => {
             let tok = ctx.token.text_range().start();
-            match (patctx.ref_token.as_ref(), patctx.mut_token.as_ref()) {
+            match (pattern_ctx.ref_token.as_ref(), pattern_ctx.mut_token.as_ref()) {
                 (None, None) => {
                     acc.add_keyword(ctx, "ref");
                     acc.add_keyword(ctx, "mut");
@@ -40,11 +40,11 @@ pub(crate) fn complete_pattern(
         }
     }
 
-    if patctx.record_pat.is_some() {
+    if pattern_ctx.record_pat.is_some() {
         return;
     }
 
-    let refutable = patctx.refutability == PatternRefutability::Refutable;
+    let refutable = pattern_ctx.refutability == PatternRefutability::Refutable;
     let single_variant_enum = |enum_: hir::Enum| ctx.db.enum_data(enum_.into()).variants.len() == 1;
 
     if let Some(hir::Adt::Enum(e)) =
@@ -55,9 +55,9 @@ pub(crate) fn complete_pattern(
                 acc,
                 ctx,
                 e,
-                &patctx.impl_,
+                &pattern_ctx.impl_,
                 |acc, ctx, variant, path| {
-                    acc.add_qualified_variant_pat(ctx, variant, path);
+                    acc.add_qualified_variant_pat(ctx, pattern_ctx, variant, path);
                 },
             );
         }
@@ -69,26 +69,39 @@ pub(crate) fn complete_pattern(
         let add_simple_path = match res {
             hir::ScopeDef::ModuleDef(def) => match def {
                 hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    acc.add_struct_pat(ctx, strukt, Some(name.clone()));
+                    acc.add_struct_pat(ctx, pattern_ctx, strukt, Some(name.clone()));
                     true
                 }
                 hir::ModuleDef::Variant(variant)
                     if refutable || single_variant_enum(variant.parent_enum(ctx.db)) =>
                 {
-                    acc.add_variant_pat(ctx, variant, Some(name.clone()));
+                    acc.add_variant_pat(ctx, pattern_ctx, variant, Some(name.clone()));
                     true
                 }
                 hir::ModuleDef::Adt(hir::Adt::Enum(e)) => refutable || single_variant_enum(e),
                 hir::ModuleDef::Const(..) => refutable,
                 hir::ModuleDef::Module(..) => true,
                 hir::ModuleDef::Macro(mac) if mac.is_fn_like(ctx.db) => {
-                    return acc.add_macro(ctx, mac, name)
+                    return acc.add_macro(
+                        ctx,
+                        &PathCompletionCtx {
+                            has_call_parens: false,
+                            has_macro_bang: false,
+                            qualified: Qualified::No,
+                            parent: None,
+                            kind: crate::context::PathKind::Pat { pat_ctx: pattern_ctx.clone() },
+                            has_type_args: false,
+                            use_tree_parent: false,
+                        },
+                        mac,
+                        name,
+                    )
                 }
                 _ => false,
             },
             hir::ScopeDef::ImplSelfType(impl_) => match impl_.self_ty(ctx.db).as_adt() {
                 Some(hir::Adt::Struct(strukt)) => {
-                    acc.add_struct_pat(ctx, strukt, Some(name.clone()));
+                    acc.add_struct_pat(ctx, pattern_ctx, strukt, Some(name.clone()));
                     true
                 }
                 Some(hir::Adt::Enum(e)) => refutable || single_variant_enum(e),
@@ -111,7 +124,7 @@ pub(crate) fn complete_pattern(
 pub(crate) fn complete_pattern_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
 ) {
     match qualified {
         Qualified::With { resolution: Some(resolution), is_super_chain, .. } => {
@@ -132,7 +145,7 @@ pub(crate) fn complete_pattern_path(
                         };
 
                         if add_resolution {
-                            acc.add_resolution(ctx, name, def);
+                            acc.add_path_resolution(ctx, path_ctx, name, def);
                         }
                     }
                 }
@@ -150,9 +163,9 @@ pub(crate) fn complete_pattern_path(
                         }
                         hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Enum(e))) => {
                             cov_mark::hit!(enum_plain_qualified_use_tree);
-                            e.variants(ctx.db)
-                                .into_iter()
-                                .for_each(|variant| acc.add_enum_variant(ctx, variant, None));
+                            e.variants(ctx.db).into_iter().for_each(|variant| {
+                                acc.add_enum_variant(ctx, path_ctx, variant, None)
+                            });
                             e.ty(ctx.db)
                         }
                         hir::PathResolution::Def(hir::ModuleDef::Adt(hir::Adt::Union(u))) => {
@@ -197,7 +210,7 @@ pub(crate) fn complete_pattern_path(
             ctx.process_all_names(&mut |name, res| {
                 // FIXME: properly filter here
                 if let ScopeDef::ModuleDef(_) = res {
-                    acc.add_resolution(ctx, name, res);
+                    acc.add_path_resolution(ctx, path_ctx, name, res);
                 }
             });
 
diff --git a/crates/ide-completion/src/completions/record.rs b/crates/ide-completion/src/completions/record.rs
index 12c449bf352..9f834e1ca15 100644
--- a/crates/ide-completion/src/completions/record.rs
+++ b/crates/ide-completion/src/completions/record.rs
@@ -1,9 +1,6 @@
 //! Complete fields in record literals and patterns.
 use ide_db::SymbolKind;
-use syntax::{
-    ast::{self, Expr},
-    T,
-};
+use syntax::ast::{self, Expr};
 
 use crate::{
     context::{ExprCtx, PathCompletionCtx, PatternContext, Qualified},
@@ -24,6 +21,7 @@ pub(crate) fn complete_record_expr_fields(
     acc: &mut Completions,
     ctx: &CompletionContext,
     record_expr: &ast::RecordExpr,
+    &dot_prefix: &bool,
 ) {
     let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_expr.clone()));
 
@@ -45,7 +43,7 @@ pub(crate) fn complete_record_expr_fields(
             let missing_fields = ctx.sema.record_literal_missing_fields(record_expr);
 
             add_default_update(acc, ctx, ty, &missing_fields);
-            if ctx.previous_token_is(T![.]) {
+            if dot_prefix {
                 let mut item =
                     CompletionItem::new(CompletionItemKind::Snippet, ctx.source_range(), "..");
                 item.insert_text(".");
diff --git a/crates/ide-completion/src/completions/type.rs b/crates/ide-completion/src/completions/type.rs
index 0f7ca758681..dea0c701b84 100644
--- a/crates/ide-completion/src/completions/type.rs
+++ b/crates/ide-completion/src/completions/type.rs
@@ -13,7 +13,7 @@ use crate::{
 pub(crate) fn complete_type_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, .. }: &PathCompletionCtx,
     location: &TypeLocation,
 ) {
     let _p = profile::span("complete_type_path");
@@ -69,7 +69,7 @@ pub(crate) fn complete_type_path(
                     let module_scope = module.scope(ctx.db, Some(ctx.module));
                     for (name, def) in module_scope {
                         if scope_def_applicable(def) {
-                            acc.add_resolution(ctx, name, def);
+                            acc.add_path_resolution(ctx, path_ctx, name, def);
                         }
                     }
                 }
@@ -154,7 +154,7 @@ pub(crate) fn complete_type_path(
                         _ => false,
                     };
                     if add_resolution {
-                        acc.add_resolution(ctx, name, res);
+                        acc.add_path_resolution(ctx, path_ctx, name, res);
                     }
                 });
                 return;
@@ -178,7 +178,7 @@ pub(crate) fn complete_type_path(
             }
             ctx.process_all_names(&mut |name, def| {
                 if scope_def_applicable(def) {
-                    acc.add_resolution(ctx, name, def);
+                    acc.add_path_resolution(ctx, path_ctx, name, def);
                 }
             });
         }
diff --git a/crates/ide-completion/src/completions/use_.rs b/crates/ide-completion/src/completions/use_.rs
index f262355fc06..2c039d50189 100644
--- a/crates/ide-completion/src/completions/use_.rs
+++ b/crates/ide-completion/src/completions/use_.rs
@@ -13,7 +13,7 @@ use crate::{
 pub(crate) fn complete_use_path(
     acc: &mut Completions,
     ctx: &CompletionContext,
-    PathCompletionCtx { qualified, use_tree_parent, .. }: &PathCompletionCtx,
+    path_ctx @ PathCompletionCtx { qualified, use_tree_parent, .. }: &PathCompletionCtx,
     name_ref: &Option<ast::NameRef>,
 ) {
     match qualified {
@@ -68,7 +68,7 @@ pub(crate) fn complete_use_path(
                         };
 
                         if add_resolution {
-                            let mut builder = Builder::from_resolution(ctx, name, def);
+                            let mut builder = Builder::from_resolution(ctx, path_ctx, name, def);
                             builder.set_relevance(CompletionRelevance {
                                 is_name_already_imported,
                                 ..Default::default()
@@ -81,7 +81,7 @@ pub(crate) fn complete_use_path(
                     cov_mark::hit!(enum_plain_qualified_use_tree);
                     e.variants(ctx.db)
                         .into_iter()
-                        .for_each(|variant| acc.add_enum_variant(ctx, variant, None));
+                        .for_each(|variant| acc.add_enum_variant(ctx, path_ctx, variant, None));
                 }
                 _ => {}
             }
diff --git a/crates/ide-completion/src/context.rs b/crates/ide-completion/src/context.rs
index 8c73709f4ce..441f7ad70bf 100644
--- a/crates/ide-completion/src/context.rs
+++ b/crates/ide-completion/src/context.rs
@@ -259,14 +259,17 @@ pub(super) enum NameRefKind {
     DotAccess(DotAccess),
     /// Position where we are only interested in keyword completions
     Keyword(ast::Item),
-    /// The record expression this nameref is a field of
-    RecordExpr(ast::RecordExpr),
+    /// The record expression this nameref is a field of and whether a dot precedes the completion identifier.
+    RecordExpr {
+        dot_prefix: bool,
+        expr: ast::RecordExpr,
+    },
     Pattern(PatternContext),
 }
 
 /// The identifier we are currently completing.
 #[derive(Debug)]
-pub(super) enum IdentContext {
+pub(super) enum CompletionAnalysis {
     Name(NameContext),
     NameRef(NameRefContext),
     Lifetime(LifetimeContext),
@@ -279,6 +282,7 @@ pub(super) enum IdentContext {
     },
     /// Set if we are currently completing in an unexpanded attribute, this usually implies a builtin attribute like `allow($0)`
     UnexpandedAttrTT {
+        colon_prefix: bool,
         fake_attribute_under_caret: Option<ast::Attr>,
     },
 }
@@ -334,11 +338,6 @@ pub(crate) struct CompletionContext<'a> {
     /// The expected type of what we are completing.
     pub(super) expected_type: Option<Type>,
 
-    // FIXME: This shouldn't exist
-    pub(super) previous_token: Option<SyntaxToken>,
-
-    // We might wanna split these out of CompletionContext
-    pub(super) ident_ctx: IdentContext,
     pub(super) qualifier_ctx: QualifierCtx,
 
     pub(super) locals: FxHashMap<Name, Local>,
@@ -361,11 +360,6 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
-    // FIXME: This shouldn't exist
-    pub(crate) fn previous_token_is(&self, kind: SyntaxKind) -> bool {
-        self.previous_token.as_ref().map_or(false, |tok| tok.kind() == kind)
-    }
-
     pub(crate) fn famous_defs(&self) -> FamousDefs {
         FamousDefs(&self.sema, self.krate)
     }
@@ -465,7 +459,7 @@ impl<'a> CompletionContext<'a> {
         db: &'a RootDatabase,
         position @ FilePosition { file_id, offset }: FilePosition,
         config: &'a CompletionConfig,
-    ) -> Option<CompletionContext<'a>> {
+    ) -> Option<(CompletionContext<'a>, CompletionAnalysis)> {
         let _p = profile::span("CompletionContext::new");
         let sema = Semantics::new(db);
 
@@ -507,19 +501,16 @@ impl<'a> CompletionContext<'a> {
             module,
             expected_name: None,
             expected_type: None,
-            previous_token: None,
-            // dummy value, will be overwritten
-            ident_ctx: IdentContext::UnexpandedAttrTT { fake_attribute_under_caret: None },
             qualifier_ctx: Default::default(),
             locals,
         };
-        ctx.expand_and_fill(
+        let ident_ctx = ctx.expand_and_analyze(
             original_file.syntax().clone(),
             file_with_fake_ident.syntax().clone(),
             offset,
             fake_ident_token,
         )?;
-        Some(ctx)
+        Some((ctx, ident_ctx))
     }
 }
 
diff --git a/crates/ide-completion/src/context/analysis.rs b/crates/ide-completion/src/context/analysis.rs
index 551fa7fb865..7e6c842b1e0 100644
--- a/crates/ide-completion/src/context/analysis.rs
+++ b/crates/ide-completion/src/context/analysis.rs
@@ -11,23 +11,23 @@ use syntax::{
 };
 
 use crate::context::{
-    AttrCtx, CompletionContext, DotAccess, DotAccessKind, ExprCtx, IdentContext, ItemListKind,
-    LifetimeContext, LifetimeKind, NameContext, NameKind, NameRefContext, NameRefKind, ParamKind,
-    PathCompletionCtx, PathKind, PatternContext, PatternRefutability, Qualified, QualifierCtx,
-    TypeAscriptionTarget, TypeLocation, COMPLETION_MARKER,
+    AttrCtx, CompletionAnalysis, CompletionContext, DotAccess, DotAccessKind, ExprCtx,
+    ItemListKind, LifetimeContext, LifetimeKind, NameContext, NameKind, NameRefContext,
+    NameRefKind, ParamKind, PathCompletionCtx, PathKind, PatternContext, PatternRefutability,
+    Qualified, QualifierCtx, TypeAscriptionTarget, TypeLocation, COMPLETION_MARKER,
 };
 
 impl<'a> CompletionContext<'a> {
     /// Expand attributes and macro calls at the current cursor position for both the original file
     /// and fake file repeatedly. As soon as one of the two expansions fail we stop so the original
     /// and speculative states stay in sync.
-    pub(super) fn expand_and_fill(
+    pub(super) fn expand_and_analyze(
         &mut self,
         mut original_file: SyntaxNode,
         mut speculative_file: SyntaxNode,
         mut offset: TextSize,
         mut fake_ident_token: SyntaxToken,
-    ) -> Option<()> {
+    ) -> Option<CompletionAnalysis> {
         let _p = profile::span("CompletionContext::expand_and_fill");
         let mut derive_ctx = None;
 
@@ -157,7 +157,7 @@ impl<'a> CompletionContext<'a> {
             break 'expansion;
         }
 
-        self.fill(&original_file, speculative_file, offset, derive_ctx)
+        self.analyze(&original_file, speculative_file, offset, derive_ctx)
     }
 
     /// Calculate the expected type and name of the cursor position.
@@ -254,7 +254,9 @@ impl<'a> CompletionContext<'a> {
                     // match foo { $0 }
                     // match foo { ..., pat => $0 }
                     ast::MatchExpr(it) => {
-                        let ty = if self.previous_token_is(T![=>]) {
+                        let on_arrow = previous_non_trivia_token(self.token.clone()).map_or(false, |it| T![=>] == it.kind());
+
+                        let ty = if on_arrow {
                             // match foo { ..., pat => $0 }
                             cov_mark::hit!(expected_type_match_arm_body_without_leading_char);
                             cov_mark::hit!(expected_type_match_arm_body_with_leading_char);
@@ -309,13 +311,13 @@ impl<'a> CompletionContext<'a> {
 
     /// Fill the completion context, this is what does semantic reasoning about the surrounding context
     /// of the completion location.
-    fn fill(
+    fn analyze(
         &mut self,
         original_file: &SyntaxNode,
         file_with_fake_ident: SyntaxNode,
         offset: TextSize,
         derive_ctx: Option<(SyntaxNode, SyntaxNode, TextSize, ast::Attr)>,
-    ) -> Option<()> {
+    ) -> Option<CompletionAnalysis> {
         let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased()?;
         let syntax_element = NodeOrToken::Token(fake_ident_token);
         if is_in_token_of_for_loop(syntax_element.clone()) {
@@ -327,9 +329,6 @@ impl<'a> CompletionContext<'a> {
             return None;
         }
 
-        self.previous_token =
-            syntax_element.clone().into_token().and_then(previous_non_trivia_token);
-
         (self.expected_type, self.expected_name) = self.expected_type_and_name();
 
         // Overwrite the path kind for derives
@@ -351,8 +350,7 @@ impl<'a> CompletionContext<'a> {
                             .collect(),
                     };
                 }
-                self.ident_ctx = IdentContext::NameRef(nameref_ctx);
-                return Some(());
+                return Some(CompletionAnalysis::NameRef(nameref_ctx));
             }
             return None;
         }
@@ -360,58 +358,54 @@ impl<'a> CompletionContext<'a> {
         let name_like = match find_node_at_offset(&file_with_fake_ident, offset) {
             Some(it) => it,
             None => {
-                if let Some(original) = ast::String::cast(self.original_token.clone()) {
-                    self.ident_ctx = IdentContext::String {
-                        original,
-                        expanded: ast::String::cast(self.token.clone()),
-                    };
-                } else {
-                    // Fix up trailing whitespace problem
-                    // #[attr(foo = $0
-                    let token = if self.token.kind() == SyntaxKind::WHITESPACE {
-                        self.previous_token.as_ref()?
+                let analysis =
+                    if let Some(original) = ast::String::cast(self.original_token.clone()) {
+                        CompletionAnalysis::String {
+                            original,
+                            expanded: ast::String::cast(self.token.clone()),
+                        }
                     } else {
-                        &self.token
+                        // Fix up trailing whitespace problem
+                        // #[attr(foo = $0
+                        let token =
+                            syntax::algo::skip_trivia_token(self.token.clone(), Direction::Prev)?;
+                        let p = token.parent()?;
+                        if p.kind() == SyntaxKind::TOKEN_TREE
+                            && p.ancestors().any(|it| it.kind() == SyntaxKind::META)
+                        {
+                            let colon_prefix = previous_non_trivia_token(self.token.clone())
+                                .map_or(false, |it| T![:] == it.kind());
+                            CompletionAnalysis::UnexpandedAttrTT {
+                                fake_attribute_under_caret: syntax_element
+                                    .ancestors()
+                                    .find_map(ast::Attr::cast),
+                                colon_prefix,
+                            }
+                        } else {
+                            return None;
+                        }
                     };
-                    let p = token.parent()?;
-                    if p.kind() == SyntaxKind::TOKEN_TREE
-                        && p.ancestors().any(|it| it.kind() == SyntaxKind::META)
-                    {
-                        self.ident_ctx = IdentContext::UnexpandedAttrTT {
-                            fake_attribute_under_caret: syntax_element
-                                .ancestors()
-                                .find_map(ast::Attr::cast),
-                        };
-                    } else {
-                        return None;
-                    }
-                }
-                return Some(());
+                return Some(analysis);
             }
         };
-
-        match name_like {
-            ast::NameLike::Lifetime(lifetime) => {
-                self.ident_ctx = IdentContext::Lifetime(Self::classify_lifetime(
-                    &self.sema,
-                    original_file,
-                    lifetime,
-                )?);
-            }
+        let analysis = match name_like {
+            ast::NameLike::Lifetime(lifetime) => CompletionAnalysis::Lifetime(
+                Self::classify_lifetime(&self.sema, original_file, lifetime)?,
+            ),
             ast::NameLike::NameRef(name_ref) => {
                 let parent = name_ref.syntax().parent()?;
                 let (nameref_ctx, qualifier_ctx) =
                     Self::classify_name_ref(&self.sema, &original_file, name_ref, parent.clone())?;
 
                 self.qualifier_ctx = qualifier_ctx;
-                self.ident_ctx = IdentContext::NameRef(nameref_ctx);
+                CompletionAnalysis::NameRef(nameref_ctx)
             }
             ast::NameLike::Name(name) => {
                 let name_ctx = Self::classify_name(&self.sema, original_file, name)?;
-                self.ident_ctx = IdentContext::Name(name_ctx);
+                CompletionAnalysis::Name(name_ctx)
             }
-        }
-        Some(())
+        };
+        Some(analysis)
     }
 
     fn classify_lifetime(
@@ -493,12 +487,15 @@ impl<'a> CompletionContext<'a> {
             |kind| (NameRefContext { nameref: nameref.clone(), kind }, Default::default());
 
         if let Some(record_field) = ast::RecordExprField::for_field_name(&name_ref) {
+            let dot_prefix = previous_non_trivia_token(name_ref.syntax().clone())
+                .map_or(false, |it| T![.] == it.kind());
+
             return find_node_in_file_compensated(
                 sema,
                 original_file,
                 &record_field.parent_record_lit(),
             )
-            .map(NameRefKind::RecordExpr)
+            .map(|expr| NameRefKind::RecordExpr { expr, dot_prefix })
             .map(make_res);
         }
         if let Some(record_field) = ast::RecordPatField::for_field_name_ref(&name_ref) {
@@ -1180,8 +1177,12 @@ pub(crate) fn is_in_loop_body(node: &SyntaxNode) -> bool {
         .is_some()
 }
 
-fn previous_non_trivia_token(token: SyntaxToken) -> Option<SyntaxToken> {
-    let mut token = token.prev_token();
+fn previous_non_trivia_token(e: impl Into<SyntaxElement>) -> Option<SyntaxToken> {
+    let mut token = match e.into() {
+        SyntaxElement::Node(n) => n.first_token()?,
+        SyntaxElement::Token(t) => t,
+    }
+    .prev_token();
     while let Some(inner) = token {
         if !inner.kind().is_trivia() {
             return Some(inner);
diff --git a/crates/ide-completion/src/context/tests.rs b/crates/ide-completion/src/context/tests.rs
index ce9357270b1..c5557bdafb3 100644
--- a/crates/ide-completion/src/context/tests.rs
+++ b/crates/ide-completion/src/context/tests.rs
@@ -9,7 +9,7 @@ use crate::{
 fn check_expected_type_and_name(ra_fixture: &str, expect: Expect) {
     let (db, pos) = position(ra_fixture);
     let config = TEST_CONFIG;
-    let completion_context = CompletionContext::new(&db, pos, &config).unwrap();
+    let (completion_context, _analysis) = CompletionContext::new(&db, pos, &config).unwrap();
 
     let ty = completion_context
         .expected_type
diff --git a/crates/ide-completion/src/item.rs b/crates/ide-completion/src/item.rs
index 6e5c2a9386f..4774fe9db73 100644
--- a/crates/ide-completion/src/item.rs
+++ b/crates/ide-completion/src/item.rs
@@ -10,8 +10,8 @@ use syntax::{SmolStr, TextRange};
 use text_edit::TextEdit;
 
 use crate::{
-    context::CompletionContext,
-    render::{render_resolution, RenderContext},
+    context::{CompletionContext, PathCompletionCtx},
+    render::{render_path_resolution, RenderContext},
 };
 
 /// `CompletionItem` describes a single completion variant in the editor pop-up.
@@ -434,10 +434,11 @@ pub(crate) struct Builder {
 impl Builder {
     pub(crate) fn from_resolution(
         ctx: &CompletionContext,
+        path_ctx: &PathCompletionCtx,
         local_name: hir::Name,
         resolution: hir::ScopeDef,
     ) -> Self {
-        render_resolution(RenderContext::new(ctx), local_name, resolution)
+        render_path_resolution(RenderContext::new(ctx), path_ctx, local_name, resolution)
     }
 
     pub(crate) fn build(self) -> CompletionItem {
diff --git a/crates/ide-completion/src/lib.rs b/crates/ide-completion/src/lib.rs
index 90e2628439f..fe02f05fd13 100644
--- a/crates/ide-completion/src/lib.rs
+++ b/crates/ide-completion/src/lib.rs
@@ -25,7 +25,8 @@ use text_edit::TextEdit;
 use crate::{
     completions::Completions,
     context::{
-        CompletionContext, IdentContext, NameRefContext, NameRefKind, PathCompletionCtx, PathKind,
+        CompletionAnalysis, CompletionContext, NameRefContext, NameRefKind, PathCompletionCtx,
+        PathKind,
     },
 };
 
@@ -148,12 +149,12 @@ pub fn completions(
     position: FilePosition,
     trigger_character: Option<char>,
 ) -> Option<Completions> {
-    let ctx = &CompletionContext::new(db, position, config)?;
+    let (ctx, analysis) = &CompletionContext::new(db, position, config)?;
     let mut completions = Completions::default();
 
     // prevent `(` from triggering unwanted completion noise
     if trigger_character == Some('(') {
-        if let IdentContext::NameRef(NameRefContext { kind, .. }) = &ctx.ident_ctx {
+        if let CompletionAnalysis::NameRef(NameRefContext { kind, .. }) = &analysis {
             if let NameRefKind::Path(
                 path_ctx @ PathCompletionCtx { kind: PathKind::Vis { has_in_token }, .. },
             ) = kind
@@ -168,23 +169,31 @@ pub fn completions(
     {
         let acc = &mut completions;
 
-        match &ctx.ident_ctx {
-            IdentContext::Name(name_ctx) => completions::complete_name(acc, ctx, name_ctx),
-            IdentContext::NameRef(name_ref_ctx) => {
+        match &analysis {
+            CompletionAnalysis::Name(name_ctx) => completions::complete_name(acc, ctx, name_ctx),
+            CompletionAnalysis::NameRef(name_ref_ctx) => {
                 completions::complete_name_ref(acc, ctx, name_ref_ctx)
             }
-            IdentContext::Lifetime(lifetime_ctx) => {
+            CompletionAnalysis::Lifetime(lifetime_ctx) => {
                 completions::lifetime::complete_label(acc, ctx, lifetime_ctx);
                 completions::lifetime::complete_lifetime(acc, ctx, lifetime_ctx);
             }
-            IdentContext::String { original, expanded: Some(expanded) } => {
+            CompletionAnalysis::String { original, expanded: Some(expanded) } => {
                 completions::extern_abi::complete_extern_abi(acc, ctx, expanded);
                 completions::format_string::format_string(acc, ctx, original, expanded);
             }
-            IdentContext::UnexpandedAttrTT { fake_attribute_under_caret: Some(attr) } => {
-                completions::attribute::complete_known_attribute_input(acc, ctx, attr);
+            CompletionAnalysis::UnexpandedAttrTT {
+                colon_prefix,
+                fake_attribute_under_caret: Some(attr),
+            } => {
+                completions::attribute::complete_known_attribute_input(
+                    acc,
+                    ctx,
+                    colon_prefix,
+                    attr,
+                );
             }
-            IdentContext::UnexpandedAttrTT { .. } | IdentContext::String { .. } => (),
+            CompletionAnalysis::UnexpandedAttrTT { .. } | CompletionAnalysis::String { .. } => (),
         }
     }
 
@@ -196,22 +205,26 @@ pub fn completions(
 pub fn resolve_completion_edits(
     db: &RootDatabase,
     config: &CompletionConfig,
-    position: FilePosition,
+    FilePosition { file_id, offset }: FilePosition,
     imports: impl IntoIterator<Item = (String, String)>,
 ) -> Option<Vec<TextEdit>> {
     let _p = profile::span("resolve_completion_edits");
-    let ctx = CompletionContext::new(db, position, config)?;
-    let position_for_import = &ctx.original_token.parent()?;
-    let scope = ImportScope::find_insert_use_container(position_for_import, &ctx.sema)?;
+    let sema = hir::Semantics::new(db);
+
+    let original_file = sema.parse(file_id);
+    let original_token =
+        syntax::AstNode::syntax(&original_file).token_at_offset(offset).left_biased()?;
+    let position_for_import = &original_token.parent()?;
+    let scope = ImportScope::find_insert_use_container(position_for_import, &sema)?;
 
-    let current_module = ctx.sema.scope(position_for_import)?.module();
+    let current_module = sema.scope(position_for_import)?.module();
     let current_crate = current_module.krate();
     let new_ast = scope.clone_for_update();
     let mut import_insert = TextEdit::builder();
 
     imports.into_iter().for_each(|(full_import_path, imported_name)| {
         let items_with_name = items_locator::items_with_name(
-            &ctx.sema,
+            &sema,
             current_crate,
             NameToImport::exact_case_sensitive(imported_name),
             items_locator::AssocItemSearch::Include,
diff --git a/crates/ide-completion/src/render.rs b/crates/ide-completion/src/render.rs
index c6091645ca8..9c339a13e7b 100644
--- a/crates/ide-completion/src/render.rs
+++ b/crates/ide-completion/src/render.rs
@@ -17,7 +17,7 @@ use ide_db::{
 use syntax::{SmolStr, SyntaxKind, TextRange};
 
 use crate::{
-    context::{IdentContext, NameRefContext, NameRefKind, PathCompletionCtx, PathKind},
+    context::{PathCompletionCtx, PathKind},
     item::{Builder, CompletionRelevanceTypeMatch},
     render::{function::render_fn, literal::render_variant_lit, macro_::render_macro},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionRelevance,
@@ -74,16 +74,6 @@ impl<'a> RenderContext<'a> {
                 .map_or(false, |it| it.kind() == SyntaxKind::MACRO_CALL)
     }
 
-    pub(crate) fn path_is_call(&self) -> bool {
-        matches!(
-            self.completion.ident_ctx,
-            IdentContext::NameRef(NameRefContext {
-                kind: NameRefKind::Path(PathCompletionCtx { has_call_parens: true, .. }),
-                ..
-            })
-        )
-    }
-
     fn is_deprecated(&self, def: impl HasAttrs) -> bool {
         let attrs = def.attrs(self.db());
         attrs.by_key("deprecated").exists()
@@ -163,12 +153,13 @@ pub(crate) fn render_tuple_field(
     item.build()
 }
 
-pub(crate) fn render_resolution(
+pub(crate) fn render_path_resolution(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     local_name: hir::Name,
     resolution: ScopeDef,
 ) -> Builder {
-    render_resolution_(ctx, local_name, None, resolution)
+    render_resolution_(ctx, path_ctx, local_name, None, resolution)
 }
 
 pub(crate) fn render_resolution_simple(
@@ -181,6 +172,7 @@ pub(crate) fn render_resolution_simple(
 
 pub(crate) fn render_resolution_with_import(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     import_edit: LocatedImport,
 ) -> Option<Builder> {
     let resolution = ScopeDef::from(import_edit.original_item);
@@ -190,7 +182,7 @@ pub(crate) fn render_resolution_with_import(
         ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(t)) => t.name(ctx.completion.db),
         _ => item_name(ctx.db(), import_edit.original_item)?,
     };
-    Some(render_resolution_(ctx, local_name, Some(import_edit), resolution))
+    Some(render_resolution_(ctx, path_ctx, local_name, Some(import_edit), resolution))
 }
 
 pub(crate) fn render_type_inference(ty_string: String, ctx: &CompletionContext) -> CompletionItem {
@@ -202,6 +194,7 @@ pub(crate) fn render_type_inference(ty_string: String, ctx: &CompletionContext)
 
 fn render_resolution_(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     local_name: hir::Name,
     import_to_add: Option<LocatedImport>,
     resolution: ScopeDef,
@@ -212,21 +205,61 @@ fn render_resolution_(
     match resolution {
         ScopeDef::ModuleDef(Macro(mac)) => {
             let ctx = ctx.import_to_add(import_to_add);
-            return render_macro(ctx, local_name, mac);
+            return render_macro(ctx, path_ctx, local_name, mac);
         }
         ScopeDef::ModuleDef(Function(func)) => {
             let ctx = ctx.import_to_add(import_to_add);
-            return render_fn(ctx, Some(local_name), func);
+            return render_fn(ctx, path_ctx, Some(local_name), func);
         }
         ScopeDef::ModuleDef(Variant(var)) => {
             let ctx = ctx.clone().import_to_add(import_to_add.clone());
-            if let Some(item) = render_variant_lit(ctx, Some(local_name.clone()), var, None) {
+            if let Some(item) =
+                render_variant_lit(ctx, path_ctx, Some(local_name.clone()), var, None)
+            {
                 return item;
             }
         }
         _ => (),
     }
-    render_resolution_simple_(ctx, local_name, import_to_add, resolution)
+    render_resolution_simple_type(ctx, path_ctx, local_name, import_to_add, resolution)
+}
+
+fn render_resolution_simple_type(
+    ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
+    local_name: hir::Name,
+    import_to_add: Option<LocatedImport>,
+    resolution: ScopeDef,
+) -> Builder {
+    let cap = ctx.snippet_cap();
+    let db = ctx.completion.db;
+    let config = ctx.completion.config;
+    let name = local_name.to_smol_str();
+    let mut item = render_resolution_simple_(ctx, local_name, import_to_add, resolution);
+    // Add `<>` for generic types
+    let type_path_no_ty_args = matches!(
+        path_ctx,
+        PathCompletionCtx { kind: PathKind::Type { .. }, has_type_args: false, .. }
+    ) && config.callable.is_some();
+    if type_path_no_ty_args {
+        if let Some(cap) = cap {
+            let has_non_default_type_params = match resolution {
+                ScopeDef::ModuleDef(hir::ModuleDef::Adt(it)) => it.has_non_default_type_params(db),
+                ScopeDef::ModuleDef(hir::ModuleDef::TypeAlias(it)) => {
+                    it.has_non_default_type_params(db)
+                }
+                _ => false,
+            };
+            if has_non_default_type_params {
+                cov_mark::hit!(inserts_angle_brackets_for_generics);
+                item.lookup_by(name.clone())
+                    .label(SmolStr::from_iter([&name, "<…>"]))
+                    .trigger_call_info()
+                    .insert_snippet(cap, format!("{}<$0>", name));
+            }
+        }
+    }
+    item
 }
 
 fn render_resolution_simple_(
@@ -289,34 +322,6 @@ fn render_resolution_simple_(
         }
     };
 
-    // Add `<>` for generic types
-    let type_path_no_ty_args = matches!(
-        ctx.completion.ident_ctx,
-        IdentContext::NameRef(NameRefContext {
-            kind: NameRefKind::Path(PathCompletionCtx {
-                kind: PathKind::Type { .. },
-                has_type_args: false,
-                ..
-            }),
-            ..
-        })
-    ) && ctx.completion.config.callable.is_some();
-    if type_path_no_ty_args {
-        if let Some(cap) = ctx.snippet_cap() {
-            let has_non_default_type_params = match resolution {
-                ScopeDef::ModuleDef(Adt(it)) => it.has_non_default_type_params(db),
-                ScopeDef::ModuleDef(TypeAlias(it)) => it.has_non_default_type_params(db),
-                _ => false,
-            };
-            if has_non_default_type_params {
-                cov_mark::hit!(inserts_angle_brackets_for_generics);
-                item.lookup_by(local_name.clone())
-                    .label(SmolStr::from_iter([&local_name, "<…>"]))
-                    .trigger_call_info()
-                    .insert_snippet(cap, format!("{}<$0>", local_name));
-            }
-        }
-    }
     item.set_documentation(scope_def_docs(db, resolution))
         .set_deprecated(scope_def_is_deprecated(&ctx, resolution));
 
diff --git a/crates/ide-completion/src/render/function.rs b/crates/ide-completion/src/render/function.rs
index 48539a03b18..3666ee40e2f 100644
--- a/crates/ide-completion/src/render/function.rs
+++ b/crates/ide-completion/src/render/function.rs
@@ -8,8 +8,7 @@ use syntax::SmolStr;
 
 use crate::{
     context::{
-        CompletionContext, DotAccess, DotAccessKind, IdentContext, NameRefContext, NameRefKind,
-        PathCompletionCtx, PathKind, Qualified,
+        CompletionContext, DotAccess, DotAccessKind, PathCompletionCtx, PathKind, Qualified,
     },
     item::{Builder, CompletionItem, CompletionItemKind, CompletionRelevance},
     render::{compute_exact_name_match, compute_ref_match, compute_type_match, RenderContext},
@@ -23,21 +22,54 @@ enum FuncKind {
 
 pub(crate) fn render_fn(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     local_name: Option<hir::Name>,
     func: hir::Function,
 ) -> Builder {
     let _p = profile::span("render_fn");
-    render(ctx, local_name, func, FuncKind::Function)
+    let func_kind = FuncKind::Function;
+    let params = match ctx.completion.config.snippet_cap {
+        Some(_) => {
+            if !matches!(
+                path_ctx,
+                PathCompletionCtx { kind: PathKind::Expr { .. }, has_call_parens: true, .. }
+                    | PathCompletionCtx { kind: PathKind::Use | PathKind::Type { .. }, .. }
+            ) {
+                params(ctx.completion, func, &func_kind, false)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    };
+    render(
+        ctx,
+        local_name,
+        func,
+        func_kind,
+        params,
+        matches!(path_ctx.qualified, Qualified::With { .. }),
+    )
 }
 
 pub(crate) fn render_method(
     ctx: RenderContext<'_>,
+    dot_access: &DotAccess,
     receiver: Option<hir::Name>,
     local_name: Option<hir::Name>,
     func: hir::Function,
 ) -> Builder {
     let _p = profile::span("render_method");
-    render(ctx, local_name, func, FuncKind::Method(receiver))
+    let func_kind = FuncKind::Method(receiver);
+    let params = match ctx.completion.config.snippet_cap {
+        Some(_) => match dot_access {
+            DotAccess { kind: DotAccessKind::Method { has_parens: true }, .. } => None,
+            _ => params(ctx.completion, func, &func_kind, true),
+        },
+        _ => None,
+    };
+
+    render(ctx, local_name, func, func_kind, params, false)
 }
 
 fn render(
@@ -45,6 +77,8 @@ fn render(
     local_name: Option<hir::Name>,
     func: hir::Function,
     func_kind: FuncKind,
+    params: Option<(Option<hir::SelfParam>, Vec<hir::Param>)>,
+    qualified_path: bool,
 ) -> Builder {
     let db = completion.db;
 
@@ -80,16 +114,6 @@ fn render(
         // FIXME For now we don't properly calculate the edits for ref match
         // completions on methods or qualified paths, so we've disabled them.
         // See #8058.
-        let qualified_path = matches!(
-            ctx.completion.ident_ctx,
-            IdentContext::NameRef(NameRefContext {
-                kind: NameRefKind::Path(PathCompletionCtx {
-                    qualified: Qualified::With { .. },
-                    ..
-                }),
-                ..
-            })
-        );
         if matches!(func_kind, FuncKind::Function) && !qualified_path {
             item.ref_match(ref_match);
         }
@@ -100,11 +124,9 @@ fn render(
         .detail(detail(db, func))
         .lookup_by(name.to_smol_str());
 
-    match completion.config.snippet_cap {
-        Some(cap) => {
-            if let Some((self_param, params)) = params(completion, func, &func_kind) {
-                add_call_parens(&mut item, completion, cap, call, self_param, params);
-            }
+    match completion.config.snippet_cap.zip(params) {
+        Some((cap, (self_param, params))) => {
+            add_call_parens(&mut item, completion, cap, call, self_param, params);
         }
         _ => (),
     }
@@ -254,37 +276,12 @@ fn params(
     ctx: &CompletionContext<'_>,
     func: hir::Function,
     func_kind: &FuncKind,
+    has_dot_receiver: bool,
 ) -> Option<(Option<hir::SelfParam>, Vec<hir::Param>)> {
     if ctx.config.callable.is_none() {
         return None;
     }
 
-    let has_dot_receiver = match ctx.ident_ctx {
-        IdentContext::NameRef(NameRefContext {
-            kind:
-                NameRefKind::DotAccess(DotAccess {
-                    kind: DotAccessKind::Method { has_parens: true },
-                    ..
-                }),
-            ..
-        }) => return None,
-        IdentContext::NameRef(NameRefContext {
-            kind: NameRefKind::DotAccess(DotAccess { .. }),
-            ..
-        }) => true,
-        IdentContext::NameRef(NameRefContext {
-            kind:
-                NameRefKind::Path(
-                    PathCompletionCtx {
-                        kind: PathKind::Expr { .. }, has_call_parens: true, ..
-                    }
-                    | PathCompletionCtx { kind: PathKind::Use | PathKind::Type { .. }, .. },
-                ),
-            ..
-        }) => return None,
-        _ => false,
-    };
-
     // Don't add parentheses if the expected type is some function reference.
     if let Some(ty) = &ctx.expected_type {
         // FIXME: check signature matches?
diff --git a/crates/ide-completion/src/render/literal.rs b/crates/ide-completion/src/render/literal.rs
index 042c9742579..b89030990e4 100644
--- a/crates/ide-completion/src/render/literal.rs
+++ b/crates/ide-completion/src/render/literal.rs
@@ -4,9 +4,7 @@ use hir::{db::HirDatabase, Documentation, HasAttrs, StructKind};
 use ide_db::SymbolKind;
 
 use crate::{
-    context::{
-        CompletionContext, IdentContext, NameRefContext, NameRefKind, PathCompletionCtx, PathKind,
-    },
+    context::{CompletionContext, PathCompletionCtx, PathKind},
     item::{Builder, CompletionItem},
     render::{
         compute_ref_match, compute_type_match,
@@ -21,6 +19,7 @@ use crate::{
 
 pub(crate) fn render_variant_lit(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     local_name: Option<hir::Name>,
     variant: hir::Variant,
     path: Option<hir::ModPath>,
@@ -29,11 +28,12 @@ pub(crate) fn render_variant_lit(
     let db = ctx.db();
 
     let name = local_name.unwrap_or_else(|| variant.name(db));
-    render(ctx, Variant::EnumVariant(variant), name, path)
+    render(ctx, path_ctx, Variant::EnumVariant(variant), name, path)
 }
 
 pub(crate) fn render_struct_literal(
     ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     strukt: hir::Struct,
     path: Option<hir::ModPath>,
     local_name: Option<hir::Name>,
@@ -42,29 +42,21 @@ pub(crate) fn render_struct_literal(
     let db = ctx.db();
 
     let name = local_name.unwrap_or_else(|| strukt.name(db));
-    render(ctx, Variant::Struct(strukt), name, path)
+    render(ctx, path_ctx, Variant::Struct(strukt), name, path)
 }
 
 fn render(
     ctx @ RenderContext { completion, .. }: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
     thing: Variant,
     name: hir::Name,
     path: Option<hir::ModPath>,
 ) -> Option<Builder> {
     let db = completion.db;
     let mut kind = thing.kind(db);
-    let should_add_parens = match &completion.ident_ctx {
-        IdentContext::NameRef(NameRefContext {
-            kind: NameRefKind::Path(PathCompletionCtx { has_call_parens: true, .. }),
-            ..
-        }) => false,
-        IdentContext::NameRef(NameRefContext {
-            kind:
-                NameRefKind::Path(PathCompletionCtx {
-                    kind: PathKind::Use | PathKind::Type { .. }, ..
-                }),
-            ..
-        }) => false,
+    let should_add_parens = match &path_ctx {
+        PathCompletionCtx { has_call_parens: true, .. } => false,
+        PathCompletionCtx { kind: PathKind::Use | PathKind::Type { .. }, .. } => false,
         _ => true,
     };
 
diff --git a/crates/ide-completion/src/render/macro_.rs b/crates/ide-completion/src/render/macro_.rs
index 0c9c65f4231..6da7bb3193b 100644
--- a/crates/ide-completion/src/render/macro_.rs
+++ b/crates/ide-completion/src/render/macro_.rs
@@ -5,18 +5,24 @@ use ide_db::SymbolKind;
 use syntax::SmolStr;
 
 use crate::{
-    context::{IdentContext, NameRefContext, NameRefKind, PathCompletionCtx, PathKind},
+    context::{PathCompletionCtx, PathKind},
     item::{Builder, CompletionItem},
     render::RenderContext,
 };
 
-pub(crate) fn render_macro(ctx: RenderContext<'_>, name: hir::Name, macro_: hir::Macro) -> Builder {
+pub(crate) fn render_macro(
+    ctx: RenderContext<'_>,
+    path_ctx: &PathCompletionCtx,
+    name: hir::Name,
+    macro_: hir::Macro,
+) -> Builder {
     let _p = profile::span("render_macro");
-    render(ctx, name, macro_)
+    render(ctx, path_ctx, name, macro_)
 }
 
 fn render(
     ctx @ RenderContext { completion, .. }: RenderContext<'_>,
+    PathCompletionCtx { kind, has_macro_bang, has_call_parens, .. }: &PathCompletionCtx,
     name: hir::Name,
     macro_: hir::Macro,
 ) -> Builder {
@@ -33,13 +39,7 @@ fn render(
     let is_fn_like = macro_.is_fn_like(completion.db);
     let (bra, ket) = if is_fn_like { guess_macro_braces(&name, docs_str) } else { ("", "") };
 
-    let needs_bang = match &completion.ident_ctx {
-        IdentContext::NameRef(NameRefContext {
-            kind: NameRefKind::Path(PathCompletionCtx { kind, has_macro_bang, .. }),
-            ..
-        }) => is_fn_like && *kind != PathKind::Use && !has_macro_bang,
-        _ => is_fn_like,
-    };
+    let needs_bang = is_fn_like && *kind != PathKind::Use && !has_macro_bang;
 
     let mut item = CompletionItem::new(
         SymbolKind::from(macro_.kind(completion.db)),
@@ -53,7 +53,7 @@ fn render(
 
     let name = &*name;
     match ctx.snippet_cap() {
-        Some(cap) if needs_bang && !ctx.path_is_call() => {
+        Some(cap) if needs_bang && !has_call_parens => {
             let snippet = format!("{}!{}$0{}", name, bra, ket);
             let lookup = banged_name(name);
             item.insert_snippet(cap, snippet).lookup_by(lookup);
diff --git a/crates/ide-completion/src/render/pattern.rs b/crates/ide-completion/src/render/pattern.rs
index 74564bb3aae..463d2929550 100644
--- a/crates/ide-completion/src/render/pattern.rs
+++ b/crates/ide-completion/src/render/pattern.rs
@@ -6,16 +6,14 @@ use itertools::Itertools;
 use syntax::SmolStr;
 
 use crate::{
-    context::{
-        IdentContext, NameContext, NameKind, NameRefContext, NameRefKind, ParamKind,
-        PathCompletionCtx, PathKind, PatternContext,
-    },
+    context::{ParamKind, PatternContext},
     render::{variant::visible_fields, RenderContext},
     CompletionItem, CompletionItemKind,
 };
 
 pub(crate) fn render_struct_pat(
     ctx: RenderContext<'_>,
+    pattern_ctx: &PatternContext,
     strukt: hir::Struct,
     local_name: Option<Name>,
 ) -> Option<CompletionItem> {
@@ -30,13 +28,21 @@ pub(crate) fn render_struct_pat(
     }
 
     let name = local_name.unwrap_or_else(|| strukt.name(ctx.db())).to_smol_str();
-    let pat = render_pat(&ctx, &name, strukt.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    let pat = render_pat(
+        &ctx,
+        pattern_ctx,
+        &name,
+        strukt.kind(ctx.db()),
+        &visible_fields,
+        fields_omitted,
+    )?;
 
     Some(build_completion(ctx, name, pat, strukt))
 }
 
 pub(crate) fn render_variant_pat(
     ctx: RenderContext<'_>,
+    pattern_ctx: &PatternContext,
     variant: hir::Variant,
     local_name: Option<Name>,
     path: Option<&hir::ModPath>,
@@ -50,7 +56,14 @@ pub(crate) fn render_variant_pat(
         Some(path) => path.to_string().into(),
         None => local_name.unwrap_or_else(|| variant.name(ctx.db())).to_smol_str(),
     };
-    let pat = render_pat(&ctx, &name, variant.kind(ctx.db()), &visible_fields, fields_omitted)?;
+    let pat = render_pat(
+        &ctx,
+        pattern_ctx,
+        &name,
+        variant.kind(ctx.db()),
+        &visible_fields,
+        fields_omitted,
+    )?;
 
     Some(build_completion(ctx, name, pat, variant))
 }
@@ -75,49 +88,28 @@ fn build_completion(
 
 fn render_pat(
     ctx: &RenderContext<'_>,
+    pattern_ctx: &PatternContext,
     name: &str,
     kind: StructKind,
     fields: &[hir::Field],
     fields_omitted: bool,
 ) -> Option<String> {
-    let has_call_parens = matches!(
-        ctx.completion.ident_ctx,
-        IdentContext::NameRef(NameRefContext {
-            kind: NameRefKind::Path(PathCompletionCtx { has_call_parens: true, .. }),
-            ..
-        })
-    );
     let mut pat = match kind {
-        StructKind::Tuple if !has_call_parens => {
-            render_tuple_as_pat(ctx.snippet_cap(), fields, name, fields_omitted)
-        }
-        StructKind::Record if !has_call_parens => {
+        StructKind::Tuple => render_tuple_as_pat(ctx.snippet_cap(), fields, name, fields_omitted),
+        StructKind::Record => {
             render_record_as_pat(ctx.db(), ctx.snippet_cap(), fields, name, fields_omitted)
         }
         StructKind::Unit => return None,
-        _ => name.to_owned(),
     };
 
-    let needs_ascription = !has_call_parens
-        && matches!(
-            &ctx.completion.ident_ctx,
-            IdentContext::NameRef(NameRefContext {
-                kind: NameRefKind::Path(PathCompletionCtx {
-                    kind: PathKind::Pat {
-                        pat_ctx
-                    },
-                    ..
-                }),
-                ..
-            }) | IdentContext::Name(NameContext {
-                kind: NameKind::IdentPat(pat_ctx), ..}
-            )
-            if matches!(pat_ctx, PatternContext {
-                param_ctx: Some((.., ParamKind::Function(_))),
-                has_type_ascription: false,
-                ..
-            })
-        );
+    let needs_ascription = matches!(
+        pattern_ctx,
+        PatternContext {
+            param_ctx: Some((.., ParamKind::Function(_))),
+            has_type_ascription: false,
+            ..
+        }
+    );
     if needs_ascription {
         pat.push(':');
         pat.push(' ');
diff --git a/crates/ide-completion/src/tests/flyimport.rs b/crates/ide-completion/src/tests/flyimport.rs
index a3bc1025e95..c393e16e7a5 100644
--- a/crates/ide-completion/src/tests/flyimport.rs
+++ b/crates/ide-completion/src/tests/flyimport.rs
@@ -1,22 +1,22 @@
 use expect_test::{expect, Expect};
 
 use crate::{
-    context::{IdentContext, NameContext, NameKind, NameRefKind},
+    context::{CompletionAnalysis, NameContext, NameKind, NameRefKind},
     tests::{check_edit, check_edit_with_config, TEST_CONFIG},
 };
 
 fn check(ra_fixture: &str, expect: Expect) {
     let config = TEST_CONFIG;
     let (db, position) = crate::tests::position(ra_fixture);
-    let ctx = crate::context::CompletionContext::new(&db, position, &config).unwrap();
+    let (ctx, analysis) = crate::context::CompletionContext::new(&db, position, &config).unwrap();
 
     let mut acc = crate::completions::Completions::default();
-    if let IdentContext::Name(NameContext { kind: NameKind::IdentPat(pat_ctx), .. }) =
-        &ctx.ident_ctx
+    if let CompletionAnalysis::Name(NameContext { kind: NameKind::IdentPat(pat_ctx), .. }) =
+        &analysis
     {
         crate::completions::flyimport::import_on_the_fly_pat(&mut acc, &ctx, pat_ctx);
     }
-    if let IdentContext::NameRef(name_ref_ctx) = &ctx.ident_ctx {
+    if let CompletionAnalysis::NameRef(name_ref_ctx) = &analysis {
         match &name_ref_ctx.kind {
             NameRefKind::Path(path) => {
                 crate::completions::flyimport::import_on_the_fly_path(&mut acc, &ctx, path);