613 files changed, 31173 insertions, 32781 deletions

diff --git a/crates/expect/Cargo.toml b/crates/expect/Cargo.toml
new file mode 100644
index 000000000..77775630d
--- /dev/null
+++ b/crates/expect/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "expect"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+license = "MIT OR Apache-2.0"
+
+[lib]
+doctest = false
+
+[dependencies]
+once_cell = "1"
+difference = "2"
+stdx = { path = "../stdx" }
diff --git a/crates/expect/src/lib.rs b/crates/expect/src/lib.rs
new file mode 100644
index 000000000..21a458d47
--- /dev/null
+++ b/crates/expect/src/lib.rs
@@ -0,0 +1,356 @@
+//! Snapshot testing library, see
+//! https://github.com/rust-analyzer/rust-analyzer/pull/5101
+use std::{
+    collections::HashMap,
+    env, fmt, fs, mem,
+    ops::Range,
+    panic,
+    path::{Path, PathBuf},
+    sync::Mutex,
+};
+
+use difference::Changeset;
+use once_cell::sync::Lazy;
+use stdx::{lines_with_ends, trim_indent};
+
+const HELP: &str = "
+You can update all `expect![[]]` tests by running:
+
+    env UPDATE_EXPECT=1 cargo test
+
+To update a single test, place the cursor on `expect` token and use `run` feature of rust-analyzer.
+";
+
+fn update_expect() -> bool {
+    env::var("UPDATE_EXPECT").is_ok()
+}
+
+/// expect![[r#"inline snapshot"#]]
+#[macro_export]
+macro_rules! expect {
+    [[$data:literal]] => {$crate::Expect {
+        position: $crate::Position {
+            file: file!(),
+            line: line!(),
+            column: column!(),
+        },
+        data: $data,
+    }};
+    [[]] => { $crate::expect![[""]] };
+}
+
+/// expect_file!["/crates/foo/test_data/bar.html"]
+#[macro_export]
+macro_rules! expect_file {
+    [$path:expr] => {$crate::ExpectFile {
+        path: std::path::PathBuf::from($path)
+    }};
+}
+
+#[derive(Debug)]
+pub struct Expect {
+    pub position: Position,
+    pub data: &'static str,
+}
+
+#[derive(Debug)]
+pub struct ExpectFile {
+    pub path: PathBuf,
+}
+
+#[derive(Debug)]
+pub struct Position {
+    pub file: &'static str,
+    pub line: u32,
+    pub column: u32,
+}
+
+impl fmt::Display for Position {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}:{}", self.file, self.line, self.column)
+    }
+}
+
+impl Expect {
+    pub fn assert_eq(&self, actual: &str) {
+        let trimmed = self.trimmed();
+        if &trimmed == actual {
+            return;
+        }
+        Runtime::fail_expect(self, &trimmed, actual);
+    }
+    pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) {
+        let actual = format!("{:#?}\n", actual);
+        self.assert_eq(&actual)
+    }
+
+    fn trimmed(&self) -> String {
+        if !self.data.contains('\n') {
+            return self.data.to_string();
+        }
+        trim_indent(self.data)
+    }
+
+    fn locate(&self, file: &str) -> Location {
+        let mut target_line = None;
+        let mut line_start = 0;
+        for (i, line) in lines_with_ends(file).enumerate() {
+            if i == self.position.line as usize - 1 {
+                let pat = "expect![[";
+                let offset = line.find(pat).unwrap();
+                let literal_start = line_start + offset + pat.len();
+                let indent = line.chars().take_while(|&it| it == ' ').count();
+                target_line = Some((literal_start, indent));
+                break;
+            }
+            line_start += line.len();
+        }
+        let (literal_start, line_indent) = target_line.unwrap();
+        let literal_length =
+            file[literal_start..].find("]]").expect("Couldn't find matching `]]` for `expect![[`.");
+        let literal_range = literal_start..literal_start + literal_length;
+        Location { line_indent, literal_range }
+    }
+}
+
+impl ExpectFile {
+    pub fn assert_eq(&self, actual: &str) {
+        let expected = self.read();
+        if actual == expected {
+            return;
+        }
+        Runtime::fail_file(self, &expected, actual);
+    }
+    pub fn assert_debug_eq(&self, actual: &impl fmt::Debug) {
+        let actual = format!("{:#?}\n", actual);
+        self.assert_eq(&actual)
+    }
+    fn read(&self) -> String {
+        fs::read_to_string(self.abs_path()).unwrap_or_default().replace("\r\n", "\n")
+    }
+    fn write(&self, contents: &str) {
+        fs::write(self.abs_path(), contents).unwrap()
+    }
+    fn abs_path(&self) -> PathBuf {
+        WORKSPACE_ROOT.join(&self.path)
+    }
+}
+
+#[derive(Default)]
+struct Runtime {
+    help_printed: bool,
+    per_file: HashMap<&'static str, FileRuntime>,
+}
+static RT: Lazy<Mutex<Runtime>> = Lazy::new(Default::default);
+
+impl Runtime {
+    fn fail_expect(expect: &Expect, expected: &str, actual: &str) {
+        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        if update_expect() {
+            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.position);
+            rt.per_file
+                .entry(expect.position.file)
+                .or_insert_with(|| FileRuntime::new(expect))
+                .update(expect, actual);
+            return;
+        }
+        rt.panic(expect.position.to_string(), expected, actual);
+    }
+
+    fn fail_file(expect: &ExpectFile, expected: &str, actual: &str) {
+        let mut rt = RT.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
+        if update_expect() {
+            println!("\x1b[1m\x1b[92mupdating\x1b[0m: {}", expect.path.display());
+            expect.write(actual);
+            return;
+        }
+        rt.panic(expect.path.display().to_string(), expected, actual);
+    }
+
+    fn panic(&mut self, position: String, expected: &str, actual: &str) {
+        let print_help = !mem::replace(&mut self.help_printed, true);
+        let help = if print_help { HELP } else { "" };
+
+        let diff = Changeset::new(actual, expected, "\n");
+
+        println!(
+            "\n
+\x1b[1m\x1b[91merror\x1b[97m: expect test failed\x1b[0m
+   \x1b[1m\x1b[34m-->\x1b[0m {}
+{}
+\x1b[1mExpect\x1b[0m:
+----
+{}
+----
+
+\x1b[1mActual\x1b[0m:
+----
+{}
+----
+
+\x1b[1mDiff\x1b[0m:
+----
+{}
+----
+",
+            position, help, expected, actual, diff
+        );
+        // Use resume_unwind instead of panic!() to prevent a backtrace, which is unnecessary noise.
+        panic::resume_unwind(Box::new(()));
+    }
+}
+
+struct FileRuntime {
+    path: PathBuf,
+    original_text: String,
+    patchwork: Patchwork,
+}
+
+impl FileRuntime {
+    fn new(expect: &Expect) -> FileRuntime {
+        let path = WORKSPACE_ROOT.join(expect.position.file);
+        let original_text = fs::read_to_string(&path).unwrap();
+        let patchwork = Patchwork::new(original_text.clone());
+        FileRuntime { path, original_text, patchwork }
+    }
+    fn update(&mut self, expect: &Expect, actual: &str) {
+        let loc = expect.locate(&self.original_text);
+        let patch = format_patch(loc.line_indent.clone(), actual);
+        self.patchwork.patch(loc.literal_range, &patch);
+        fs::write(&self.path, &self.patchwork.text).unwrap()
+    }
+}
+
+#[derive(Debug)]
+struct Location {
+    line_indent: usize,
+    literal_range: Range<usize>,
+}
+
+#[derive(Debug)]
+struct Patchwork {
+    text: String,
+    indels: Vec<(Range<usize>, usize)>,
+}
+
+impl Patchwork {
+    fn new(text: String) -> Patchwork {
+        Patchwork { text, indels: Vec::new() }
+    }
+    fn patch(&mut self, mut range: Range<usize>, patch: &str) {
+        self.indels.push((range.clone(), patch.len()));
+        self.indels.sort_by_key(|(delete, _insert)| delete.start);
+
+        let (delete, insert) = self
+            .indels
+            .iter()
+            .take_while(|(delete, _)| delete.start < range.start)
+            .map(|(delete, insert)| (delete.end - delete.start, insert))
+            .fold((0usize, 0usize), |(x1, y1), (x2, y2)| (x1 + x2, y1 + y2));
+
+        for pos in &mut [&mut range.start, &mut range.end] {
+            **pos -= delete;
+            **pos += insert;
+        }
+
+        self.text.replace_range(range, &patch);
+    }
+}
+
+fn format_patch(line_indent: usize, patch: &str) -> String {
+    let mut max_hashes = 0;
+    let mut cur_hashes = 0;
+    for byte in patch.bytes() {
+        if byte != b'#' {
+            cur_hashes = 0;
+            continue;
+        }
+        cur_hashes += 1;
+        max_hashes = max_hashes.max(cur_hashes);
+    }
+    let hashes = &"#".repeat(max_hashes + 1);
+    let indent = &" ".repeat(line_indent);
+    let is_multiline = patch.contains('\n');
+
+    let mut buf = String::new();
+    buf.push('r');
+    buf.push_str(hashes);
+    buf.push('"');
+    if is_multiline {
+        buf.push('\n');
+    }
+    let mut final_newline = false;
+    for line in lines_with_ends(patch) {
+        if is_multiline && !line.trim().is_empty() {
+            buf.push_str(indent);
+            buf.push_str("    ");
+        }
+        buf.push_str(line);
+        final_newline = line.ends_with('\n');
+    }
+    if final_newline {
+        buf.push_str(indent);
+    }
+    buf.push('"');
+    buf.push_str(hashes);
+    buf
+}
+
+static WORKSPACE_ROOT: Lazy<PathBuf> = Lazy::new(|| {
+    let my_manifest =
+        env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned());
+    // Heuristic, see https://github.com/rust-lang/cargo/issues/3946
+    Path::new(&my_manifest)
+        .ancestors()
+        .filter(|it| it.join("Cargo.toml").exists())
+        .last()
+        .unwrap()
+        .to_path_buf()
+});
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_format_patch() {
+        let patch = format_patch(0, "hello\nworld\n");
+        expect![[r##"
+            r#"
+                hello
+                world
+            "#"##]]
+        .assert_eq(&patch);
+
+        let patch = format_patch(4, "single line");
+        expect![[r##"r#"single line"#"##]].assert_eq(&patch);
+    }
+
+    #[test]
+    fn test_patchwork() {
+        let mut patchwork = Patchwork::new("one two three".to_string());
+        patchwork.patch(4..7, "zwei");
+        patchwork.patch(0..3, "один");
+        patchwork.patch(8..13, "3");
+        expect![[r#"
+            Patchwork {
+                text: "один zwei 3",
+                indels: [
+                    (
+                        0..3,
+                        8,
+                    ),
+                    (
+                        4..7,
+                        4,
+                    ),
+                    (
+                        8..13,
+                        1,
+                    ),
+                ],
+            }
+        "#]]
+        .assert_debug_eq(&patchwork);
+    }
+}
diff --git a/crates/flycheck/Cargo.toml b/crates/flycheck/Cargo.toml
index dc26b8ce7..ff8a1e568 100644
--- a/crates/flycheck/Cargo.toml
+++ b/crates/flycheck/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "flycheck"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 
 [lib]
 doctest = false
@@ -10,7 +11,7 @@ doctest = false
 [dependencies]
 crossbeam-channel = "0.4.0"
 log = "0.4.8"
-cargo_metadata = "0.10.0"
+cargo_metadata = "0.11.1"
 serde_json = "1.0.48"
 jod-thread = "0.1.1"
 ra_toolchain = { path = "../ra_toolchain" }
diff --git a/crates/flycheck/src/lib.rs b/crates/flycheck/src/lib.rs
index 1023d3040..7c38f5ef9 100644
--- a/crates/flycheck/src/lib.rs
+++ b/crates/flycheck/src/lib.rs
@@ -14,14 +14,17 @@ use std::{
 use crossbeam_channel::{never, select, unbounded, Receiver, Sender};
 
 pub use cargo_metadata::diagnostic::{
-    Applicability, Diagnostic, DiagnosticLevel, DiagnosticSpan, DiagnosticSpanMacroExpansion,
+    Applicability, Diagnostic, DiagnosticCode, DiagnosticLevel, DiagnosticSpan,
+    DiagnosticSpanMacroExpansion,
 };
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FlycheckConfig {
     CargoCommand {
         command: String,
+        target_triple: Option<String>,
         all_targets: bool,
+        no_default_features: bool,
         all_features: bool,
         features: Vec<String>,
         extra_args: Vec<String>,
@@ -132,6 +135,7 @@ impl FlycheckActor {
                     self.cancel_check_process();
 
                     let mut command = self.check_command();
+                    log::info!("restart flycheck {:?}", command);
                     command.stdout(Stdio::piped()).stderr(Stdio::null()).stdin(Stdio::null());
                     if let Ok(child) = command.spawn().map(JodChild) {
                         self.cargo_handle = Some(CargoHandle::spawn(child));
@@ -176,6 +180,8 @@ impl FlycheckActor {
         let mut cmd = match &self.config {
             FlycheckConfig::CargoCommand {
                 command,
+                target_triple,
+                no_default_features,
                 all_targets,
                 all_features,
                 extra_args,
@@ -185,14 +191,23 @@ impl FlycheckActor {
                 cmd.arg(command);
                 cmd.args(&["--workspace", "--message-format=json", "--manifest-path"])
                     .arg(self.workspace_root.join("Cargo.toml"));
+
+                if let Some(target) = target_triple {
+                    cmd.args(&["--target", target.as_str()]);
+                }
                 if *all_targets {
                     cmd.arg("--all-targets");
                 }
                 if *all_features {
                     cmd.arg("--all-features");
-                } else if !features.is_empty() {
-                    cmd.arg("--features");
-                    cmd.arg(features.join(" "));
+                } else {
+                    if *no_default_features {
+                        cmd.arg("--no-default-features");
+                    }
+                    if !features.is_empty() {
+                        cmd.arg("--features");
+                        cmd.arg(features.join(" "));
+                    }
                 }
                 cmd.args(extra_args);
                 cmd
diff --git a/crates/paths/Cargo.toml b/crates/paths/Cargo.toml
index 646ee7fd5..cbe2c26e2 100644
--- a/crates/paths/Cargo.toml
+++ b/crates/paths/Cargo.toml
@@ -3,6 +3,7 @@ name = "paths"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 edition = "2018"
+license = "MIT OR Apache-2.0"
 
 [lib]
 doctest = false
diff --git a/crates/ra_arena/Cargo.toml b/crates/ra_arena/Cargo.toml
index d287dbb73..66c3738f4 100644
--- a/crates/ra_arena/Cargo.toml
+++ b/crates/ra_arena/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_arena"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 
 [lib]
 doctest = false
diff --git a/crates/ra_assists/Cargo.toml b/crates/ra_assists/Cargo.toml
index 3bcf58ba4..bd2905f08 100644
--- a/crates/ra_assists/Cargo.toml
+++ b/crates/ra_assists/Cargo.toml
@@ -3,6 +3,7 @@ edition = "2018"
 name = "ra_assists"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
+license = "MIT OR Apache-2.0"
 
 [lib]
 doctest = false
diff --git a/crates/ra_assists/src/assist_config.rs b/crates/ra_assists/src/assist_config.rs
index c0a0226fb..cda2abfb9 100644
--- a/crates/ra_assists/src/assist_config.rs
+++ b/crates/ra_assists/src/assist_config.rs
@@ -4,9 +4,12 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
 
+use crate::AssistKind;
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct AssistConfig {
     pub snippet_cap: Option<SnippetCap>,
+    pub allowed: Option<Vec<AssistKind>>,
 }
 
 impl AssistConfig {
@@ -22,6 +25,6 @@ pub struct SnippetCap {
 
 impl Default for AssistConfig {
     fn default() -> Self {
-        AssistConfig { snippet_cap: Some(SnippetCap { _private: () }) }
+        AssistConfig { snippet_cap: Some(SnippetCap { _private: () }), allowed: None }
     }
 }
diff --git a/crates/ra_assists/src/assist_context.rs b/crates/ra_assists/src/assist_context.rs
index ee614de72..3407df856 100644
--- a/crates/ra_assists/src/assist_context.rs
+++ b/crates/ra_assists/src/assist_context.rs
@@ -19,7 +19,7 @@ use ra_text_edit::TextEditBuilder;
 
 use crate::{
     assist_config::{AssistConfig, SnippetCap},
-    Assist, AssistId, GroupLabel, ResolvedAssist,
+    Assist, AssistId, AssistKind, GroupLabel, ResolvedAssist,
 };
 
 /// `AssistContext` allows to apply an assist or check if it could be applied.
@@ -55,7 +55,6 @@ use crate::{
 pub(crate) struct AssistContext<'a> {
     pub(crate) config: &'a AssistConfig,
     pub(crate) sema: Semantics<'a, RootDatabase>,
-    pub(crate) db: &'a RootDatabase,
     pub(crate) frange: FileRange,
     source_file: SourceFile,
 }
@@ -67,8 +66,11 @@ impl<'a> AssistContext<'a> {
         frange: FileRange,
     ) -> AssistContext<'a> {
         let source_file = sema.parse(frange.file_id);
-        let db = sema.db;
-        AssistContext { config, sema, db, frange, source_file }
+        AssistContext { config, sema, frange, source_file }
+    }
+
+    pub(crate) fn db(&self) -> &RootDatabase {
+        self.sema.db
     }
 
     // NB, this ignores active selection.
@@ -101,14 +103,26 @@ pub(crate) struct Assists {
     resolve: bool,
     file: FileId,
     buf: Vec<(Assist, Option<SourceChange>)>,
+    allowed: Option<Vec<AssistKind>>,
 }
 
 impl Assists {
     pub(crate) fn new_resolved(ctx: &AssistContext) -> Assists {
-        Assists { resolve: true, file: ctx.frange.file_id, buf: Vec::new() }
+        Assists {
+            resolve: true,
+            file: ctx.frange.file_id,
+            buf: Vec::new(),
+            allowed: ctx.config.allowed.clone(),
+        }
     }
+
     pub(crate) fn new_unresolved(ctx: &AssistContext) -> Assists {
-        Assists { resolve: false, file: ctx.frange.file_id, buf: Vec::new() }
+        Assists {
+            resolve: false,
+            file: ctx.frange.file_id,
+            buf: Vec::new(),
+            allowed: ctx.config.allowed.clone(),
+        }
     }
 
     pub(crate) fn finish_unresolved(self) -> Vec<Assist> {
@@ -137,9 +151,13 @@ impl Assists {
         target: TextRange,
         f: impl FnOnce(&mut AssistBuilder),
     ) -> Option<()> {
+        if !self.is_allowed(&id) {
+            return None;
+        }
         let label = Assist::new(id, label.into(), None, target);
         self.add_impl(label, f)
     }
+
     pub(crate) fn add_group(
         &mut self,
         group: &GroupLabel,
@@ -148,9 +166,14 @@ impl Assists {
         target: TextRange,
         f: impl FnOnce(&mut AssistBuilder),
     ) -> Option<()> {
+        if !self.is_allowed(&id) {
+            return None;
+        }
+
         let label = Assist::new(id, label.into(), Some(group.clone()), target);
         self.add_impl(label, f)
     }
+
     fn add_impl(&mut self, label: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
         let source_change = if self.resolve {
             let mut builder = AssistBuilder::new(self.file);
@@ -168,13 +191,20 @@ impl Assists {
         self.buf.sort_by_key(|(label, _edit)| label.target.len());
         self.buf
     }
+
+    fn is_allowed(&self, id: &AssistId) -> bool {
+        match &self.allowed {
+            Some(allowed) => allowed.iter().any(|kind| kind.contains(id.1)),
+            None => true,
+        }
+    }
 }
 
 pub(crate) struct AssistBuilder {
     edit: TextEditBuilder,
     file_id: FileId,
     is_snippet: bool,
-    edits: Vec<SourceFileEdit>,
+    change: SourceChange,
 }
 
 impl AssistBuilder {
@@ -183,7 +213,7 @@ impl AssistBuilder {
             edit: TextEditBuilder::default(),
             file_id,
             is_snippet: false,
-            edits: Vec::new(),
+            change: SourceChange::default(),
         }
     }
 
@@ -195,8 +225,8 @@ impl AssistBuilder {
         let edit = mem::take(&mut self.edit).finish();
         if !edit.is_empty() {
             let new_edit = SourceFileEdit { file_id: self.file_id, edit };
-            assert!(!self.edits.iter().any(|it| it.file_id == new_edit.file_id));
-            self.edits.push(new_edit);
+            assert!(!self.change.source_file_edits.iter().any(|it| it.file_id == new_edit.file_id));
+            self.change.source_file_edits.push(new_edit);
         }
     }
 
@@ -263,10 +293,10 @@ impl AssistBuilder {
 
     fn finish(mut self) -> SourceChange {
         self.commit();
-        let mut res: SourceChange = mem::take(&mut self.edits).into();
+        let mut change = mem::take(&mut self.change);
         if self.is_snippet {
-            res.is_snippet = true;
+            change.is_snippet = true;
         }
-        res
+        change
     }
 }
diff --git a/crates/ra_assists/src/ast_transform.rs b/crates/ra_assists/src/ast_transform.rs
index 00fa95b6c..5ea4f9f5b 100644
--- a/crates/ra_assists/src/ast_transform.rs
+++ b/crates/ra_assists/src/ast_transform.rs
@@ -2,7 +2,6 @@
 use rustc_hash::FxHashMap;
 
 use hir::{HirDisplay, PathResolution, SemanticsScope};
-use ra_ide_db::RootDatabase;
 use ra_syntax::{
     algo::SyntaxRewriter,
     ast::{self, AstNode},
@@ -32,17 +31,17 @@ impl<'a> AstTransform<'a> for NullTransformer {
 }
 
 pub struct SubstituteTypeParams<'a> {
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    source_scope: &'a SemanticsScope<'a>,
     substs: FxHashMap<hir::TypeParam, ast::TypeRef>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> SubstituteTypeParams<'a> {
     pub fn for_trait_impl(
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
+        source_scope: &'a SemanticsScope<'a>,
         // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
         trait_: hir::Trait,
-        impl_def: ast::ImplDef,
+        impl_def: ast::Impl,
     ) -> SubstituteTypeParams<'a> {
         let substs = get_syntactic_substs(impl_def).unwrap_or_default();
         let generic_def: hir::GenericDef = trait_.into();
@@ -81,7 +80,7 @@ impl<'a> SubstituteTypeParams<'a> {
 
         // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the
         // trait ref, and then go from the types in the substs back to the syntax)
-        fn get_syntactic_substs(impl_def: ast::ImplDef) -> Option<Vec<ast::TypeRef>> {
+        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::TypeRef>> {
             let target_trait = impl_def.target_trait()?;
             let path_type = match target_trait {
                 ast::TypeRef::PathType(path) => path,
@@ -126,16 +125,13 @@ impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
 }
 
 pub struct QualifyPaths<'a> {
-    target_scope: &'a SemanticsScope<'a, RootDatabase>,
-    source_scope: &'a SemanticsScope<'a, RootDatabase>,
+    target_scope: &'a SemanticsScope<'a>,
+    source_scope: &'a SemanticsScope<'a>,
     previous: Box<dyn AstTransform<'a> + 'a>,
 }
 
 impl<'a> QualifyPaths<'a> {
-    pub fn new(
-        target_scope: &'a SemanticsScope<'a, RootDatabase>,
-        source_scope: &'a SemanticsScope<'a, RootDatabase>,
-    ) -> Self {
+    pub fn new(target_scope: &'a SemanticsScope<'a>, source_scope: &'a SemanticsScope<'a>) -> Self {
         Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
     }
 
@@ -156,7 +152,7 @@ impl<'a> QualifyPaths<'a> {
         let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
         match resolution {
             PathResolution::Def(def) => {
-                let found_path = from.find_use_path(self.source_scope.db, def)?;
+                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
                 let mut path = path_to_ast(found_path);
 
                 let type_args = p
diff --git a/crates/ra_assists/src/handlers/add_custom_impl.rs b/crates/ra_assists/src/handlers/add_custom_impl.rs
index fa70c8496..b67438b6b 100644
--- a/crates/ra_assists/src/handlers/add_custom_impl.rs
+++ b/crates/ra_assists/src/handlers/add_custom_impl.rs
@@ -8,7 +8,7 @@ use stdx::SepBy;
 
 use crate::{
     assist_context::{AssistContext, Assists},
-    AssistId,
+    AssistId, AssistKind,
 };
 
 // Assist: add_custom_impl
@@ -29,8 +29,8 @@ use crate::{
 // }
 // ```
 pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let input = ctx.find_node_at_offset::<ast::AttrInput>()?;
-    let attr = input.syntax().parent().and_then(ast::Attr::cast)?;
+    let attr = ctx.find_node_at_offset::<ast::Attr>()?;
+    let input = attr.token_tree()?;
 
     let attr_name = attr
         .syntax()
@@ -52,7 +52,7 @@ pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<
         format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name);
 
     let target = attr.syntax().text_range();
-    acc.add(AssistId("add_custom_impl"), label, target, |builder| {
+    acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| {
         let new_attr_input = input
             .syntax()
             .descendants_with_tokens()
diff --git a/crates/ra_assists/src/handlers/add_explicit_type.rs b/crates/ra_assists/src/handlers/add_explicit_type.rs
index 90b06a625..e69f0a89b 100644
--- a/crates/ra_assists/src/handlers/add_explicit_type.rs
+++ b/crates/ra_assists/src/handlers/add_explicit_type.rs
@@ -1,10 +1,10 @@
 use hir::HirDisplay;
 use ra_syntax::{
-    ast::{self, AstNode, LetStmt, NameOwner, TypeAscriptionOwner},
+    ast::{self, AstNode, LetStmt, NameOwner},
     TextRange,
 };
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: add_explicit_type
 //
@@ -22,11 +22,11 @@ use crate::{AssistContext, AssistId, Assists};
 // }
 // ```
 pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let stmt = ctx.find_node_at_offset::<LetStmt>()?;
-    let module = ctx.sema.scope(stmt.syntax()).module()?;
-    let expr = stmt.initializer()?;
+    let let_stmt = ctx.find_node_at_offset::<LetStmt>()?;
+    let module = ctx.sema.scope(let_stmt.syntax()).module()?;
+    let expr = let_stmt.initializer()?;
     // Must be a binding
-    let pat = match stmt.pat()? {
+    let pat = match let_stmt.pat()? {
         ast::Pat::BindPat(bind_pat) => bind_pat,
         _ => return None,
     };
@@ -34,8 +34,8 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     // The binding must have a name
     let name = pat.name()?;
     let name_range = name.syntax().text_range();
-    let stmt_range = stmt.syntax().text_range();
-    let eq_range = stmt.eq_token()?.text_range();
+    let stmt_range = let_stmt.syntax().text_range();
+    let eq_range = let_stmt.eq_token()?.text_range();
     // Assist should only be applicable if cursor is between 'let' and '='
     let let_range = TextRange::new(stmt_range.start(), eq_range.start());
     let cursor_in_range = let_range.contains_range(ctx.frange.range);
@@ -44,7 +44,7 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
     }
     // Assist not applicable if the type has already been specified
     // and it has no placeholders
-    let ascribed_ty = stmt.ascribed_type();
+    let ascribed_ty = let_stmt.ty();
     if let Some(ty) = &ascribed_ty {
         if ty.syntax().descendants().find_map(ast::PlaceholderType::cast).is_none() {
             return None;
@@ -57,9 +57,9 @@ pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Optio
         return None;
     }
 
-    let inferred_type = ty.display_source_code(ctx.db, module.into()).ok()?;
+    let inferred_type = ty.display_source_code(ctx.db(), module.into()).ok()?;
     acc.add(
-        AssistId("add_explicit_type"),
+        AssistId("add_explicit_type", AssistKind::RefactorRewrite),
         format!("Insert explicit type `{}`", inferred_type),
         pat_range,
         |builder| match ascribed_ty {
diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs
deleted file mode 100644
index eceba7d0a..000000000
--- a/crates/ra_assists/src/handlers/add_impl.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use ra_syntax::ast::{self, AstNode, NameOwner, TypeParamsOwner};
-use stdx::{format_to, SepBy};
-
-use crate::{AssistContext, AssistId, Assists};
-
-// Assist: add_impl
-//
-// Adds a new inherent impl for a type.
-//
-// ```
-// struct Ctx<T: Clone> {
-//     data: T,<|>
-// }
-// ```
-// ->
-// ```
-// struct Ctx<T: Clone> {
-//     data: T,
-// }
-//
-// impl<T: Clone> Ctx<T> {
-//     $0
-// }
-// ```
-pub(crate) fn add_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let nominal = ctx.find_node_at_offset::<ast::NominalDef>()?;
-    let name = nominal.name()?;
-    let target = nominal.syntax().text_range();
-    acc.add(AssistId("add_impl"), format!("Implement {}", name.text().as_str()), target, |edit| {
-        let type_params = nominal.type_param_list();
-        let start_offset = nominal.syntax().text_range().end();
-        let mut buf = String::new();
-        buf.push_str("\n\nimpl");
-        if let Some(type_params) = &type_params {
-            format_to!(buf, "{}", type_params.syntax());
-        }
-        buf.push_str(" ");
-        buf.push_str(name.text().as_str());
-        if let Some(type_params) = type_params {
-            let lifetime_params = type_params
-                .lifetime_params()
-                .filter_map(|it| it.lifetime_token())
-                .map(|it| it.text().clone());
-            let type_params =
-                type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone());
-
-            let generic_params = lifetime_params.chain(type_params).sep_by(", ");
-            format_to!(buf, "<{}>", generic_params)
-        }
-        match ctx.config.snippet_cap {
-            Some(cap) => {
-                buf.push_str(" {\n    $0\n}");
-                edit.insert_snippet(cap, start_offset, buf);
-            }
-            None => {
-                buf.push_str(" {\n}");
-                edit.insert(start_offset, buf);
-            }
-        }
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::tests::{check_assist, check_assist_target};
-
-    use super::*;
-
-    #[test]
-    fn test_add_impl() {
-        check_assist(add_impl, "struct Foo {<|>}\n", "struct Foo {}\n\nimpl Foo {\n    $0\n}\n");
-        check_assist(
-            add_impl,
-            "struct Foo<T: Clone> {<|>}",
-            "struct Foo<T: Clone> {}\n\nimpl<T: Clone> Foo<T> {\n    $0\n}",
-        );
-        check_assist(
-            add_impl,
-            "struct Foo<'a, T: Foo<'a>> {<|>}",
-            "struct Foo<'a, T: Foo<'a>> {}\n\nimpl<'a, T: Foo<'a>> Foo<'a, T> {\n    $0\n}",
-        );
-    }
-
-    #[test]
-    fn add_impl_target() {
-        check_assist_target(
-            add_impl,
-            "
-struct SomeThingIrrelevant;
-/// Has a lifetime parameter
-struct Foo<'a, T: Foo<'a>> {<|>}
-struct EvenMoreIrrelevant;
-",
-            "/// Has a lifetime parameter
-struct Foo<'a, T: Foo<'a>> {}",
-        );
-    }
-}
diff --git a/crates/ra_assists/src/handlers/add_missing_impl_members.rs b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
index abacd4065..95a750aee 100644
--- a/crates/ra_assists/src/handlers/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/handlers/add_missing_impl_members.rs
@@ -12,7 +12,7 @@ use crate::{
     assist_context::{AssistContext, Assists},
     ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
     utils::{get_missing_assoc_items, render_snippet, resolve_target_trait, Cursor},
-    AssistId,
+    AssistId, AssistKind,
 };
 
 #[derive(PartialEq)]
@@ -111,16 +111,17 @@ fn add_missing_impl_members_inner(
     label: &'static str,
 ) -> Option<()> {
     let _p = ra_prof::profile("add_missing_impl_members_inner");
-    let impl_def = ctx.find_node_at_offset::<ast::ImplDef>()?;
-    let impl_item_list = impl_def.item_list()?;
+    let impl_def = ctx.find_node_at_offset::<ast::Impl>()?;
+    let impl_item_list = impl_def.assoc_item_list()?;
 
     let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
 
     let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
         match item {
-            ast::AssocItem::FnDef(def) => def.name(),
-            ast::AssocItem::TypeAliasDef(def) => def.name(),
-            ast::AssocItem::ConstDef(def) => def.name(),
+            ast::AssocItem::Fn(def) => def.name(),
+            ast::AssocItem::TypeAlias(def) => def.name(),
+            ast::AssocItem::Const(def) => def.name(),
+            ast::AssocItem::MacroCall(_) => None,
         }
         .map(|it| it.text().clone())
     };
@@ -128,13 +129,13 @@ fn add_missing_impl_members_inner(
     let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
         .iter()
         .map(|i| match i {
-            hir::AssocItem::Function(i) => ast::AssocItem::FnDef(i.source(ctx.db).value),
-            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAliasDef(i.source(ctx.db).value),
-            hir::AssocItem::Const(i) => ast::AssocItem::ConstDef(i.source(ctx.db).value),
+            hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(ctx.db()).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(ctx.db()).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(ctx.db()).value),
         })
         .filter(|t| def_name(&t).is_some())
         .filter(|t| match t {
-            ast::AssocItem::FnDef(def) => match mode {
+            ast::AssocItem::Fn(def) => match mode {
                 AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
                 AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
             },
@@ -147,7 +148,7 @@ fn add_missing_impl_members_inner(
     }
 
     let target = impl_def.syntax().text_range();
-    acc.add(AssistId(assist_id), label, target, |builder| {
+    acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| {
         let n_existing_items = impl_item_list.assoc_items().count();
         let source_scope = ctx.sema.scope_for_def(trait_);
         let target_scope = ctx.sema.scope(impl_item_list.syntax());
@@ -157,7 +158,8 @@ fn add_missing_impl_members_inner(
             .into_iter()
             .map(|it| ast_transform::apply(&*ast_transform, it))
             .map(|it| match it {
-                ast::AssocItem::FnDef(def) => ast::AssocItem::FnDef(add_body(def)),
+                ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)),
+                ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()),
                 _ => it,
             })
             .map(|it| edit::remove_attrs_and_docs(&it));
@@ -170,7 +172,7 @@ fn add_missing_impl_members_inner(
             Some(cap) => {
                 let mut cursor = Cursor::Before(first_new_item.syntax());
                 let placeholder;
-                if let ast::AssocItem::FnDef(func) = &first_new_item {
+                if let ast::AssocItem::Fn(func) = &first_new_item {
                     if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) {
                         if m.syntax().text() == "todo!()" {
                             placeholder = m;
@@ -188,7 +190,7 @@ fn add_missing_impl_members_inner(
     })
 }
 
-fn add_body(fn_def: ast::FnDef) -> ast::FnDef {
+fn add_body(fn_def: ast::Fn) -> ast::Fn {
     if fn_def.body().is_some() {
         return fn_def;
     }
@@ -684,4 +686,26 @@ impl Foo<T> for S<T> {
 }"#,
         )
     }
+
+    #[test]
+    fn test_assoc_type_bounds_are_removed() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+
+impl Tr for ()<|> {
+}"#,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+
+impl Tr for () {
+    $0type Ty;
+}"#,
+        )
+    }
 }
diff --git a/crates/ra_assists/src/handlers/add_turbo_fish.rs b/crates/ra_assists/src/handlers/add_turbo_fish.rs
index 26acf81f2..0c565e89a 100644
--- a/crates/ra_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ra_assists/src/handlers/add_turbo_fish.rs
@@ -4,7 +4,7 @@ use test_utils::mark;
 
 use crate::{
     assist_context::{AssistContext, Assists},
-    AssistId,
+    AssistId, AssistKind,
 };
 
 // Assist: add_turbo_fish
@@ -25,7 +25,14 @@ use crate::{
 // }
 // ```
 pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let ident = ctx.find_token_at_offset(SyntaxKind::IDENT)?;
+    let ident = ctx.find_token_at_offset(SyntaxKind::IDENT).or_else(|| {
+        let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
+        if arg_list.args().count() > 0 {
+            return None;
+        }
+        mark::hit!(add_turbo_fish_after_call);
+        arg_list.l_paren_token()?.prev_token().filter(|it| it.kind() == SyntaxKind::IDENT)
+    })?;
     let next_token = ident.next_token()?;
     if next_token.kind() == T![::] {
         mark::hit!(add_turbo_fish_one_fish_is_enough);
@@ -45,12 +52,15 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
         mark::hit!(add_turbo_fish_non_generic);
         return None;
     }
-    acc.add(AssistId("add_turbo_fish"), "Add `::<>`", ident.text_range(), |builder| {
-        match ctx.config.snippet_cap {
+    acc.add(
+        AssistId("add_turbo_fish", AssistKind::RefactorRewrite),
+        "Add `::<>`",
+        ident.text_range(),
+        |builder| match ctx.config.snippet_cap {
             Some(cap) => builder.insert_snippet(cap, ident.text_range().end(), "::<${0:_}>"),
             None => builder.insert(ident.text_range().end(), "::<_>"),
-        }
-    })
+        },
+    )
 }
 
 #[cfg(test)]
@@ -80,6 +90,26 @@ fn main() {
     }
 
     #[test]
+    fn add_turbo_fish_after_call() {
+        mark::check!(add_turbo_fish_after_call);
+        check_assist(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make()<|>;
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make::<${0:_}>();
+}
+"#,
+        );
+    }
+
+    #[test]
     fn add_turbo_fish_method() {
         check_assist(
             add_turbo_fish,
diff --git a/crates/ra_assists/src/handlers/apply_demorgan.rs b/crates/ra_assists/src/handlers/apply_demorgan.rs
index 233e8fb8e..de701f8b8 100644
--- a/crates/ra_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ra_assists/src/handlers/apply_demorgan.rs
@@ -1,6 +1,6 @@
 use ra_syntax::ast::{self, AstNode};
 
-use crate::{utils::invert_boolean_expression, AssistContext, AssistId, Assists};
+use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: apply_demorgan
 //
@@ -39,11 +39,16 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
     let rhs_range = rhs.syntax().text_range();
     let not_rhs = invert_boolean_expression(rhs);
 
-    acc.add(AssistId("apply_demorgan"), "Apply De Morgan's law", op_range, |edit| {
-        edit.replace(op_range, opposite_op);
-        edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
-        edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
-    })
+    acc.add(
+        AssistId("apply_demorgan", AssistKind::RefactorRewrite),
+        "Apply De Morgan's law",
+        op_range,
+        |edit| {
+            edit.replace(op_range, opposite_op);
+            edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+            edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+        },
+    )
 }
 
 // Return the opposite text for a given logical operator, if it makes sense
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index d1cafa7d9..01e7b7a44 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -5,7 +5,7 @@ use hir::{
     AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
     Type,
 };
-use ra_ide_db::{imports_locator::ImportsLocator, RootDatabase};
+use ra_ide_db::{imports_locator, RootDatabase};
 use ra_prof::profile;
 use ra_syntax::{
     ast::{self, AstNode},
@@ -13,7 +13,9 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists, GroupLabel};
+use crate::{
+    utils::insert_use_statement, AssistContext, AssistId, AssistKind, Assists, GroupLabel,
+};
 
 // Assist: auto_import
 //
@@ -35,8 +37,8 @@ use crate::{utils::insert_use_statement, AssistContext, AssistId, Assists, Group
 // # pub mod std { pub mod collections { pub struct HashMap { } } }
 // ```
 pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let auto_import_assets = AutoImportAssets::new(&ctx)?;
-    let proposed_imports = auto_import_assets.search_for_imports(ctx.db);
+    let auto_import_assets = AutoImportAssets::new(ctx)?;
+    let proposed_imports = auto_import_assets.search_for_imports(ctx);
     if proposed_imports.is_empty() {
         return None;
     }
@@ -46,7 +48,7 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     for import in proposed_imports {
         acc.add_group(
             &group,
-            AssistId("auto_import"),
+            AssistId("auto_import", AssistKind::QuickFix),
             format!("Import `{}`", &import),
             range,
             |builder| {
@@ -90,7 +92,7 @@ impl AutoImportAssets {
 
     fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistContext) -> Option<Self> {
         let syntax_under_caret = path_under_caret.syntax().to_owned();
-        if syntax_under_caret.ancestors().find_map(ast::UseItem::cast).is_some() {
+        if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
             return None;
         }
 
@@ -127,11 +129,11 @@ impl AutoImportAssets {
         GroupLabel(name)
     }
 
-    fn search_for_imports(&self, db: &RootDatabase) -> BTreeSet<ModPath> {
+    fn search_for_imports(&self, ctx: &AssistContext) -> BTreeSet<ModPath> {
         let _p = profile("auto_import::search_for_imports");
+        let db = ctx.db();
         let current_crate = self.module_with_name_to_import.krate();
-        ImportsLocator::new(db, current_crate)
-            .find_imports(&self.get_search_query())
+        imports_locator::find_imports(&ctx.sema, current_crate, &self.get_search_query())
             .into_iter()
             .filter_map(|candidate| match &self.import_candidate {
                 ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
@@ -811,6 +813,146 @@ fn main() {
     }
 
     #[test]
+    fn trait_method_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_method()
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::test_func<|>tion
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                dep::test_mod::TestStruct::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_const_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::CONST<|>
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    const CONST: bool;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const CONST: bool = true;
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                dep::test_mod::TestStruct::CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_as_method_cross_crate() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_func<|>tion()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn private_trait_cross_crate() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
     fn not_applicable_for_imported_trait_for_method() {
         check_assist_not_applicable(
             auto_import,
diff --git a/crates/ra_assists/src/handlers/change_return_type_to_result.rs b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
index 855baf187..167e162d8 100644
--- a/crates/ra_assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/ra_assists/src/handlers/change_return_type_to_result.rs
@@ -3,7 +3,7 @@ use ra_syntax::{
     AstNode, SyntaxNode,
 };
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 use test_utils::mark;
 
 // Assist: change_return_type_to_result
@@ -20,9 +20,9 @@ use test_utils::mark;
 pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
     // FIXME: extend to lambdas as well
-    let fn_def = ret_type.syntax().parent().and_then(ast::FnDef::cast)?;
+    let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?;
 
-    let type_ref = &ret_type.type_ref()?;
+    let type_ref = &ret_type.ty()?;
     let ret_type_str = type_ref.syntax().text().to_string();
     let first_part_ret_type = ret_type_str.splitn(2, '<').next();
     if let Some(ret_type_first_part) = first_part_ret_type {
@@ -35,8 +35,8 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex
     let block_expr = &fn_def.body()?;
 
     acc.add(
-        AssistId("change_return_type_to_result"),
-        "Change return type to Result",
+        AssistId("change_return_type_to_result", AssistKind::RefactorRewrite),
+        "Wrap return type in Result",
         type_ref.syntax().text_range(),
         |builder| {
             let mut tail_return_expr_collector = TailReturnCollector::new();
@@ -240,7 +240,7 @@ fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
         Expr::ParenExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::PathExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::Label(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
-        Expr::RecordLit(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
+        Expr::RecordExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::IndexExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::MethodCallExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
         Expr::AwaitExpr(expr) => Some(vec![NodeType::Leaf(expr.syntax().clone())]),
diff --git a/crates/ra_assists/src/handlers/change_visibility.rs b/crates/ra_assists/src/handlers/change_visibility.rs
index 157c7b665..724daa93f 100644
--- a/crates/ra_assists/src/handlers/change_visibility.rs
+++ b/crates/ra_assists/src/handlers/change_visibility.rs
@@ -1,12 +1,12 @@
 use ra_syntax::{
     ast::{self, NameOwner, VisibilityOwner},
     AstNode,
-    SyntaxKind::{CONST_DEF, ENUM_DEF, FN_DEF, MODULE, STRUCT_DEF, TRAIT_DEF, VISIBILITY},
+    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT, VISIBILITY},
     T,
 };
 use test_utils::mark;
 
-use crate::{utils::vis_offset, AssistContext, AssistId, Assists};
+use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: change_visibility
 //
@@ -28,12 +28,15 @@ pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Optio
 
 fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let item_keyword = ctx.token_at_offset().find(|leaf| {
-        matches!(leaf.kind(), T![const] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait])
+        matches!(
+            leaf.kind(),
+            T![const] | T![static] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait]
+        )
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
         let parent = keyword.parent();
-        let def_kws = vec![CONST_DEF, FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
+        let def_kws = vec![CONST, STATIC, FN, MODULE, STRUCT, ENUM, TRAIT];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
             return None;
@@ -44,7 +47,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
         }
         (vis_offset(&parent), keyword.text_range())
     } else if let Some(field_name) = ctx.find_node_at_offset::<ast::Name>() {
-        let field = field_name.syntax().ancestors().find_map(ast::RecordFieldDef::cast)?;
+        let field = field_name.syntax().ancestors().find_map(ast::RecordField::cast)?;
         if field.name()? != field_name {
             mark::hit!(change_visibility_field_false_positive);
             return None;
@@ -53,7 +56,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
             return None;
         }
         (vis_offset(field.syntax()), field_name.syntax().text_range())
-    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleFieldDef>() {
+    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleField>() {
         if field.visibility().is_some() {
             return None;
         }
@@ -62,16 +65,21 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
         return None;
     };
 
-    acc.add(AssistId("change_visibility"), "Change visibility to pub(crate)", target, |edit| {
-        edit.insert(offset, "pub(crate) ");
-    })
+    acc.add(
+        AssistId("change_visibility", AssistKind::RefactorRewrite),
+        "Change visibility to pub(crate)",
+        target,
+        |edit| {
+            edit.insert(offset, "pub(crate) ");
+        },
+    )
 }
 
 fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
     if vis.syntax().text() == "pub" {
         let target = vis.syntax().text_range();
         return acc.add(
-            AssistId("change_visibility"),
+            AssistId("change_visibility", AssistKind::RefactorRewrite),
             "Change Visibility to pub(crate)",
             target,
             |edit| {
@@ -82,7 +90,7 @@ fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
     if vis.syntax().text() == "pub(crate)" {
         let target = vis.syntax().text_range();
         return acc.add(
-            AssistId("change_visibility"),
+            AssistId("change_visibility", AssistKind::RefactorRewrite),
             "Change visibility to pub",
             target,
             |edit| {
@@ -147,6 +155,11 @@ mod tests {
     }
 
     #[test]
+    fn change_visibility_static() {
+        check_assist(change_visibility, "<|>static FOO = 3u8;", "pub(crate) static FOO = 3u8;");
+    }
+
+    #[test]
     fn change_visibility_handles_comment_attrs() {
         check_assist(
             change_visibility,
diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index dfade7432..3650289fd 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -8,14 +8,14 @@ use ra_syntax::{
         make,
     },
     AstNode,
-    SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
+    SyntaxKind::{FN, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
     SyntaxNode,
 };
 
 use crate::{
     assist_context::{AssistContext, Assists},
     utils::invert_boolean_expression,
-    AssistId,
+    AssistId, AssistKind,
 };
 
 // Assist: convert_to_guarded_return
@@ -88,7 +88,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
 
     let early_expression: ast::Expr = match parent_container.kind() {
         WHILE_EXPR | LOOP_EXPR => make::expr_continue(),
-        FN_DEF => make::expr_return(),
+        FN => make::expr_return(),
         _ => return None,
     };
 
@@ -99,86 +99,92 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
     then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
 
     let target = if_expr.syntax().text_range();
-    acc.add(AssistId("convert_to_guarded_return"), "Convert to guarded return", target, |edit| {
-        let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
-        let new_block = match if_let_pat {
-            None => {
-                // If.
-                let new_expr = {
-                    let then_branch =
-                        make::block_expr(once(make::expr_stmt(early_expression).into()), None);
-                    let cond = invert_boolean_expression(cond_expr);
-                    make::expr_if(make::condition(cond, None), then_branch).indent(if_indent_level)
-                };
-                replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
-            }
-            Some((path, bound_ident)) => {
-                // If-let.
-                let match_expr = {
-                    let happy_arm = {
-                        let pat = make::tuple_struct_pat(
-                            path,
-                            once(make::bind_pat(make::name("it")).into()),
-                        );
-                        let expr = {
-                            let name_ref = make::name_ref("it");
-                            let segment = make::path_segment(name_ref);
-                            let path = make::path_unqualified(segment);
-                            make::expr_path(path)
-                        };
-                        make::match_arm(once(pat.into()), expr)
+    acc.add(
+        AssistId("convert_to_guarded_return", AssistKind::RefactorRewrite),
+        "Convert to guarded return",
+        target,
+        |edit| {
+            let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
+            let new_block = match if_let_pat {
+                None => {
+                    // If.
+                    let new_expr = {
+                        let then_branch =
+                            make::block_expr(once(make::expr_stmt(early_expression).into()), None);
+                        let cond = invert_boolean_expression(cond_expr);
+                        make::expr_if(make::condition(cond, None), then_branch)
+                            .indent(if_indent_level)
                     };
+                    replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
+                }
+                Some((path, bound_ident)) => {
+                    // If-let.
+                    let match_expr = {
+                        let happy_arm = {
+                            let pat = make::tuple_struct_pat(
+                                path,
+                                once(make::bind_pat(make::name("it")).into()),
+                            );
+                            let expr = {
+                                let name_ref = make::name_ref("it");
+                                let segment = make::path_segment(name_ref);
+                                let path = make::path_unqualified(segment);
+                                make::expr_path(path)
+                            };
+                            make::match_arm(once(pat.into()), expr)
+                        };
 
-                    let sad_arm = make::match_arm(
-                        // FIXME: would be cool to use `None` or `Err(_)` if appropriate
-                        once(make::placeholder_pat().into()),
-                        early_expression,
-                    );
+                        let sad_arm = make::match_arm(
+                            // FIXME: would be cool to use `None` or `Err(_)` if appropriate
+                            once(make::placeholder_pat().into()),
+                            early_expression,
+                        );
 
-                    make::expr_match(cond_expr, make::match_arm_list(vec![happy_arm, sad_arm]))
-                };
+                        make::expr_match(cond_expr, make::match_arm_list(vec![happy_arm, sad_arm]))
+                    };
 
-                let let_stmt = make::let_stmt(
-                    make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
-                    Some(match_expr),
+                    let let_stmt = make::let_stmt(
+                        make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
+                        Some(match_expr),
+                    );
+                    let let_stmt = let_stmt.indent(if_indent_level);
+                    replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
+                }
+            };
+            edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
+
+            fn replace(
+                new_expr: &SyntaxNode,
+                then_block: &ast::BlockExpr,
+                parent_block: &ast::BlockExpr,
+                if_expr: &ast::IfExpr,
+            ) -> SyntaxNode {
+                let then_block_items = then_block.dedent(IndentLevel(1));
+                let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
+                let end_of_then =
+                    if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
+                        end_of_then.prev_sibling_or_token().unwrap()
+                    } else {
+                        end_of_then
+                    };
+                let mut then_statements = new_expr.children_with_tokens().chain(
+                    then_block_items
+                        .syntax()
+                        .children_with_tokens()
+                        .skip(1)
+                        .take_while(|i| *i != end_of_then),
                 );
-                let let_stmt = let_stmt.indent(if_indent_level);
-                replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
+                replace_children(
+                    &parent_block.syntax(),
+                    RangeInclusive::new(
+                        if_expr.clone().syntax().clone().into(),
+                        if_expr.syntax().clone().into(),
+                    ),
+                    &mut then_statements,
+                )
             }
-        };
-        edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
-
-        fn replace(
-            new_expr: &SyntaxNode,
-            then_block: &ast::BlockExpr,
-            parent_block: &ast::BlockExpr,
-            if_expr: &ast::IfExpr,
-        ) -> SyntaxNode {
-            let then_block_items = then_block.dedent(IndentLevel(1));
-            let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
-            let end_of_then =
-                if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
-                    end_of_then.prev_sibling_or_token().unwrap()
-                } else {
-                    end_of_then
-                };
-            let mut then_statements = new_expr.children_with_tokens().chain(
-                then_block_items
-                    .syntax()
-                    .children_with_tokens()
-                    .skip(1)
-                    .take_while(|i| *i != end_of_then),
-            );
-            replace_children(
-                &parent_block.syntax(),
-                RangeInclusive::new(
-                    if_expr.clone().syntax().clone().into(),
-                    if_expr.syntax().clone().into(),
-                ),
-                &mut then_statements,
-            )
-        }
-    })
+        },
+    )
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
index 43b4584b4..ccec688ca 100644
--- a/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/ra_assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -10,7 +10,8 @@ use ra_syntax::{
 use rustc_hash::FxHashSet;
 
 use crate::{
-    assist_context::AssistBuilder, utils::insert_use_statement, AssistContext, AssistId, Assists,
+    assist_context::AssistBuilder, utils::insert_use_statement, AssistContext, AssistId,
+    AssistKind, Assists,
 };
 
 // Assist: extract_struct_from_enum_variant
@@ -30,30 +31,30 @@ pub(crate) fn extract_struct_from_enum_variant(
     acc: &mut Assists,
     ctx: &AssistContext,
 ) -> Option<()> {
-    let variant = ctx.find_node_at_offset::<ast::EnumVariant>()?;
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let field_list = match variant.kind() {
         ast::StructKind::Tuple(field_list) => field_list,
         _ => return None,
     };
     let variant_name = variant.name()?.to_string();
     let variant_hir = ctx.sema.to_def(&variant)?;
-    if existing_struct_def(ctx.db, &variant_name, &variant_hir) {
+    if existing_struct_def(ctx.db(), &variant_name, &variant_hir) {
         return None;
     }
     let enum_ast = variant.parent_enum();
     let visibility = enum_ast.visibility();
     let enum_hir = ctx.sema.to_def(&enum_ast)?;
-    let variant_hir_name = variant_hir.name(ctx.db);
+    let variant_hir_name = variant_hir.name(ctx.db());
     let enum_module_def = ModuleDef::from(enum_hir);
-    let current_module = enum_hir.module(ctx.db);
+    let current_module = enum_hir.module(ctx.db());
     let target = variant.syntax().text_range();
     acc.add(
-        AssistId("extract_struct_from_enum_variant"),
+        AssistId("extract_struct_from_enum_variant", AssistKind::RefactorRewrite),
         "Extract struct from enum variant",
         target,
         |builder| {
             let definition = Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir));
-            let res = definition.find_usages(&ctx.db, None);
+            let res = definition.find_usages(&ctx.sema, None);
             let start_offset = variant.parent_enum().syntax().text_range().start();
             let mut visited_modules_set = FxHashSet::default();
             visited_modules_set.insert(current_module);
@@ -101,7 +102,7 @@ fn insert_import(
     enum_module_def: &ModuleDef,
     variant_hir_name: &Name,
 ) -> Option<()> {
-    let db = ctx.db;
+    let db = ctx.db();
     let mod_path = module.find_use_path(db, enum_module_def.clone());
     if let Some(mut mod_path) = mod_path {
         mod_path.segments.pop();
diff --git a/crates/ra_assists/src/handlers/extract_variable.rs b/crates/ra_assists/src/handlers/extract_variable.rs
index c4150d2bb..b925a2884 100644
--- a/crates/ra_assists/src/handlers/extract_variable.rs
+++ b/crates/ra_assists/src/handlers/extract_variable.rs
@@ -2,14 +2,13 @@ use ra_syntax::{
     ast::{self, AstNode},
     SyntaxKind::{
         BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
-        WHITESPACE,
     },
     SyntaxNode,
 };
 use stdx::format_to;
 use test_utils::mark;
 
-use crate::{AssistContext, AssistId, Assists};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: extract_variable
 //
@@ -36,87 +35,84 @@ pub(crate) fn extract_variable(acc: &mut Assists, ctx: &AssistContext) -> Option
         mark::hit!(extract_var_in_comment_is_not_applicable);
         return None;
     }
-    let expr = node.ancestors().find_map(valid_target_expr)?;
-    let (anchor_stmt, wrap_in_block) = anchor_stmt(expr.clone())?;
-    let indent = anchor_stmt.prev_sibling_or_token()?.as_token()?.clone();
-    if indent.kind() != WHITESPACE {
-        return None;
-    }
-    let target = expr.syntax().text_range();
-    acc.add(AssistId("extract_variable"), "Extract into variable", target, move |edit| {
-        let field_shorthand = match expr.syntax().parent().and_then(ast::RecordField::cast) {
-            Some(field) => field.name_ref(),
-            None => None,
-        };
-
-        let mut buf = String::new();
-
-        let var_name = match &field_shorthand {
-            Some(it) => it.to_string(),
-            None => "var_name".to_string(),
-        };
-        let expr_range = match &field_shorthand {
-            Some(it) => it.syntax().text_range().cover(expr.syntax().text_range()),
-            None => expr.syntax().text_range(),
-        };
-
-        if wrap_in_block {
-            format_to!(buf, "{{ let {} = ", var_name);
-        } else {
-            format_to!(buf, "let {} = ", var_name);
-        };
-        format_to!(buf, "{}", expr.syntax());
-
-        let full_stmt = ast::ExprStmt::cast(anchor_stmt.clone());
-        let is_full_stmt = if let Some(expr_stmt) = &full_stmt {
-            Some(expr.syntax().clone()) == expr_stmt.expr().map(|e| e.syntax().clone())
-        } else {
-            false
-        };
-        if is_full_stmt {
-            mark::hit!(test_extract_var_expr_stmt);
-            if full_stmt.unwrap().semicolon_token().is_none() {
-                buf.push_str(";");
+    let to_extract = node.ancestors().find_map(valid_target_expr)?;
+    let anchor = Anchor::from(&to_extract)?;
+    let indent = anchor.syntax().prev_sibling_or_token()?.as_token()?.clone();
+    let target = to_extract.syntax().text_range();
+    acc.add(
+        AssistId("extract_variable", AssistKind::RefactorExtract),
+        "Extract into variable",
+        target,
+        move |edit| {
+            let field_shorthand =
+                match to_extract.syntax().parent().and_then(ast::RecordExprField::cast) {
+                    Some(field) => field.name_ref(),
+                    None => None,
+                };
+
+            let mut buf = String::new();
+
+            let var_name = match &field_shorthand {
+                Some(it) => it.to_string(),
+                None => "var_name".to_string(),
+            };
+            let expr_range = match &field_shorthand {
+                Some(it) => it.syntax().text_range().cover(to_extract.syntax().text_range()),
+                None => to_extract.syntax().text_range(),
+            };
+
+            if let Anchor::WrapInBlock(_) = anchor {
+                format_to!(buf, "{{ let {} = ", var_name);
+            } else {
+                format_to!(buf, "let {} = ", var_name);
+            };
+            format_to!(buf, "{}", to_extract.syntax());
+
+            if let Anchor::Replace(stmt) = anchor {
+                mark::hit!(test_extract_var_expr_stmt);
+                if stmt.semicolon_token().is_none() {
+                    buf.push_str(";");
+                }
+                match ctx.config.snippet_cap {
+                    Some(cap) => {
+                        let snip = buf
+                            .replace(&format!("let {}", var_name), &format!("let $0{}", var_name));
+                        edit.replace_snippet(cap, expr_range, snip)
+                    }
+                    None => edit.replace(expr_range, buf),
+                }
+                return;
             }
+
+            buf.push_str(";");
+
+            // We want to maintain the indent level,
+            // but we do not want to duplicate possible
+            // extra newlines in the indent block
+            let text = indent.text();
+            if text.starts_with('\n') {
+                buf.push_str("\n");
+                buf.push_str(text.trim_start_matches('\n'));
+            } else {
+                buf.push_str(text);
+            }
+
+            edit.replace(expr_range, var_name.clone());
+            let offset = anchor.syntax().text_range().start();
             match ctx.config.snippet_cap {
                 Some(cap) => {
                     let snip =
                         buf.replace(&format!("let {}", var_name), &format!("let $0{}", var_name));
-                    edit.replace_snippet(cap, expr_range, snip)
+                    edit.insert_snippet(cap, offset, snip)
                 }
-                None => edit.replace(expr_range, buf),
+                None => edit.insert(offset, buf),
             }
-            return;
-        }
-
-        buf.push_str(";");
-
-        // We want to maintain the indent level,
-        // but we do not want to duplicate possible
-        // extra newlines in the indent block
-        let text = indent.text();
-        if text.starts_with('\n') {
-            buf.push_str("\n");
-            buf.push_str(text.trim_start_matches('\n'));
-        } else {
-            buf.push_str(text);
-        }
 
-        edit.replace(expr_range, var_name.clone());
-        let offset = anchor_stmt.text_range().start();
-        match ctx.config.snippet_cap {
-            Some(cap) => {
-                let snip =
-                    buf.replace(&format!("let {}", var_name), &format!("let $0{}", var_name));
-                edit.insert_snippet(cap, offset, snip)
+            if let Anchor::WrapInBlock(_) = anchor {
+                edit.insert(anchor.syntax().text_range().end(), " }");
             }
-            None => edit.insert(offset, buf),
-        }
-
-        if wrap_in_block {
-            edit.insert(anchor_stmt.text_range().end(), " }");
-        }
-    })
+        },
+    )
 }
 
 /// Check whether the node is a valid expression which can be extracted to a variable.
@@ -133,32 +129,48 @@ fn valid_target_expr(node: SyntaxNode) -> Option<ast::Expr> {
     }
 }
 
-/// Returns the syntax node which will follow the freshly extractd var
-/// and a boolean indicating whether we have to wrap it within a { } block
-/// to produce correct code.
-/// It can be a statement, the last in a block expression or a wanna be block
-/// expression like a lambda or match arm.
-fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> {
-    expr.syntax().ancestors().find_map(|node| {
-        if let Some(expr) = node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr()) {
-            if expr.syntax() == &node {
-                mark::hit!(test_extract_var_last_expr);
-                return Some((node, false));
+enum Anchor {
+    Before(SyntaxNode),
+    Replace(ast::ExprStmt),
+    WrapInBlock(SyntaxNode),
+}
+
+impl Anchor {
+    fn from(to_extract: &ast::Expr) -> Option<Anchor> {
+        to_extract.syntax().ancestors().find_map(|node| {
+            if let Some(expr) =
+                node.parent().and_then(ast::BlockExpr::cast).and_then(|it| it.expr())
+            {
+                if expr.syntax() == &node {
+                    mark::hit!(test_extract_var_last_expr);
+                    return Some(Anchor::Before(node));
+                }
             }
-        }
 
-        if let Some(parent) = node.parent() {
-            if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
-                return Some((node, true));
+            if let Some(parent) = node.parent() {
+                if parent.kind() == MATCH_ARM || parent.kind() == LAMBDA_EXPR {
+                    return Some(Anchor::WrapInBlock(node));
+                }
             }
-        }
 
-        if ast::Stmt::cast(node.clone()).is_some() {
-            return Some((node, false));
-        }
+            if let Some(stmt) = ast::Stmt::cast(node.clone()) {
+                if let ast::Stmt::ExprStmt(stmt) = stmt {
+                    if stmt.expr().as_ref() == Some(to_extract) {
+                        return Some(Anchor::Replace(stmt));
+                    }
+                }
+                return Some(Anchor::Before(node));
+            }
+            None
+        })
+    }
 
-        None
-    })
+    fn syntax(&self) -> &SyntaxNode {
+        match self {
+            Anchor::Before(it) | Anchor::WrapInBlock(it) => it,
+            Anchor::Replace(stmt) => stmt.syntax(),
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index 64270c86f..708e1bc6c 100644
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -8,7 +8,7 @@ use test_utils::mark;
 
 use crate::{
     utils::{render_snippet, Cursor, FamousDefs},
-    AssistContext, AssistId, Assists,
+    AssistContext, AssistId, AssistKind, Assists,
 };
 
 // Assist: fill_match_arms
@@ -51,11 +51,11 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     let module = ctx.sema.scope(expr.syntax()).module()?;
 
     let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
-        let variants = enum_def.variants(ctx.db);
+        let variants = enum_def.variants(ctx.db());
 
         let mut variants = variants
             .into_iter()
-            .filter_map(|variant| build_pat(ctx.db, module, variant))
+            .filter_map(|variant| build_pat(ctx.db(), module, variant))
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect::<Vec<_>>();
@@ -84,11 +84,11 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
         // where each tuple represents a proposed match arm.
         enum_defs
             .into_iter()
-            .map(|enum_def| enum_def.variants(ctx.db))
+            .map(|enum_def| enum_def.variants(ctx.db()))
             .multi_cartesian_product()
             .map(|variants| {
                 let patterns =
-                    variants.into_iter().filter_map(|variant| build_pat(ctx.db, module, variant));
+                    variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
                 ast::Pat::from(make::tuple_pat(patterns))
             })
             .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
@@ -103,24 +103,37 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     }
 
     let target = match_expr.syntax().text_range();
-    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |builder| {
-        let new_arm_list = match_arm_list.remove_placeholder();
-        let n_old_arms = new_arm_list.arms().count();
-        let new_arm_list = new_arm_list.append_arms(missing_arms);
-        let first_new_arm = new_arm_list.arms().nth(n_old_arms);
-        let old_range = match_arm_list.syntax().text_range();
-        match (first_new_arm, ctx.config.snippet_cap) {
-            (Some(first_new_arm), Some(cap)) => {
-                let snippet = render_snippet(
-                    cap,
-                    new_arm_list.syntax(),
-                    Cursor::Before(first_new_arm.syntax()),
-                );
-                builder.replace_snippet(cap, old_range, snippet);
-            }
-            _ => builder.replace(old_range, new_arm_list.to_string()),
-        }
-    })
+    acc.add(
+        AssistId("fill_match_arms", AssistKind::QuickFix),
+        "Fill match arms",
+        target,
+        |builder| {
+            let new_arm_list = match_arm_list.remove_placeholder();
+            let n_old_arms = new_arm_list.arms().count();
+            let new_arm_list = new_arm_list.append_arms(missing_arms);
+            let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+            let old_range = match_arm_list.syntax().text_range();
+            match (first_new_arm, ctx.config.snippet_cap) {
+                (Some(first_new_arm), Some(cap)) => {
+                    let extend_lifetime;
+                    let cursor = match first_new_arm
+                        .syntax()
+                        .descendants()
+                        .find_map(ast::PlaceholderPat::cast)
+                    {
+                        Some(it) => {
+                            extend_lifetime = it.syntax().clone();
+                            Cursor::Replace(&extend_lifetime)
+                        }
+                        None => Cursor::Before(first_new_arm.syntax()),
+                    };
+                    let snippet = render_snippet(cap, new_arm_list.syntax(), cursor);
+                    builder.replace_snippet(cap, old_range, snippet);
+                }
+                _ => builder.replace(old_range, new_arm_list.to_string()),
+            }
+        },
+    )
 }
 
 fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
@@ -286,30 +299,22 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(Option<i32>),
-            }
-            fn main() {
-                match A::As<|> {
-                    A::Cs(_) | A::Bs => {}
-                }
-            }
-            "#,
+enum A { As, Bs, Cs(Option<i32>) }
+fn main() {
+    match A::As<|> {
+        A::Cs(_) | A::Bs => {}
+    }
+}
+"#,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(Option<i32>),
-            }
-            fn main() {
-                match A::As {
-                    A::Cs(_) | A::Bs => {}
-                    $0A::As => {}
-                }
-            }
-            "#,
+enum A { As, Bs, Cs(Option<i32>) }
+fn main() {
+    match A::As {
+        A::Cs(_) | A::Bs => {}
+        $0A::As => {}
+    }
+}
+"#,
         );
     }
 
@@ -318,47 +323,29 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs,
-                Ds(String),
-                Es(B),
-            }
-            enum B {
-                Xs,
-                Ys,
-            }
-            fn main() {
-                match A::As<|> {
-                    A::Bs if 0 < 1 => {}
-                    A::Ds(_value) => { let x = 1; }
-                    A::Es(B::Xs) => (),
-                }
-            }
-            "#,
+enum A { As, Bs, Cs, Ds(String), Es(B) }
+enum B { Xs, Ys }
+fn main() {
+    match A::As<|> {
+        A::Bs if 0 < 1 => {}
+        A::Ds(_value) => { let x = 1; }
+        A::Es(B::Xs) => (),
+    }
+}
+"#,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs,
-                Ds(String),
-                Es(B),
-            }
-            enum B {
-                Xs,
-                Ys,
-            }
-            fn main() {
-                match A::As {
-                    A::Bs if 0 < 1 => {}
-                    A::Ds(_value) => { let x = 1; }
-                    A::Es(B::Xs) => (),
-                    $0A::As => {}
-                    A::Cs => {}
-                }
-            }
-            "#,
+enum A { As, Bs, Cs, Ds(String), Es(B) }
+enum B { Xs, Ys }
+fn main() {
+    match A::As {
+        A::Bs if 0 < 1 => {}
+        A::Ds(_value) => { let x = 1; }
+        A::Es(B::Xs) => (),
+        $0A::As => {}
+        A::Cs => {}
+    }
+}
+"#,
         );
     }
 
@@ -367,32 +354,24 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(Option<i32>),
-            }
-            fn main() {
-                match A::As<|> {
-                    A::As(_) => {}
-                    a @ A::Bs(_) => {}
-                }
-            }
-            "#,
+enum A { As, Bs, Cs(Option<i32>) }
+fn main() {
+    match A::As<|> {
+        A::As(_) => {}
+        a @ A::Bs(_) => {}
+    }
+}
+"#,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(Option<i32>),
-            }
-            fn main() {
-                match A::As {
-                    A::As(_) => {}
-                    a @ A::Bs(_) => {}
-                    $0A::Cs(_) => {}
-                }
-            }
-            "#,
+enum A { As, Bs, Cs(Option<i32>) }
+fn main() {
+    match A::As {
+        A::As(_) => {}
+        a @ A::Bs(_) => {}
+        A::Cs(${0:_}) => {}
+    }
+}
+"#,
         );
     }
 
@@ -401,39 +380,27 @@ mod tests {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(String),
-                Ds(String, String),
-                Es { x: usize, y: usize }
-            }
+enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
 
-            fn main() {
-                let a = A::As;
-                match a<|> {}
-            }
-            "#,
+fn main() {
+    let a = A::As;
+    match a<|> {}
+}
+"#,
             r#"
-            enum A {
-                As,
-                Bs,
-                Cs(String),
-                Ds(String, String),
-                Es { x: usize, y: usize }
-            }
+enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
 
-            fn main() {
-                let a = A::As;
-                match a {
-                    $0A::As => {}
-                    A::Bs => {}
-                    A::Cs(_) => {}
-                    A::Ds(_, _) => {}
-                    A::Es { x, y } => {}
-                }
-            }
-            "#,
+fn main() {
+    let a = A::As;
+    match a {
+        $0A::As => {}
+        A::Bs => {}
+        A::Cs(_) => {}
+        A::Ds(_, _) => {}
+        A::Es { x, y } => {}
+    }
+}
+"#,
         );
     }
 
@@ -773,7 +740,7 @@ fn foo(opt: Option<i32>) {
             r#"
 fn foo(opt: Option<i32>) {
     match opt {
-        $0Some(_) => {}
+        Some(${0:_}) => {}
         None => {}
     }
 }
diff --git a/crates/ra_assists/src/handlers/fix_visibility.rs b/crates/ra_assists/src/handlers/fix_visibility.rs
index 19d4dac5e..1aefa79cc 100644
--- a/crates/ra_assists/src/handlers/fix_visibility.rs
+++ b/crates/ra_assists/src/handlers/fix_visibility.rs
@@ -2,7 +2,8 @@ use hir::{db::HirDatabase, HasSource, HasVisibility, PathResolution};
 use ra_db::FileId;
 use ra_syntax::{ast, AstNode, TextRange, TextSize};
 
-use crate::{utils::vis_offset, AssistContext, AssistId, Assists};
+use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
+use ast::VisibilityOwner;
 
 // FIXME: this really should be a fix for diagnostic, rather than an assist.
 
@@ -41,14 +42,15 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
     };
 
     let current_module = ctx.sema.scope(&path.syntax()).module()?;
-    let target_module = def.module(ctx.db)?;
+    let target_module = def.module(ctx.db())?;
 
-    let vis = target_module.visibility_of(ctx.db, &def)?;
-    if vis.is_visible_from(ctx.db, current_module.into()) {
+    let vis = target_module.visibility_of(ctx.db(), &def)?;
+    if vis.is_visible_from(ctx.db(), current_module.into()) {
         return None;
     };
 
-    let (offset, target, target_file, target_name) = target_data_for_def(ctx.db, def)?;
+    let (offset, current_visibility, target, target_file, target_name) =
+        target_data_for_def(ctx.db(), def)?;
 
     let missing_visibility =
         if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
@@ -58,54 +60,78 @@ fn add_vis_to_referenced_module_def(acc: &mut Assists, ctx: &AssistContext) -> O
         Some(name) => format!("Change visibility of {} to {}", name, missing_visibility),
     };
 
-    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+    acc.add(AssistId("fix_visibility", AssistKind::QuickFix), assist_label, target, |builder| {
         builder.edit_file(target_file);
         match ctx.config.snippet_cap {
-            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
-            None => builder.insert(offset, format!("{} ", missing_visibility)),
+            Some(cap) => match current_visibility {
+                Some(current_visibility) => builder.replace_snippet(
+                    cap,
+                    current_visibility.syntax().text_range(),
+                    format!("$0{}", missing_visibility),
+                ),
+                None => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            },
+            None => match current_visibility {
+                Some(current_visibility) => {
+                    builder.replace(current_visibility.syntax().text_range(), missing_visibility)
+                }
+                None => builder.insert(offset, format!("{} ", missing_visibility)),
+            },
         }
     })
 }
 
 fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let record_field: ast::RecordField = ctx.find_node_at_offset()?;
+    let record_field: ast::RecordExprField = ctx.find_node_at_offset()?;
     let (record_field_def, _) = ctx.sema.resolve_record_field(&record_field)?;
 
     let current_module = ctx.sema.scope(record_field.syntax()).module()?;
-    let visibility = record_field_def.visibility(ctx.db);
-    if visibility.is_visible_from(ctx.db, current_module.into()) {
+    let visibility = record_field_def.visibility(ctx.db());
+    if visibility.is_visible_from(ctx.db(), current_module.into()) {
         return None;
     }
 
-    let parent = record_field_def.parent_def(ctx.db);
-    let parent_name = parent.name(ctx.db);
-    let target_module = parent.module(ctx.db);
+    let parent = record_field_def.parent_def(ctx.db());
+    let parent_name = parent.name(ctx.db());
+    let target_module = parent.module(ctx.db());
 
-    let in_file_source = record_field_def.source(ctx.db);
-    let (offset, target) = match in_file_source.value {
+    let in_file_source = record_field_def.source(ctx.db());
+    let (offset, current_visibility, target) = match in_file_source.value {
         hir::FieldSource::Named(it) => {
             let s = it.syntax();
-            (vis_offset(s), s.text_range())
+            (vis_offset(s), it.visibility(), s.text_range())
         }
         hir::FieldSource::Pos(it) => {
             let s = it.syntax();
-            (vis_offset(s), s.text_range())
+            (vis_offset(s), it.visibility(), s.text_range())
         }
     };
 
     let missing_visibility =
         if current_module.krate() == target_module.krate() { "pub(crate)" } else { "pub" };
-    let target_file = in_file_source.file_id.original_file(ctx.db);
+    let target_file = in_file_source.file_id.original_file(ctx.db());
 
-    let target_name = record_field_def.name(ctx.db);
+    let target_name = record_field_def.name(ctx.db());
     let assist_label =
         format!("Change visibility of {}.{} to {}", parent_name, target_name, missing_visibility);
 
-    acc.add(AssistId("fix_visibility"), assist_label, target, |builder| {
+    acc.add(AssistId("fix_visibility", AssistKind::QuickFix), assist_label, target, |builder| {
         builder.edit_file(target_file);
         match ctx.config.snippet_cap {
-            Some(cap) => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
-            None => builder.insert(offset, format!("{} ", missing_visibility)),
+            Some(cap) => match current_visibility {
+                Some(current_visibility) => builder.replace_snippet(
+                    cap,
+                    dbg!(current_visibility.syntax()).text_range(),
+                    format!("$0{}", missing_visibility),
+                ),
+                None => builder.insert_snippet(cap, offset, format!("$0{} ", missing_visibility)),
+            },
+            None => match current_visibility {
+                Some(current_visibility) => {
+                    builder.replace(current_visibility.syntax().text_range(), missing_visibility)
+                }
+                None => builder.insert(offset, format!("{} ", missing_visibility)),
+            },
         }
     })
 }
@@ -113,24 +139,30 @@ fn add_vis_to_referenced_record_field(acc: &mut Assists, ctx: &AssistContext) ->
 fn target_data_for_def(
     db: &dyn HirDatabase,
     def: hir::ModuleDef,
-) -> Option<(TextSize, TextRange, FileId, Option<hir::Name>)> {
+) -> Option<(TextSize, Option<ast::Visibility>, TextRange, FileId, Option<hir::Name>)> {
     fn offset_target_and_file_id<S, Ast>(
         db: &dyn HirDatabase,
         x: S,
-    ) -> (TextSize, TextRange, FileId)
+    ) -> (TextSize, Option<ast::Visibility>, TextRange, FileId)
     where
         S: HasSource<Ast = Ast>,
-        Ast: AstNode,
+        Ast: AstNode + ast::VisibilityOwner,
     {
         let source = x.source(db);
         let in_file_syntax = source.syntax();
         let file_id = in_file_syntax.file_id;
         let syntax = in_file_syntax.value;
-        (vis_offset(syntax), syntax.text_range(), file_id.original_file(db.upcast()))
+        let current_visibility = source.value.visibility();
+        (
+            vis_offset(syntax),
+            current_visibility,
+            syntax.text_range(),
+            file_id.original_file(db.upcast()),
+        )
     }