12 files changed, 354 insertions, 314 deletions

diff --git a/crates/ide_completion/src/completions/flyimport.rs b/crates/ide_completion/src/completions/flyimport.rs
index 9d5b61562..be9cfbded 100644
--- a/crates/ide_completion/src/completions/flyimport.rs
+++ b/crates/ide_completion/src/completions/flyimport.rs
@@ -110,13 +110,7 @@ pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext)
     if !ctx.config.enable_imports_on_the_fly {
         return None;
     }
-    if ctx.use_item_syntax.is_some()
-        || ctx.attribute_under_caret.is_some()
-        || ctx.mod_declaration_under_caret.is_some()
-        || ctx.record_lit_syntax.is_some()
-        || ctx.has_trait_parent
-        || ctx.has_impl_parent
-    {
+    if ctx.use_item_syntax.is_some() || ctx.is_path_disallowed() {
         return None;
     }
     let potential_import_name = {
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 61b667104..58e35bad9 100644
--- a/crates/ide_completion/src/completions/keyword.rs
+++ b/crates/ide_completion/src/completions/keyword.rs
@@ -2,7 +2,7 @@
 
 use std::iter;
 
-use syntax::SyntaxKind;
+use syntax::{SyntaxKind, T};
 
 use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
 
@@ -49,78 +49,75 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         return;
     }
 
-    let has_trait_or_impl_parent = ctx.has_impl_parent || ctx.has_trait_parent;
-    if ctx.trait_as_prev_sibling || ctx.impl_as_prev_sibling {
+    let has_trait_or_impl_parent = ctx.has_impl_or_trait_parent();
+    let has_block_expr_parent = ctx.has_block_expr_parent();
+    let has_item_list_parent = ctx.has_item_list_parent();
+    if ctx.has_impl_or_trait_prev_sibling() {
         add_keyword(ctx, acc, "where", "where ");
         return;
     }
-    if ctx.unsafe_is_prev {
-        if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
-            add_keyword(ctx, acc, "fn", "fn $0() {}")
+    if ctx.previous_token_is(T![unsafe]) {
+        if has_item_list_parent || has_block_expr_parent {
+            add_keyword(ctx, acc, "fn", "fn $1($2) {\n    $0\n}")
         }
 
-        if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
-            add_keyword(ctx, acc, "trait", "trait $0 {}");
-            add_keyword(ctx, acc, "impl", "impl $0 {}");
+        if has_item_list_parent || has_block_expr_parent {
+            add_keyword(ctx, acc, "trait", "trait $1 {\n    $0\n}");
+            add_keyword(ctx, acc, "impl", "impl $1 {\n    $0\n}");
         }
 
         return;
     }
-    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
-    {
-        add_keyword(ctx, acc, "fn", "fn $0() {}");
+    if has_item_list_parent || has_trait_or_impl_parent || has_block_expr_parent {
+        add_keyword(ctx, acc, "fn", "fn $1($2) {\n    $0\n}");
     }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+    if has_item_list_parent || has_block_expr_parent {
         add_keyword(ctx, acc, "use", "use ");
-        add_keyword(ctx, acc, "impl", "impl $0 {}");
-        add_keyword(ctx, acc, "trait", "trait $0 {}");
+        add_keyword(ctx, acc, "impl", "impl $1 {\n    $0\n}");
+        add_keyword(ctx, acc, "trait", "trait $1 {\n    $0\n}");
     }
 
-    if ctx.has_item_list_or_source_file_parent {
-        add_keyword(ctx, acc, "enum", "enum $0 {}");
+    if has_item_list_parent {
+        add_keyword(ctx, acc, "enum", "enum $1 {\n    $0\n}");
         add_keyword(ctx, acc, "struct", "struct $0");
-        add_keyword(ctx, acc, "union", "union $0 {}");
+        add_keyword(ctx, acc, "union", "union $1 {\n    $0\n}");
     }
 
     if ctx.is_expr {
-        add_keyword(ctx, acc, "match", "match $0 {}");
-        add_keyword(ctx, acc, "while", "while $0 {}");
-        add_keyword(ctx, acc, "while let", "while let $1 = $0 {}");
-        add_keyword(ctx, acc, "loop", "loop {$0}");
-        add_keyword(ctx, acc, "if", "if $0 {}");
-        add_keyword(ctx, acc, "if let", "if let $1 = $0 {}");
-        add_keyword(ctx, acc, "for", "for $1 in $0 {}");
+        add_keyword(ctx, acc, "match", "match $1 {\n    $0\n}");
+        add_keyword(ctx, acc, "while", "while $1 {\n    $0\n}");
+        add_keyword(ctx, acc, "while let", "while let $1 = $2 {\n    $0\n}");
+        add_keyword(ctx, acc, "loop", "loop {\n    $0\n}");
+        add_keyword(ctx, acc, "if", "if $1 {\n    $0\n}");
+        add_keyword(ctx, acc, "if let", "if let $1 = $2 {\n    $0\n}");
+        add_keyword(ctx, acc, "for", "for $1 in $2 {\n    $0\n}");
     }
 
-    if ctx.if_is_prev || ctx.block_expr_parent {
+    if ctx.previous_token_is(T![if]) || ctx.previous_token_is(T![while]) || has_block_expr_parent {
         add_keyword(ctx, acc, "let", "let ");
     }
 
     if ctx.after_if {
-        add_keyword(ctx, acc, "else", "else {$0}");
-        add_keyword(ctx, acc, "else if", "else if $0 {}");
+        add_keyword(ctx, acc, "else", "else {\n    $0\n}");
+        add_keyword(ctx, acc, "else if", "else if $1 {\n    $0\n}");
     }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+    if has_item_list_parent || has_block_expr_parent {
         add_keyword(ctx, acc, "mod", "mod $0");
     }
-    if ctx.bind_pat_parent || ctx.ref_pat_parent {
+    if ctx.has_ident_or_ref_pat_parent() {
         add_keyword(ctx, acc, "mut", "mut ");
     }
-    if ctx.has_item_list_or_source_file_parent || has_trait_or_impl_parent || ctx.block_expr_parent
-    {
+    if has_item_list_parent || has_trait_or_impl_parent || has_block_expr_parent {
         add_keyword(ctx, acc, "const", "const ");
         add_keyword(ctx, acc, "type", "type ");
     }
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+    if has_item_list_parent || has_block_expr_parent {
         add_keyword(ctx, acc, "static", "static ");
     };
-    if (ctx.has_item_list_or_source_file_parent) || ctx.block_expr_parent {
+    if has_item_list_parent || has_block_expr_parent {
         add_keyword(ctx, acc, "extern", "extern ");
     }
-    if ctx.has_item_list_or_source_file_parent
-        || has_trait_or_impl_parent
-        || ctx.block_expr_parent
-        || ctx.is_match_arm
+    if has_item_list_parent || has_trait_or_impl_parent || has_block_expr_parent || ctx.is_match_arm
     {
         add_keyword(ctx, acc, "unsafe", "unsafe ");
     }
@@ -133,7 +130,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
             add_keyword(ctx, acc, "break", "break");
         }
     }
-    if ctx.has_item_list_or_source_file_parent || ctx.has_impl_parent | ctx.has_field_list_parent {
+    if has_item_list_parent || ctx.has_impl_parent() || ctx.has_field_list_parent() {
         add_keyword(ctx, acc, "pub(crate)", "pub(crate) ");
         add_keyword(ctx, acc, "pub", "pub ");
     }
@@ -141,7 +138,7 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     if !ctx.is_trivial_path {
         return;
     }
-    let fn_def = match &ctx.function_syntax {
+    let fn_def = match &ctx.function_def {
         Some(it) => it,
         None => return,
     };
@@ -342,7 +339,9 @@ mod tests {
         check_edit(
             "else",
             r#"fn quux() { if true { () } $0 }"#,
-            r#"fn quux() { if true { () } else {$0} }"#,
+            r#"fn quux() { if true { () } else {
+    $0
+} }"#,
         );
     }
 
@@ -646,7 +645,9 @@ fn foo() {
 fn main() { let x = $0 }
 "#,
             r#"
-fn main() { let x = match $0 {}; }
+fn main() { let x = match $1 {
+    $0
+}; }
 "#,
         );
 
@@ -660,7 +661,9 @@ fn main() {
 "#,
             r#"
 fn main() {
-    let x = if $0 {};
+    let x = if $1 {
+    $0
+};
     let y = 92;
 }
 "#,
@@ -676,7 +679,9 @@ fn main() {
 "#,
             r#"
 fn main() {
-    let x = loop {$0};
+    let x = loop {
+    $0
+};
     bar();
 }
 "#,
diff --git a/crates/ide_completion/src/completions/lifetime.rs b/crates/ide_completion/src/completions/lifetime.rs
index 5eeddf7a4..5f6285b84 100644
--- a/crates/ide_completion/src/completions/lifetime.rs
+++ b/crates/ide_completion/src/completions/lifetime.rs
@@ -8,19 +8,24 @@ pub(crate) fn complete_lifetime(acc: &mut Completions, ctx: &CompletionContext)
     if !ctx.lifetime_allowed {
         return;
     }
+    let lp_string;
     let param_lifetime = match (
         &ctx.lifetime_syntax,
         ctx.lifetime_param_syntax.as_ref().and_then(|lp| lp.lifetime()),
     ) {
         (Some(lt), Some(lp)) if lp == lt.clone() => return,
-        (Some(_), Some(lp)) => Some(lp.to_string()),
+        (Some(_), Some(lp)) => {
+            lp_string = lp.to_string();
+            Some(&lp_string)
+        }
         _ => None,
     };
 
     ctx.scope.process_all_names(&mut |name, res| {
         if let ScopeDef::GenericParam(hir::GenericParam::LifetimeParam(_)) = res {
-            if param_lifetime != Some(name.to_string()) {
-                acc.add_resolution(ctx, name.to_string(), &res);
+            let name = name.to_string();
+            if param_lifetime != Some(&name) {
+                acc.add_resolution(ctx, name, &res);
             }
         }
     });
diff --git a/crates/ide_completion/src/completions/macro_in_item_position.rs b/crates/ide_completion/src/completions/macro_in_item_position.rs
index 2be299ac2..c5e377500 100644
--- a/crates/ide_completion/src/completions/macro_in_item_position.rs
+++ b/crates/ide_completion/src/completions/macro_in_item_position.rs
@@ -4,13 +4,15 @@ use crate::{CompletionContext, Completions};
 
 pub(crate) fn complete_macro_in_item_position(acc: &mut Completions, ctx: &CompletionContext) {
     // Show only macros in top level.
-    if ctx.is_new_item {
-        ctx.scope.process_all_names(&mut |name, res| {
-            if let hir::ScopeDef::MacroDef(mac) = res {
-                acc.add_macro(ctx, Some(name.to_string()), mac);
-            }
-        })
+    if !ctx.is_new_item {
+        return;
     }
+
+    ctx.scope.process_all_names(&mut |name, res| {
+        if let hir::ScopeDef::MacroDef(mac) = res {
+            acc.add_macro(ctx, Some(name.to_string()), mac);
+        }
+    })
 }
 
 #[cfg(test)]
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index 8dc9ab73c..b84e9a967 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -1,17 +1,15 @@
 //! Completes constants and paths in patterns.
 
-use crate::{CompletionContext, Completions};
+use crate::{context::PatternRefutability, CompletionContext, Completions};
 
 /// Completes constants and paths in patterns.
 pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_pat_binding_or_const || ctx.is_irrefutable_pat_binding) {
-        return;
-    }
-    if ctx.record_pat_syntax.is_some() {
-        return;
-    }
+    let refutable = match ctx.is_pat_or_const {
+        Some(it) => it == PatternRefutability::Refutable,
+        None => return,
+    };
 
-    if !ctx.is_irrefutable_pat_binding {
+    if refutable {
         if let Some(hir::Adt::Enum(e)) =
             ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
         {
@@ -31,14 +29,14 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                     acc.add_struct_pat(ctx, *strukt, Some(name.clone()));
                     true
                 }
-                hir::ModuleDef::Variant(variant) if !ctx.is_irrefutable_pat_binding => {
+                hir::ModuleDef::Variant(variant) if refutable => {
                     acc.add_variant_pat(ctx, *variant, Some(name.clone()));
                     true
                 }
                 hir::ModuleDef::Adt(hir::Adt::Enum(..))
                 | hir::ModuleDef::Variant(..)
                 | hir::ModuleDef::Const(..)
-                | hir::ModuleDef::Module(..) => !ctx.is_irrefutable_pat_binding,
+                | hir::ModuleDef::Module(..) => refutable,
                 _ => false,
             },
             hir::ScopeDef::MacroDef(_) => true,
@@ -47,7 +45,7 @@ pub(crate) fn complete_pattern(acc: &mut Completions, ctx: &CompletionContext) {
                     acc.add_struct_pat(ctx, strukt, Some(name.clone()));
                     true
                 }
-                Some(hir::Adt::Enum(_)) => !ctx.is_irrefutable_pat_binding,
+                Some(hir::Adt::Enum(_)) => refutable,
                 _ => true,
             },
             _ => false,
@@ -402,4 +400,31 @@ impl Foo {
             "#]],
         )
     }
+
+    #[test]
+    fn completes_in_record_field_pat() {
+        check_snippet(
+            r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar: $0 }: Foo) {}
+"#,
+            expect![[r#"
+                bn Foo Foo { bar$1 }$0
+                bn Bar Bar($1)$0
+            "#]],
+        )
+    }
+
+    #[test]
+    fn skips_in_record_field_pat_name() {
+        check_snippet(
+            r#"
+struct Foo { bar: Bar }
+struct Bar(u32);
+fn outer(Foo { bar$0 }: Foo) {}
+"#,
+            expect![[r#""#]],
+        )
+    }
 }
diff --git a/crates/ide_completion/src/completions/qualified_path.rs b/crates/ide_completion/src/completions/qualified_path.rs
index eedb44873..ed48f61af 100644
--- a/crates/ide_completion/src/completions/qualified_path.rs
+++ b/crates/ide_completion/src/completions/qualified_path.rs
@@ -7,21 +7,19 @@ use syntax::AstNode;
 use crate::{CompletionContext, Completions};
 
 pub(crate) fn complete_qualified_path(acc: &mut Completions, ctx: &CompletionContext) {
+    if ctx.is_path_disallowed() {
+        return;
+    }
     let path = match &ctx.path_qual {
         Some(path) => path.clone(),
         None => return,
     };
 
-    if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
-        return;
-    }
-
-    let context_module = ctx.scope.module();
-
     let resolution = match ctx.sema.resolve_path(&path) {
         Some(res) => res,
         None => return,
     };
+    let context_module = ctx.scope.module();
 
     // Add associated types on type parameters and `Self`.
     resolution.assoc_type_shorthand_candidates(ctx.db, |_, alias| {
diff --git a/crates/ide_completion/src/completions/record.rs b/crates/ide_completion/src/completions/record.rs
index 40006fb74..e1526b70b 100644
--- a/crates/ide_completion/src/completions/record.rs
+++ b/crates/ide_completion/src/completions/record.rs
@@ -13,20 +13,19 @@ pub(crate) fn complete_record(acc: &mut Completions, ctx: &CompletionContext) ->
             let ty = ctx.sema.type_of_expr(&Expr::RecordExpr(record_lit.clone()));
             let default_trait = FamousDefs(&ctx.sema, ctx.krate).core_default_Default();
             let impl_default_trait = default_trait
-                .and_then(|default_trait| ty.map(|ty| ty.impls_trait(ctx.db, default_trait, &[])))
-                .unwrap_or(false);
+                .zip(ty)
+                .map_or(false, |(default_trait, ty)| ty.impls_trait(ctx.db, default_trait, &[]));
 
             let missing_fields = ctx.sema.record_literal_missing_fields(record_lit);
             if impl_default_trait && !missing_fields.is_empty() {
                 let completion_text = "..Default::default()";
-                let completion_text = completion_text
-                    .strip_prefix(ctx.token.to_string().as_str())
-                    .unwrap_or(completion_text);
                 let mut item = CompletionItem::new(
                     CompletionKind::Snippet,
                     ctx.source_range(),
-                    "..Default::default()",
+                    completion_text,
                 );
+                let completion_text =
+                    completion_text.strip_prefix(ctx.token.text()).unwrap_or(completion_text);
                 item.insert_text(completion_text).kind(SymbolKind::Field);
                 item.add_to(acc);
             }
diff --git a/crates/ide_completion/src/completions/snippet.rs b/crates/ide_completion/src/completions/snippet.rs
index 14cfb61de..defc25b00 100644
--- a/crates/ide_completion/src/completions/snippet.rs
+++ b/crates/ide_completion/src/completions/snippet.rs
@@ -14,7 +14,7 @@ fn snippet(ctx: &CompletionContext, cap: SnippetCap, label: &str, snippet: &str)
 }
 
 pub(crate) fn complete_expr_snippet(acc: &mut Completions, ctx: &CompletionContext) {
-    if !(ctx.is_trivial_path && ctx.function_syntax.is_some()) {
+    if !(ctx.is_trivial_path && ctx.function_def.is_some()) {
         return;
     }
     let cap = match ctx.config.snippet_cap {
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 7875500c1..046a393ae 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -9,11 +9,7 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
     if !ctx.is_trivial_path {
         return;
     }
-    if ctx.record_lit_syntax.is_some()
-        || ctx.record_pat_syntax.is_some()
-        || ctx.attribute_under_caret.is_some()
-        || ctx.mod_declaration_under_caret.is_some()
-    {
+    if ctx.is_path_disallowed() {
         return;
     }
 
@@ -86,7 +82,7 @@ fn quux(x: Option<Enum>) {
     }
 }
 "#,
-            expect![[""]],
+            expect![[r#""#]],
         );
     }
 
@@ -102,7 +98,7 @@ fn quux(x: Option<Enum>) {
     }
 }
 "#,
-            expect![[""]],
+            expect![[r#""#]],
         );
     }
 
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 2f3fb1710..66577df94 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -1,29 +1,53 @@
 //! See `CompletionContext` structure.
 
 use hir::{Local, ScopeDef, Semantics, SemanticsScope, Type};
-use ide_db::base_db::{FilePosition, SourceDatabase};
-use ide_db::{call_info::ActiveParameter, RootDatabase};
+use ide_db::{
+    base_db::{FilePosition, SourceDatabase},
+    call_info::ActiveParameter,
+    RootDatabase,
+};
 use syntax::{
     algo::find_node_at_offset,
     ast::{self, NameOrNameRef, NameOwner},
     match_ast, AstNode, NodeOrToken,
-    SyntaxKind::*,
-    SyntaxNode, SyntaxToken, TextRange, TextSize,
+    SyntaxKind::{self, *},
+    SyntaxNode, SyntaxToken, TextRange, TextSize, T,
 };
-
 use text_edit::Indel;
 
 use crate::{
     patterns::{
-        fn_is_prev, for_is_prev2, has_bind_pat_parent, has_block_expr_parent,
-        has_field_list_parent, has_impl_as_prev_sibling, has_impl_parent,
-        has_item_list_or_source_file_parent, has_ref_parent, has_trait_as_prev_sibling,
-        has_trait_parent, if_is_prev, inside_impl_trait_block, is_in_loop_body, is_match_arm,
-        unsafe_is_prev,
+        for_is_prev2, has_bind_pat_parent, has_block_expr_parent, has_field_list_parent,
+        has_impl_parent, has_item_list_or_source_file_parent, has_prev_sibling, has_ref_parent,
+        has_trait_parent, inside_impl_trait_block, is_in_loop_body, is_match_arm, previous_token,
     },
     CompletionConfig,
 };
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum PatternRefutability {
+    Refutable,
+    Irrefutable,
+}
+
+/// Direct parent container of the cursor position
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum ImmediateLocation {
+    Impl,
+    Trait,
+    RecordFieldList,
+    RefPatOrExpr,
+    IdentPat,
+    BlockExpr,
+    ItemList,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum PrevSibling {
+    Trait,
+    Impl,
+}
+
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
@@ -41,23 +65,33 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) expected_name: Option<NameOrNameRef>,
     pub(super) expected_type: Option<Type>,
     pub(super) name_ref_syntax: Option<ast::NameRef>,
-    pub(super) lifetime_syntax: Option<ast::Lifetime>,
-    pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
-    pub(super) function_syntax: Option<ast::Fn>,
+
     pub(super) use_item_syntax: Option<ast::Use>,
+
+    /// The parent function of the cursor position if it exists.
+    pub(super) function_def: Option<ast::Fn>,
+    /// The parent impl of the cursor position if it exists.
+    pub(super) impl_def: Option<ast::Impl>,
+
+    /// RecordExpr the token is a field of
     pub(super) record_lit_syntax: Option<ast::RecordExpr>,
+    /// RecordPat the token is a field of
     pub(super) record_pat_syntax: Option<ast::RecordPat>,
-    pub(super) record_field_syntax: Option<ast::RecordExprField>,
-    pub(super) impl_def: Option<ast::Impl>,
+
+    // potentially set if we are completing a lifetime
+    pub(super) lifetime_syntax: Option<ast::Lifetime>,
+    pub(super) lifetime_param_syntax: Option<ast::LifetimeParam>,
     pub(super) lifetime_allowed: bool,
+    pub(super) is_label_ref: bool,
+
+    // potentially set if we are completing a name
+    pub(super) is_pat_or_const: Option<PatternRefutability>,
+    pub(super) is_param: bool,
+
+    pub(super) completion_location: Option<ImmediateLocation>,
+
     /// FIXME: `ActiveParameter` is string-based, which is very very wrong
     pub(super) active_parameter: Option<ActiveParameter>,
-    pub(super) is_param: bool,
-    pub(super) is_label_ref: bool,
-    /// If a name-binding or reference to a const in a pattern.
-    /// Irrefutable patterns (like let) are excluded.
-    pub(super) is_pat_binding_or_const: bool,
-    pub(super) is_irrefutable_pat_binding: bool,
     /// A single-indent path, like `foo`. `::foo` should not be considered a trivial path.
     pub(super) is_trivial_path: bool,
     /// If not a trivial path, the prefix (qualifier).
@@ -82,26 +116,17 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) has_type_args: bool,
     pub(super) attribute_under_caret: Option<ast::Attr>,
     pub(super) mod_declaration_under_caret: Option<ast::Module>,
-    pub(super) unsafe_is_prev: bool,
-    pub(super) if_is_prev: bool,
-    pub(super) block_expr_parent: bool,
-    pub(super) bind_pat_parent: bool,
-    pub(super) ref_pat_parent: bool,
+    pub(super) locals: Vec<(String, Local)>,
+
+    // keyword patterns
+    pub(super) previous_token: Option<SyntaxToken>,
+    pub(super) prev_sibling: Option<PrevSibling>,
     pub(super) in_loop_body: bool,
-    pub(super) has_trait_parent: bool,
-    pub(super) has_impl_parent: bool,
-    pub(super) inside_impl_trait_block: bool,
-    pub(super) has_field_list_parent: bool,
-    pub(super) trait_as_prev_sibling: bool,
-    pub(super) impl_as_prev_sibling: bool,
     pub(super) is_match_arm: bool,
-    pub(super) has_item_list_or_source_file_parent: bool,
-    pub(super) for_is_prev2: bool,
-    pub(super) fn_is_prev: bool,
     pub(super) incomplete_let: bool,
-    pub(super) locals: Vec<(String, Local)>,
-}
 
+    no_completion_required: bool,
+}
 impl<'a> CompletionContext<'a> {
     pub(super) fn new(
         db: &'a RootDatabase,
@@ -149,17 +174,15 @@ impl<'a> CompletionContext<'a> {
             name_ref_syntax: None,
             lifetime_syntax: None,
             lifetime_param_syntax: None,
-            function_syntax: None,
+            function_def: None,
             use_item_syntax: None,
             record_lit_syntax: None,
             record_pat_syntax: None,
-            record_field_syntax: None,
             impl_def: None,
             active_parameter: ActiveParameter::at(db, position),
             is_label_ref: false,
             is_param: false,
-            is_pat_binding_or_const: false,
-            is_irrefutable_pat_binding: false,
+            is_pat_or_const: None,
             is_trivial_path: false,
             path_qual: None,
             after_if: false,
@@ -175,22 +198,12 @@ impl<'a> CompletionContext<'a> {
             has_type_args: false,
             attribute_under_caret: None,
             mod_declaration_under_caret: None,
-            unsafe_is_prev: false,
-            if_is_prev: false,
-            block_expr_parent: false,
-            bind_pat_parent: false,
-            ref_pat_parent: false,
+            previous_token: None,
             in_loop_body: false,
-            has_trait_parent: false,
-            has_impl_parent: false,
-            inside_impl_trait_block: false,
-            has_field_list_parent: false,
-            trait_as_prev_sibling: false,
-            impl_as_prev_sibling: false,
+            completion_location: None,
+            prev_sibling: None,
             is_match_arm: false,
-            has_item_list_or_source_file_parent: false,
-            for_is_prev2: false,
-            fn_is_prev: false,
+            no_completion_required: false,
             incomplete_let: false,
             locals,
         };
@@ -245,7 +258,7 @@ impl<'a> CompletionContext<'a> {
     ///   Exception for this case is `impl Trait for Foo`, where we would like to hint trait method names.
     /// - `for _ i$0` -- obviously, it'll be "in" keyword.
     pub(crate) fn no_completion_required(&self) -> bool {
-        (self.fn_is_prev && !self.inside_impl_trait_block) || self.for_is_prev2
+        self.no_completion_required
     }
 
     /// The range of the identifier that is being completed.
@@ -264,33 +277,92 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
+    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 has_impl_or_trait_parent(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::Trait) | Some(ImmediateLocation::Impl)
+        )
+    }
+
+    pub(crate) fn has_block_expr_parent(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::BlockExpr))
+    }
+
+    pub(crate) fn has_item_list_parent(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::ItemList))
+    }
+
+    pub(crate) fn has_ident_or_ref_pat_parent(&self) -> bool {
+        matches!(
+            self.completion_location,
+            Some(ImmediateLocation::IdentPat) | Some(ImmediateLocation::RefPatOrExpr)
+        )
+    }
+
+    pub(crate) fn has_impl_parent(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::Impl))
+    }
+
+    pub(crate) fn has_field_list_parent(&self) -> bool {
+        matches!(self.completion_location, Some(ImmediateLocation::RecordFieldList))
+    }
+
+    pub(crate) fn has_impl_or_trait_prev_sibling(&self) -> bool {
+        self.prev_sibling.is_some()
+    }
+
+    pub(crate) fn is_path_disallowed(&self) -> bool {
+        self.record_lit_syntax.is_some()
+            || self.record_pat_syntax.is_some()
+            || self.attribute_under_caret.is_some()
+            || self.mod_declaration_under_caret.is_some()
+            || self.has_impl_or_trait_parent()
+    }
+
     fn fill_keyword_patterns(&mut self, file_with_fake_ident: &SyntaxNode, offset: TextSize) {
         let fake_ident_token = file_with_fake_ident.token_at_offset(offset).right_biased().unwrap();
         let syntax_element = NodeOrToken::Token(fake_ident_token);
-        self.block_expr_parent = has_block_expr_parent(syntax_element.clone());
-        self.unsafe_is_prev = unsafe_is_prev(syntax_element.clone());
-        self.if_is_prev = if_is_prev(syntax_element.clone());
-        self.bind_pat_parent = has_bind_pat_parent(syntax_element.clone());
-        self.ref_pat_parent = has_ref_parent(syntax_element.clone());
+        self.previous_token = previous_token(syntax_element.clone());
         self.in_loop_body = is_in_loop_body(syntax_element.clone());
-        self.has_trait_parent = has_trait_parent(syntax_element.clone());
-        self.has_impl_parent = has_impl_parent(syntax_element.clone());
-        self.inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
-        self.has_field_list_parent = has_field_list_parent(syntax_element.clone());
-        self.impl_as_prev_sibling = has_impl_as_prev_sibling(syntax_element.clone());
-        self.trait_as_prev_sibling = has_trait_as_prev_sibling(syntax_element.clone());
         self.is_match_arm = is_match_arm(syntax_element.clone());
-        self.has_item_list_or_source_file_parent =
-            has_item_list_or_source_file_parent(syntax_element.clone());
+        if has_prev_sibling(syntax_element.clone(), IMPL) {
+            self.prev_sibling = Some(PrevSibling::Impl)
+        } else if has_prev_sibling(syntax_element.clone(), TRAIT) {
+            self.prev_sibling = Some(PrevSibling::Trait)
+        }
+
+        if has_block_expr_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::BlockExpr);
+        } else if has_bind_pat_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::IdentPat);
+        } else if has_ref_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::RefPatOrExpr);
+        } else if has_impl_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::Impl);
+        } else if has_field_list_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::RecordFieldList);
+        } else if has_trait_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::Trait);
+        } else if has_item_list_or_source_file_parent(syntax_element.clone()) {
+            self.completion_location = Some(ImmediateLocation::ItemList);
+        }
+
         self.mod_declaration_under_caret =
             find_node_at_offset::<ast::Module>(&file_with_fake_ident, offset)
                 .filter(|module| module.item_list().is_none());
-        self.for_is_prev2 = for_is_prev2(syntax_element.clone());
-        self.fn_is_prev = fn_is_prev(syntax_element.clone());
         self.incomplete_let =
             syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
                 it.syntax().text_range().end() == syntax_element.text_range().end()
             });
+
+        let inside_impl_trait_block = inside_impl_trait_block(syntax_element.clone());
+        let fn_is_prev = self.previous_token_is(T![fn]);
+        let for_is_prev2 = for_is_prev2(syntax_element.clone());
+        self.no_completion_required = (fn_is_prev && !inside_impl_trait_block) || for_is_prev2;
     }
 
     fn fill_impl_def(&mut self) {
@@ -412,67 +484,19 @@ impl<'a> CompletionContext<'a> {
         self.expected_type = expected_type;
         self.expected_name = expected_name;
         self.attribute_under_caret = find_node_at_offset(&file_with_fake_ident, offset);
-
-        if let Some(lifetime) = find_node_at_offset::<ast::Lifetime>(&file_with_fake_ident, offset)
-        {
-            self.classify_lifetime(original_file, lifetime, offset);
-        }
-
-        // First, let's try to complete a reference to some declaration.
-        if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(&file_with_fake_ident, offset) {
-            // Special case, `trait T { fn foo(i_am_a_name_ref) {} }`.
-            // See RFC#1685.
-            if is_node::<ast::Param>(name_ref.syntax()) {
-                self.is_param = true;
-                return;
-            }
-            // FIXME: remove this (V) duplication and make the check more precise
-            if name_ref.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
-                self.record_pat_syntax =
-                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
-            }
-            self.classify_name_ref(original_file, name_ref, offset);
-        }
-
-        // Otherwise, see if this is a declaration. We can use heuristics to
-        // suggest declaration names, see `CompletionKind::Magic`.
-        if let Some(name) = find_node_at_offset::<ast::Name>(&file_with_fake_ident, offset) {
-            if let Some(bind_pat) = name.syntax().ancestors().find_map(ast::IdentPat::cast) {
-                self.is_pat_binding_or_const = true;
-                if bind_pat.at_token().is_some()
-                    || bind_pat.ref_token().is_some()
-                    || bind_pat.mut_token().is_some()
-                {
-                    self.is_pat_binding_or_const = false;
-                }
-                if bind_pat.syntax().parent().and_then(ast::RecordPatFieldList::cast).is_some() {
-                    self.is_pat_binding_or_const = false;
-                }
-                if let Some(Some(pat)) = bind_pat.syntax().ancestors().find_map(|node| {
-                    match_ast! {
-                        match node {
-                            ast::LetStmt(it) => Some(it.pat()),
-                            ast::Param(it) => Some(it.pat()),
-                            _ => None,
-                        }
-                    }
-                }) {
-                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
-                        self.is_pat_binding_or_const = false;
-                        self.is_irrefutable_pat_binding = true;
-                    }
-                }
-
-                self.fill_impl_def();
+        let name_like = match find_node_at_offset(&&file_with_fake_ident, offset) {
+            Some(it) => it,
+            None => return,
+        };
+        match name_like {
+            ast::NameLike::Lifetime(lifetime) => {
+                self.classify_lifetime(original_file, lifetime, offset);
             }
-            if is_node::<ast::Param>(name.syntax()) {
-                self.is_param = true;
-                return;
+            ast::NameLike::NameRef(name_ref) => {
+                self.classify_name_ref(original_file, name_ref, offset);
             }
-            // FIXME: remove this (^) duplication and make the check more precise
-            if name.syntax().ancestors().find_map(ast::RecordPatFieldList::cast).is_some() {
-                self.record_pat_syntax =
-                    self.sema.find_node_at_offset_with_macros(&original_file, offset);
+            ast::NameLike::Name(name) => {
+                self.classify_name(original_file, name, offset);
             }
         }
     }
@@ -506,22 +530,71 @@ impl<'a> CompletionContext<'a> {
         }
     }
 
+    fn classify_name(&mut self, original_file: &SyntaxNode, name: ast::Name, offset: TextSize) {
+        if let Some(bind_pat) = name.syntax().parent().and_then(ast::IdentPat::cast) {
+            self.is_pat_or_const = Some(PatternRefutability::Refutable);
+            // if any of these is here our bind pat can't be a const pat anymore
+            let complex_ident_pat = bind_pat.at_token().is_some()
+                || bind_pat.ref_token().is_some()
+                || bind_pat.mut_token().is_some();
+            if complex_ident_pat {
+                self.is_pat_or_const = None;
+            } else {
+                let irrefutable_pat = bind_pat.syntax().ancestors().find_map(|node| {
+                    match_ast! {
+                        match node {
+                            ast::LetStmt(it) => Some(it.pat()),
+                            ast::Param(it) => Some(it.pat()),
+                            _ => None,
+                        }
+                    }
+                });
+                if let Some(Some(pat)) = irrefutable_pat {
+                    // This check is here since we could be inside a pattern in the initializer expression of the let statement.
+                    if pat.syntax().text_range().contains_range(bind_pat.syntax().text_range()) {
+                        self.is_pat_or_const = Some(PatternRefutability::Irrefutable);
+                    }
+                }
+
+                let is_name_in_field_pat = bind_pat
+                    .syntax()
+                    .parent()
+                    .and_then(ast::RecordPatField::cast)
+                    .map_or(false, |pat_field| pat_field.name_ref().is_none());
+                if is_name_in_field_pat {
+                    self.is_pat_or_const = None;
+                }
+            }
+
+            self.fill_impl_def();
+        }
+        self.is_param |= is_node::<ast::Param>(name.syntax());
+        if ast::RecordPatField::for_field_name(&name).is_some() {
+            self.record_pat_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
+        }
+    }
+
     fn classify_name_ref(
         &mut self,
         original_file: &SyntaxNode,
         name_ref: ast::NameRef,
         offset: TextSize,
     ) {
-        self.name_ref_syntax =
-            find_node_at_offset(original_file, name_ref.syntax().text_range().start());
-        let name_range = name_ref.syntax().text_range();
+        self.fill_impl_def();
         if ast::RecordExprField::for_field_name(&name_ref).is_some() {
             self.record_lit_syntax =
                 self.sema.find_node_at_offset_with_macros(original_file, offset);
         }
+        if ast::RecordPatField::for_field_name_ref(&name_ref).is_some() {
+            self.record_pat_syntax =
+                self.sema.find_node_at_offset_with_macros(&original_file, offset);
+        }
 
-        self.fill_impl_def();
+        self.name_ref_syntax =
+            find_node_at_offset(original_file, name_ref.syntax().text_range().start());
 
+        let name_range = name_ref.syntax().text_range();
         let top_node = name_ref
             .syntax()
             .ancestors()
@@ -529,31 +602,20 @@ impl<'a> CompletionContext<'a> {
             .last()
             .unwrap();
 
-        match top_node.parent().map(|it| it.kind()) {
-            Some(SOURCE_FILE) | Some(ITEM_LIST) => {
-                self.is_new_item = true;
-                return;
-            }
-            _ => (),
+        if matches!(top_node.parent().map(|it| it.kind()), Some(SOURCE_FILE) | Some(ITEM_LIST)) {
+            self.is_new_item = true;
+            return;
         }
 
         self.use_item_syntax =
             self.sema.token_ancestors_with_macros(self.token.clone()).find_map(ast::Use::cast);
 
-        self.function_syntax = self
+        self.function_def = self
             .sema
             .token_ancestors_with_macros(self.token.clone())
             .take_while(|it| it.kind() != SOURCE_FILE && it.kind() != MODULE)
             .find_map(ast::Fn::cast);
 
-        self.record_field_syntax = self
-            .sema
-            .token_ancestors_with_macros(self.token.clone())
-            .take_while(|it| {
-                it.kind() != SOURCE_FILE && it.kind() != MODULE && it.kind() != CALL_EXPR
-            })
-            .find_map(ast::RecordExprField::cast);
-
         let parent = match name_ref.syntax().parent() {
             Some(it) => it,
             None => return,
@@ -626,6 +688,7 @@ impl<'a> CompletionContext<'a> {
                 }
             }
         }
+
         if let Some(field_expr) = ast::FieldExpr::cast(parent.clone()) {
             // The receiver comes before the point of insertion of the fake
             // ident, so it should have the same range in the non-modified file
@@ -643,6 +706,7 @@ impl<'a> CompletionContext<'a> {
                     false
                 };
         }
+
         if let Some(method_call_expr) = ast::MethodCallExpr::cast(parent) {
             // As above
             self.dot_receiver = method_call_expr
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index d82564381..04f2c532b 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -4,7 +4,7 @@ use syntax::{
     algo::non_trivia_sibling,
     ast::{self, LoopBodyOwner},
     match_ast, AstNode, Direction, NodeOrToken, SyntaxElement,
-    SyntaxKind::*,
+    SyntaxKind::{self, *},
     SyntaxNode, SyntaxToken, T,
 };
 
@@ -73,6 +73,7 @@ fn test_has_block_expr_parent() {
 pub(crate) fn has_bind_pat_parent(element: SyntaxElement) -> bool {
     element.ancestors().any(|it| it.kind() == IDENT_PAT)
 }
+
 #[test]
 fn test_has_bind_pat_parent() {
     check_pattern_is_applicable(r"fn my_fn(m$0) {}", has_bind_pat_parent);
@@ -91,11 +92,10 @@ fn test_has_ref_parent() {
 }
 
 pub(crate) fn has_item_list_or_source_file_parent(element: SyntaxElement) -> bool {
-    let ancestor = not_same_range_ancestor(element);
-    if !ancestor.is_some() {
-        return true;
+    match not_same_range_ancestor(element) {
+        Some(it) => it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST,
+        None => true,
     }
-    ancestor.filter(|it| it.kind() == SOURCE_FILE || it.kind() == ITEM_LIST).is_some()
 }
 #[test]
 fn test_has_item_list_or_source_file_parent() {
@@ -115,36 +115,8 @@ fn test_is_match_arm() {
     check_pattern_is_applicable(r"fn my_fn() { match () { () => m$0 } }", is_match_arm);
 }
 
-pub(crate) fn unsafe_is_prev(element: SyntaxElement) -> bool {
-    element
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![unsafe])
-        .is_some()
-}
-#[test]
-fn test_unsafe_is_prev() {
-    check_pattern_is_applicable(r"unsafe i$0", unsafe_is_prev);
-}
-
-pub(crate) fn if_is_prev(element: SyntaxElement) -> bool {
-    element
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![if])
-        .is_some()
-}
-
-pub(crate) fn fn_is_prev(element: SyntaxElement) -> bool {
-    element
-        .into_token()
-        .and_then(|it| previous_non_trivia_token(it))
-        .filter(|it| it.kind() == T![fn])
-        .is_some()
-}
-#[test]
-fn test_fn_is_prev() {
-    check_pattern_is_applicable(r"fn l$0", fn_is_prev);
+pub(crate) fn previous_token(element: SyntaxElement) -> Option<SyntaxToken> {
+    element.into_token().and_then(|it| previous_non_trivia_token(it))
 }
 
 /// Check if the token previous to the previous one is `for`.
@@ -162,47 +134,30 @@ fn test_for_is_prev2() {
     check_pattern_is_applicable(r"for i i$0", for_is_prev2);
 }
 
-#[test]
-fn test_if_is_prev() {
-    check_pattern_is_applicable(r"if l$0", if_is_prev);
-}
-
-pub(crate) fn has_trait_as_prev_sibling(element: SyntaxElement) -> bool {
-    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == TRAIT).is_some()
-}
-#[test]
-fn test_has_trait_as_prev_sibling() {
-    check_pattern_is_applicable(r"trait A w$0 {}", has_trait_as_prev_sibling);
-}
-
-pub(crate) fn has_impl_as_prev_sibling(element: SyntaxElement) -> bool {
-    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == IMPL).is_some()
+pub(crate) fn has_prev_sibling(element: SyntaxElement, kind: SyntaxKind) -> bool {
+    previous_sibling_or_ancestor_sibling(element).filter(|it| it.kind() == kind).is_some()
 }
 #[test]
 fn test_has_impl_as_prev_sibling() {
-    check_pattern_is_applicable(r"impl A w$0 {}", has_impl_as_prev_sibling);
+    check_pattern_is_applicable(r"impl A w$0 {}", |it| has_prev_sibling(it, IMPL));
 }
 
 pub(crate) fn is_in_loop_body(element: SyntaxElement) -> bool {
-    for node in element.ancestors() {
-        if node.kind() == FN || node.kind() == CLOSURE_EXPR {
-            break;
-        }
-        let loop_body = match_ast! {
-            match node {
-                ast::ForExpr(it) => it.loop_body(),
-                ast::WhileExpr(it) => it.loop_body(),
-                ast::LoopExpr(it) => it.loop_body(),
-                _ => None,
-            }
-        };
-        if let Some(body) = loop_body {
-            if body.syntax().text_range().contains_range(element.text_range()) {
-                return true;
-            }
-        }
-    }
-    false
+    element
+        .ancestors()
+        .take_while(|it| it.kind() != FN && it.kind() != CLOSURE_EXPR)
+        .find_map(|it| {
+            let loop_body = match_ast! {
+                match it {
+                    ast::ForExpr(it) => it.loop_body(),
+                    ast::WhileExpr(it) => it.loop_body(),
+                    ast::LoopExpr(it) => it.loop_body(),
+                    _ => None,
+                }
+            };
+            loop_body.filter(|it| it.syntax().text_range().contains_range(element.text_range()))
+        })
+        .is_some()
 }
 
 fn not_same_range_ancestor(element: SyntaxElement) -> Option<SyntaxNode> {
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index d7f96b864..91300c56e 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -187,10 +187,7 @@ impl<'a> Render<'a> {
             ScopeDef::ModuleDef(Function(func)) => {
                 return render_fn(self.ctx, import_to_add, Some(local_name), *func);
             }
-            ScopeDef::ModuleDef(Variant(_))
-                if self.ctx.completion.is_pat_binding_or_const
-                    | self.ctx.completion.is_irrefutable_pat_binding =>
-            {
+            ScopeDef::ModuleDef(Variant(_)) if self.ctx.completion.is_pat_or_const.is_some() => {
                 CompletionItemKind::SymbolKind(SymbolKind::Variant)
             }
             ScopeDef::ModuleDef(Variant(var)) => {