21 files changed, 276 insertions, 239 deletions

diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs
index 3f940124c..37a050415 100644
--- a/crates/hir/src/source_analyzer.rs
+++ b/crates/hir/src/source_analyzer.rs
@@ -308,7 +308,11 @@ impl SourceAnalyzer {
             }
         }
 
-        resolve_hir_path_(db, &self.resolver, &hir_path, prefer_value_ns)
+        if parent().map_or(false, |it| ast::Visibility::can_cast(it.kind())) {
+            resolve_hir_path_qualifier(db, &self.resolver, &hir_path)
+        } else {
+            resolve_hir_path_(db, &self.resolver, &hir_path, prefer_value_ns)
+        }
     }
 
     pub(crate) fn record_literal_missing_fields(
diff --git a/crates/hir_expand/src/eager.rs b/crates/hir_expand/src/eager.rs
index e165b9c5f..1464320ba 100644
--- a/crates/hir_expand/src/eager.rs
+++ b/crates/hir_expand/src/eager.rs
@@ -197,7 +197,7 @@ fn eager_macro_recur(
     macro_resolver: &dyn Fn(ast::Path) -> Option<MacroDefId>,
     mut diagnostic_sink: &mut dyn FnMut(mbe::ExpandError),
 ) -> Result<SyntaxNode, ErrorEmitted> {
-    let original = curr.value.clone().clone_for_update();
+    let original = curr.value.clone_for_update();
 
     let children = original.descendants().filter_map(ast::MacroCall::cast);
     let mut replacements = Vec::new();
diff --git a/crates/hir_ty/src/infer/coerce.rs b/crates/hir_ty/src/infer/coerce.rs
index 765a02b1c..03b97e7db 100644
--- a/crates/hir_ty/src/infer/coerce.rs
+++ b/crates/hir_ty/src/infer/coerce.rs
@@ -76,17 +76,17 @@ impl<'a> InferenceContext<'a> {
         // way around first would mean we make the type variable `!`, instead of
         // just marking it as possibly diverging.
         if self.coerce(&ty2, &ty1) {
-            ty1.clone()
+            ty1
         } else if self.coerce(&ty1, &ty2) {
-            ty2.clone()
+            ty2
         } else {
             if let Some(id) = id {
                 self.result
                     .type_mismatches
-                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2.clone() });
+                    .insert(id.into(), TypeMismatch { expected: ty1.clone(), actual: ty2 });
             }
             cov_mark::hit!(coerce_merge_fail_fallback);
-            ty1.clone()
+            ty1
         }
     }
 
@@ -183,7 +183,7 @@ impl<'a> InferenceContext<'a> {
         // details of coercion errors though, so I think it's useful to leave
         // the structure like it is.
 
-        let canonicalized = self.canonicalize(from_ty.clone());
+        let canonicalized = self.canonicalize(from_ty);
         let autoderef = autoderef::autoderef(
             self.db,
             self.resolver.krate(),
@@ -389,7 +389,7 @@ impl<'a> InferenceContext<'a> {
                 // The CoerceUnsized trait should have two generic params: Self and T.
                 return Err(TypeError);
             }
-            b.push(coerce_from.clone()).push(to_ty.clone()).build()
+            b.push(coerce_from).push(to_ty.clone()).build()
         };
 
         let goal: InEnvironment<DomainGoal> =
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 79a732106..97507305c 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -44,7 +44,7 @@ impl<'a> InferenceContext<'a> {
             if !could_unify {
                 self.result.type_mismatches.insert(
                     tgt_expr.into(),
-                    TypeMismatch { expected: expected_ty.clone(), actual: ty.clone() },
+                    TypeMismatch { expected: expected_ty, actual: ty.clone() },
                 );
             }
         }
@@ -57,15 +57,14 @@ impl<'a> InferenceContext<'a> {
         let ty = self.infer_expr_inner(expr, &expected);
         let ty = if let Some(target) = expected.only_has_type(&mut self.table) {
             if !self.coerce(&ty, &target) {
-                self.result.type_mismatches.insert(
-                    expr.into(),
-                    TypeMismatch { expected: target.clone(), actual: ty.clone() },
-                );
+                self.result
+                    .type_mismatches
+                    .insert(expr.into(), TypeMismatch { expected: target, actual: ty.clone() });
                 // Return actual type when type mismatch.
                 // This is needed for diagnostic when return type mismatch.
                 ty
             } else {
-                target.clone()
+                target
             }
         } else {
             ty
diff --git a/crates/hir_ty/src/infer/pat.rs b/crates/hir_ty/src/infer/pat.rs
index 9c8e3b6ae..83e0a7a9e 100644
--- a/crates/hir_ty/src/infer/pat.rs
+++ b/crates/hir_ty/src/infer/pat.rs
@@ -196,7 +196,7 @@ impl<'a> InferenceContext<'a> {
                 let inner_ty = if let Some(subpat) = subpat {
                     self.infer_pat(*subpat, &expected, default_bm)
                 } else {
-                    expected.clone()
+                    expected
                 };
                 let inner_ty = self.insert_type_vars_shallow(inner_ty);
 
@@ -266,10 +266,9 @@ impl<'a> InferenceContext<'a> {
         // use a new type variable if we got error type here
         let ty = self.insert_type_vars_shallow(ty);
         if !self.unify(&ty, &expected) {
-            self.result.type_mismatches.insert(
-                pat.into(),
-                TypeMismatch { expected: expected.clone(), actual: ty.clone() },
-            );
+            self.result
+                .type_mismatches
+                .insert(pat.into(), TypeMismatch { expected: expected, actual: ty.clone() });
         }
         self.write_pat_ty(pat, ty.clone());
         ty
diff --git a/crates/ide/src/annotations.rs b/crates/ide/src/annotations.rs
index 5ebe7fd0e..b0c4ed60a 100644
--- a/crates/ide/src/annotations.rs
+++ b/crates/ide/src/annotations.rs
@@ -5,7 +5,7 @@ use ide_db::{
     helpers::visit_file_defs,
     RootDatabase,
 };
-use syntax::{ast::NameOwner, AstNode, TextRange, TextSize};
+use syntax::{ast::NameOwner, AstNode, TextRange};
 
 use crate::{
     fn_references::find_all_methods,
@@ -80,26 +80,26 @@ pub(crate) fn annotations(
 
     visit_file_defs(&Semantics::new(db), file_id, &mut |def| match def {
         Either::Left(def) => {
-            let node = match def {
+            let range = match def {
                 hir::ModuleDef::Const(konst) => {
-                    konst.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    konst.source(db).and_then(|node| name_range(&node, file_id))
                 }
                 hir::ModuleDef::Trait(trait_) => {
-                    trait_.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    trait_.source(db).and_then(|node| name_range(&node, file_id))
                 }
                 hir::ModuleDef::Adt(hir::Adt::Struct(strukt)) => {
-                    strukt.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    strukt.source(db).and_then(|node| name_range(&node, file_id))
                 }
                 hir::ModuleDef::Adt(hir::Adt::Enum(enum_)) => {
-                    enum_.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    enum_.source(db).and_then(|node| name_range(&node, file_id))
                 }
                 hir::ModuleDef::Adt(hir::Adt::Union(union)) => {
-                    union.source(db).and_then(|node| range_and_position_of(&node, file_id))
+                    union.source(db).and_then(|node| name_range(&node, file_id))
                 }
                 _ => None,
             };
-            let (offset, range) = match node {
-                Some(node) => node,
+            let (range, offset) = match range {
+                Some(range) => (range, range.start()),
                 None => return,
             };
 
@@ -122,18 +122,12 @@ pub(crate) fn annotations(
                 });
             }
 
-            fn range_and_position_of<T: NameOwner>(
-                node: &InFile<T>,
-                file_id: FileId,
-            ) -> Option<(TextSize, TextRange)> {
-                if node.file_id != file_id.into() {
+            fn name_range<T: NameOwner>(node: &InFile<T>, file_id: FileId) -> Option<TextRange> {
+                if node.file_id == file_id.into() {
+                    node.value.name().map(|it| it.syntax().text_range())
+                } else {
                     // Node is outside the file we are adding annotations to (e.g. macros).
                     None
-                } else {
-                    Some((
-                        node.value.name()?.syntax().text_range().start(),
-                        node.value.syntax().text_range(),
-                    ))
                 }
             }
         }
@@ -141,13 +135,15 @@ pub(crate) fn annotations(
     });
 
     if config.annotate_method_references {
-        annotations.extend(find_all_methods(db, file_id).into_iter().map(|method| Annotation {
-            range: method.range,
-            kind: AnnotationKind::HasReferences {
-                position: FilePosition { file_id, offset: method.range.start() },
-                data: None,
+        annotations.extend(find_all_methods(db, file_id).into_iter().map(
+            |FileRange { file_id, range }| Annotation {
+                range,
+                kind: AnnotationKind::HasReferences {
+                    position: FilePosition { file_id, offset: range.start() },
+                    data: None,
+                },
             },
-        }));
+        ));
     }
 
     annotations
@@ -266,7 +262,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..22,
+                        range: 6..10,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
@@ -287,7 +283,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 24..48,
+                        range: 30..36,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
@@ -370,7 +366,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasImpls {
                             position: FilePosition {
                                 file_id: FileId(
@@ -384,7 +380,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
@@ -478,7 +474,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasImpls {
                             position: FilePosition {
                                 file_id: FileId(
@@ -502,7 +498,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
@@ -529,7 +525,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 14..34,
+                        range: 20..31,
                         kind: HasImpls {
                             position: FilePosition {
                                 file_id: FileId(
@@ -553,7 +549,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 14..34,
+                        range: 20..31,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
@@ -712,7 +708,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasImpls {
                             position: FilePosition {
                                 file_id: FileId(
@@ -736,7 +732,7 @@ fn main() {
                         },
                     },
                     Annotation {
-                        range: 0..12,
+                        range: 7..11,
                         kind: HasReferences {
                             position: FilePosition {
                                 file_id: FileId(
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index cf1a8bad7..7f7f4d38a 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -49,6 +49,30 @@ pub struct HlRange {
 // The general rule is that a reference to an entity gets colored the same way as the entity itself.
 // We also give special modifier for `mut` and `&mut` local variables.
 //
+// .Token Modifiers
+//
+// Token modifiers allow to style some elements in the source code more precisely.
+//
+// Rust-analyzer currently emits the following token modifiers:
+//
+// [horizontal]
+// associated:: Emitted for associated items.
+// async:: Emitted for async functions and the `async` and `await` keywords.
+// attribute:: Emitted for tokens inside attributes.
+// callable:: Emitted for locals whose types implements one of the `Fn*` traits.
+// consuming:: Emitted for locals that are being consumed when use in a function call.
+// controlFlow:: Emitted for control-flow related tokens, this includes the `?` operator.
+// declaration:: Emitted for names of definitions, like `foo` in `fn foo() {}`.
+// documentation:: Emitted for documentation comments.
+// injected:: Emitted for doc-string injected highlighting like rust source blocks in documentation.
+// intraDocLink:: Emitted for intra doc links in doc-strings.
+// library:: Emitted for items that are defined outside of the current crate.
+// mutable:: Emitted for mutable locals and statics.
+// static:: Emitted for "static" functions, also known as functions that do not take a `self` param.
+// trait:: Emitted for associated trait items.
+// unsafe:: Emitted for unsafe operations, like unsafe function calls, as well as the `unsafe` token.
+//
+//
 // image::https://user-images.githubusercontent.com/48062697/113164457-06cfb980-9239-11eb-819b-0f93e646acf8.png[]
 // image::https://user-images.githubusercontent.com/48062697/113187625-f7f50100-9250-11eb-825e-91c58f236071.png[]
 pub(crate) fn highlight(
diff --git a/crates/ide/src/syntax_highlighting/highlight.rs b/crates/ide/src/syntax_highlighting/highlight.rs
index b4a3d39c9..9503c936d 100644
--- a/crates/ide/src/syntax_highlighting/highlight.rs
+++ b/crates/ide/src/syntax_highlighting/highlight.rs
@@ -71,7 +71,7 @@ pub(super) fn element(
         }
         NAME_REF => {
             let name_ref = element.into_node().and_then(ast::NameRef::cast).unwrap();
-            highlight_func_by_name_ref(sema, &name_ref).unwrap_or_else(|| {
+            highlight_func_by_name_ref(sema, krate, &name_ref).unwrap_or_else(|| {
                 let is_self = name_ref.self_token().is_some();
                 let h = match NameRefClass::classify(sema, &name_ref) {
                     Some(name_kind) => match name_kind {
@@ -108,7 +108,7 @@ pub(super) fn element(
                         NameRefClass::FieldShorthand { .. } => SymbolKind::Field.into(),
                     },
                     None if syntactic_name_ref_highlighting => {
-                        highlight_name_ref_by_syntax(name_ref, sema)
+                        highlight_name_ref_by_syntax(name_ref, sema, krate)
                     }
                     None => HlTag::UnresolvedReference.into(),
                 };
@@ -434,19 +434,23 @@ fn highlight_def(db: &RootDatabase, krate: Option<hir::Crate>, def: Definition)
 
 fn highlight_func_by_name_ref(
     sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
     name_ref: &ast::NameRef,
 ) -> Option<Highlight> {
     let mc = name_ref.syntax().parent().and_then(ast::MethodCallExpr::cast)?;
-    highlight_method_call(sema, &mc)
+    highlight_method_call(sema, krate, &mc)
 }
 
 fn highlight_method_call(
     sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
     method_call: &ast::MethodCallExpr,
 ) -> Option<Highlight> {
     let func = sema.resolve_method_call(&method_call)?;
+
     let mut h = SymbolKind::Function.into();
     h |= HlMod::Associated;
+
     if func.is_unsafe(sema.db) || sema.is_unsafe_method_call(&method_call) {
         h |= HlMod::Unsafe;
     }
@@ -454,7 +458,10 @@ fn highlight_method_call(
         h |= HlMod::Async;
     }
     if func.as_assoc_item(sema.db).and_then(|it| it.containing_trait(sema.db)).is_some() {
-        h |= HlMod::Trait
+        h |= HlMod::Trait;
+    }
+    if Some(func.module(sema.db).krate()) != krate {
+        h |= HlMod::Library;
     }
 
     if let Some(self_param) = func.self_param(sema.db) {
@@ -503,7 +510,11 @@ fn highlight_name_by_syntax(name: ast::Name) -> Highlight {
     tag.into()
 }
 
-fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabase>) -> Highlight {
+fn highlight_name_ref_by_syntax(
+    name: ast::NameRef,
+    sema: &Semantics<RootDatabase>,
+    krate: Option<hir::Crate>,
+) -> Highlight {
     let default = HlTag::UnresolvedReference;
 
     let parent = match name.syntax().parent() {
@@ -514,7 +525,7 @@ fn highlight_name_ref_by_syntax(name: ast::NameRef, sema: &Semantics<RootDatabas
     match parent.kind() {
         METHOD_CALL_EXPR => {
             return ast::MethodCallExpr::cast(parent)
-                .and_then(|it| highlight_method_call(sema, &it))
+                .and_then(|it| highlight_method_call(sema, krate, &it))
                 .unwrap_or_else(|| SymbolKind::Function.into());
         }
         FIELD_EXPR => {
diff --git a/crates/ide/src/syntax_highlighting/tags.rs b/crates/ide/src/syntax_highlighting/tags.rs
index e94f17cd9..9d481deae 100644
--- a/crates/ide/src/syntax_highlighting/tags.rs
+++ b/crates/ide/src/syntax_highlighting/tags.rs
@@ -37,6 +37,8 @@ pub enum HlTag {
     None,
 }
 
+// Don't forget to adjust the feature description in crates/ide/src/syntax_highlighting.rs.
+// And make sure to use the lsp strings used when converting to the protocol in crates\rust-analyzer\src\semantic_tokens.rs, not the names of the variants here.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[repr(u8)]
 pub enum HlMod {
diff --git a/crates/ide/src/syntax_highlighting/test_data/highlighting.html b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
index 055d21109..0264e39a3 100644
--- a/crates/ide/src/syntax_highlighting/test_data/highlighting.html
+++ b/crates/ide/src/syntax_highlighting/test_data/highlighting.html
@@ -258,7 +258,7 @@ pre                 { color: #DCDCCC; background: #3F3F3F; font-size: 22px; padd
 
     <span class="keyword">let</span> <span class="variable declaration">control_flow</span> <span class="operator">=</span> <span class="module library">foo</span><span class="operator">::</span><span class="function library">identity</span><span class="parenthesis">(</span><span class="module library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Continue</span><span class="parenthesis">)</span><span class="semicolon">;</span>
 
-    <span class="keyword control">if</span> <span class="keyword">let</span> <span class="module library">foo</span><span class="operator">::</span><span class="enum library">ControlFlow</span><span class="operator">::</span><span class="enum_variant library">Die</span> <span class="operator">=</span> <span class="variable">control_flow</span> <span class="brace">{</span>
+    <span class="keyword control">if</span> <span class="variable">control_flow</span><span class="operator">.</span><span class="function associated consuming library">should_die</span><span class="parenthesis">(</span><span class="parenthesis">)</span> <span class="brace">{</span>
         foo::<span class="macro">die!</span><span class="parenthesis">(</span><span class="parenthesis">)</span><span class="semicolon">;</span>
     <span class="brace">}</span>
 <span class="brace">}</span>
diff --git a/crates/ide/src/syntax_highlighting/tests.rs b/crates/ide/src/syntax_highlighting/tests.rs
index be4447ebb..662b53481 100644
--- a/crates/ide/src/syntax_highlighting/tests.rs
+++ b/crates/ide/src/syntax_highlighting/tests.rs
@@ -232,7 +232,7 @@ fn use_foo_items() {
 
     let control_flow = foo::identity(foo::ControlFlow::Continue);
 
-    if let foo::ControlFlow::Die = control_flow {
+    if control_flow.should_die() {
         foo::die!();
     }
 }
@@ -249,6 +249,12 @@ pub enum ControlFlow {
     Die,
 }
 
+impl ControlFlow {
+    pub fn should_die(self) -> bool {
+        matches!(self, ControlFlow::Die)
+    }
+}
+
 pub fn identity<T>(x: T) -> T { x }
 
 pub mod consts {
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 79cb08d69..6da880b52 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -55,7 +55,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
     let refs_in_target = find_refs_in_mod(ctx, target_module, Some(current_module))?;
     let imported_defs = find_imported_defs(ctx, star)?;
 
-    let target = parent.clone().either(|n| n.syntax().clone(), |n| n.syntax().clone());
+    let target = parent.either(|n| n.syntax().clone(), |n| n.syntax().clone());
     acc.add(
         AssistId("expand_glob_import", AssistKind::RefactorRewrite),
         "Expand glob import",
diff --git a/crates/ide_completion/src/completions/keyword.rs b/crates/ide_completion/src/completions/keyword.rs
index 61b667104..fa6bcc955 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};
 
@@ -54,51 +54,51 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
         add_keyword(ctx, acc, "where", "where ");
         return;
     }
-    if ctx.unsafe_is_prev {
+    if ctx.previous_token_is(T![unsafe]) {
         if ctx.has_item_list_or_source_file_parent || ctx.block_expr_parent {
-            add_keyword(ctx, acc, "fn", "fn $0() {}")
+            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 {}");
+            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() {}");
+        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, "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 {}");
+        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]) || ctx.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 {
         add_keyword(ctx, acc, "mod", "mod $0");
@@ -342,7 +342,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 +648,9 @@ fn foo() {
 fn main() { let x = $0 }
 "#,
             r#"
-fn main() { let x = match $0 {}; }
+fn main() { let x = match $1 {
+    $0
+}; }
 "#,
         );
 
@@ -660,7 +664,9 @@ fn main() {
 "#,
             r#"
 fn main() {
-    let x = if $0 {};
+    let x = if $1 {
+    $0
+};
     let y = 92;
 }
 "#,
@@ -676,7 +682,9 @@ fn main() {
 "#,
             r#"
 fn main() {
-    let x = loop {$0};
+    let x = loop {
+    $0
+};
     bar();
 }
 "#,
diff --git a/crates/ide_completion/src/completions/pattern.rs b/crates/ide_completion/src/completions/pattern.rs
index 8dc9ab73c..3329a4844 100644
--- a/crates/ide_completion/src/completions/pattern.rs
+++ b/crates/ide_completion/src/completions/pattern.rs
@@ -1,17 +1,18 @@
 //! Completes constants and paths in patterns.
 
-use crate::{CompletionContext, Completions};
+use crate::{context::IsPatOrConst, 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) {
+    if ctx.is_pat_or_const == IsPatOrConst::No {
         return;
     }
     if ctx.record_pat_syntax.is_some() {
         return;
     }
 
-    if !ctx.is_irrefutable_pat_binding {
+    let refutable = ctx.is_pat_or_const == IsPatOrConst::Refutable;
+    if refutable {
         if let Some(hir::Adt::Enum(e)) =
             ctx.expected_type.as_ref().and_then(|ty| ty.strip_references().as_adt())
         {
@@ -31,14 +32,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 +48,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,
diff --git a/crates/ide_completion/src/completions/unqualified_path.rs b/crates/ide_completion/src/completions/unqualified_path.rs
index 7875500c1..b8f8ef25f 100644
--- a/crates/ide_completion/src/completions/unqualified_path.rs
+++ b/crates/ide_completion/src/completions/unqualified_path.rs
@@ -13,6 +13,8 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
         || ctx.record_pat_syntax.is_some()
         || ctx.attribute_under_caret.is_some()
         || ctx.mod_declaration_under_caret.is_some()
+        || ctx.has_impl_parent
+        || ctx.has_trait_parent
     {
         return;
     }
@@ -86,7 +88,7 @@ fn quux(x: Option<Enum>) {
     }
 }
 "#,
-            expect![[""]],
+            expect![[r#""#]],
         );
     }
 
@@ -102,7 +104,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..9d761aa43 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -1,29 +1,37 @@
 //! 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_as_prev_sibling, has_impl_parent, has_item_list_or_source_file_parent,
+        has_ref_parent, has_trait_as_prev_sibling, has_trait_parent, inside_impl_trait_block,
+        is_in_loop_body, is_match_arm, previous_token,
     },
     CompletionConfig,
 };
 
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) enum IsPatOrConst {
+    No,
+    Refutable,
+    Irrefutable,
+}
+
 /// `CompletionContext` is created early during completion to figure out, where
 /// exactly is the cursor, syntax-wise.
 #[derive(Debug)]
@@ -41,23 +49,26 @@ 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>,
     pub(super) record_lit_syntax: Option<ast::RecordExpr>,
     pub(super) record_pat_syntax: Option<ast::RecordPat>,
     pub(super) record_field_syntax: Option<ast::RecordExprField>,
+    /// The parent impl of the cursor position if it exists.
     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: IsPatOrConst,
+    pub(super) is_param: bool,
+
     /// 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).
@@ -81,27 +92,27 @@ pub(crate) struct CompletionContext<'a> {
     pub(super) is_path_type: bool,
     pub(super) has_type_args: bool,
     pub(super) attribute_under_caret: Option<ast::Attr>,
+    pub(super) locals: Vec<(String, Local)>,
+
     pub(super) mod_declaration_under_caret: Option<ast::Module>,
-    pub(super) unsafe_is_prev: bool,
-    pub(super) if_is_prev: bool,
+    pub(super) has_trait_parent: bool,
+    pub(super) has_impl_parent: bool,
+
+    // keyword patterns
+    pub(super) previous_token: Option<SyntaxToken>,
     pub(super) block_expr_parent: bool,
     pub(super) bind_pat_parent: bool,
     pub(super) ref_pat_parent: bool,
     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,
@@ -158,8 +169,7 @@ impl<'a> CompletionContext<'a> {
             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: IsPatOrConst::No,
             is_trivial_path: false,
             path_qual: None,
             after_if: false,
@@ -175,22 +185,19 @@ 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,
+            previous_token: None,
             block_expr_parent: false,
             bind_pat_parent: false,
             ref_pat_parent: false,
             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,
             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 +252,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 +271,39 @@ 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)
+    }
+
     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.previous_token = previous_token(syntax_element.clone());
         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.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());
         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 +425,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,12 +471,64 @@ 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 = IsPatOrConst::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 = IsPatOrConst::No;
+            } else if let Some(pat_field) =
+                bind_pat.syntax().parent().and_then(ast::RecordPatField::cast)
+            {
+                if pat_field.name_ref().is_none() {
+                    self.is_pat_or_const = IsPatOrConst::No;
+                }
+            } 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 = IsPatOrConst::Irrefutable;
+                    }
+                }
+            }
+
+            self.fill_impl_def();
+        }
+        if is_node::<ast::Param>(name.syntax()) {
+            self.is_param = true;
+            return;
+        }
+        // FIXME: remove this (V) 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);
+        }
+    }
+
     fn classify_name_ref(
         &mut self,
         original_file: &SyntaxNode,
         name_ref: ast::NameRef,
         offset: TextSize,
     ) {
+        // FIXME: remove this (^) 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.name_ref_syntax =
             find_node_at_offset(original_file, name_ref.syntax().text_range().start());
         let name_range = name_ref.syntax().text_range();
diff --git a/crates/ide_completion/src/patterns.rs b/crates/ide_completion/src/patterns.rs
index d82564381..3d8a83ed8 100644
--- a/crates/ide_completion/src/patterns.rs
+++ b/crates/ide_completion/src/patterns.rs
@@ -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,11 +134,6 @@ 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()
 }
diff --git a/crates/ide_completion/src/render.rs b/crates/ide_completion/src/render.rs
index d7f96b864..21f0da5f8 100644
--- a/crates/ide_completion/src/render.rs
+++ b/crates/ide_completion/src/render.rs
@@ -20,6 +20,7 @@ use ide_db::{
 use syntax::TextRange;
 
 use crate::{
+    context::IsPatOrConst,
     item::{CompletionRelevanceTypeMatch, ImportEdit},
     CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, CompletionRelevance,
 };
@@ -188,8 +189,7 @@ impl<'a> Render<'a> {
                 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 =>
+                if self.ctx.completion.is_pat_or_const != IsPatOrConst::No =>
             {
                 CompletionItemKind::SymbolKind(SymbolKind::Variant)
             }
diff --git a/crates/project_model/src/build_data.rs b/crates/project_model/src/build_data.rs
index 3aa546980..33a4f8168 100644
--- a/crates/project_model/src/build_data.rs
+++ b/crates/project_model/src/build_data.rs
@@ -214,7 +214,7 @@ impl WorkspaceBuildData {
                             acc
                         };
                         let package_build_data =
-                            res.per_package.entry(package_id.repr.clone()).or_default();
+                            res.per_package.entry(package_id.repr).or_default();
                         // cargo_metadata crate returns default (empty) path for
                         // older cargos, which is not absolute, so work around that.
                         if !out_dir.as_str().is_empty() {
@@ -237,13 +237,13 @@ impl WorkspaceBuildData {
                             {
                                 let filename = AbsPathBuf::assert(PathBuf::from(&filename));
                                 let package_build_data =
-                                    res.per_package.entry(package_id.repr.clone()).or_default();
+                                    res.per_package.entry(package_id.repr).or_default();
                                 package_build_data.proc_macro_dylib_path = Some(filename);
                             }
                         }
                     }
                     Message::CompilerMessage(message) => {
-                        progress(message.target.name.clone());
+                        progress(message.target.name);
                     }
                     Message::BuildFinished(_) => {}
                     Message::TextLine(_) => {}
diff --git a/crates/project_model/src/cargo_workspace.rs b/crates/project_model/src/cargo_workspace.rs
index a8fee4f08..b8ad08364 100644
--- a/crates/project_model/src/cargo_workspace.rs
+++ b/crates/project_model/src/cargo_workspace.rs
@@ -346,11 +346,8 @@ impl CargoWorkspace {
 
         let workspace_root =
             AbsPathBuf::assert(PathBuf::from(meta.workspace_root.into_os_string()));
-        let build_data_config = BuildDataConfig::new(
-            cargo_toml.to_path_buf(),
-            config.clone(),
-            Arc::new(meta.packages.clone()),
-        );
+        let build_data_config =
+            BuildDataConfig::new(cargo_toml.to_path_buf(), config.clone(), Arc::new(meta.packages));
 
         Ok(CargoWorkspace { packages, targets, workspace_root, build_data_config })
     }
diff --git a/editors/code/src/run.ts b/editors/code/src/run.ts
index 138e3f686..d0be84068 100644
--- a/editors/code/src/run.ts
+++ b/editors/code/src/run.ts
@@ -142,7 +142,11 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     const target = vscode.workspace.workspaceFolders![0]; // safe, see main activate()
     const cargoTask = await tasks.buildCargoTask(target, definition, runnable.label, args, config.cargoRunner, true);
+
     cargoTask.presentationOptions.clear = true;
+    // Sadly, this doesn't prevent focus stealing if the terminal is currently
+    // hidden, and will become revealed due to task exucution.
+    cargoTask.presentationOptions.focus = false;
 
     return cargoTask;
 }