43 files changed, 406 insertions, 379 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 12a8896a3..29e70d8fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -45,7 +45,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "backtrace"
-version = "0.3.40"
+version = "0.3.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "backtrace-sys 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1113,7 +1113,7 @@ dependencies = [
 name = "ra_prof"
 version = "0.1.0"
 dependencies = [
- "backtrace 0.3.40 (registry+https://github.com/rust-lang/crates.io-index)",
+ "backtrace 0.3.41 (registry+https://github.com/rust-lang/crates.io-index)",
  "itertools 0.8.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "jemalloc-ctl 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "jemallocator 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1780,7 +1780,7 @@ dependencies = [
 "checksum atty 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 "checksum autocfg 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "1d49d90015b3c36167a20fe2810c5cd875ad504b39cff3d4eae7977e6b7c1cb2"
 "checksum autocfg 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
-"checksum backtrace 0.3.40 (registry+https://github.com/rust-lang/crates.io-index)" = "924c76597f0d9ca25d762c25a4d369d51267536465dc5064bdf0eb073ed477ea"
+"checksum backtrace 0.3.41 (registry+https://github.com/rust-lang/crates.io-index)" = "a4ed64ae6d9ebfd9893193c4b2532b1292ec97bd8271c9d7d0fa90cd78a34cba"
 "checksum backtrace-sys 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491"
 "checksum base64 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
 "checksum bit-set 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e84c238982c4b1e1ee668d136c510c67a13465279c0cb367ea6baf6310620a80"
diff --git a/bors.toml b/bors.toml
index 0bc71860f..bf5553df4 100644
--- a/bors.toml
+++ b/bors.toml
@@ -1,6 +1,6 @@
 status = [
     "Rust (ubuntu-latest)",
-    "Rust (windows-latest)",
+    # "Rust (windows-latest)",
     "Rust (macos-latest)",
     "TypeScript"
 ]
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 28152f724..1a65b5dc0 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -84,6 +84,8 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
         f: impl FnOnce(&mut AssistBuilder),
     ) -> Option<Assist> {
         let label = AssistLabel { label: label.into(), id };
+        assert!(label.label.chars().nth(0).unwrap().is_uppercase());
+
         let assist = if self.should_compute_edit {
             let action = {
                 let mut edit = AssistBuilder::default();
diff --git a/crates/ra_assists/src/assists/add_custom_impl.rs b/crates/ra_assists/src/assists/add_custom_impl.rs
index 9b8955710..f91034967 100644
--- a/crates/ra_assists/src/assists/add_custom_impl.rs
+++ b/crates/ra_assists/src/assists/add_custom_impl.rs
@@ -49,7 +49,10 @@ pub(crate) fn add_custom_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
     let annotated_name = annotated.syntax().text().to_string();
     let start_offset = annotated.syntax().parent()?.text_range().end();
 
-    ctx.add_assist(AssistId("add_custom_impl"), "add custom impl", |edit| {
+    let label =
+        format!("Add custom impl '{}' for '{}'", trait_token.text().as_str(), annotated_name);
+
+    ctx.add_assist(AssistId("add_custom_impl"), label, |edit| {
         edit.target(attr.syntax().text_range());
 
         let new_attr_input = input
diff --git a/crates/ra_assists/src/assists/add_derive.rs b/crates/ra_assists/src/assists/add_derive.rs
index 764b17bd8..6d9af3905 100644
--- a/crates/ra_assists/src/assists/add_derive.rs
+++ b/crates/ra_assists/src/assists/add_derive.rs
@@ -28,7 +28,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_derive(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let node_start = derive_insertion_offset(&nominal)?;
-    ctx.add_assist(AssistId("add_derive"), "add `#[derive]`", |edit| {
+    ctx.add_assist(AssistId("add_derive"), "Add `#[derive]`", |edit| {
         let derive_attr = nominal
             .attrs()
             .filter_map(|x| x.as_simple_call())
diff --git a/crates/ra_assists/src/assists/add_explicit_type.rs b/crates/ra_assists/src/assists/add_explicit_type.rs
index 2c602a79e..f9f826b88 100644
--- a/crates/ra_assists/src/assists/add_explicit_type.rs
+++ b/crates/ra_assists/src/assists/add_explicit_type.rs
@@ -47,10 +47,14 @@ pub(crate) fn add_explicit_type(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
         return None;
     }
 
-    ctx.add_assist(AssistId("add_explicit_type"), "add explicit type", |edit| {
-        edit.target(pat_range);
-        edit.insert(name_range.end(), format!(": {}", ty.display(db)));
-    })
+    ctx.add_assist(
+        AssistId("add_explicit_type"),
+        format!("Insert explicit type '{}'", ty.display(db)),
+        |edit| {
+            edit.target(pat_range);
+            edit.insert(name_range.end(), format!(": {}", ty.display(db)));
+        },
+    )
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/assists/add_impl.rs b/crates/ra_assists/src/assists/add_impl.rs
index 7da0cfd0d..4b326c837 100644
--- a/crates/ra_assists/src/assists/add_impl.rs
+++ b/crates/ra_assists/src/assists/add_impl.rs
@@ -30,7 +30,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn add_impl(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
     let name = nominal.name()?;
-    ctx.add_assist(AssistId("add_impl"), "add impl", |edit| {
+    ctx.add_assist(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), |edit| {
         edit.target(nominal.syntax().text_range());
         let type_params = nominal.type_param_list();
         let start_offset = nominal.syntax().text_range().end();
diff --git a/crates/ra_assists/src/assists/add_import.rs b/crates/ra_assists/src/assists/add_import.rs
index b8752cbad..bf6cfe865 100644
--- a/crates/ra_assists/src/assists/add_import.rs
+++ b/crates/ra_assists/src/assists/add_import.rs
@@ -72,7 +72,7 @@ pub(crate) fn add_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         }
     };
 
-    ctx.add_assist(AssistId("add_import"), format!("import {}", fmt_segments(&segments)), |edit| {
+    ctx.add_assist(AssistId("add_import"), format!("Import {}", fmt_segments(&segments)), |edit| {
         apply_auto_import(&position, &path, &segments, edit.text_edit_builder());
     })
 }
diff --git a/crates/ra_assists/src/assists/add_missing_impl_members.rs b/crates/ra_assists/src/assists/add_missing_impl_members.rs
index bf1136193..5bb937bde 100644
--- a/crates/ra_assists/src/assists/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/assists/add_missing_impl_members.rs
@@ -48,7 +48,7 @@ pub(crate) fn add_missing_impl_members(ctx: AssistCtx<impl HirDatabase>) -> Opti
         ctx,
         AddMissingImplMembersMode::NoDefaultMethods,
         "add_impl_missing_members",
-        "add missing impl members",
+        "Implement missing members",
     )
 }
 
@@ -89,7 +89,7 @@ pub(crate) fn add_missing_default_members(ctx: AssistCtx<impl HirDatabase>) -> O
         ctx,
         AddMissingImplMembersMode::DefaultMethodsOnly,
         "add_impl_default_members",
-        "add impl default members",
+        "Implement default members",
     )
 }
 
diff --git a/crates/ra_assists/src/assists/add_new.rs b/crates/ra_assists/src/assists/add_new.rs
index b2f946fac..d148d6e73 100644
--- a/crates/ra_assists/src/assists/add_new.rs
+++ b/crates/ra_assists/src/assists/add_new.rs
@@ -43,7 +43,7 @@ pub(crate) fn add_new(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     // Return early if we've found an existing new fn
     let impl_block = find_struct_impl(&ctx, &strukt)?;
 
-    ctx.add_assist(AssistId("add_new"), "add new fn", |edit| {
+    ctx.add_assist(AssistId("add_new"), "Add default constructor", |edit| {
         edit.target(strukt.syntax().text_range());
 
         let mut buf = String::with_capacity(512);
diff --git a/crates/ra_assists/src/assists/apply_demorgan.rs b/crates/ra_assists/src/assists/apply_demorgan.rs
index 7c57c0560..666dce4e6 100644
--- a/crates/ra_assists/src/assists/apply_demorgan.rs
+++ b/crates/ra_assists/src/assists/apply_demorgan.rs
@@ -39,7 +39,7 @@ pub(crate) fn apply_demorgan(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
     let not_lhs = invert_boolean_expression(&lhs)?;
     let not_rhs = invert_boolean_expression(&rhs)?;
 
-    ctx.add_assist(AssistId("apply_demorgan"), "apply demorgan's law", |edit| {
+    ctx.add_assist(AssistId("apply_demorgan"), "Apply De Morgan's law", |edit| {
         edit.target(op_range);
         edit.replace(op_range, opposite_op);
         edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
diff --git a/crates/ra_assists/src/assists/change_visibility.rs b/crates/ra_assists/src/assists/change_visibility.rs
index 132c9dc1d..fd766bb46 100644
--- a/crates/ra_assists/src/assists/change_visibility.rs
+++ b/crates/ra_assists/src/assists/change_visibility.rs
@@ -57,7 +57,7 @@ fn add_vis(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         (vis_offset(field.syntax()), ident.text_range())
     };
 
-    ctx.add_assist(AssistId("change_visibility"), "make pub(crate)", |edit| {
+    ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub(crate)", |edit| {
         edit.target(target);
         edit.insert(offset, "pub(crate) ");
         edit.set_cursor(offset);
@@ -77,14 +77,18 @@ fn vis_offset(node: &SyntaxNode) -> TextUnit {
 
 fn change_vis(ctx: AssistCtx<impl HirDatabase>, vis: ast::Visibility) -> Option<Assist> {
     if vis.syntax().text() == "pub" {
-        return ctx.add_assist(AssistId("change_visibility"), "change to pub(crate)", |edit| {
-            edit.target(vis.syntax().text_range());
-            edit.replace(vis.syntax().text_range(), "pub(crate)");
-            edit.set_cursor(vis.syntax().text_range().start())
-        });
+        return ctx.add_assist(
+            AssistId("change_visibility"),
+            "Change Visibility to pub(crate)",
+            |edit| {
+                edit.target(vis.syntax().text_range());
+                edit.replace(vis.syntax().text_range(), "pub(crate)");
+                edit.set_cursor(vis.syntax().text_range().start())
+            },
+        );
     }
     if vis.syntax().text() == "pub(crate)" {
-        return ctx.add_assist(AssistId("change_visibility"), "change to pub", |edit| {
+        return ctx.add_assist(AssistId("change_visibility"), "Change visibility to pub", |edit| {
             edit.target(vis.syntax().text_range());
             edit.replace(vis.syntax().text_range(), "pub");
             edit.set_cursor(vis.syntax().text_range().start());
diff --git a/crates/ra_assists/src/assists/early_return.rs b/crates/ra_assists/src/assists/early_return.rs
index 023917aca..487ee9eef 100644
--- a/crates/ra_assists/src/assists/early_return.rs
+++ b/crates/ra_assists/src/assists/early_return.rs
@@ -95,7 +95,7 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx<impl HirDatabase>) -> Opt
     then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
     let cursor_position = ctx.frange.range.start();
 
-    ctx.add_assist(AssistId("convert_to_guarded_return"), "convert to guarded return", |edit| {
+    ctx.add_assist(AssistId("convert_to_guarded_return"), "Convert to guarded return", |edit| {
         let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
         let new_block = match if_let_pat {
             None => {
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 99d80998c..01758d23a 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -57,7 +57,7 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 
     let db = ctx.db;
 
-    ctx.add_assist(AssistId("fill_match_arms"), "fill match arms", |edit| {
+    ctx.add_assist(AssistId("fill_match_arms"), "Fill match arms", |edit| {
         let indent_level = IndentLevel::from_node(match_arm_list.syntax());
 
         let new_arm_list = {
diff --git a/crates/ra_assists/src/assists/flip_binexpr.rs b/crates/ra_assists/src/assists/flip_binexpr.rs
index 2d91b2a7e..2074087cd 100644
--- a/crates/ra_assists/src/assists/flip_binexpr.rs
+++ b/crates/ra_assists/src/assists/flip_binexpr.rs
@@ -34,7 +34,7 @@ pub(crate) fn flip_binexpr(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         return None;
     }
 
-    ctx.add_assist(AssistId("flip_binexpr"), "flip binary expression", |edit| {
+    ctx.add_assist(AssistId("flip_binexpr"), "Flip binary expression", |edit| {
         edit.target(op_range);
         if let FlipAction::FlipAndReplaceOp(new_op) = action {
             edit.replace(op_range, new_op);
diff --git a/crates/ra_assists/src/assists/flip_comma.rs b/crates/ra_assists/src/assists/flip_comma.rs
index 9be1c1dc6..dd0c405ed 100644
--- a/crates/ra_assists/src/assists/flip_comma.rs
+++ b/crates/ra_assists/src/assists/flip_comma.rs
@@ -29,7 +29,7 @@ pub(crate) fn flip_comma(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         return None;
     }
 
-    ctx.add_assist(AssistId("flip_comma"), "flip comma", |edit| {
+    ctx.add_assist(AssistId("flip_comma"), "Flip comma", |edit| {
         edit.target(comma.text_range());
         edit.replace(prev.text_range(), next.to_string());
         edit.replace(next.text_range(), prev.to_string());
diff --git a/crates/ra_assists/src/assists/flip_trait_bound.rs b/crates/ra_assists/src/assists/flip_trait_bound.rs
index 6017b39dd..50b3fa492 100644
--- a/crates/ra_assists/src/assists/flip_trait_bound.rs
+++ b/crates/ra_assists/src/assists/flip_trait_bound.rs
@@ -33,7 +33,7 @@ pub(crate) fn flip_trait_bound(ctx: AssistCtx<impl HirDatabase>) -> Option<Assis
         non_trivia_sibling(plus.clone().into(), Direction::Next)?,
     );
 
-    ctx.add_assist(AssistId("flip_trait_bound"), "flip trait bound", |edit| {
+    ctx.add_assist(AssistId("flip_trait_bound"), "Flip trait bounds", |edit| {
         edit.target(plus.text_range());
         edit.replace(before.text_range(), after.to_string());
         edit.replace(after.text_range(), before.to_string());
diff --git a/crates/ra_assists/src/assists/inline_local_variable.rs b/crates/ra_assists/src/assists/inline_local_variable.rs
index 18a34502c..164aee90c 100644
--- a/crates/ra_assists/src/assists/inline_local_variable.rs
+++ b/crates/ra_assists/src/assists/inline_local_variable.rs
@@ -93,7 +93,7 @@ pub(crate) fn inline_local_varialbe(ctx: AssistCtx<impl HirDatabase>) -> Option<
 
     ctx.add_assist(
         AssistId("inline_local_variable"),
-        "inline local variable",
+        "Inline variable",
         move |edit: &mut AssistBuilder| {
             edit.delete(delete_range);
             for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
diff --git a/crates/ra_assists/src/assists/introduce_variable.rs b/crates/ra_assists/src/assists/introduce_variable.rs
index 0623d4475..19e211e0f 100644
--- a/crates/ra_assists/src/assists/introduce_variable.rs
+++ b/crates/ra_assists/src/assists/introduce_variable.rs
@@ -43,7 +43,7 @@ pub(crate) fn introduce_variable(ctx: AssistCtx<impl HirDatabase>) -> Option<Ass
     if indent.kind() != WHITESPACE {
         return None;
     }
-    ctx.add_assist(AssistId("introduce_variable"), "introduce variable", move |edit| {
+    ctx.add_assist(AssistId("introduce_variable"), "Extract into variable", move |edit| {
         let mut buf = String::new();
 
         let cursor_offset = if wrap_in_block {
diff --git a/crates/ra_assists/src/assists/invert_if.rs b/crates/ra_assists/src/assists/invert_if.rs
index bababa3e2..16352c040 100644
--- a/crates/ra_assists/src/assists/invert_if.rs
+++ b/crates/ra_assists/src/assists/invert_if.rs
@@ -41,7 +41,7 @@ pub(crate) fn invert_if(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         let else_node = else_block.syntax();
         let else_range = else_node.text_range();
         let then_range = then_node.text_range();
-        return ctx.add_assist(AssistId("invert_if"), "invert if branches", |edit| {
+        return ctx.add_assist(AssistId("invert_if"), "Invert if", |edit| {
             edit.target(if_range);
             edit.replace(cond_range, flip_cond.syntax().text());
             edit.replace(else_range, then_node.text());
diff --git a/crates/ra_assists/src/assists/merge_match_arms.rs b/crates/ra_assists/src/assists/merge_match_arms.rs
index e9f2cae91..aca391155 100644
--- a/crates/ra_assists/src/assists/merge_match_arms.rs
+++ b/crates/ra_assists/src/assists/merge_match_arms.rs
@@ -52,7 +52,7 @@ pub(crate) fn merge_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assis
 
     let cursor_to_end = current_arm.syntax().text_range().end() - ctx.frange.range.start();
 
-    ctx.add_assist(AssistId("merge_match_arms"), "merge match arms", |edit| {
+    ctx.add_assist(AssistId("merge_match_arms"), "Merge match arms", |edit| {
         fn contains_placeholder(a: &MatchArm) -> bool {
             a.pats().any(|x| match x {
                 ra_syntax::ast::Pat::PlaceholderPat(..) => true,
diff --git a/crates/ra_assists/src/assists/move_bounds.rs b/crates/ra_assists/src/assists/move_bounds.rs
index 3145d7625..355adddc3 100644
--- a/crates/ra_assists/src/assists/move_bounds.rs
+++ b/crates/ra_assists/src/assists/move_bounds.rs
@@ -46,7 +46,7 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx<impl HirDatabase>) -> O
         _ => return None,
     };
 
-    ctx.add_assist(AssistId("move_bounds_to_where_clause"), "move_bounds_to_where_clause", |edit| {
+    ctx.add_assist(AssistId("move_bounds_to_where_clause"), "Move to where clause", |edit| {
         let new_params = type_param_list
             .type_params()
             .filter(|it| it.type_bound_list().is_some())
diff --git a/crates/ra_assists/src/assists/move_guard.rs b/crates/ra_assists/src/assists/move_guard.rs
index b49ec6172..41a31e677 100644
--- a/crates/ra_assists/src/assists/move_guard.rs
+++ b/crates/ra_assists/src/assists/move_guard.rs
@@ -41,7 +41,7 @@ pub(crate) fn move_guard_to_arm_body(ctx: AssistCtx<impl HirDatabase>) -> Option
     let arm_expr = match_arm.expr()?;
     let buf = format!("if {} {{ {} }}", guard_conditions.syntax().text(), arm_expr.syntax().text());
 
-    ctx.add_assist(AssistId("move_guard_to_arm_body"), "move guard to arm body", |edit| {
+    ctx.add_assist(AssistId("move_guard_to_arm_body"), "Move guard to arm body", |edit| {
         edit.target(guard.syntax().text_range());
         let offseting_amount = match space_before_guard.and_then(|it| it.into_token()) {
             Some(tok) => {
@@ -111,7 +111,7 @@ pub(crate) fn move_arm_cond_to_match_guard(ctx: AssistCtx<impl HirDatabase>) ->
 
     ctx.add_assist(
         AssistId("move_arm_cond_to_match_guard"),
-        "move condition to match guard",
+        "Move condition to match guard",
         |edit| {
             edit.target(if_expr.syntax().text_range());
             let then_only_expr = then_block.block().and_then(|it| it.statements().next()).is_none();
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 93912a470..e79c51673 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -25,7 +25,7 @@ use crate::{Assist, AssistCtx, AssistId};
 pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
     let value = token.value()?;
-    ctx.add_assist(AssistId("make_raw_string"), "make raw string", |edit| {
+    ctx.add_assist(AssistId("make_raw_string"), "Rewrite as raw string", |edit| {
         edit.target(token.syntax().text_range());
         let max_hash_streak = count_hashes(&value);
         let mut hashes = String::with_capacity(max_hash_streak + 1);
@@ -54,7 +54,7 @@ pub(crate) fn make_raw_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
 pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
     let value = token.value()?;
-    ctx.add_assist(AssistId("make_usual_string"), "make usual string", |edit| {
+    ctx.add_assist(AssistId("make_usual_string"), "Rewrite as regular string", |edit| {
         edit.target(token.syntax().text_range());
         // parse inside string to escape `"`
         let escaped = value.escape_default().to_string();
@@ -79,7 +79,7 @@ pub(crate) fn make_usual_string(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 // ```
 pub(crate) fn add_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
     let token = ctx.find_token_at_offset(RAW_STRING)?;
-    ctx.add_assist(AssistId("add_hash"), "add hash to raw string", |edit| {
+    ctx.add_assist(AssistId("add_hash"), "Add # to raw string", |edit| {
         edit.target(token.text_range());
         edit.insert(token.text_range().start() + TextUnit::of_char('r'), "#");
         edit.insert(token.text_range().end(), "#");
@@ -108,7 +108,7 @@ pub(crate) fn remove_hash(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         // no hash to remove
         return None;
     }
-    ctx.add_assist(AssistId("remove_hash"), "remove hash from raw string", |edit| {
+    ctx.add_assist(AssistId("remove_hash"), "Remove hash from raw string", |edit| {
         edit.target(token.text_range());
         let result = &text[2..text.len() - 1];
         let result = if result.starts_with('\"') {
diff --git a/crates/ra_assists/src/assists/remove_dbg.rs b/crates/ra_assists/src/assists/remove_dbg.rs
index aedf8747f..cf211ab84 100644
--- a/crates/ra_assists/src/assists/remove_dbg.rs
+++ b/crates/ra_assists/src/assists/remove_dbg.rs
@@ -58,7 +58,7 @@ pub(crate) fn remove_dbg(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         text.slice(without_parens).to_string()
     };
 
-    ctx.add_assist(AssistId("remove_dbg"), "remove dbg!()", |edit| {
+    ctx.add_assist(AssistId("remove_dbg"), "Remove dbg!()", |edit| {
         edit.target(macro_call.syntax().text_range());
         edit.replace(macro_range, macro_content);
         edit.set_cursor(cursor_pos);
diff --git a/crates/ra_assists/src/assists/replace_if_let_with_match.rs b/crates/ra_assists/src/assists/replace_if_let_with_match.rs
index 3272801ff..c9b62e5ff 100644
--- a/crates/ra_assists/src/assists/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/assists/replace_if_let_with_match.rs
@@ -42,7 +42,7 @@ pub(crate) fn replace_if_let_with_match(ctx: AssistCtx<impl HirDatabase>) -> Opt
         ast::ElseBranch::IfExpr(_) => return None,
     };
 
-    ctx.add_assist(AssistId("replace_if_let_with_match"), "replace with match", |edit| {
+    ctx.add_assist(AssistId("replace_if_let_with_match"), "Replace with match", |edit| {
         let match_expr = build_match_expr(expr, pat, then_block, else_block);
         edit.target(if_expr.syntax().text_range());
         edit.replace_node_and_indent(if_expr.syntax(), match_expr);
diff --git a/crates/ra_assists/src/assists/split_import.rs b/crates/ra_assists/src/assists/split_import.rs
index 5f8d6b0be..6038c4858 100644
--- a/crates/ra_assists/src/assists/split_import.rs
+++ b/crates/ra_assists/src/assists/split_import.rs
@@ -32,7 +32,7 @@ pub(crate) fn split_import(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         None => top_path.syntax().text_range().end(),
     };
 
-    ctx.add_assist(AssistId("split_import"), "split import", |edit| {
+    ctx.add_assist(AssistId("split_import"), "Split import", |edit| {
         edit.target(colon_colon.text_range());
         edit.insert(l_curly, "{");
         edit.insert(r_curly, "}");
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 712ff6f6a..150b34ac7 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -292,8 +292,11 @@ mod tests {
         let assists = super::assists(&db, frange);
         let mut assists = assists.iter();
 
-        assert_eq!(assists.next().expect("expected assist").0.label, "make pub(crate)");
-        assert_eq!(assists.next().expect("expected assist").0.label, "add `#[derive]`");
+        assert_eq!(
+            assists.next().expect("expected assist").0.label,
+            "Change visibility to pub(crate)"
+        );
+        assert_eq!(assists.next().expect("expected assist").0.label, "Add `#[derive]`");
     }
 
     #[test]
@@ -312,7 +315,7 @@ mod tests {
         let assists = super::assists(&db, frange);
         let mut assists = assists.iter();
 
-        assert_eq!(assists.next().expect("expected assist").0.label, "introduce variable");
-        assert_eq!(assists.next().expect("expected assist").0.label, "replace with match");
+        assert_eq!(assists.next().expect("expected assist").0.label, "Extract into variable");
+        assert_eq!(assists.next().expect("expected assist").0.label, "Replace with match");
     }
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index a177cebca..3b479356f 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -21,8 +21,8 @@ use hir_expand::{
     MacroDefId,
 };
 use hir_ty::{
-    autoderef, display::HirFormatter, expr::ExprValidator, ApplicationTy, Canonical, InEnvironment,
-    TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
+    autoderef, display::HirFormatter, expr::ExprValidator, method_resolution, ApplicationTy,
+    Canonical, InEnvironment, TraitEnvironment, Ty, TyDefId, TypeCtor, TypeWalk,
 };
 use ra_db::{CrateId, Edition, FileId};
 use ra_prof::profile;
@@ -120,7 +120,8 @@ impl_froms!(
     BuiltinType
 );
 
-pub use hir_def::{attr::Attrs, visibility::Visibility};
+pub use hir_def::{attr::Attrs, visibility::Visibility, AssocItemId};
+use rustc_hash::FxHashSet;
 
 impl Module {
     pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
@@ -878,6 +879,28 @@ impl Type {
         }
     }
 
+    /// Checks that particular type `ty` implements `std::future::Future`.
+    /// This function is used in `.await` syntax completion.
+    pub fn impls_future(&self, db: &impl HirDatabase) -> bool {
+        let krate = self.krate;
+
+        let std_future_trait =
+            db.lang_item(krate, "future_trait".into()).and_then(|it| it.as_trait());
+        let std_future_trait = match std_future_trait {
+            Some(it) => it,
+            None => return false,
+        };
+
+        let canonical_ty = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+        method_resolution::implements_trait(
+            &canonical_ty,
+            db,
+            self.ty.environment.clone(),
+            krate,
+            std_future_trait,
+        )
+    }
+
     // FIXME: this method is broken, as it doesn't take closures into account.
     pub fn as_callable(&self) -> Option<CallableDef> {
         Some(self.ty.value.as_callable()?.0)
@@ -986,6 +1009,65 @@ impl Type {
         None
     }
 
+    pub fn iterate_method_candidates<T>(
+        &self,
+        db: &impl HirDatabase,
+        krate: Crate,
+        traits_in_scope: &FxHashSet<TraitId>,
+        name: Option<&Name>,
+        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
+    ) -> Option<T> {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        // FIXME replace Unknown by bound vars here
+        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+
+        let env = self.ty.environment.clone();
+        let krate = krate.id;
+
+        method_resolution::iterate_method_candidates(
+            &canonical,
+            db,
+            env,
+            krate,
+            traits_in_scope,
+            name,
+            method_resolution::LookupMode::MethodCall,
+            |ty, it| match it {
+                AssocItemId::FunctionId(f) => callback(ty, f.into()),
+                _ => None,
+            },
+        )
+    }
+
+    pub fn iterate_path_candidates<T>(
+        &self,
+        db: &impl HirDatabase,
+        krate: Crate,
+        traits_in_scope: &FxHashSet<TraitId>,
+        name: Option<&Name>,
+        mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
+    ) -> Option<T> {
+        // There should be no inference vars in types passed here
+        // FIXME check that?
+        // FIXME replace Unknown by bound vars here
+        let canonical = Canonical { value: self.ty.value.clone(), num_vars: 0 };
+
+        let env = self.ty.environment.clone();
+        let krate = krate.id;
+
+        method_resolution::iterate_method_candidates(
+            &canonical,
+            db,
+            env,
+            krate,
+            traits_in_scope,
+            name,
+            method_resolution::LookupMode::Path,
+            |ty, it| callback(ty, it.into()),
+        )
+    }
+
     pub fn as_adt(&self) -> Option<Adt> {
         let (adt, _subst) = self.ty.value.as_adt()?;
         Some(adt.into())
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 3d13978d4..a1cf89010 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -27,7 +27,7 @@ macro_rules! impl_froms {
 }
 
 pub mod db;
-pub mod source_binder;
+pub mod source_analyzer;
 
 pub mod diagnostics;
 
@@ -46,7 +46,7 @@ pub use crate::{
     },
     from_source::FromSource,
     has_source::HasSource,
-    source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
+    source_analyzer::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer},
 };
 
 pub use hir_def::{
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_analyzer.rs
index a2a9d968c..76e0bff34 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_analyzer.rs
@@ -15,17 +15,13 @@ use hir_def::{
     },
     expr::{ExprId, PatId},
     nameres::ModuleSource,
-    path::path,
     resolver::{self, resolver_for_scope, HasResolver, Resolver, TypeNs, ValueNs},
-    AssocItemId, DefWithBodyId,
+    DefWithBodyId, TraitId,
 };
 use hir_expand::{
     hygiene::Hygiene, name::AsName, AstId, HirFileId, InFile, MacroCallId, MacroCallKind,
 };
-use hir_ty::{
-    method_resolution::{self, implements_trait},
-    Canonical, InEnvironment, InferenceResult, TraitEnvironment, Ty,
-};
+use hir_ty::{InEnvironment, InferenceResult, TraitEnvironment};
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, AstNode},
@@ -33,71 +29,13 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNode, SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
 };
+use rustc_hash::FxHashSet;
 
 use crate::{
-    db::HirDatabase, Adt, AssocItem, Const, DefWithBody, Enum, EnumVariant, FromSource, Function,
-    ImplBlock, Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias,
-    TypeParam,
+    db::HirDatabase, Adt, Const, DefWithBody, Enum, EnumVariant, FromSource, Function, ImplBlock,
+    Local, MacroDef, Name, Path, ScopeDef, Static, Struct, Trait, Type, TypeAlias, TypeParam,
 };
 
-fn try_get_resolver_for_node(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> Option<Resolver> {
-    match_ast! {
-        match (node.value) {
-            ast::Module(it) => {
-                let src = node.with_value(it);
-                Some(crate::Module::from_declaration(db, src)?.id.resolver(db))
-            },
-             ast::SourceFile(it) => {
-                let src = node.with_value(ModuleSource::SourceFile(it));
-                Some(crate::Module::from_definition(db, src)?.id.resolver(db))
-            },
-            ast::StructDef(it) => {
-                let src = node.with_value(it);
-                Some(Struct::from_source(db, src)?.id.resolver(db))
-            },
-            ast::EnumDef(it) => {
-                let src = node.with_value(it);
-                Some(Enum::from_source(db, src)?.id.resolver(db))
-            },
-            ast::ImplBlock(it) => {
-                let src = node.with_value(it);
-                Some(ImplBlock::from_source(db, src)?.id.resolver(db))
-            },
-            ast::TraitDef(it) => {
-                let src = node.with_value(it);
-                Some(Trait::from_source(db, src)?.id.resolver(db))
-            },
-            _ => match node.value.kind() {
-                FN_DEF | CONST_DEF | STATIC_DEF => {
-                    let def = def_with_body_from_child_node(db, node)?;
-                    let def = DefWithBodyId::from(def);
-                    Some(def.resolver(db))
-                }
-                // FIXME add missing cases
-                _ => None
-            }
-        }
-    }
-}
-
-fn def_with_body_from_child_node(
-    db: &impl HirDatabase,
-    child: InFile<&SyntaxNode>,
-) -> Option<DefWithBody> {
-    let _p = profile("def_with_body_from_child_node");
-    child.cloned().ancestors_with_macros(db).find_map(|node| {
-        let n = &node.value;
-        match_ast! {
-            match n {
-                ast::FnDef(def)  => { return Function::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                ast::ConstDef(def) => { return Const::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                ast::StaticDef(def) => { return Static::from_source(db, node.with_value(def)).map(DefWithBody::from); },
-                _ => { None },
-            }
-        }
-    })
-}
-
 /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
 /// original source files. It should not be used inside the HIR itself.
 #[derive(Debug)]
@@ -409,68 +347,9 @@ impl SourceAnalyzer {
             .collect()
     }
 
-    pub fn iterate_method_candidates<T>(
-        &self,
-        db: &impl HirDatabase,
-        ty: &Type,
-        name: Option<&Name>,
-        mut callback: impl FnMut(&Ty, Function) -> Option<T>,
-    ) -> Option<T> {
-        // There should be no inference vars in types passed here
-        // FIXME check that?
-        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
-        method_resolution::iterate_method_candidates(
-            &canonical,
-            db,
-            &self.resolver,
-            name,
-            method_resolution::LookupMode::MethodCall,
-            |ty, it| match it {
-                AssocItemId::FunctionId(f) => callback(ty, f.into()),
-                _ => None,
-            },
-        )
-    }
-
-    pub fn iterate_path_candidates<T>(
-        &self,
-        db: &impl HirDatabase,
-        ty: &Type,
-        name: Option<&Name>,
-        mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
-    ) -> Option<T> {
-        // There should be no inference vars in types passed here
-        // FIXME check that?
-        // FIXME replace Unknown by bound vars here
-        let canonical = Canonical { value: ty.ty.value.clone(), num_vars: 0 };
-        method_resolution::iterate_method_candidates(
-            &canonical,
-            db,
-            &self.resolver,
-            name,
-            method_resolution::LookupMode::Path,
-            |ty, it| callback(ty, it.into()),
-        )
-    }
-
-    /// Checks that particular type `ty` implements `std::future::Future`.
-    /// This function is used in `.await` syntax completion.
-    pub fn impls_future(&self, db: &impl HirDatabase, ty: Type) -> bool {
-        let std_future_path = path![std::future::Future];
-
-        let std_future_trait = match self.resolver.resolve_known_trait(db, &std_future_path) {
-            Some(it) => it.into(),
-            _ => return false,
-        };
-
-        let krate = match self.resolver.krate() {
-            Some(krate) => krate,
-            _ => return false,
-        };
-
-        let canonical_ty = Canonical { value: ty.ty.value, num_vars: 0 };
-        implements_trait(&canonical_ty, db, &self.resolver, krate.into(), std_future_trait)
+    /// Note: `FxHashSet<TraitId>` should be treated as an opaque type, passed into `Type
+    pub fn traits_in_scope(&self, db: &impl HirDatabase) -> FxHashSet<TraitId> {
+        self.resolver.traits_in_scope(db)
     }
 
     pub fn expand(
@@ -487,6 +366,64 @@ impl SourceAnalyzer {
     }
 }
 
+fn try_get_resolver_for_node(db: &impl HirDatabase, node: InFile<&SyntaxNode>) -> Option<Resolver> {
+    match_ast! {
+        match (node.value) {
+            ast::Module(it) => {
+                let src = node.with_value(it);
+                Some(crate::Module::from_declaration(db, src)?.id.resolver(db))
+            },
+             ast::SourceFile(it) => {
+                let src = node.with_value(ModuleSource::SourceFile(it));
+                Some(crate::Module::from_definition(db, src)?.id.resolver(db))
+            },
+            ast::StructDef(it) => {
+                let src = node.with_value(it);
+                Some(Struct::from_source(db, src)?.id.resolver(db))
+            },
+            ast::EnumDef(it) => {
+                let src = node.with_value(it);
+                Some(Enum::from_source(db, src)?.id.resolver(db))
+            },
+            ast::ImplBlock(it) => {
+                let src = node.with_value(it);
+                Some(ImplBlock::from_source(db, src)?.id.resolver(db))
+            },
+            ast::TraitDef(it) => {
+                let src = node.with_value(it);
+                Some(Trait::from_source(db, src)?.id.resolver(db))
+            },
+            _ => match node.value.kind() {
+                FN_DEF | CONST_DEF | STATIC_DEF => {
+                    let def = def_with_body_from_child_node(db, node)?;
+                    let def = DefWithBodyId::from(def);
+                    Some(def.resolver(db))
+                }
+                // FIXME add missing cases
+                _ => None
+            }
+        }
+    }
+}
+
+fn def_with_body_from_child_node(
+    db: &impl HirDatabase,
+    child: InFile<&SyntaxNode>,
+) -> Option<DefWithBody> {
+    let _p = profile("def_with_body_from_child_node");
+    child.cloned().ancestors_with_macros(db).find_map(|node| {
+        let n = &node.value;
+        match_ast! {
+            match n {
+                ast::FnDef(def)  => { return Function::from_source(db, node.with_value(def)).map(DefWithBody::from); },
+                ast::ConstDef(def) => { return Const::from_source(db, node.with_value(def)).map(DefWithBody::from); },
+                ast::StaticDef(def) => { return Static::from_source(db, node.with_value(def)).map(DefWithBody::from); },
+                _ => { None },
+            }
+        }
+    })
+}
+
 fn scope_for(
     scopes: &ExprScopes,
     source_map: &BodySourceMap,
diff --git a/crates/ra_hir_expand/src/builtin_macro.rs b/crates/ra_hir_expand/src/builtin_macro.rs
index e9e275670..f3f959ac6 100644
--- a/crates/ra_hir_expand/src/builtin_macro.rs
+++ b/crates/ra_hir_expand/src/builtin_macro.rs
@@ -1,8 +1,8 @@
 //! Builtin macro
 use crate::db::AstDatabase;
 use crate::{
-    ast::{self, AstNode},
-    name, AstId, CrateId, HirFileId, MacroCallId, MacroDefId, MacroDefKind, TextUnit,
+    ast::{self},
+    name, AstId, CrateId, MacroCallId, MacroDefId, MacroDefKind, TextUnit,
 };
 
 use crate::quote;
@@ -61,48 +61,13 @@ register_builtin! {
     (format_args_nl, FormatArgsNl) => format_args_expand
 }
 
-fn to_line_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
-    let file_id = file.original_file(db);
-
-    // FIXME: if the file is coming from macro, we return a dummy value for now.
-    if file.call_node(db).map(|it| it.file_id != file_id.into()).unwrap_or(true) {
-        return 0;
-    }
-
-    let text = db.file_text(file_id);
-    let mut line_num = 1;
-
-    let pos = pos.to_usize();
-    if pos > text.len() {
-        // FIXME: `pos` at the moment could be an offset inside the "wrong" file
-        // in this case, when we know it's wrong, we return a dummy value
-        return 0;
-    }
-    // Count line end
-    for (i, c) in text.chars().enumerate() {
-        if i == pos {
-            break;
-        }
-        if c == '\n' {
-            line_num += 1;
-        }
-    }
-    line_num
-}
-
 fn line_expand(
-    db: &dyn AstDatabase,
-    id: MacroCallId,
+    _db: &dyn AstDatabase,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
-    let loc = db.lookup_intern_macro(id);
-
-    let arg = loc.kind.arg(db).ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
-    let arg_start = arg.text_range().start();
-
-    let file = id.as_file();
-    let line_num = to_line_number(db, file, arg_start);
-
+    // dummy implementation for type-checking purposes
+    let line_num = 0;
     let expanded = quote! {
         #line_num
     };
@@ -154,48 +119,13 @@ fn option_env_expand(
     Ok(expanded)
 }
 
-fn to_col_number(db: &dyn AstDatabase, file: HirFileId, pos: TextUnit) -> usize {
-    let file_id = file.original_file(db);
-    // FIXME: if the file is coming from macro, we return a dummy value for now.
-    if file.call_node(db).map(|it| it.file_id != file_id.into()).unwrap_or(true) {
-        return 0;
-    }
-    let text = db.file_text(file_id);
-
-    let pos = pos.to_usize();
-    if pos > text.len() {
-        // FIXME: `pos` at the moment could be an offset inside the "wrong" file
-        // in this case we return a dummy value so that we don't `panic!`
-        return 0;
-    }
-
-    let mut col_num = 1;
-    for c in text[..pos].chars().rev() {
-        if c == '\n' {
-            break;
-        }
-        col_num += 1;
-    }
-    col_num
-}
-
 fn column_expand(
-    db: &dyn AstDatabase,
-    id: MacroCallId,
+    _db: &dyn AstDatabase,
+    _id: MacroCallId,
     _tt: &tt::Subtree,
 ) -> Result<tt::Subtree, mbe::ExpandError> {
-    let loc = db.lookup_intern_macro(id);
-    let macro_call = match loc.kind {
-        crate::MacroCallKind::FnLike(ast_id) => ast_id.to_node(db),
-        _ => panic!("column macro called as attr"),
-    };
-
-    let _arg = macro_call.token_tree().ok_or_else(|| mbe::ExpandError::UnexpectedToken)?;
-    let col_start = macro_call.syntax().text_range().start();
-
-    let file = id.as_file();
-    let col_num = to_col_number(db, file, col_start);
-
+    // dummy implementation for type-checking purposes
+    let col_num = 0;
     let expanded = quote! {
         #col_num
     };
@@ -284,7 +214,7 @@ fn format_args_expand(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{name::AsName, test_db::TestDB, MacroCallKind, MacroCallLoc};
+    use crate::{name::AsName, test_db::TestDB, AstNode, MacroCallKind, MacroCallLoc};
     use ra_db::{fixture::WithFixture, SourceDatabase};
     use ra_syntax::ast::NameOwner;
 
@@ -330,7 +260,7 @@ mod tests {
             "#,
         );
 
-        assert_eq!(expanded, "13");
+        assert_eq!(expanded, "0");
     }
 
     #[test]
@@ -343,7 +273,7 @@ mod tests {
             "#,
         );
 
-        assert_eq!(expanded, "4");
+        assert_eq!(expanded, "0");
     }
 
     #[test]
diff --git a/crates/ra_hir_ty/src/infer/expr.rs b/crates/ra_hir_ty/src/infer/expr.rs
index 3af05394c..d6a17e469 100644
--- a/crates/ra_hir_ty/src/infer/expr.rs
+++ b/crates/ra_hir_ty/src/infer/expr.rs
@@ -569,12 +569,19 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     ) -> Ty {
         let receiver_ty = self.infer_expr(receiver, &Expectation::none());
         let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
-        let resolved = method_resolution::lookup_method(
-            &canonicalized_receiver.value,
-            self.db,
-            method_name,
-            &self.resolver,
-        );
+
+        let traits_in_scope = self.resolver.traits_in_scope(self.db);
+
+        let resolved = self.resolver.krate().and_then(|krate| {
+            method_resolution::lookup_method(
+                &canonicalized_receiver.value,
+                self.db,
+                self.trait_env.clone(),
+                krate,
+                &traits_in_scope,
+                method_name,
+            )
+        });
         let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
             Some((ty, func)) => {
                 let ty = canonicalized_receiver.decanonicalize_ty(ty);
diff --git a/crates/ra_hir_ty/src/infer/path.rs b/crates/ra_hir_ty/src/infer/path.rs
index ffd358367..2c1d4831d 100644
--- a/crates/ra_hir_ty/src/infer/path.rs
+++ b/crates/ra_hir_ty/src/infer/path.rs
@@ -11,7 +11,7 @@ use hir_expand::name::Name;
 
 use crate::{db::HirDatabase, method_resolution, Substs, Ty, TypeWalk, ValueTyDefId};
 
-use super::{ExprOrPatId, InferenceContext, TraitRef};
+use super::{ExprOrPatId, InferenceContext, TraitEnvironment, TraitRef};
 
 impl<'a, D: HirDatabase> InferenceContext<'a, D> {
     pub(super) fn infer_path(
@@ -193,11 +193,16 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         }
 
         let canonical_ty = self.canonicalizer().canonicalize_ty(ty.clone());
+        let env = TraitEnvironment::lower(self.db, &self.resolver);
+        let krate = self.resolver.krate()?;
+        let traits_in_scope = self.resolver.traits_in_scope(self.db);
 
         method_resolution::iterate_method_candidates(
             &canonical_ty.value,
             self.db,
-            &self.resolver.clone(),
+            env,
+            krate,
+            &traits_in_scope,
             Some(name),
             method_resolution::LookupMode::Path,
             move |_ty, item| {
diff --git a/crates/ra_hir_ty/src/method_resolution.rs b/crates/ra_hir_ty/src/method_resolution.rs
index 888dc3116..5bacbbd7c 100644
--- a/crates/ra_hir_ty/src/method_resolution.rs
+++ b/crates/ra_hir_ty/src/method_resolution.rs
@@ -6,13 +6,13 @@ use std::sync::Arc;
 
 use arrayvec::ArrayVec;
 use hir_def::{
-    lang_item::LangItemTarget, resolver::Resolver, type_ref::Mutability, AssocContainerId,
-    AssocItemId, FunctionId, HasModule, ImplId, Lookup, TraitId,
+    lang_item::LangItemTarget, type_ref::Mutability, AssocContainerId, AssocItemId, FunctionId,
+    HasModule, ImplId, Lookup, TraitId,
 };
 use hir_expand::name::Name;
 use ra_db::CrateId;
 use ra_prof::profile;
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use super::Substs;
 use crate::{
@@ -144,14 +144,24 @@ impl Ty {
 pub(crate) fn lookup_method(
     ty: &Canonical<Ty>,
     db: &impl HirDatabase,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: &Name,
-    resolver: &Resolver,
 ) -> Option<(Ty, FunctionId)> {
-    iterate_method_candidates(ty, db, resolver, Some(name), LookupMode::MethodCall, |ty, f| match f
-    {
-        AssocItemId::FunctionId(f) => Some((ty.clone(), f)),
-        _ => None,
-    })
+    iterate_method_candidates(
+        ty,
+        db,
+        env,
+        krate,
+        &traits_in_scope,
+        Some(name),
+        LookupMode::MethodCall,
+        |ty, f| match f {
+            AssocItemId::FunctionId(f) => Some((ty.clone(), f)),
+            _ => None,
+        },
+    )
 }
 
 /// Whether we're looking up a dotted method call (like `v.len()`) or a path
@@ -172,7 +182,9 @@ pub enum LookupMode {
 pub fn iterate_method_candidates<T>(
     ty: &Canonical<Ty>,
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     mode: LookupMode,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
@@ -187,9 +199,7 @@ pub fn iterate_method_candidates<T>(
             // Also note that when we've got a receiver like &S, even if the method we
             // find in the end takes &self, we still do the autoderef step (just as
             // rustc does an autoderef and then autoref again).
-            let environment = TraitEnvironment::lower(db, resolver);
-            let ty = InEnvironment { value: ty.clone(), environment };
-            let krate = resolver.krate()?;
+            let ty = InEnvironment { value: ty.clone(), environment: env.clone() };
 
             // We have to be careful about the order we're looking at candidates
             // in here. Consider the case where we're resolving `x.clone()`
@@ -209,7 +219,9 @@ pub fn iterate_method_candidates<T>(
                 if let Some(result) = iterate_method_candidates_with_autoref(
                     &deref_chain[i..],
                     db,
-                    resolver,
+                    env.clone(),
+                    krate,
+                    traits_in_scope,
                     name,
                     &mut callback,
                 ) {
@@ -220,7 +232,15 @@ pub fn iterate_method_candidates<T>(
         }
         LookupMode::Path => {
             // No autoderef for path lookups
-            iterate_method_candidates_for_self_ty(&ty, db, resolver, name, &mut callback)
+            iterate_method_candidates_for_self_ty(
+                &ty,
+                db,
+                env,
+                krate,
+                traits_in_scope,
+                name,
+                &mut callback,
+            )
         }
     }
 }
@@ -228,7 +248,9 @@ pub fn iterate_method_candidates<T>(
 fn iterate_method_candidates_with_autoref<T>(
     deref_chain: &[Canonical<Ty>],
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
 ) -> Option<T> {
@@ -236,7 +258,9 @@ fn iterate_method_candidates_with_autoref<T>(
         &deref_chain[0],
         &deref_chain[1..],
         db,
-        resolver,
+        env.clone(),
+        krate,
+        &traits_in_scope,
         name,
         &mut callback,
     ) {
@@ -250,7 +274,9 @@ fn iterate_method_candidates_with_autoref<T>(
         &refed,
         deref_chain,
         db,
-        resolver,
+        env.clone(),
+        krate,
+        &traits_in_scope,
         name,
         &mut callback,
     ) {
@@ -264,7 +290,9 @@ fn iterate_method_candidates_with_autoref<T>(
         &ref_muted,
         deref_chain,
         db,
-        resolver,
+        env.clone(),
+        krate,
+        &traits_in_scope,
         name,
         &mut callback,
     ) {
@@ -277,14 +305,15 @@ fn iterate_method_candidates_by_receiver<T>(
     receiver_ty: &Canonical<Ty>,
     rest_of_deref_chain: &[Canonical<Ty>],
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
 ) -> Option<T> {
     // We're looking for methods with *receiver* type receiver_ty. These could
     // be found in any of the derefs of receiver_ty, so we have to go through
     // that.
-    let krate = resolver.krate()?;
     for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
         if let Some(result) =
             iterate_inherent_methods(self_ty, db, name, Some(receiver_ty), krate, &mut callback)
@@ -296,7 +325,9 @@ fn iterate_method_candidates_by_receiver<T>(
         if let Some(result) = iterate_trait_method_candidates(
             self_ty,
             db,
-            resolver,
+            env.clone(),
+            krate,
+            &traits_in_scope,
             name,
             Some(receiver_ty),
             &mut callback,
@@ -310,17 +341,25 @@ fn iterate_method_candidates_by_receiver<T>(
 fn iterate_method_candidates_for_self_ty<T>(
     self_ty: &Canonical<Ty>,
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
 ) -> Option<T> {
-    let krate = resolver.krate()?;
     if let Some(result) = iterate_inherent_methods(self_ty, db, name, None, krate, &mut callback) {
         return Some(result);
     }
-    if let Some(result) =
-        iterate_trait_method_candidates(self_ty, db, resolver, name, None, &mut callback)
-    {
+    if let Some(result) = iterate_trait_method_candidates(
+        self_ty,
+        db,
+        env,
+        krate,
+        traits_in_scope,
+        name,
+        None,
+        &mut callback,
+    ) {
         return Some(result);
     }
     None
@@ -329,14 +368,13 @@ fn iterate_method_candidates_for_self_ty<T>(
 fn iterate_trait_method_candidates<T>(
     self_ty: &Canonical<Ty>,
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
+    krate: CrateId,
+    traits_in_scope: &FxHashSet<TraitId>,
     name: Option<&Name>,
     receiver_ty: Option<&Canonical<Ty>>,
     mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
 ) -> Option<T> {
-    let krate = resolver.krate()?;
-    // FIXME: maybe put the trait_env behind a query (need to figure out good input parameters for that)
-    let env = TraitEnvironment::lower(db, resolver);
     // if ty is `impl Trait` or `dyn Trait`, the trait doesn't need to be in scope
     let inherent_trait = self_ty.value.inherent_trait().into_iter();
     // if we have `T: Trait` in the param env, the trait doesn't need to be in scope
@@ -344,8 +382,7 @@ fn iterate_trait_method_candidates<T>(
         .trait_predicates_for_self_ty(&self_ty.value)
         .map(|tr| tr.trait_)
         .flat_map(|t| all_super_traits(db, t));
-    let traits =
-        inherent_trait.chain(traits_from_env).chain(resolver.traits_in_scope(db).into_iter());
+    let traits = inherent_trait.chain(traits_from_env).chain(traits_in_scope.iter().copied());
     'traits: for t in traits {
         let data = db.trait_data(t);
 
@@ -465,7 +502,7 @@ fn transform_receiver_ty(
 pub fn implements_trait(
     ty: &Canonical<Ty>,
     db: &impl HirDatabase,
-    resolver: &Resolver,
+    env: Arc<TraitEnvironment>,
     krate: CrateId,
     trait_: TraitId,
 ) -> bool {
@@ -474,7 +511,6 @@ pub fn implements_trait(
         // anyway, but currently Chalk doesn't implement `dyn/impl Trait` yet
         return true;
     }
-    let env = TraitEnvironment::lower(db, resolver);
     let goal = generic_implements_goal(db, env, trait_, ty.clone());
     let solution = db.trait_solve(krate.into(), goal);
 
diff --git a/crates/ra_hir_ty/src/tests/macros.rs b/crates/ra_hir_ty/src/tests/macros.rs
index 9d09d93a7..652420ea8 100644
--- a/crates/ra_hir_ty/src/tests/macros.rs
+++ b/crates/ra_hir_ty/src/tests/macros.rs
@@ -374,7 +374,7 @@ fn main() {
 }
 "#),
         @r###"
-    ![0; 1) '6': i32
+    ![0; 1) '0': i32
     [64; 88) '{     ...!(); }': ()
     [74; 75) 'x': i32
     "###
@@ -412,7 +412,7 @@ fn main() {
 }
 "#),
         @r###"
-    ![0; 2) '13': i32
+    ![0; 1) '0': i32
     [66; 92) '{     ...!(); }': ()
     [76; 77) 'x': i32
     "###
diff --git a/crates/ra_ide/src/completion/complete_dot.rs b/crates/ra_ide/src/completion/complete_dot.rs
index 210a685e4..2ca78c927 100644
--- a/crates/ra_ide/src/completion/complete_dot.rs
+++ b/crates/ra_ide/src/completion/complete_dot.rs
@@ -27,7 +27,7 @@ pub(super) fn complete_dot(acc: &mut Completions, ctx: &CompletionContext) {
     complete_methods(acc, ctx, &receiver_ty);
 
     // Suggest .await syntax for types that implement Future trait
-    if ctx.analyzer.impls_future(ctx.db, receiver_ty) {
+    if receiver_ty.impls_future(ctx.db) {
         CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), "await")
             .detail("expr.await")
             .insert_text("await")
@@ -53,13 +53,16 @@ fn complete_fields(acc: &mut Completions, ctx: &CompletionContext, receiver: &Ty
 }
 
 fn complete_methods(acc: &mut Completions, ctx: &CompletionContext, receiver: &Type) {
-    let mut seen_methods = FxHashSet::default();
-    ctx.analyzer.iterate_method_candidates(ctx.db, receiver, None, |_ty, func| {
-        if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
-            acc.add_function(ctx, func);
-        }
-        None::<()>
-    });
+    if let Some(krate) = ctx.module.map(|it| it.krate()) {
+        let mut seen_methods = FxHashSet::default();
+        let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+        receiver.iterate_method_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, func| {
+            if func.has_self_param(ctx.db) && seen_methods.insert(func.name(ctx.db)) {
+                acc.add_function(ctx, func);
+            }
+            None::<()>
+        });
+    }
 }
 
 #[cfg(test)]
@@ -525,6 +528,7 @@ mod tests {
 
             //- /std/lib.rs
             pub mod future {
+                #[lang = "future_trait"]
                 pub trait Future {}
             }
             "###, CompletionKind::Keyword),
diff --git a/crates/ra_ide/src/completion/complete_path.rs b/crates/ra_ide/src/completion/complete_path.rs
index 0dce9dc2d..af24e9f48 100644
--- a/crates/ra_ide/src/completion/complete_path.rs
+++ b/crates/ra_ide/src/completion/complete_path.rs
@@ -49,22 +49,24 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
                 hir::ModuleDef::TypeAlias(a) => a.ty(ctx.db),
                 _ => unreachable!(),
             };
-            ctx.analyzer.iterate_path_candidates(ctx.db, &ty, None, |_ty, item| {
-                match item {
-                    hir::AssocItem::Function(func) => {
-                        if !func.has_self_param(ctx.db) {
-                            acc.add_function(ctx, func);
-                        }
-                    }
-                    hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
-                    hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
-                }
-                None::<()>
-            });
             // Iterate assoc types separately
             // FIXME: complete T::AssocType
             let krate = ctx.module.map(|m| m.krate());
             if let Some(krate) = krate {
+                let traits_in_scope = ctx.analyzer.traits_in_scope(ctx.db);
+                ty.iterate_path_candidates(ctx.db, krate, &traits_in_scope, None, |_ty, item| {
+                    match item {
+                        hir::AssocItem::Function(func) => {
+                            if !func.has_self_param(ctx.db) {
+                                acc.add_function(ctx, func);
+                            }
+                        }
+                        hir::AssocItem::Const(ct) => acc.add_const(ctx, ct),
+                        hir::AssocItem::TypeAlias(ty) => acc.add_type_alias(ctx, ty),
+                    }
+                    None::<()>
+                });
+
                 ty.iterate_impl_items(ctx.db, krate, |item| {
                     match item {
                         hir::AssocItem::Function(_) | hir::AssocItem::Const(_) => {}
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index a9a8538b7..f2db575ea 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -710,6 +710,7 @@ pub fn handle_code_action(
             title: command.title.clone(),
             kind: match assist.id {
                 AssistId("introduce_variable") => Some("refactor.extract.variable".to_string()),
+                AssistId("add_custom_impl") => Some("refactor.rewrite.add_custom_impl".to_string()),
                 _ => None,
             },
             diagnostics: None,
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 222ac15f8..445e3b3e4 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -111,55 +111,46 @@ pub(crate) fn validate(root: &SyntaxNode) -> Vec<SyntaxError> {
     errors
 }
 
-// FIXME: kill duplication
 fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
+    fn unquote(text: &str, prefix_len: usize, end_delimiter: char) -> Option<&str> {
+        text.rfind(end_delimiter).and_then(|end| text.get(prefix_len..end))
+    }
+
     let token = literal.token();
     let text = token.text().as_str();
+
+    let mut push_err = |prefix_len, (off, err): (usize, unescape::EscapeError)| {
+        let off = token.text_range().start() + TextUnit::from_usize(off + prefix_len);
+        acc.push(SyntaxError::new(err.into(), off));
+    };
+
     match token.kind() {
         BYTE => {
-            if let Some(end) = text.rfind('\'') {
-                if let Some(without_quotes) = text.get(2..end) {
-                    if let Err((off, err)) = unescape::unescape_byte(without_quotes) {
-                        let off = token.text_range().start() + TextUnit::from_usize(off + 2);
-                        acc.push(SyntaxError::new(err.into(), off))
-                    }
-                }
+            if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape::unescape_byte) {
+                push_err(2, e);
             }
         }
         CHAR => {
-            if let Some(end) = text.rfind('\'') {
-                if let Some(without_quotes) = text.get(1..end) {
-                    if let Err((off, err)) = unescape::unescape_char(without_quotes) {
-                        let off = token.text_range().start() + TextUnit::from_usize(off + 1);
-                        acc.push(SyntaxError::new(err.into(), off))
-                    }
-                }
+            if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape::unescape_char) {
+                push_err(1, e);
             }
         }
         BYTE_STRING => {
-            if let Some(end) = text.rfind('\"') {
-                if let Some(without_quotes) = text.get(2..end) {
-                    unescape::unescape_byte_str(without_quotes, &mut |range, char| {
-                        if let Err(err) = char {
-                            let off = range.start;
-                            let off = token.text_range().start() + TextUnit::from_usize(off + 2);
-                            acc.push(SyntaxError::new(err.into(), off))
-                        }
-                    })
-                }
+            if let Some(without_quotes) = unquote(text, 2, '"') {
+                unescape::unescape_byte_str(without_quotes, &mut |range, char| {
+                    if let Err(err) = char {
+                        push_err(2, (range.start, err));
+                    }
+                })
             }
         }
         STRING => {
-            if let Some(end) = text.rfind('\"') {
-                if let Some(without_quotes) = text.get(1..end) {
-                    unescape::unescape_str(without_quotes, &mut |range, char| {
-                        if let Err(err) = char {
-                            let off = range.start;
-                            let off = token.text_range().start() + TextUnit::from_usize(off + 1);
-                            acc.push(SyntaxError::new(err.into(), off))
-                        }
-                    })
-                }
+            if let Some(without_quotes) = unquote(text, 1, '"') {
+                unescape::unescape_str(without_quotes, &mut |range, char| {
+                    if let Err(err) = char {
+                        push_err(1, (range.start, err));
+                    }
+                })
             }
         }
         _ => (),
diff --git a/editors/code/package-lock.json b/editors/code/package-lock.json
index 3059323aa..05c57c7ff 100644
--- a/editors/code/package-lock.json
+++ b/editors/code/package-lock.json
@@ -889,32 +889,32 @@
             }
         },
         "vscode-jsonrpc": {
-            "version": "5.0.0-next.5",
-            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-5.0.0-next.5.tgz",
-            "integrity": "sha512-k9akfglxWgr0dtLNscq2uBq48XJwnhf4EaDxn05KQowRwR0DkNML0zeYqFRLtXZe6x5vpL5ppyu4o6GqL+23YQ=="
+            "version": "5.0.0",
+            "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-5.0.0.tgz",
+            "integrity": "sha512-QeAniC/xTWauVQgyNgEqNJ0Qm/Jw8QySGRQhRFPwb8c4FPp9k6QNgJp0ayXWws5qhdaHkiXkGPlzjOPZFQQKLw=="
         },
         "vscode-languageclient": {
-            "version": "6.0.0-next.9",
-            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-6.0.0-next.9.tgz",
-            "integrity": "sha512-NEpeeFM9FKrrRqlBHXGfwpkhtnjruDz3zfFBP+Cymr10qigAEtE/JsODJsIG/ErGqjh3/JXxu8SUOVTGu5oK+w==",
+            "version": "6.0.0",
+            "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-6.0.0.tgz",
+            "integrity": "sha512-6MDksAP79GRbcHFsXS6ndo12s0m/h7eNdS/IanRgWxaezqB4a4KzHIHrE0bE+nSFB+snaSToGs1bxnPeKdO5fQ==",
             "requires": {
                 "semver": "^6.3.0",
-                "vscode-languageserver-protocol": "^3.15.0-next.14"
+                "vscode-languageserver-protocol": "^3.15.0"
             }
         },
         "vscode-languageserver-protocol": {
-            "version": "3.15.0-next.14",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.15.0-next.14.tgz",
-            "integrity": "sha512-xUwwno6Q6RFd2Z2EWV9D3dQlsKPnHyiZMNWq+EC7JJdp2WH1gRlD+KPX4UGRCnJK0WI5omqHV313IESPwRY5xA==",
+            "version": "3.15.0",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.15.0.tgz",
+            "integrity": "sha512-PZEopQzHR3Lo422HeDxCpGN0sYz+kReO+du3F/AcFT1cCPunoVsDJv7ikEolFRKEn+hEIZiAaIX4yoSZ+ip5Nw==",
             "requires": {
-                "vscode-jsonrpc": "^5.0.0-next.5",
-                "vscode-languageserver-types": "^3.15.0-next.9"
+                "vscode-jsonrpc": "^5.0.0",
+                "vscode-languageserver-types": "3.15.0"
             }
         },
         "vscode-languageserver-types": {
-            "version": "3.15.0-next.9",
-            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.0-next.9.tgz",
-            "integrity": "sha512-Rl/8qJ6932nrHCdPn+9y0x08uLVQaSLRG+U4JzhyKpWU4eJbVaDRoAcz1Llj7CErJGbPr6kdBvShPy5fRfR+Uw=="
+            "version": "3.15.0",
+            "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.0.tgz",
+            "integrity": "sha512-AXteNagMhBWnZ6gNN0UB4HTiD/7TajgfHl6jaM6O7qz3zDJw0H3Jf83w05phihnBRCML+K6Ockh8f8bL0OObPw=="
         },
         "wrappy": {
             "version": "1.0.2",
diff --git a/editors/code/package.json b/editors/code/package.json
index ed637d114..d4c310734 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -25,7 +25,7 @@
     "dependencies": {
         "jsonc-parser": "^2.1.0",
         "seedrandom": "^3.0.5",
-        "vscode-languageclient": "^6.0.0-next.9"
+        "vscode-languageclient": "^6.0.0"
     },
     "devDependencies": {
         "@rollup/plugin-commonjs": "^11.0.0",
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index ec2790b63..fc21c8813 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -42,6 +42,7 @@ export class Config {
 
     private prevEnhancedTyping: null | boolean = null;
     private prevCargoFeatures: null | CargoFeatures = null;
+    private prevCargoWatchOptions: null | CargoWatchOptions = null;
 
     constructor(ctx: vscode.ExtensionContext) {
         vscode.workspace.onDidChangeConfiguration(_ => this.refresh(), ctx.subscriptions);
@@ -174,6 +175,21 @@ export class Config {
         }
         this.prevCargoFeatures = { ...this.cargoFeatures };
 
+        if (this.prevCargoWatchOptions !== null) {
+            const changed =
+                this.cargoWatchOptions.enable !== this.prevCargoWatchOptions.enable ||
+                this.cargoWatchOptions.command !== this.prevCargoWatchOptions.command ||
+                this.cargoWatchOptions.allTargets !== this.prevCargoWatchOptions.allTargets ||
+                this.cargoWatchOptions.arguments.length !== this.prevCargoWatchOptions.arguments.length ||
+                this.cargoWatchOptions.arguments.some(
+                    (v, i) => v !== this.prevCargoWatchOptions!.arguments[i],
+                );
+            if (changed) {
+                requireReloadMessage = 'Changing cargo-watch options requires a reload';
+            }
+        }
+        this.prevCargoWatchOptions = { ...this.cargoWatchOptions };
+
         if (requireReloadMessage !== null) {
             const reloadAction = 'Reload now';
             vscode.window