101 files changed, 1465 insertions, 1240 deletions
diff --git a/crates/assists/src/assist_config.rs b/crates/assists/src/assist_config.rs
index 4fe8ea761..9cabf037c 100644
--- a/crates/assists/src/assist_config.rs
+++ b/crates/assists/src/assist_config.rs
@@ -4,7 +4,7 @@
 //! module, and we use to statically check that we only produce snippet
 //! assists if we are allowed to.
-use ide_db::helpers::{insert_use::MergeBehavior, SnippetCap};
+use ide_db::helpers::{insert_use::InsertUseConfig, SnippetCap};
 use crate::AssistKind;
@@ -14,9 +14,3 @@ pub struct AssistConfig {
    pub allowed: Option<Vec<AssistKind>>,
    pub insert_use: InsertUseConfig,
 }
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct InsertUseConfig {
-    pub merge: Option<MergeBehavior>,
-    pub prefix_kind: hir::PrefixKind,
-}
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index 91cc63427..8d93edba2 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -2,7 +2,6 @@
 use std::mem;
-use algo::find_covering_element;
 use hir::Semantics;
 use ide_db::{
    base_db::{AnchoredPathBuf, FileId, FileRange},
@@ -10,7 +9,7 @@ use ide_db::{
 };
 use ide_db::{
    label::Label,
-    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
+    source_change::{FileSystemEdit, SourceChange},
    RootDatabase,
 };
 use syntax::{
@@ -94,11 +93,11 @@ impl<'a> AssistContext<'a> {
        self.sema.find_node_at_offset_with_descend(self.source_file.syntax(), self.offset())
    }
    pub(crate) fn covering_element(&self) -> SyntaxElement {
-        find_covering_element(self.source_file.syntax(), self.frange.range)
+        self.source_file.syntax().covering_element(self.frange.range)
    }
    // FIXME: remove
    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
-        find_covering_element(self.source_file.syntax(), range)
+        self.source_file.syntax().covering_element(range)
    }
 }
@@ -180,20 +179,12 @@ impl Assists {
 pub(crate) struct AssistBuilder {
    edit: TextEditBuilder,
    file_id: FileId,
-    is_snippet: bool,
+    source_change: SourceChange,
-    source_file_edits: Vec<SourceFileEdit>,
-    file_system_edits: Vec<FileSystemEdit>,
 }
 impl AssistBuilder {
    pub(crate) fn new(file_id: FileId) -> AssistBuilder {
-        AssistBuilder {
+        AssistBuilder { edit: TextEdit::builder(), file_id, source_change: SourceChange::default() }
-            edit: TextEdit::builder(),
-            file_id,
-            is_snippet: false,
-            source_file_edits: Vec::default(),
-            file_system_edits: Vec::default(),
-        }
    }
    pub(crate) fn edit_file(&mut self, file_id: FileId) {
@@ -204,15 +195,7 @@ impl AssistBuilder {
    fn commit(&mut self) {
        let edit = mem::take(&mut self.edit).finish();
        if !edit.is_empty() {
-            match self.source_file_edits.binary_search_by_key(&self.file_id, |edit| edit.file_id) {
+            self.source_change.insert_source_edit(self.file_id, edit);
-                Ok(idx) => self.source_file_edits[idx]
-                    .edit
-                    .union(edit)
-                    .expect("overlapping edits for same file"),
-                Err(idx) => self
-                    .source_file_edits
-                    .insert(idx, SourceFileEdit { file_id: self.file_id, edit }),
-            }
        }
    }
@@ -231,7 +214,7 @@ impl AssistBuilder {
        offset: TextSize,
        snippet: impl Into<String>,
    ) {
-        self.is_snippet = true;
+        self.source_change.is_snippet = true;
        self.insert(offset, snippet);
    }
    /// Replaces specified `range` of text with a given string.
@@ -245,7 +228,7 @@ impl AssistBuilder {
        range: TextRange,
        snippet: impl Into<String>,
    ) {
-        self.is_snippet = true;
+        self.source_change.is_snippet = true;
        self.replace(range, snippet);
    }
    pub(crate) fn replace_ast<N: AstNode>(&mut self, old: N, new: N) {
@@ -260,15 +243,11 @@ impl AssistBuilder {
    pub(crate) fn create_file(&mut self, dst: AnchoredPathBuf, content: impl Into<String>) {
        let file_system_edit =
            FileSystemEdit::CreateFile { dst: dst.clone(), initial_contents: content.into() };
-        self.file_system_edits.push(file_system_edit);
+        self.source_change.push_file_system_edit(file_system_edit);
    }
    fn finish(mut self) -> SourceChange {
        self.commit();
-        SourceChange {
+        mem::take(&mut self.source_change)
-            source_file_edits: mem::take(&mut self.source_file_edits),
-            file_system_edits: mem::take(&mut self.file_system_edits),
-            is_snippet: self.is_snippet,
-        }
    }
 }
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index 55620f0f3..4e2a4fcd9 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,13 +1,11 @@
 use ide_db::helpers::{
+    import_assets::{ImportAssets, ImportCandidate},
    insert_use::{insert_use, ImportScope},
    mod_path_to_ast,
 };
 use syntax::ast;
-use crate::{
+use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
-    utils::import_assets::{ImportAssets, ImportCandidate},
-    AssistContext, AssistId, AssistKind, Assists, GroupLabel,
-};
 // Feature: Auto Import
 //
@@ -121,8 +119,7 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
 fn import_group_message(import_candidate: &ImportCandidate) -> GroupLabel {
    let name = match import_candidate {
-        ImportCandidate::UnqualifiedName(candidate)
+        ImportCandidate::Path(candidate) => format!("Import {}", &candidate.name),
-        | ImportCandidate::QualifierStart(candidate) => format!("Import {}", &candidate.name),
        ImportCandidate::TraitAssocItem(candidate) => {
            format!("Import a trait for item {}", &candidate.name)
        }
diff --git a/crates/assists/src/handlers/inline_local_variable.rs b/crates/assists/src/handlers/inline_local_variable.rs
index dc798daaa..0e63a60e8 100644
--- a/crates/assists/src/handlers/inline_local_variable.rs
+++ b/crates/assists/src/handlers/inline_local_variable.rs
@@ -79,29 +79,30 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
                None => return Ok(false),
            };
-            Ok(!matches!((&initializer_expr, usage_parent),
+            Ok(!matches!(
+                (&initializer_expr, usage_parent),
                (ast::Expr::CallExpr(_), _)
-                | (ast::Expr::IndexExpr(_), _)
+                    | (ast::Expr::IndexExpr(_), _)
-                | (ast::Expr::MethodCallExpr(_), _)
+                    | (ast::Expr::MethodCallExpr(_), _)
-                | (ast::Expr::FieldExpr(_), _)
+                    | (ast::Expr::FieldExpr(_), _)
-                | (ast::Expr::TryExpr(_), _)
+                    | (ast::Expr::TryExpr(_), _)
-                | (ast::Expr::RefExpr(_), _)
+                    | (ast::Expr::RefExpr(_), _)
-                | (ast::Expr::Literal(_), _)
+                    | (ast::Expr::Literal(_), _)
-                | (ast::Expr::TupleExpr(_), _)
+                    | (ast::Expr::TupleExpr(_), _)
-                | (ast::Expr::ArrayExpr(_), _)
+                    | (ast::Expr::ArrayExpr(_), _)
-                | (ast::Expr::ParenExpr(_), _)
+                    | (ast::Expr::ParenExpr(_), _)
-                | (ast::Expr::PathExpr(_), _)
+                    | (ast::Expr::PathExpr(_), _)
-                | (ast::Expr::BlockExpr(_), _)
+                    | (ast::Expr::BlockExpr(_), _)
-                | (ast::Expr::EffectExpr(_), _)
+                    | (ast::Expr::EffectExpr(_), _)
-                | (_, ast::Expr::CallExpr(_))
+                    | (_, ast::Expr::CallExpr(_))
-                | (_, ast::Expr::TupleExpr(_))
+                    | (_, ast::Expr::TupleExpr(_))
-                | (_, ast::Expr::ArrayExpr(_))
+                    | (_, ast::Expr::ArrayExpr(_))
-                | (_, ast::Expr::ParenExpr(_))
+                    | (_, ast::Expr::ParenExpr(_))
-                | (_, ast::Expr::ForExpr(_))
+                    | (_, ast::Expr::ForExpr(_))
-                | (_, ast::Expr::WhileExpr(_))
+                    | (_, ast::Expr::WhileExpr(_))
-                | (_, ast::Expr::BreakExpr(_))
+                    | (_, ast::Expr::BreakExpr(_))
-                | (_, ast::Expr::ReturnExpr(_))
+                    | (_, ast::Expr::ReturnExpr(_))
-                | (_, ast::Expr::MatchExpr(_))
+                    | (_, ast::Expr::MatchExpr(_))
            ))
        })
        .collect::<Result<Vec<_>, _>>()?;
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index f7fbf37f4..a7d9fd4dc 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,7 +1,10 @@
 use std::iter;
 use hir::AsName;
-use ide_db::helpers::mod_path_to_ast;
+use ide_db::helpers::{
+    import_assets::{ImportAssets, ImportCandidate},
+    mod_path_to_ast,
+};
 use ide_db::RootDatabase;
 use syntax::{
    ast,
@@ -12,7 +15,6 @@ use test_utils::mark;
 use crate::{
    assist_context::{AssistContext, Assists},
-    utils::import_assets::{ImportAssets, ImportCandidate},
    AssistId, AssistKind, GroupLabel,
 };
@@ -53,17 +55,18 @@ pub(crate) fn qualify_path(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
    let qualify_candidate = match candidate {
-        ImportCandidate::QualifierStart(_) => {
+        ImportCandidate::Path(candidate) => {
-            mark::hit!(qualify_path_qualifier_start);
+            if candidate.qualifier.is_some() {
-            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+                mark::hit!(qualify_path_qualifier_start);
-            let (prev_segment, segment) = (path.qualifier()?.segment()?, path.segment()?);
+                let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
-            QualifyCandidate::QualifierStart(segment, prev_segment.generic_arg_list())
+                let (prev_segment, segment) = (path.qualifier()?.segment()?, path.segment()?);
-        }
+                QualifyCandidate::QualifierStart(segment, prev_segment.generic_arg_list())
-        ImportCandidate::UnqualifiedName(_) => {
+            } else {
-            mark::hit!(qualify_path_unqualified_name);
+                mark::hit!(qualify_path_unqualified_name);
-            let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
+                let path = ast::Path::cast(import_assets.syntax_under_caret().clone())?;
-            let generics = path.segment()?.generic_arg_list();
+                let generics = path.segment()?.generic_arg_list();
-            QualifyCandidate::UnqualifiedName(generics)
+                QualifyCandidate::UnqualifiedName(generics)
+            }
        }
        ImportCandidate::TraitAssocItem(_) => {
            mark::hit!(qualify_path_trait_assoc_item);
@@ -186,7 +189,7 @@ fn item_as_trait(item: hir::ItemInNs) -> Option<hir::Trait> {
 fn group_label(candidate: &ImportCandidate) -> GroupLabel {
    let name = match candidate {
-        ImportCandidate::UnqualifiedName(it) | ImportCandidate::QualifierStart(it) => &it.name,
+        ImportCandidate::Path(it) => &it.name,
        ImportCandidate::TraitAssocItem(it) | ImportCandidate::TraitMethod(it) => &it.name,
    };
    GroupLabel(format!("Qualify {}", name))
@@ -194,8 +197,13 @@ fn group_label(candidate: &ImportCandidate) -> GroupLabel {
 fn label(candidate: &ImportCandidate, import: &hir::ModPath) -> String {
    match candidate {
-        ImportCandidate::UnqualifiedName(_) => format!("Qualify as `{}`", &import),
+        ImportCandidate::Path(candidate) => {
-        ImportCandidate::QualifierStart(_) => format!("Qualify with `{}`", &import),
+            if candidate.qualifier.is_some() {
+                format!("Qualify with `{}`", &import)
+            } else {
+                format!("Qualify as `{}`", &import)
+            }
+        }
        ImportCandidate::TraitAssocItem(_) => format!("Qualify `{}`", &import),
        ImportCandidate::TraitMethod(_) => format!("Qualify with cast as `{}`", &import),
    }
diff --git a/crates/assists/src/handlers/unmerge_use.rs b/crates/assists/src/handlers/unmerge_use.rs
new file mode 100644
index 000000000..3dbef8e51
--- /dev/null
+++ b/crates/assists/src/handlers/unmerge_use.rs
@@ -0,0 +1,231 @@
+use syntax::{
+    algo::SyntaxRewriter,
+    ast::{self, edit::AstNodeEdit, VisibilityOwner},
+    AstNode, SyntaxKind,
+};
+use test_utils::mark;
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+// Assist: unmerge_use
+//
+// Extracts single use item from use list.
+//
+// ```
+// use std::fmt::{Debug, Display$0};
+// ```
+// ->
+// ```
+// use std::fmt::{Debug};
+// use std::fmt::Display;
+// ```
+pub(crate) fn unmerge_use(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let tree: ast::UseTree = ctx.find_node_at_offset()?;
+    let tree_list = tree.syntax().parent().and_then(ast::UseTreeList::cast)?;
+    if tree_list.use_trees().count() < 2 {
+        mark::hit!(skip_single_use_item);
+        return None;
+    }
+    let use_: ast::Use = tree_list.syntax().ancestors().find_map(ast::Use::cast)?;
+    let path = resolve_full_path(&tree)?;
+    let target = tree.syntax().text_range();
+    acc.add(
+        AssistId("unmerge_use", AssistKind::RefactorRewrite),
+        "Unmerge use",
+        target,
+        |builder| {
+            let new_use = ast::make::use_(
+                use_.visibility(),
+                ast::make::use_tree(
+                    path,
+                    tree.use_tree_list(),
+                    tree.rename(),
+                    tree.star_token().is_some(),
+                ),
+            );
+            let mut rewriter = SyntaxRewriter::default();
+            rewriter += tree.remove();
+            rewriter.insert_after(use_.syntax(), &ast::make::tokens::single_newline());
+            if let ident_level @ 1..=usize::MAX = use_.indent_level().0 as usize {
+                rewriter.insert_after(
+                    use_.syntax(),
+                    &ast::make::tokens::whitespace(&" ".repeat(4 * ident_level)),
+                );
+            }
+            rewriter.insert_after(use_.syntax(), new_use.syntax());
+            builder.rewrite(rewriter);
+        },
+    )
+}
+fn resolve_full_path(tree: &ast::UseTree) -> Option<ast::Path> {
+    let mut paths = tree
+        .syntax()
+        .ancestors()
+        .take_while(|n| n.kind() != SyntaxKind::USE_KW)
+        .filter_map(ast::UseTree::cast)
+        .filter_map(|t| t.path());
+    let mut final_path = paths.next()?;
+    for path in paths {
+        final_path = ast::make::path_concat(path, final_path)
+    }
+    Some(final_path)
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn skip_single_use_item() {
+        mark::check!(skip_single_use_item);
+        check_assist_not_applicable(
+            unmerge_use,
+            r"
+use std::fmt::Debug$0;
+",
+        );
+        check_assist_not_applicable(
+            unmerge_use,
+            r"
+use std::fmt::{Debug$0};
+",
+        );
+        check_assist_not_applicable(
+            unmerge_use,
+            r"
+use std::fmt::Debug as Dbg$0;
+",
+        );
+    }
+    #[test]
+    fn skip_single_glob_import() {
+        check_assist_not_applicable(
+            unmerge_use,
+            r"
+use std::fmt::*$0;
+",
+        );
+    }
+    #[test]
+    fn unmerge_use_item() {
+        check_assist(
+            unmerge_use,
+            r"
+use std::fmt::{Debug, Display$0};
+",
+            r"
+use std::fmt::{Debug};
+use std::fmt::Display;
+",
+        );
+        check_assist(
+            unmerge_use,
+            r"
+use std::fmt::{Debug, format$0, Display};
+",
+            r"
+use std::fmt::{Debug, Display};
+use std::fmt::format;
+",
+        );
+    }
+    #[test]
+    fn unmerge_glob_import() {
+        check_assist(
+            unmerge_use,
+            r"
+use std::fmt::{*$0, Display};
+",
+            r"
+use std::fmt::{Display};
+use std::fmt::*;
+",
+        );
+    }
+    #[test]
+    fn unmerge_renamed_use_item() {
+        check_assist(
+            unmerge_use,
+            r"
+use std::fmt::{Debug, Display as Disp$0};
+",
+            r"
+use std::fmt::{Debug};
+use std::fmt::Display as Disp;
+",
+        );
+    }
+    #[test]
+    fn unmerge_indented_use_item() {
+        check_assist(
+            unmerge_use,
+            r"
+mod format {
+    use std::fmt::{Debug, Display$0 as Disp, format};
+}
+",
+            r"
+mod format {
+    use std::fmt::{Debug, format};
+    use std::fmt::Display as Disp;
+}
+",
+        );
+    }
+    #[test]
+    fn unmerge_nested_use_item() {
+        check_assist(
+            unmerge_use,
+            r"
+use foo::bar::{baz::{qux$0, foobar}, barbaz};
+",
+            r"
+use foo::bar::{baz::{foobar}, barbaz};
+use foo::bar::baz::qux;
+",
+        );
+        check_assist(
+            unmerge_use,
+            r"
+use foo::bar::{baz$0::{qux, foobar}, barbaz};
+",
+            r"
+use foo::bar::{barbaz};
+use foo::bar::baz::{qux, foobar};
+",
+        );
+    }
+    #[test]
+    fn unmerge_use_item_with_visibility() {
+        check_assist(
+            unmerge_use,
+            r"
+pub use std::fmt::{Debug, Display$0};
+",
+            r"
+pub use std::fmt::{Debug};
+pub use std::fmt::Display;
+",
+        );
+    }
+}
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index 1080294ab..14178a651 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -24,7 +24,7 @@ use syntax::TextRange;
 pub(crate) use crate::assist_context::{AssistContext, Assists};
-pub use assist_config::{AssistConfig, InsertUseConfig};
+pub use assist_config::AssistConfig;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AssistKind {
@@ -156,6 +156,7 @@ mod handlers {
    mod replace_unwrap_with_match;
    mod split_import;
    mod toggle_ignore;
+    mod unmerge_use;
    mod unwrap_block;
    mod wrap_return_type_in_result;
@@ -213,6 +214,7 @@ mod handlers {
            replace_unwrap_with_match::replace_unwrap_with_match,
            split_import::split_import,
            toggle_ignore::toggle_ignore,
+            unmerge_use::unmerge_use,
            unwrap_block::unwrap_block,
            wrap_return_type_in_result::wrap_return_type_in_result,
            // These are manually sorted for better priorities
diff --git a/crates/assists/src/tests.rs b/crates/assists/src/tests.rs
index fef29a0b8..32bd8698b 100644
--- a/crates/assists/src/tests.rs
+++ b/crates/assists/src/tests.rs
@@ -3,16 +3,17 @@ mod generated;
 use hir::Semantics;
 use ide_db::{
    base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
-    helpers::{insert_use::MergeBehavior, SnippetCap},
+    helpers::{
+        insert_use::{InsertUseConfig, MergeBehavior},
+        SnippetCap,
+    },
    source_change::FileSystemEdit,
    RootDatabase,
 };
 use syntax::TextRange;
 use test_utils::{assert_eq_text, extract_offset, extract_range};
-use crate::{
+use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists};
-    handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists, InsertUseConfig,
-};
 use stdx::{format_to, trim_indent};
 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
@@ -80,10 +81,8 @@ fn check_doc_test(assist_id: &str, before: &str, after: &str) {
    let actual = {
        let source_change = assist.source_change.unwrap();
        let mut actual = before;
-        for source_file_edit in source_change.source_file_edits {
+        if let Some(source_file_edit) = source_change.get_source_edit(file_id) {
-            if source_file_edit.file_id == file_id {
+            source_file_edit.apply(&mut actual);
-                source_file_edit.edit.apply(&mut actual)
-            }
        }
        actual
    };
@@ -116,37 +115,33 @@ fn check(handler: Handler, before: &str, expected: ExpectedResult, assist_label:
    match (assist, expected) {
        (Some(assist), ExpectedResult::After(after)) => {
-            let mut source_change = assist.source_change.unwrap();
+            let source_change = assist.source_change.unwrap();
            assert!(!source_change.source_file_edits.is_empty());
            let skip_header = source_change.source_file_edits.len() == 1
                && source_change.file_system_edits.len() == 0;
-            source_change.source_file_edits.sort_by_key(|it| it.file_id);
            let mut buf = String::new();
-            for source_file_edit in source_change.source_file_edits {
+            for (file_id, edit) in source_change.source_file_edits {
-                let mut text = db.file_text(source_file_edit.file_id).as_ref().to_owned();
+                let mut text = db.file_text(file_id).as_ref().to_owned();
-                source_file_edit.edit.apply(&mut text);
+                edit.apply(&mut text);
                if !skip_header {
-                    let sr = db.file_source_root(source_file_edit.file_id);
+                    let sr = db.file_source_root(file_id);
                    let sr = db.source_root(sr);
-                    let path = sr.path_for_file(&source_file_edit.file_id).unwrap();
+                    let path = sr.path_for_file(&file_id).unwrap();
                    format_to!(buf, "//- {}\n", path)
                }
                buf.push_str(&text);
            }
-            for file_system_edit in source_change.file_system_edits.clone() {
+            for file_system_edit in source_change.file_system_edits {
-                match file_system_edit {
+                if let FileSystemEdit::CreateFile { dst, initial_contents } = file_system_edit {
-                    FileSystemEdit::CreateFile { dst, initial_contents } => {
+                    let sr = db.file_source_root(dst.anchor);
-                        let sr = db.file_source_root(dst.anchor);
+                    let sr = db.source_root(sr);
-                        let sr = db.source_root(sr);
+                    let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
-                        let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
+                    base.pop();
-                        base.pop();
+                    let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
-                        let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
+                    format_to!(buf, "//- {}\n", created_file_path);
-                        format_to!(buf, "//- {}\n", created_file_path);
+                    buf.push_str(&initial_contents);
-                        buf.push_str(&initial_contents);
-                    }
-                    _ => (),
                }
            }
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 217f577eb..d48d063b4 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -1138,6 +1138,20 @@ fn arithmetics {
 }
 #[test]
+fn doctest_unmerge_use() {
+    check_doc_test(
+        "unmerge_use",
+        r#####"
+use std::fmt::{Debug, Display$0};
+"#####,
+        r#####"
+use std::fmt::{Debug};
+use std::fmt::Display;
+"#####,
+    )
+}
+#[test]
 fn doctest_unwrap_block() {
    check_doc_test(
        "unwrap_block",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 9ea96eb73..fc9f83bab 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -1,5 +1,4 @@
 //! Assorted functions shared by several assists.
-pub(crate) mod import_assets;
 use std::ops;
diff --git a/crates/completion/src/completions.rs b/crates/completion/src/completions.rs
index 00c9e76f0..c3ce6e51d 100644
--- a/crates/completion/src/completions.rs
+++ b/crates/completion/src/completions.rs
@@ -13,6 +13,7 @@ pub(crate) mod postfix;
 pub(crate) mod macro_in_item_position;
 pub(crate) mod trait_impl;
 pub(crate) mod mod_;
+pub(crate) mod flyimport;
 use hir::{ModPath, ScopeDef, Type};
diff --git a/crates/completion/src/completions/flyimport.rs b/crates/completion/src/completions/flyimport.rs
new file mode 100644
index 000000000..222809638
--- /dev/null
+++ b/crates/completion/src/completions/flyimport.rs
@@ -0,0 +1,291 @@
+//! Feature: completion with imports-on-the-fly
+//!
+//! When completing names in the current scope, proposes additional imports from other modules or crates,
+//! if they can be qualified in the scope and their name contains all symbols from the completion input
+//! (case-insensitive, in any order or places).
+//!
+//! ```
+//! fn main() {
+//!     pda$0
+//! }
+//! # pub mod std { pub mod marker { pub struct PhantomData { } } }
+//! ```
+//! ->
+//! ```
+//! use std::marker::PhantomData;
+//!
+//! fn main() {
+//!     PhantomData
+//! }
+//! # pub mod std { pub mod marker { pub struct PhantomData { } } }
+//! ```
+//!
+//! .Fuzzy search details
+//!
+//! To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
+//! (i.e. in `HashMap` in the `std::collections::HashMap` path).
+//! For the same reasons, avoids searching for any imports for inputs with their length less that 2 symbols.
+//!
+//! .Import configuration
+//!
+//! It is possible to configure how use-trees are merged with the `importMergeBehavior` setting.
+//! Mimics the corresponding behavior of the `Auto Import` feature.
+//!
+//! .LSP and performance implications
+//!
+//! The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the `additionalTextEdits`
+//! (case sensitive) resolve client capability in its client capabilities.
+//! This way the server is able to defer the costly computations, doing them for a selected completion item only.
+//! For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
+//! which might be slow ergo the feature is automatically disabled.
+//!
+//! .Feature toggle
+//!
+//! The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.enableAutoimportCompletions` flag.
+//! Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
+//! capability enabled.
+use either::Either;
+use hir::{ModPath, ScopeDef};
+use ide_db::{helpers::insert_use::ImportScope, imports_locator};
+use syntax::AstNode;
+use test_utils::mark;
+use crate::{
+    context::CompletionContext,
+    render::{render_resolution_with_import, RenderContext},
+    ImportEdit,
+};
+use super::Completions;
+pub(crate) fn import_on_the_fly(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
+    if !ctx.config.enable_autoimport_completions {
+        return None;
+    }
+    if ctx.attribute_under_caret.is_some() || ctx.mod_declaration_under_caret.is_some() {
+        return None;
+    }
+    let potential_import_name = ctx.token.to_string();
+    if potential_import_name.len() < 2 {
+        return None;
+    }
+    let _p = profile::span("import_on_the_fly").detail(|| potential_import_name.to_string());
+    let current_module = ctx.scope.module()?;
+    let anchor = ctx.name_ref_syntax.as_ref()?;
+    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
+    let user_input_lowercased = potential_import_name.to_lowercase();
+    let mut all_mod_paths = imports_locator::find_similar_imports(
+        &ctx.sema,
+        ctx.krate?,
+        Some(40),
+        potential_import_name,
+        true,
+        true,
+    )
+    .filter_map(|import_candidate| {
+        Some(match import_candidate {
+            Either::Left(module_def) => {
+                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
+            }
+            Either::Right(macro_def) => {
+                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
+            }
+        })
+    })
+    .filter(|(mod_path, _)| mod_path.len() > 1)
+    .collect::<Vec<_>>();
+    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
+        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
+    });
+    acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
+        render_resolution_with_import(
+            RenderContext::new(ctx),
+            ImportEdit { import_path, import_scope: import_scope.clone() },
+            &definition,
+        )
+    }));
+    Some(())
+}
+fn compute_fuzzy_completion_order_key(
+    proposed_mod_path: &ModPath,
+    user_input_lowercased: &str,
+) -> usize {
+    mark::hit!(certain_fuzzy_order_test);
+    let proposed_import_name = match proposed_mod_path.segments.last() {
+        Some(name) => name.to_string().to_lowercase(),
+        None => return usize::MAX,
+    };
+    match proposed_import_name.match_indices(user_input_lowercased).next() {
+        Some((first_matching_index, _)) => first_matching_index,
+        None => usize::MAX,
+    }
+}
+#[cfg(test)]
+mod tests {
+    use expect_test::{expect, Expect};
+    use test_utils::mark;
+    use crate::{
+        item::CompletionKind,
+        test_utils::{check_edit, completion_list},
+    };
+    fn check(ra_fixture: &str, expect: Expect) {
+        let actual = completion_list(ra_fixture, CompletionKind::Magic);
+        expect.assert_eq(&actual);
+    }
+    #[test]
+    fn function_fuzzy_completion() {
+        check_edit(
+            "stdin",
+            r#"
+//- /lib.rs crate:dep
+pub mod io {
+    pub fn stdin() {}
+};
+//- /main.rs crate:main deps:dep
+fn main() {
+    stdi$0
+}
+"#,
+            r#"
+use dep::io::stdin;
+fn main() {
+    stdin()$0
+}
+"#,
+        );
+    }
+    #[test]
+    fn macro_fuzzy_completion() {
+        check_edit(
+            "macro_with_curlies!",
+            r#"
+//- /lib.rs crate:dep
+/// Please call me as macro_with_curlies! {}
+#[macro_export]
+macro_rules! macro_with_curlies {
+    () => {}
+}
+//- /main.rs crate:main deps:dep
+fn main() {
+    curli$0
+}
+"#,
+            r#"
+use dep::macro_with_curlies;
+fn main() {
+    macro_with_curlies! {$0}
+}
+"#,
+        );
+    }
+    #[test]
+    fn struct_fuzzy_completion() {
+        check_edit(
+            "ThirdStruct",
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    pub struct SecondStruct;
+    pub struct ThirdStruct;
+}
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+fn main() {
+    this$0
+}
+"#,
+            r#"
+use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
+fn main() {
+    ThirdStruct
+}
+"#,
+        );
+    }
+    #[test]
+    fn fuzzy_completions_come_in_specific_order() {
+        mark::check!(certain_fuzzy_order_test);
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub struct FirstStruct;
+pub mod some_module {
+    // already imported, omitted
+    pub struct SecondStruct;
+    // does not contain all letters from the query, omitted
+    pub struct UnrelatedOne;
+    // contains all letters from the query, but not in sequence, displayed last
+    pub struct ThiiiiiirdStruct;
+    // contains all letters from the query, but not in the beginning, displayed second
+    pub struct AfterThirdStruct;
+    // contains all letters from the query in the begginning, displayed first
+    pub struct ThirdStruct;
+}
+//- /main.rs crate:main deps:dep
+use dep::{FirstStruct, some_module::SecondStruct};
+fn main() {
+    hir$0
+}
+"#,
+            expect![[r#"
+                st dep::some_module::ThirdStruct
+                st dep::some_module::AfterThirdStruct
+                st dep::some_module::ThiiiiiirdStruct
+            "#]],
+        );
+    }
+    #[test]
+    fn does_not_propose_names_in_scope() {
+        check(
+            r#"
+//- /lib.rs crate:dep
+pub mod test_mod {
+    pub trait TestTrait {
+        const SPECIAL_CONST: u8;
+        type HumbleType;
+        fn weird_function();
+        fn random_method(&self);
+    }
+    pub struct TestStruct {}
+    impl TestTrait for TestStruct {
+        const SPECIAL_CONST: u8 = 42;
+        type HumbleType = ();
+        fn weird_function() {}
+        fn random_method(&self) {}
+    }
+}
+//- /main.rs crate:main deps:dep
+use dep::test_mod::TestStruct;
+fn main() {
+    TestSt$0
+}
+"#,
+            expect![[r#""#]],
+        );
+    }
+}
diff --git a/crates/completion/src/completions/keyword.rs b/crates/completion/src/completions/keyword.rs
index 425a688ff..c1af348dc 100644
--- a/crates/completion/src/completions/keyword.rs
+++ b/crates/completion/src/completions/keyword.rs
@@ -1,6 +1,6 @@
 //! Completes keywords.
-use syntax::{ast, SyntaxKind};
+use syntax::SyntaxKind;
 use test_utils::mark;
 use crate::{CompletionContext, CompletionItem, CompletionItemKind, CompletionKind, Completions};
@@ -86,8 +86,8 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        add_keyword(ctx, acc, "match", "match $0 {}");
        add_keyword(ctx, acc, "while", "while $0 {}");
        add_keyword(ctx, acc, "loop", "loop {$0}");
-        add_keyword(ctx, acc, "if", "if ");
+        add_keyword(ctx, acc, "if", "if $0 {}");
-        add_keyword(ctx, acc, "if let", "if let ");
+        add_keyword(ctx, acc, "if let", "if let $1 = $0 {}");
    }
    if ctx.if_is_prev || ctx.block_expr_parent {
@@ -143,47 +143,49 @@ pub(crate) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
        Some(it) => it,
        None => return,
    };
-    acc.add_all(complete_return(ctx, &fn_def, ctx.can_be_stmt));
-}
-fn keyword(ctx: &CompletionContext, kw: &str, snippet: &str) -> CompletionItem {
-    let res = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-        .kind(CompletionItemKind::Keyword);
-    match ctx.config.snippet_cap {
+    add_keyword(
-        Some(cap) => res.insert_snippet(cap, snippet),
+        ctx,
-        _ => res.insert_text(if snippet.contains('$') { kw } else { snippet }),
+        acc,
-    }
+        "return",
-    .build()
+        match (ctx.can_be_stmt, fn_def.ret_type().is_some()) {
+            (true, true) => "return $0;",
+            (true, false) => "return;",
+            (false, true) => "return $0",
+            (false, false) => "return",
+        },
+    )
 }
 fn add_keyword(ctx: &CompletionContext, acc: &mut Completions, kw: &str, snippet: &str) {
-    acc.add(keyword(ctx, kw, snippet));
+    let builder = CompletionItem::new(CompletionKind::Keyword, ctx.source_range(), kw)
-}
+        .kind(CompletionItemKind::Keyword);
+    let builder = match ctx.config.snippet_cap {
-fn complete_return(
+        Some(cap) => {
-    ctx: &CompletionContext,
+            let tmp;
-    fn_def: &ast::Fn,
+            let snippet = if snippet.ends_with('}') && ctx.incomplete_let {
-    can_be_stmt: bool,
+                mark::hit!(let_semi);
-) -> Option<CompletionItem> {
+                tmp = format!("{};", snippet);
-    let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
+                &tmp
-        (true, true) => "return $0;",
+            } else {
-        (true, false) => "return;",
+                snippet
-        (false, true) => "return $0",
+            };
-        (false, false) => "return",
+            builder.insert_snippet(cap, snippet)
+        }
+        None => builder.insert_text(if snippet.contains('$') { kw } else { snippet }),
    };
-    Some(keyword(ctx, "return", snip))
+    acc.add(builder.build());
 }
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
+    use test_utils::mark;
    use crate::{
        test_utils::{check_edit, completion_list},
        CompletionKind,
    };
-    use test_utils::mark;
    fn check(ra_fixture: &str, expect: Expect) {
        let actual = completion_list(ra_fixture, CompletionKind::Keyword);
@@ -609,4 +611,50 @@ fn foo() {
            "#]],
        );
    }
+    #[test]
+    fn let_semi() {
+        mark::check!(let_semi);
+        check_edit(
+            "match",
+            r#"
+fn main() { let x = $0 }
+"#,
+            r#"
+fn main() { let x = match $0 {}; }
+"#,
+        );
+        check_edit(
+            "if",
+            r#"
+fn main() {
+    let x = $0
+    let y = 92;
+}
+"#,
+            r#"
+fn main() {
+    let x = if $0 {};
+    let y = 92;
+}
+"#,
+        );
+        check_edit(
+            "loop",
+            r#"
+fn main() {
+    let x = $0
+    bar();
+}
+"#,
+            r#"
+fn main() {
+    let x = loop {$0};
+    bar();
+}
+"#,
+        );
+    }
 }
diff --git a/crates/completion/src/completions/unqualified_path.rs b/crates/completion/src/completions/unqualified_path.rs
index 53e1391f3..ac5596ca4 100644
--- a/crates/completion/src/completions/unqualified_path.rs
+++ b/crates/completion/src/completions/unqualified_path.rs
@@ -2,17 +2,11 @@
 use std::iter;
-use either::Either;
+use hir::{Adt, ModuleDef, ScopeDef, Type};
-use hir::{Adt, ModPath, ModuleDef, ScopeDef, Type};
-use ide_db::helpers::insert_use::ImportScope;
-use ide_db::imports_locator;
 use syntax::AstNode;
 use test_utils::mark;
-use crate::{
+use crate::{CompletionContext, Completions};
-    render::{render_resolution_with_import, RenderContext},
-    CompletionContext, Completions, ImportEdit,
-};
 pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionContext) {
    if !(ctx.is_trivial_path || ctx.is_pat_binding_or_const) {
@@ -45,10 +39,6 @@ pub(crate) fn complete_unqualified_path(acc: &mut Completions, ctx: &CompletionC
        }
        acc.add_resolution(ctx, name.to_string(), &res)
    });
-    if ctx.config.enable_autoimport_completions {
-        fuzzy_completion(acc, ctx);
-    }
 }
 fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
@@ -77,124 +67,13 @@ fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &T
    }
 }
-// Feature: Fuzzy Completion and Autoimports
-//
-// When completing names in the current scope, proposes additional imports from other modules or crates,
-// if they can be qualified in the scope and their name contains all symbols from the completion input
-// (case-insensitive, in any order or places).
-//
-// ```
-// fn main() {
-//     pda$0
-// }
-// # pub mod std { pub mod marker { pub struct PhantomData { } } }
-// ```
-// ->
-// ```
-// use std::marker::PhantomData;
-//
-// fn main() {
-//     PhantomData
-// }
-// # pub mod std { pub mod marker { pub struct PhantomData { } } }
-// ```
-//
-// .Fuzzy search details
-//
-// To avoid an excessive amount of the results returned, completion input is checked for inclusion in the names only
-// (i.e. in `HashMap` in the `std::collections::HashMap` path).
-// For the same reasons, avoids searching for any imports for inputs with their length less that 2 symbols.
-//
-// .Merge Behavior
-//
-// It is possible to configure how use-trees are merged with the `importMergeBehavior` setting.
-// Mimics the corresponding behavior of the `Auto Import` feature.
-//
-// .LSP and performance implications
-//
-// The feature is enabled only if the LSP client supports LSP protocol version 3.16+ and reports the `additionalTextEdits`
-// (case sensitive) resolve client capability in its client capabilities.
-// This way the server is able to defer the costly computations, doing them for a selected completion item only.
-// For clients with no such support, all edits have to be calculated on the completion request, including the fuzzy search completion ones,
-// which might be slow ergo the feature is automatically disabled.
-//
-// .Feature toggle
-//
-// The feature can be forcefully turned off in the settings with the `rust-analyzer.completion.enableAutoimportCompletions` flag.
-// Note that having this flag set to `true` does not guarantee that the feature is enabled: your client needs to have the corredponding
-// capability enabled.
-fn fuzzy_completion(acc: &mut Completions, ctx: &CompletionContext) -> Option<()> {
-    let potential_import_name = ctx.token.to_string();
-    let _p = profile::span("fuzzy_completion").detail(|| potential_import_name.clone());
-    if potential_import_name.len() < 2 {
-        return None;
-    }
-    let current_module = ctx.scope.module()?;
-    let anchor = ctx.name_ref_syntax.as_ref()?;
-    let import_scope = ImportScope::find_insert_use_container(anchor.syntax(), &ctx.sema)?;
-    let user_input_lowercased = potential_import_name.to_lowercase();
-    let mut all_mod_paths = imports_locator::find_similar_imports(
-        &ctx.sema,
-        ctx.krate?,
-        Some(40),
-        potential_import_name,
-        true,
-        true,
-    )
-    .filter_map(|import_candidate| {
-        Some(match import_candidate {
-            Either::Left(module_def) => {
-                (current_module.find_use_path(ctx.db, module_def)?, ScopeDef::ModuleDef(module_def))
-            }
-            Either::Right(macro_def) => {
-                (current_module.find_use_path(ctx.db, macro_def)?, ScopeDef::MacroDef(macro_def))
-            }
-        })
-    })
-    .filter(|(mod_path, _)| mod_path.len() > 1)
-    .collect::<Vec<_>>();
-    all_mod_paths.sort_by_cached_key(|(mod_path, _)| {
-        compute_fuzzy_completion_order_key(mod_path, &user_input_lowercased)
-    });
-    acc.add_all(all_mod_paths.into_iter().filter_map(|(import_path, definition)| {
-        render_resolution_with_import(
-            RenderContext::new(ctx),
-            ImportEdit { import_path, import_scope: import_scope.clone() },
-            &definition,
-        )
-    }));
-    Some(())
-}
-fn compute_fuzzy_completion_order_key(
-    proposed_mod_path: &ModPath,
-    user_input_lowercased: &str,
-) -> usize {
-    mark::hit!(certain_fuzzy_order_test);
-    let proposed_import_name = match proposed_mod_path.segments.last() {
-        Some(name) => name.to_string().to_lowercase(),
-        None => return usize::MAX,
-    };
-    match proposed_import_name.match_indices(user_input_lowercased).next() {
-        Some((first_matching_index, _)) => first_matching_index,
-        None => usize::MAX,
-    }
-}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
    use test_utils::mark;
    use crate::{
-        test_utils::{
+        test_utils::{check_edit, completion_list_with_config, TEST_CONFIG},
-            check_edit, check_edit_with_config, completion_list_with_config, TEST_CONFIG,
-        },
        CompletionConfig, CompletionKind,
    };
@@ -855,128 +734,4 @@ impl My$0
            "#]],
        )
    }
-    #[test]
-    fn function_fuzzy_completion() {
-        check_edit_with_config(
-            TEST_CONFIG,
-            "stdin",
-            r#"
-//- /lib.rs crate:dep
-pub mod io {
-    pub fn stdin() {}
-};
-//- /main.rs crate:main deps:dep
-fn main() {
-    stdi$0
-}
-"#,
-            r#"
-use dep::io::stdin;
-fn main() {
-    stdin()$0
-}
-"#,
-        );
-    }
-    #[test]
-    fn macro_fuzzy_completion() {
-        check_edit_with_config(
-            TEST_CONFIG,
-            "macro_with_curlies!",
-            r#"
-//- /lib.rs crate:dep
-/// Please call me as macro_with_curlies! {}
-#[macro_export]
-macro_rules! macro_with_curlies {
-    () => {}
-}
-//- /main.rs crate:main deps:dep
-fn main() {
-    curli$0
-}
-"#,
-            r#"
-use dep::macro_with_curlies;
-fn main() {
-    macro_with_curlies! {$0}
-}
-"#,
-        );
-    }
-    #[test]
-    fn struct_fuzzy_completion() {
-        check_edit_with_config(
-            TEST_CONFIG,
-            "ThirdStruct",
-            r#"
-//- /lib.rs crate:dep
-pub struct FirstStruct;
-pub mod some_module {
-    pub struct SecondStruct;
-    pub struct ThirdStruct;
-}
-//- /main.rs crate:main deps:dep
-use dep::{FirstStruct, some_module::SecondStruct};
-fn main() {
-    this$0
-}
-"#,
-            r#"
-use dep::{FirstStruct, some_module::{SecondStruct, ThirdStruct}};
-fn main() {
-    ThirdStruct
-}
-"#,
-        );
-    }
-    #[test]
-    fn fuzzy_completions_come_in_specific_order() {
-        mark::check!(certain_fuzzy_order_test);
-        check_with_config(
-            TEST_CONFIG,
-            r#"
-//- /lib.rs crate:dep
-pub struct FirstStruct;
-pub mod some_module {
-    // already imported, omitted
-    pub struct SecondStruct;
-    // does not contain all letters from the query, omitted
-    pub struct UnrelatedOne;
-    // contains all letters from the query, but not in sequence, displayed last
-    pub struct ThiiiiiirdStruct;
-    // contains all letters from the query, but not in the beginning, displayed second
-    pub struct AfterThirdStruct;
-    // contains all letters from the query in the begginning, displayed first
-    pub struct ThirdStruct;
-}
-//- /main.rs crate:main deps:dep
-use dep::{FirstStruct, some_module::SecondStruct};
-fn main() {
-    hir$0
-}
-"#,
-            expect![[r#"
-                fn main()           fn main()
-                st SecondStruct
-                st FirstStruct
-                md dep
-                st dep::some_module::ThirdStruct
-                st dep::some_module::AfterThirdStruct
-                st dep::some_module::ThiiiiiirdStruct
-            "#]],
-        );
-    }
 }
diff --git a/crates/completion/src/config.rs b/crates/completion/src/config.rs
index b4439b7d1..58fc700f3 100644
--- a/crates/completion/src/config.rs
+++ b/crates/completion/src/config.rs
@@ -4,7 +4,7 @@
 //! module, and we use to statically check that we only produce snippet
 //! completions if we are allowed to.
-use ide_db::helpers::{insert_use::MergeBehavior, SnippetCap};
+use ide_db::helpers::{insert_use::InsertUseConfig, SnippetCap};
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CompletionConfig {
@@ -13,5 +13,5 @@ pub struct CompletionConfig {
    pub add_call_parenthesis: bool,
    pub add_call_argument_snippets: bool,
    pub snippet_cap: Option<SnippetCap>,
-    pub merge: Option<MergeBehavior>,
+    pub insert_use: InsertUseConfig,
 }
diff --git a/crates/completion/src/context.rs b/crates/completion/src/context.rs
index ebf28e887..b1e8eba85 100644
--- a/crates/completion/src/context.rs
+++ b/crates/completion/src/context.rs
@@ -4,10 +4,8 @@ use hir::{Local, ScopeDef, Semantics, SemanticsScope, Type};
 use ide_db::base_db::{FilePosition, SourceDatabase};
 use ide_db::{call_info::ActiveParameter, RootDatabase};
 use syntax::{
-    algo::{find_covering_element, find_node_at_offset},
+    algo::find_node_at_offset, ast, match_ast, AstNode, NodeOrToken, SyntaxKind::*, SyntaxNode,
-    ast, match_ast, AstNode, NodeOrToken,
+    SyntaxToken, TextRange, TextSize,
-    SyntaxKind::*,
-    SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
 use test_utils::mark;
 use text_edit::Indel;
@@ -92,6 +90,7 @@ pub(crate) struct CompletionContext<'a> {
    pub(super) has_item_list_or_source_file_parent: bool,
    pub(super) for_is_prev2: bool,
    pub(super) fn_is_prev: bool,
+    pub(super) incomplete_let: bool,
    pub(super) locals: Vec<(String, Local)>,
 }
@@ -132,9 +131,9 @@ impl<'a> CompletionContext<'a> {
            scope,
            db,
            config,
+            position,
            original_token,
            token,
-            position,
            krate,
            expected_type: None,
            name_ref_syntax: None,
@@ -155,30 +154,31 @@ impl<'a> CompletionContext<'a> {
            is_expr: false,
            is_new_item: false,
            dot_receiver: None,
+            dot_receiver_is_ambiguous_float_literal: false,
            is_call: false,
            is_pattern_call: false,
            is_macro_call: false,
            is_path_type: false,
            has_type_args: false,
-            dot_receiver_is_ambiguous_float_literal: false,
            attribute_under_caret: None,
            mod_declaration_under_caret: None,
            unsafe_is_prev: false,
-            in_loop_body: false,
+            if_is_prev: false,
-            ref_pat_parent: false,
-            bind_pat_parent: false,
            block_expr_parent: false,
+            bind_pat_parent: false,
+            ref_pat_parent: false,
+            in_loop_body: false,
            has_trait_parent: false,
            has_impl_parent: false,
            inside_impl_trait_block: false,
            has_field_list_parent: false,
            trait_as_prev_sibling: false,
            impl_as_prev_sibling: false,
-            if_is_prev: false,
            is_match_arm: false,
            has_item_list_or_source_file_parent: false,
            for_is_prev2: false,
            fn_is_prev: false,
+            incomplete_let: false,
            locals,
        };
@@ -270,6 +270,10 @@ impl<'a> CompletionContext<'a> {
                .filter(|module| module.item_list().is_none());
        self.for_is_prev2 = for_is_prev2(syntax_element.clone());
        self.fn_is_prev = fn_is_prev(syntax_element.clone());
+        self.incomplete_let =
+            syntax_element.ancestors().take(6).find_map(ast::LetStmt::cast).map_or(false, |it| {
+                it.syntax().text_range().end() == syntax_element.text_range().end()
+            });
    }
    fn fill(
@@ -507,7 +511,7 @@ impl<'a> CompletionContext<'a> {
 }
 fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
-    find_covering_element(syntax, range).ancestors().find_map(N::cast)
+    syntax.covering_element(range).ancestors().find_map(N::cast)
 }
 fn is_node<N: AstNode>(node: &SyntaxNode) -> bool {
diff --git a/crates/completion/src/lib.rs b/crates/completion/src/lib.rs
index 6cba88a6b..ee1b822e7 100644
--- a/crates/completion/src/lib.rs
+++ b/crates/completion/src/lib.rs
@@ -127,6 +127,7 @@ pub fn completions(
    completions::macro_in_item_position::complete_macro_in_item_position(&mut acc, &ctx);
    completions::trait_impl::complete_trait_impl(&mut acc, &ctx);
    completions::mod_::complete_mod(&mut acc, &ctx);
+    completions::flyimport::import_on_the_fly(&mut acc, &ctx);
    Some(acc)
 }
@@ -153,7 +154,9 @@ pub fn resolve_completion_edits(
        })
        .find(|mod_path| mod_path.to_string() == full_import_path)?;
-    ImportEdit { import_path, import_scope }.to_text_edit(config.merge).map(|edit| vec![edit])
+    ImportEdit { import_path, import_scope }
+        .to_text_edit(config.insert_use.merge)
+        .map(|edit| vec![edit])
 }
 #[cfg(test)]
diff --git a/crates/completion/src/render.rs b/crates/completion/src/render.rs
index e93c59f71..820dd01d1 100644
--- a/crates/completion/src/render.rs
+++ b/crates/completion/src/render.rs
@@ -51,11 +51,16 @@ pub(crate) fn render_resolution_with_import<'a>(
    import_edit: ImportEdit,
    resolution: &ScopeDef,
 ) -> Option<CompletionItem> {
-    Render::new(ctx).render_resolution(
+    Render::new(ctx)
-        import_edit.import_path.segments.last()?.to_string(),
+        .render_resolution(
-        Some(import_edit),
+            import_edit.import_path.segments.last()?.to_string(),
-        resolution,
+            Some(import_edit),
-    )
+            resolution,
+        )
+        .map(|mut item| {
+            item.completion_kind = CompletionKind::Magic;
+            item
+        })
 }
 /// Interface for data and methods required for items rendering.
diff --git a/crates/completion/src/test_utils.rs b/crates/completion/src/test_utils.rs
index 3f4b9d4ac..6ea6da989 100644
--- a/crates/completion/src/test_utils.rs
+++ b/crates/completion/src/test_utils.rs
@@ -1,9 +1,12 @@
 //! Runs completion for testing purposes.
-use hir::Semantics;
+use hir::{PrefixKind, Semantics};
 use ide_db::{
    base_db::{fixture::ChangeFixture, FileLoader, FilePosition},
-    helpers::{insert_use::MergeBehavior, SnippetCap},
+    helpers::{
+        insert_use::{InsertUseConfig, MergeBehavior},
+        SnippetCap,
+    },
    RootDatabase,
 };
 use itertools::Itertools;
@@ -19,7 +22,10 @@ pub(crate) const TEST_CONFIG: CompletionConfig = CompletionConfig {
    add_call_parenthesis: true,
    add_call_argument_snippets: true,
    snippet_cap: SnippetCap::new(true),
-    merge: Some(MergeBehavior::Full),
+    insert_use: InsertUseConfig {
+        merge: Some(MergeBehavior::Full),
+        prefix_kind: PrefixKind::Plain,
+    },
 };
 /// Creates analysis from a multi-file fixture, returns positions marked with $0.
@@ -110,7 +116,7 @@ pub(crate) fn check_edit_with_config(
    let mut combined_edit = completion.text_edit().to_owned();
    if let Some(import_text_edit) =
-        completion.import_to_add().and_then(|edit| edit.to_text_edit(config.merge))
+        completion.import_to_add().and_then(|edit| edit.to_text_edit(config.insert_use.merge))
    {
        combined_edit.union(import_text_edit).expect(
            "Failed to apply completion resolve changes: change ranges overlap, but should not",
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs
index cd689c869..ab213e04c 100644
--- a/crates/hir/src/semantics.rs
+++ b/crates/hir/src/semantics.rs
@@ -750,6 +750,7 @@ to_def_impls![
    (crate::ConstParam, ast::ConstParam, const_param_to_def),
    (crate::MacroDef, ast::MacroRules, macro_rules_to_def),
    (crate::Local, ast::IdentPat, bind_pat_to_def),
+    (crate::Local, ast::SelfParam, self_param_to_def),
    (crate::Label, ast::Label, label_to_def),
 ];
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs
index 4b9ebff72..9bf60c72a 100644
--- a/crates/hir/src/semantics/source_to_def.rs
+++ b/crates/hir/src/semantics/source_to_def.rs
@@ -114,6 +114,15 @@ impl SourceToDefCtx<'_, '_> {
        let pat_id = source_map.node_pat(src.as_ref())?;
        Some((container, pat_id))
    }
+    pub(super) fn self_param_to_def(
+        &mut self,
+        src: InFile<ast::SelfParam>,
+    ) -> Option<(DefWithBodyId, PatId)> {
+        let container = self.find_pat_or_label_container(src.as_ref().map(|it| it.syntax()))?;
+        let (_body, source_map) = self.db.body_with_source_map(container);
+        let pat_id = source_map.node_self_param(src.as_ref())?;
+        Some((container, pat_id))
+    }
    pub(super) fn label_to_def(
        &mut self,
        src: InFile<ast::Label>,
diff --git a/crates/hir_def/Cargo.toml b/crates/hir_def/Cargo.toml
index 5d21283f7..023d288d1 100644
--- a/crates/hir_def/Cargo.toml
+++ b/crates/hir_def/Cargo.toml
@@ -20,7 +20,7 @@ fst = { version = "0.4", default-features = false }
 itertools = "0.10.0"
 indexmap = "1.4.0"
 smallvec = "1.4.0"
-la-arena = "0.1.0"
+la-arena = { version = "0.1.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
 base_db = { path = "../base_db", version = "0.0.0" }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 27575c537..4ce5e5b72 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -386,6 +386,10 @@ impl ExprCollector<'_> {
                let expr = e.expr().map(|e| self.collect_expr(e));
                self.alloc_expr(Expr::Return { expr }, syntax_ptr)
            }
+            ast::Expr::YieldExpr(e) => {
+                let expr = e.expr().map(|e| self.collect_expr(e));
+                self.alloc_expr(Expr::Yield { expr }, syntax_ptr)
+            }
            ast::Expr::RecordExpr(e) => {
                let path = e.path().and_then(|path| self.expander.parse_path(path));
                let mut field_ptrs = Vec::new();
diff --git a/crates/hir_def/src/expr.rs b/crates/hir_def/src/expr.rs
index af01d32dc..a293df9f1 100644
--- a/crates/hir_def/src/expr.rs
+++ b/crates/hir_def/src/expr.rs
@@ -99,6 +99,9 @@ pub enum Expr {
    Return {
        expr: Option<ExprId>,
    },
+    Yield {
+        expr: Option<ExprId>,
+    },
    RecordLit {
        path: Option<Path>,
        fields: Vec<RecordLitField>,
@@ -294,7 +297,7 @@ impl Expr {
                }
            }
            Expr::Continue { .. } => {}
-            Expr::Break { expr, .. } | Expr::Return { expr } => {
+            Expr::Break { expr, .. } | Expr::Return { expr } | Expr::Yield { expr } => {
                if let Some(expr) = expr {
                    f(*expr);
                }
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index 61059c349..85ddc2c47 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -258,7 +258,7 @@ impl Resolver {
    ) -> Option<ResolveValueResult> {
        let n_segments = path.segments.len();
        let tmp = name![self];
-        let first_name = if path.is_self() { &tmp } else { &path.segments.first()? };
+        let first_name = if path.is_self() { &tmp } else { path.segments.first()? };
        let skip_to_mod = path.kind != PathKind::Plain && !path.is_self();
        for scope in self.scopes.iter().rev() {
            match scope {
diff --git a/crates/hir_expand/Cargo.toml b/crates/hir_expand/Cargo.toml
index b535a3d4f..1b1c7da65 100644
--- a/crates/hir_expand/Cargo.toml
+++ b/crates/hir_expand/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 log = "0.4.8"
 either = "1.5.3"
 rustc-hash = "1.0.0"
-la-arena = "0.1.0"
+la-arena = { version = "0.1.0", path = "../../lib/arena" }
 base_db = { path = "../base_db", version = "0.0.0" }
 syntax = { path = "../syntax", version = "0.0.0" }
diff --git a/crates/hir_expand/src/ast_id_map.rs b/crates/hir_expand/src/ast_id_map.rs
index f4f6e11fd..2401b0cc5 100644
--- a/crates/hir_expand/src/ast_id_map.rs
+++ b/crates/hir_expand/src/ast_id_map.rs
@@ -72,10 +72,12 @@ impl AstIdMap {
        // get lower ids then children. That is, adding a new child does not
        // change parent's id. This means that, say, adding a new function to a
        // trait does not change ids of top-level items, which helps caching.
-        bfs(node, |it| {
+        bdfs(node, |it| match ast::Item::cast(it) {
-            if let Some(module_item) = ast::Item::cast(it) {
+            Some(module_item) => {
                res.alloc(module_item.syntax());
+                true
            }
+            None => false,
        });
        res
    }
@@ -105,14 +107,30 @@ impl AstIdMap {
    }
 }
-/// Walks the subtree in bfs order, calling `f` for each node.
+/// Walks the subtree in bdfs order, calling `f` for each node. What is bdfs
-fn bfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode)) {
+/// order? It is a mix of breadth-first and depth first orders. Nodes for which
+/// `f` returns true are visited breadth-first, all the other nodes are explored
+/// depth-first.
+///
+/// In other words, the size of the bfs queue is bound by the number of "true"
+/// nodes.
+fn bdfs(node: &SyntaxNode, mut f: impl FnMut(SyntaxNode) -> bool) {
    let mut curr_layer = vec![node.clone()];
    let mut next_layer = vec![];
    while !curr_layer.is_empty() {
        curr_layer.drain(..).for_each(|node| {
-            next_layer.extend(node.children());
+            let mut preorder = node.preorder();
-            f(node);
+            while let Some(event) = preorder.next() {
+                match event {
+                    syntax::WalkEvent::Enter(node) => {
+                        if f(node.clone()) {
+                            next_layer.extend(node.children());
+                            preorder.skip_subtree();
+                        }
+                    }
+                    syntax::WalkEvent::Leave(_) => {}
+                }
+            }
        });
        std::mem::swap(&mut curr_layer, &mut next_layer);
    }
diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index c62086390..467516eb7 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs
@@ -118,7 +118,7 @@ pub fn expand_hypothetical(
        parse_macro_with_arg(db, macro_file, Some(std::sync::Arc::new((tt, tmap_1)))).value?;
    let token_id = macro_def.0.map_id_down(token_id);
    let range = tmap_2.range_by_token(token_id)?.by_kind(token_to_map.kind())?;
-    let token = syntax::algo::find_covering_element(&node.syntax_node(), range).into_token()?;
+    let token = node.syntax_node().covering_element(range).into_token()?;
    Some((node.syntax_node(), token))
 }
diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 3fa1b1d77..e388ddacc 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs
@@ -22,7 +22,7 @@ use std::sync::Arc;
 use base_db::{impl_intern_key, salsa, CrateId, FileId, FileRange};
 use syntax::{
-    algo::{self, skip_trivia_token},
+    algo::skip_trivia_token,
    ast::{self, AstNode},
    Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
 };
@@ -335,7 +335,7 @@ impl ExpansionInfo {
        let range = self.exp_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
-        let token = algo::find_covering_element(&self.expanded.value, range).into_token()?;
+        let token = self.expanded.value.covering_element(range).into_token()?;
        Some(self.expanded.with_value(token))
    }
@@ -360,8 +360,8 @@ impl ExpansionInfo {
        };
        let range = token_map.range_by_token(token_id)?.by_kind(token.value.kind())?;
-        let token = algo::find_covering_element(&tt.value, range + tt.value.text_range().start())
+        let token =
-            .into_token()?;
+            tt.value.covering_element(range + tt.value.text_range().start()).into_token()?;
        Some((tt.with_value(token), origin))
    }
 }
diff --git a/crates/hir_ty/Cargo.toml b/crates/hir_ty/Cargo.toml
index 436c1405b..a6916af90 100644
--- a/crates/hir_ty/Cargo.toml
+++ b/crates/hir_ty/Cargo.toml
@@ -20,7 +20,7 @@ scoped-tls = "1"
 chalk-solve = { version = "0.47", default-features = false }
 chalk-ir = "0.47"
 chalk-recursive = "0.47"
-la-arena = "0.1.0"
+la-arena = { version = "0.1.0", path = "../../lib/arena" }
 stdx = { path = "../stdx", version = "0.0.0" }
 hir_def = { path = "../hir_def", version = "0.0.0" }
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index f2fc69b2f..9bf3b51b0 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -367,6 +367,13 @@ impl<'a> InferenceContext<'a> {
                }
                Ty::simple(TypeCtor::Never)
            }
+            Expr::Yield { expr } => {
+                // FIXME: track yield type for coercion
+                if let Some(expr) = expr {
+                    self.infer_expr(*expr, &Expectation::none());
+                }
+                Ty::simple(TypeCtor::Never)
+            }
            Expr::RecordLit { path, fields, spread } => {
                let (ty, def_id) = self.resolve_variant(path.as_ref());
                if let Some(variant) = def_id {
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs
index 055c0a79c..b35bc2bae 100644
--- a/crates/ide/src/diagnostics.rs
+++ b/crates/ide/src/diagnostics.rs
@@ -13,17 +13,16 @@ use hir::{
    diagnostics::{Diagnostic as _, DiagnosticCode, DiagnosticSinkBuilder},
    Semantics,
 };
-use ide_db::base_db::SourceDatabase;
+use ide_db::{base_db::SourceDatabase, RootDatabase};
-use ide_db::RootDatabase;
 use itertools::Itertools;
 use rustc_hash::FxHashSet;
 use syntax::{
    ast::{self, AstNode},
-    SyntaxNode, TextRange, T,
+    SyntaxNode, TextRange,
 };
 use text_edit::TextEdit;
-use crate::{FileId, Label, SourceChange, SourceFileEdit};
+use crate::{FileId, Label, SourceChange};
 use self::fixes::DiagnosticWithFix;
@@ -220,7 +219,7 @@ fn check_unnecessary_braces_in_use_statement(
            Diagnostic::hint(use_range, "Unnecessary braces in use statement".to_string())
                .with_fix(Some(Fix::new(
                    "Remove unnecessary braces",
-                    SourceFileEdit { file_id, edit }.into(),
+                    SourceChange::from_text_edit(file_id, edit),
                    use_range,
                ))),
        );
@@ -233,7 +232,7 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
    single_use_tree: &ast::UseTree,
 ) -> Option<TextEdit> {
    let use_tree_list_node = single_use_tree.syntax().parent()?;
-    if single_use_tree.path()?.segment()?.syntax().first_child_or_token()?.kind() == T![self] {
+    if single_use_tree.path()?.segment()?.self_token().is_some() {
        let start = use_tree_list_node.prev_sibling_or_token()?.text_range().start();
        let end = use_tree_list_node.text_range().end();
        return Some(TextEdit::delete(TextRange::new(start, end)));
@@ -265,13 +264,11 @@ mod tests {
            .unwrap();
        let fix = diagnostic.fix.unwrap();
        let actual = {
-            let file_id = fix.source_change.source_file_edits.first().unwrap().file_id;
+            let file_id = *fix.source_change.source_file_edits.keys().next().unwrap();
            let mut actual = analysis.file_text(file_id).unwrap().to_string();
-            // Go from the last one to the first one, so that ranges won't be affected by previous edits.
+            for edit in fix.source_change.source_file_edits.values() {
-            // FIXME: https://github.com/rust-analyzer/rust-analyzer/issues/4901#issuecomment-644675309
+                edit.apply(&mut actual);
-            for edit in fix.source_change.source_file_edits.iter().rev() {
-                edit.edit.apply(&mut actual);
            }
            actual
        };
@@ -616,7 +613,7 @@ fn test_fn() {
                            Fix {
                                label: "Create module",
                                source_change: SourceChange {
-                                    source_file_edits: [],
+                                    source_file_edits: {},
                                    file_system_edits: [
                                        CreateFile {
                                            dst: AnchoredPathBuf {
diff --git a/crates/ide/src/diagnostics/field_shorthand.rs b/crates/ide/src/diagnostics/field_shorthand.rs
index 16c6ea827..5c89e2170 100644
--- a/crates/ide/src/diagnostics/field_shorthand.rs
+++ b/crates/ide/src/diagnostics/field_shorthand.rs
@@ -1,8 +1,7 @@
 //! Suggests shortening `Foo { field: field }` to `Foo { field }` in both
 //! expressions and patterns.
-use ide_db::base_db::FileId;
+use ide_db::{base_db::FileId, source_change::SourceChange};
-use ide_db::source_change::SourceFileEdit;
 use syntax::{ast, match_ast, AstNode, SyntaxNode};
 use text_edit::TextEdit;
@@ -50,7 +49,7 @@ fn check_expr_field_shorthand(
            Diagnostic::hint(field_range, "Shorthand struct initialization".to_string()).with_fix(
                Some(Fix::new(
                    "Use struct shorthand initialization",
-                    SourceFileEdit { file_id, edit }.into(),
+                    SourceChange::from_text_edit(file_id, edit),
                    field_range,
                )),
            ),
@@ -89,7 +88,7 @@ fn check_pat_field_shorthand(
        acc.push(Diagnostic::hint(field_range, "Shorthand struct pattern".to_string()).with_fix(
            Some(Fix::new(
                "Use struct field shorthand",
-                SourceFileEdit { file_id, edit }.into(),
+                SourceChange::from_text_edit(file_id, edit),
                field_range,
            )),
        ));
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index d7ad88ed5..e4335119b 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -8,9 +8,9 @@ use hir::{
    },
    HasSource, HirDisplay, InFile, Semantics, VariantDef,
 };
-use ide_db::base_db::{AnchoredPathBuf, FileId};
 use ide_db::{
-    source_change::{FileSystemEdit, SourceFileEdit},
+    base_db::{AnchoredPathBuf, FileId},
+    source_change::{FileSystemEdit, SourceChange},
    RootDatabase,
 };
 use syntax::{
@@ -88,7 +88,7 @@ impl DiagnosticWithFix for MissingFields {
        };
        Some(Fix::new(
            "Fill struct fields",
-            SourceFileEdit { file_id: self.file.original_file(sema.db), edit }.into(),
+            SourceChange::from_text_edit(self.file.original_file(sema.db), edit),
            sema.original_range(&field_list_parent.syntax()).range,
        ))
    }
@@ -101,8 +101,7 @@ impl DiagnosticWithFix for MissingOkOrSomeInTailExpr {
        let tail_expr_range = tail_expr.syntax().text_range();
        let replacement = format!("{}({})", self.required, tail_expr.syntax());
        let edit = TextEdit::replace(tail_expr_range, replacement);
-        let source_change =
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-            SourceFileEdit { file_id: self.file.original_file(sema.db), edit }.into();
        let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" };
        Some(Fix::new(name, source_change, tail_expr_range))
    }
@@ -122,8 +121,7 @@ impl DiagnosticWithFix for RemoveThisSemicolon {
            .text_range();
        let edit = TextEdit::delete(semicolon);
-        let source_change =
+        let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit);
-            SourceFileEdit { file_id: self.file.original_file(sema.db), edit }.into();
        Some(Fix::new("Remove this semicolon", source_change, semicolon))
    }
@@ -204,15 +202,11 @@ fn missing_record_expr_field_fix(
        new_field = format!(",{}", new_field);
    }
-    let source_change = SourceFileEdit {
+    let source_change = SourceChange::from_text_edit(
-        file_id: def_file_id,
+        def_file_id,
-        edit: TextEdit::insert(last_field_syntax.text_range().end(), new_field),
+        TextEdit::insert(last_field_syntax.text_range().end(), new_field),
-    };
+    );
-    return Some(Fix::new(
+    return Some(Fix::new("Create field", source_change, record_expr_field.syntax().text_range()));
-        "Create field",
-        source_change.into(),
-        record_expr_field.syntax().text_range(),
-    ));
    fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> {
        match field_def_list {
diff --git a/crates/ide/src/display/navigation_target.rs b/crates/ide/src/display/navigation_target.rs
index 4eecae697..685052e7f 100644
--- a/crates/ide/src/display/navigation_target.rs
+++ b/crates/ide/src/display/navigation_target.rs
@@ -400,24 +400,33 @@ impl TryToNav for hir::GenericParam {
 impl ToNav for hir::Local {
    fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
        let src = self.source(db);
-        let node = match &src.value {
+        let (node, focus_range) = match &src.value {
-            Either::Left(bind_pat) => {
+            Either::Left(bind_pat) => (
-                bind_pat.name().map_or_else(|| bind_pat.syntax().clone(), |it| it.syntax().clone())
+                bind_pat.syntax().clone(),
-            }
+                bind_pat
-            Either::Right(it) => it.syntax().clone(),
+                    .name()
+                    .map(|it| src.with_value(&it.syntax().clone()).original_file_range(db).range),
+            ),
+            Either::Right(it) => (it.syntax().clone(), it.self_token().map(|it| it.text_range())),
        };
        let full_range = src.with_value(&node).original_file_range(db);
        let name = match self.name(db) {
            Some(it) => it.to_string().into(),
            None => "".into(),
        };
-        let kind = if self.is_param(db) { SymbolKind::ValueParam } else { SymbolKind::Local };
+        let kind = if self.is_self(db) {
+            SymbolKind::SelfParam
+        } else if self.is_param(db) {
+            SymbolKind::ValueParam
+        } else {
+            SymbolKind::Local
+        };
        NavigationTarget {
            file_id: full_range.file_id,
            name,
            kind: Some(kind),
            full_range: full_range.range,
-            focus_range: None,
+            focus_range,
            container_name: None,
            description: None,
            docs: None,
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 56418c960..17a540972 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -3,7 +3,7 @@ use std::iter::successors;
 use hir::Semantics;
 use ide_db::RootDatabase;
 use syntax::{
-    algo::{self, find_covering_element, skip_trivia_token},
+    algo::{self, skip_trivia_token},
    ast::{self, AstNode, AstToken},
    Direction, NodeOrToken,
    SyntaxKind::{self, *},
@@ -76,7 +76,7 @@ fn try_extend_selection(
        };
        return Some(leaf_range);
    };
-    let node = match find_covering_element(root, range) {
+    let node = match root.covering_element(range) {
        NodeOrToken::Token(token) => {
            if token.text_range() != range {
                return Some(token.text_range());
@@ -120,7 +120,7 @@ fn extend_tokens_from_range(
    macro_call: ast::MacroCall,
    original_range: TextRange,
 ) -> Option<TextRange> {
-    let src = find_covering_element(&macro_call.syntax(), original_range);
+    let src = macro_call.syntax().covering_element(original_range);
    let (first_token, last_token) = match src {
        NodeOrToken::Node(it) => (it.first_token()?, it.last_token()?),
        NodeOrToken::Token(it) => (it.clone(), it),
diff --git a/crates/ide/src/goto_definition.rs b/crates/ide/src/goto_definition.rs
index cd4afc804..988a5668f 100644
--- a/crates/ide/src/goto_definition.rs
+++ b/crates/ide/src/goto_definition.rs
@@ -1,7 +1,6 @@
 use either::Either;
 use hir::{HasAttrs, ModuleDef, Semantics};
 use ide_db::{
-    base_db::FileId,
    defs::{Definition, NameClass, NameRefClass},
    symbol_index, RootDatabase,
 };
@@ -13,7 +12,7 @@ use crate::{
    display::{ToNav, TryToNav},
    doc_links::extract_definitions_from_markdown,
    runnables::doc_owner_to_def,
-    FilePosition, NavigationTarget, RangeInfo, SymbolKind,
+    FilePosition, NavigationTarget, RangeInfo,
 };
 // Feature: Go to Definition
@@ -49,19 +48,6 @@ pub(crate) fn goto_definition(
                let nav = def.try_to_nav(sema.db)?;
                vec![nav]
            },
-            ast::SelfParam(self_param) => {
-                vec![self_to_nav_target(self_param, position.file_id)?]
-            },
-            ast::PathSegment(segment) => {
-                segment.self_token()?;
-                let path = segment.parent_path();
-                if path.qualifier().is_some() && !ast::PathExpr::can_cast(path.syntax().parent()?.kind()) {
-                    return None;
-                }
-                let func = segment.syntax().ancestors().find_map(ast::Fn::cast)?;
-                let self_param = func.param_list()?.self_param()?;
-                vec![self_to_nav_target(self_param, position.file_id)?]
-            },
            ast::Lifetime(lt) => if let Some(name_class) = NameClass::classify_lifetime(&sema, &lt) {
                let def = name_class.referenced_or_defined(sema.db);
                let nav = def.try_to_nav(sema.db)?;
@@ -69,6 +55,11 @@ pub(crate) fn goto_definition(
            } else {
                reference_definition(&sema, Either::Left(&lt)).to_vec()
            },
+            ast::SelfParam(self_param) => {
+                let def = NameClass::classify_self_param(&sema, &self_param)?.referenced_or_defined(sema.db);
+                let nav = def.try_to_nav(sema.db)?;
+                vec![nav]
+            },
            _ => return None,
        }
    };
@@ -134,20 +125,6 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
    }
 }
-fn self_to_nav_target(self_param: ast::SelfParam, file_id: FileId) -> Option<NavigationTarget> {
-    let self_token = self_param.self_token()?;
-    Some(NavigationTarget {
-        file_id,
-        full_range: self_param.syntax().text_range(),
-        focus_range: Some(self_token.text_range()),
-        name: self_token.text().clone(),
-        kind: Some(SymbolKind::SelfParam),
-        container_name: None,
-        description: None,
-        docs: None,
-    })
-}
 #[derive(Debug)]
 pub(crate) enum ReferenceResult {
    Exact(NavigationTarget),
diff --git a/crates/ide/src/hover.rs b/crates/ide/src/hover.rs
index 317b6f011..6022bd275 100644
--- a/crates/ide/src/hover.rs
+++ b/crates/ide/src/hover.rs
@@ -98,6 +98,7 @@ pub(crate) fn hover(
            ast::NameRef(name_ref) => NameRefClass::classify(&sema, &name_ref).map(|d| d.referenced(sema.db)),
            ast::Lifetime(lifetime) => NameClass::classify_lifetime(&sema, &lifetime)
                .map_or_else(|| NameRefClass::classify_lifetime(&sema, &lifetime).map(|d| d.referenced(sema.db)), |d| d.defined(sema.db)),
+            ast::SelfParam(self_param) => NameClass::classify_self_param(&sema, &self_param).and_then(|d| d.defined(sema.db)),
            _ => None,
        }
    };
@@ -134,17 +135,14 @@ pub(crate) fn hover(
        return None;
    }
-    let node = token.ancestors().find(|n| {
+    let node = token
-        ast::Expr::can_cast(n.kind())
+        .ancestors()
-            || ast::Pat::can_cast(n.kind())
+        .find(|n| ast::Expr::can_cast(n.kind()) || ast::Pat::can_cast(n.kind()))?;
-            || ast::SelfParam::can_cast(n.kind())
-    })?;
    let ty = match_ast! {
        match node {
            ast::Expr(it) => sema.type_of_expr(&it)?,
            ast::Pat(it) => sema.type_of_pat(&it)?,
-            ast::SelfParam(self_param) => sema.type_of_self(&self_param)?,
            // If this node is a MACRO_CALL, it means that `descend_into_macros` failed to resolve.
            // (e.g expanding a builtin macro). So we give up here.
            ast::MacroCall(_it) => return None,
@@ -386,7 +384,7 @@ fn pick_best(tokens: TokenAtOffset<SyntaxToken>) -> Option<SyntaxToken> {
    return tokens.max_by_key(priority);
    fn priority(n: &SyntaxToken) -> usize {
        match n.kind() {
-            IDENT | INT_NUMBER | LIFETIME_IDENT => 3,
+            IDENT | INT_NUMBER | LIFETIME_IDENT | T![self] => 3,
            T!['('] | T![')'] => 2,
            kind if kind.is_trivia() => 0,
            _ => 1,
@@ -3130,6 +3128,39 @@ fn foo<T: Foo>(t: T$0){}
    }
    #[test]
+    fn test_hover_self_has_go_to_type() {
+        check_actions(
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(&self$0) {}
+}
+"#,
+            expect![[r#"
+                [
+                    GoToType(
+                        [
+                            HoverGotoTypeData {
+                                mod_path: "test::Foo",
+                                nav: NavigationTarget {
+                                    file_id: FileId(
+                                        0,
+                                    ),
+                                    full_range: 0..11,
+                                    focus_range: 7..10,
+                                    name: "Foo",
+                                    kind: Struct,
+                                    description: "struct Foo",
+                                },
+                            },
+                        ],
+                    ),
+                ]
+            "#]],
+        );
+    }
+    #[test]
    fn hover_displays_normalized_crate_names() {
        check(
            r#"
@@ -3193,6 +3224,7 @@ impl Foo {
 "#,
            expect![[r#"
                *&self*
                ```rust
                &Foo
                ```
@@ -3212,6 +3244,7 @@ impl Foo {
 "#,
            expect![[r#"
                *self: Arc<Foo>*
                ```rust
                Arc<Foo>
                ```
diff --git a/crates/ide/src/join_lines.rs b/crates/ide/src/join_lines.rs
index 05380f2a1..981467c8d 100644
--- a/crates/ide/src/join_lines.rs
+++ b/crates/ide/src/join_lines.rs
@@ -1,7 +1,7 @@
 use assists::utils::extract_trivial_expression;
 use itertools::Itertools;
 use syntax::{
-    algo::{find_covering_element, non_trivia_sibling},
+    algo::non_trivia_sibling,
    ast::{self, AstNode, AstToken},
    Direction, NodeOrToken, SourceFile,
    SyntaxKind::{self, USE_TREE, WHITESPACE},
@@ -31,7 +31,7 @@ pub(crate) fn join_lines(file: &SourceFile, range: TextRange) -> TextEdit {
        range
    };
-    let node = match find_covering_element(file.syntax(), range) {
+    let node = match file.syntax().covering_element(range) {
        NodeOrToken::Node(node) => node,
        NodeOrToken::Token(token) => token.parent(),
    };
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
index 1e03832ec..f8d69382e 100644
--- a/crates/ide/src/lib.rs
+++ b/crates/ide/src/lib.rs
@@ -80,7 +80,7 @@ pub use crate::{
        HlRange,
    },
 };
-pub use assists::{Assist, AssistConfig, AssistId, AssistKind, InsertUseConfig};
+pub use assists::{Assist, AssistConfig, AssistId, AssistKind};
 pub use completion::{
    CompletionConfig, CompletionItem, CompletionItemKind, CompletionScore, ImportEdit,
    InsertTextFormat,
@@ -98,7 +98,7 @@ pub use ide_db::{
    label::Label,
    line_index::{LineCol, LineIndex},
    search::SearchScope,
-    source_change::{FileSystemEdit, SourceChange, SourceFileEdit},
+    source_change::{FileSystemEdit, SourceChange},
    symbol_index::Query,
    RootDatabase,
 };
@@ -553,7 +553,7 @@ impl Analysis {
            let rule: ssr::SsrRule = query.parse()?;
            let mut match_finder = ssr::MatchFinder::in_context(db, resolve_context, selections);
            match_finder.add_rule(rule)?;
-            let edits = if parse_only { Vec::new() } else { match_finder.edits() };
+            let edits = if parse_only { Default::default() } else { match_finder.edits() };
            Ok(SourceChange::from(edits))
        })
    }
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 7d4757e02..51a2f4327 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -11,6 +11,7 @@
 pub(crate) mod rename;
+use either::Either;
 use hir::Semantics;
 use ide_db::{
    base_db::FileId,
@@ -21,10 +22,10 @@ use ide_db::{
 use syntax::{
    algo::find_node_at_offset,
    ast::{self, NameOwner},
-    match_ast, AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
+    AstNode, SyntaxNode, TextRange, TokenAtOffset, T,
 };
-use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo, SymbolKind};
+use crate::{display::TryToNav, FilePosition, FileRange, NavigationTarget, RangeInfo};
 #[derive(Debug, Clone)]
 pub struct ReferenceSearchResult {
@@ -90,10 +91,6 @@ pub(crate) fn find_all_refs(
    let _p = profile::span("find_all_refs");
    let syntax = sema.parse(position.file_id).syntax().clone();
-    if let Some(res) = try_find_self_references(&syntax, position) {
-        return Some(res);
-    }
    let (opt_name, search_kind) = if let Some(name) =
        get_struct_def_name_for_struct_literal_search(&sema, &syntax, position)
    {
@@ -122,13 +119,16 @@ pub(crate) fn find_all_refs(
    let mut kind = ReferenceKind::Other;
    if let Definition::Local(local) = def {
-        if let either::Either::Left(pat) = local.source(sema.db).value {
+        match local.source(sema.db).value {
-            if matches!(
+            Either::Left(pat) => {
-                pat.syntax().parent().and_then(ast::RecordPatField::cast),
+                if matches!(
-                Some(pat_field) if pat_field.name_ref().is_none()
+                    pat.syntax().parent().and_then(ast::RecordPatField::cast),
-            ) {
+                    Some(pat_field) if pat_field.name_ref().is_none()
-                kind = ReferenceKind::FieldShorthandForLocal;
+                ) {
+                    kind = ReferenceKind::FieldShorthandForLocal;
+                }
            }
+            Either::Right(_) => kind = ReferenceKind::SelfParam,
        }
    } else if matches!(
        def,
@@ -251,79 +251,6 @@ fn get_enum_def_name_for_struct_literal_search(
    None
 }
-fn try_find_self_references(
-    syntax: &SyntaxNode,
-    position: FilePosition,
-) -> Option<RangeInfo<ReferenceSearchResult>> {
-    let FilePosition { file_id, offset } = position;
-    let self_token = syntax.token_at_offset(offset).find(|t| t.kind() == T![self])?;
-    let parent = self_token.parent();
-    match_ast! {
-        match parent {
-            ast::SelfParam(it) => (),
-            ast::PathSegment(segment) => {
-                segment.self_token()?;
-                let path = segment.parent_path();
-                if path.qualifier().is_some() && !ast::PathExpr::can_cast(path.syntax().parent()?.kind()) {
-                    return None;
-                }
-            },
-            _ => return None,
-        }
-    };
-    let function = parent.ancestors().find_map(ast::Fn::cast)?;
-    let self_param = function.param_list()?.self_param()?;
-    let param_self_token = self_param.self_token()?;
-    let declaration = Declaration {
-        nav: NavigationTarget {
-            file_id,
-            full_range: self_param.syntax().text_range(),
-            focus_range: Some(param_self_token.text_range()),
-            name: param_self_token.text().clone(),
-            kind: Some(SymbolKind::SelfParam),
-            container_name: None,
-            description: None,
-            docs: None,
-        },
-        kind: ReferenceKind::SelfKw,
-        access: Some(if self_param.mut_token().is_some() {
-            ReferenceAccess::Write
-        } else {
-            ReferenceAccess::Read
-        }),
-    };
-    let refs = function
-        .body()
-        .map(|body| {
-            body.syntax()
-                .descendants()
-                .filter_map(ast::PathExpr::cast)
-                .filter_map(|expr| {
-                    let path = expr.path()?;
-                    if path.qualifier().is_none() {
-                        path.segment()?.self_token()
-                    } else {
-                        None
-                    }
-                })
-                .map(|token| FileReference {
-                    range: token.text_range(),
-                    kind: ReferenceKind::SelfKw,
-                    access: declaration.access, // FIXME: properly check access kind here instead of copying it from the declaration
-                })
-                .collect()
-        })
-        .unwrap_or_default();
-    let mut references = UsageSearchResult::default();
-    references.references.insert(file_id, refs);
-    Some(RangeInfo::new(
-        param_self_token.text_range(),
-        ReferenceSearchResult { declaration, references },
-    ))
-}
 #[cfg(test)]
 mod tests {
    use expect_test::{expect, Expect};
@@ -512,7 +439,7 @@ fn main() {
    i = 5;
 }"#,
            expect![[r#"
-                i Local FileId(0) 24..25 Other Write
+                i Local FileId(0) 20..25 24..25 Other Write
                FileId(0) 50..51 Other Write
                FileId(0) 54..55 Other Read
@@ -536,7 +463,7 @@ fn bar() {
 }
 "#,
            expect![[r#"
-                spam Local FileId(0) 19..23 Other
+                spam Local FileId(0) 19..23 19..23 Other
                FileId(0) 34..38 Other Read
                FileId(0) 41..45 Other Read
@@ -551,7 +478,7 @@ fn bar() {
 fn foo(i : u32) -> u32 { i$0 }
 "#,
            expect![[r#"
-                i ValueParam FileId(0) 7..8 Other
+                i ValueParam FileId(0) 7..8 7..8 Other
                FileId(0) 25..26 Other Read
            "#]],
@@ -565,7 +492,7 @@ fn foo(i : u32) -> u32 { i$0 }
 fn foo(i$0 : u32) -> u32 { i }
 "#,
            expect![[r#"
-                i ValueParam FileId(0) 7..8 Other
+                i ValueParam FileId(0) 7..8 7..8 Other
                FileId(0) 25..26 Other Read
            "#]],
@@ -813,7 +740,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                i Local FileId(0) 23..24 Other Write
+                i Local FileId(0) 19..24 23..24 Other Write
                FileId(0) 34..35 Other Write
                FileId(0) 38..39 Other Read
@@ -853,7 +780,7 @@ fn foo() {
 }
 "#,
            expect![[r#"
-                i Local FileId(0) 19..20 Other
+                i Local FileId(0) 19..20 19..20 Other
                FileId(0) 26..27 Other Write
            "#]],
@@ -995,10 +922,10 @@ impl Foo {
 }
 "#,
            expect![[r#"
-                self SelfParam FileId(0) 47..51 47..51 SelfKw Read
+                self SelfParam FileId(0) 47..51 47..51 SelfParam
-                FileId(0) 71..75 SelfKw Read
+                FileId(0) 71..75 Other Read
-                FileId(0) 152..156 SelfKw Read
+                FileId(0) 152..156 Other Read
            "#]],
        );
    }
@@ -1105,7 +1032,7 @@ fn main() {
 }
 "#,
            expect![[r#"
-                a Local FileId(0) 59..60 Other
+                a Local FileId(0) 59..60 59..60 Other
                FileId(0) 80..81 Other Read
            "#]],
@@ -1123,7 +1050,7 @@ fn main() {
 }
 "#,
            expect![[r#"
-                a Local FileId(0) 59..60 Other
+                a Local FileId(0) 59..60 59..60 Other
                FileId(0) 80..81 Other Read
            "#]],
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index c3ae568c2..9ac4af026 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -21,7 +21,7 @@ use text_edit::TextEdit;
 use crate::{
    FilePosition, FileSystemEdit, RangeInfo, ReferenceKind, ReferenceSearchResult, SourceChange,
-    SourceFileEdit, TextRange, TextSize,
+    TextRange, TextSize,
 };
 type RenameResult<T> = Result<T, RenameError>;
@@ -58,7 +58,7 @@ pub(crate) fn prepare_rename(
        rename_self_to_param(&sema, position, self_token, "dummy")
    } else {
        let RangeInfo { range, .. } = find_all_refs(&sema, position)?;
-        Ok(RangeInfo::new(range, SourceChange::from(vec![])))
+        Ok(RangeInfo::new(range, SourceChange::default()))
    }
    .map(|info| RangeInfo::new(info.range, ()))
 }
@@ -176,7 +176,7 @@ fn source_edit_from_references(
    file_id: FileId,
    references: &[FileReference],
    new_name: &str,
-) -> SourceFileEdit {
+) -> (FileId, TextEdit) {
    let mut edit = TextEdit::builder();
    for reference in references {
        let mut replacement_text = String::new();
@@ -209,8 +209,7 @@ fn source_edit_from_references(
        };
        edit.replace(range, replacement_text);
    }
+    (file_id, edit.finish())
-    SourceFileEdit { file_id, edit: edit.finish() }
 }
 fn edit_text_range_for_record_field_expr_or_pat(
@@ -250,8 +249,8 @@ fn rename_mod(
    if IdentifierKind::Ident != check_identifier(new_name)? {
        bail!("Invalid name `{0}`: cannot rename module to {0}", new_name);
    }
-    let mut source_file_edits = Vec::new();
-    let mut file_system_edits = Vec::new();
+    let mut source_change = SourceChange::default();
    let src = module.definition_source(sema.db);
    let file_id = src.file_id.original_file(sema.db);
@@ -265,7 +264,7 @@ fn rename_mod(
            };
            let dst = AnchoredPathBuf { anchor: file_id, path };
            let move_file = FileSystemEdit::MoveFile { src: file_id, dst };
-            file_system_edits.push(move_file);
+            source_change.push_file_system_edit(move_file);
        }
        ModuleSource::Module(..) => {}
    }
@@ -273,20 +272,19 @@ fn rename_mod(
    if let Some(src) = module.declaration_source(sema.db) {
        let file_id = src.file_id.original_file(sema.db);
        let name = src.value.name().unwrap();
-        let edit = SourceFileEdit {
+        source_change.insert_source_edit(
            file_id,
-            edit: TextEdit::replace(name.syntax().text_range(), new_name.into()),
+            TextEdit::replace(name.syntax().text_range(), new_name.into()),
-        };
+        );
-        source_file_edits.push(edit);
    }
    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
    let ref_edits = refs.references().iter().map(|(&file_id, references)| {
        source_edit_from_references(sema, file_id, references, new_name)
    });
-    source_file_edits.extend(ref_edits);
+    source_change.extend(ref_edits);
-    Ok(RangeInfo::new(range, SourceChange::from_edits(source_file_edits, file_system_edits)))
+    Ok(RangeInfo::new(range, source_change))
 }
 fn rename_to_self(
@@ -335,20 +333,16 @@ fn rename_to_self(
    let RangeInfo { range, info: refs } = find_all_refs(sema, position)?;
-    let mut edits = refs
+    let mut source_change = SourceChange::default();
-        .references()
+    source_change.extend(refs.references().iter().map(|(&file_id, references)| {
-        .iter()
+        source_edit_from_references(sema, file_id, references, "self")
-        .map(|(&file_id, references)| {
+    }));
-            source_edit_from_references(sema, file_id, references, "self")
+    source_change.insert_source_edit(
-        })
+        position.file_id,
-        .collect::<Vec<_>>();
+        TextEdit::replace(param_range, String::from(self_param)),
+    );
-    edits.push(SourceFileEdit {
-        file_id: position.file_id,
-        edit: TextEdit::replace(param_range, String::from(self_param)),
-    });
-    Ok(RangeInfo::new(range, SourceChange::from(edits)))
+    Ok(RangeInfo::new(range, source_change))
 }
 fn text_edit_from_self_param(
@@ -402,7 +396,7 @@ fn rename_self_to_param(
        .ok_or_else(|| format_err!("No surrounding method declaration found"))?;
    let search_range = fn_def.syntax().text_range();
-    let mut edits: Vec<SourceFileEdit> = vec![];
+    let mut source_change = SourceChange::default();
    for (idx, _) in text.match_indices("self") {
        let offset: TextSize = idx.try_into().unwrap();
@@ -416,18 +410,18 @@ fn rename_self_to_param(
            } else {
                TextEdit::replace(usage.text_range(), String::from(new_name))
            };
-            edits.push(SourceFileEdit { file_id: position.file_id, edit });
+            source_change.insert_source_edit(position.file_id, edit);
        }
    }
-    if edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
+    if source_change.source_file_edits.len() > 1 && ident_kind == IdentifierKind::Underscore {
        bail!("Cannot rename reference to `_` as it is being referenced multiple times");
    }
    let range = ast::SelfParam::cast(self_token.parent())
        .map_or(self_token.text_range(), |p| p.syntax().text_range());
-    Ok(RangeInfo::new(range, SourceChange::from(edits)))
+    Ok(RangeInfo::new(range, source_change))
 }
 fn rename_reference(
@@ -450,7 +444,7 @@ fn rename_reference(
            mark::hit!(rename_not_an_ident_ref);
            bail!("Invalid name `{}`: not an identifier", new_name)
        }
-        (IdentifierKind::ToSelf, ReferenceKind::SelfKw) => {
+        (IdentifierKind::ToSelf, ReferenceKind::SelfParam) => {
            unreachable!("rename_self_to_param should've been called instead")
        }
        (IdentifierKind::ToSelf, _) => {
@@ -464,14 +458,12 @@ fn rename_reference(
        (IdentifierKind::Ident, _) | (IdentifierKind::Underscore, _) => mark::hit!(rename_ident),
    }
-    let edit = refs
+    let mut source_change = SourceChange::default();
-        .into_iter()
+    source_change.extend(refs.into_iter().map(|(file_id, references)| {
-        .map(|(file_id, references)| {
+        source_edit_from_references(sema, file_id, &references, new_name)
-            source_edit_from_references(sema, file_id, &references, new_name)
+    }));
-        })
-        .collect::<Vec<_>>();
-    Ok(RangeInfo::new(range, SourceChange::from(edit)))
+    Ok(RangeInfo::new(range, source_change))
 }
 #[cfg(test)]
@@ -494,8 +486,8 @@ mod tests {
                let mut text_edit_builder = TextEdit::builder();
                let mut file_id: Option<FileId> = None;
                for edit in source_change.info.source_file_edits {
-                    file_id = Some(edit.file_id);
+                    file_id = Some(edit.0);
-                    for indel in edit.edit.into_iter() {
+                    for indel in edit.1.into_iter() {
                        text_edit_builder.replace(indel.delete, indel.insert);
                    }
                }
@@ -895,21 +887,18 @@ mod foo$0;
                RangeInfo {
                    range: 4..7,
                    info: SourceChange {
-                        source_file_edits: [
+                        source_file_edits: {
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                1,
-                                    1,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "foo2",
-                                        Indel {
+                                        delete: 4..7,
-                                            insert: "foo2",
+                                    },
-                                            delete: 4..7,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                        ],
+                        },
                        file_system_edits: [
                            MoveFile {
                                src: FileId(
@@ -950,34 +939,28 @@ use crate::foo$0::FooContent;
                RangeInfo {
                    range: 11..14,
                    info: SourceChange {
-                        source_file_edits: [
+                        source_file_edits: {
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                0,
-                                    0,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "quux",
-                                        Indel {
+                                        delete: 8..11,
-                                            insert: "quux",
+                                    },
-                                            delete: 8..11,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                2,
-                                    2,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "quux",
-                                        Indel {
+                                        delete: 11..14,
-                                            insert: "quux",
+                                    },
-                                            delete: 11..14,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                        ],
+                        },
                        file_system_edits: [
                            MoveFile {
                                src: FileId(
@@ -1012,21 +995,18 @@ mod fo$0o;
                RangeInfo {
                    range: 4..7,
                    info: SourceChange {
-                        source_file_edits: [
+                        source_file_edits: {
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                0,
-                                    0,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "foo2",
-                                        Indel {
+                                        delete: 4..7,
-                                            insert: "foo2",
+                                    },
-                                            delete: 4..7,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                        ],
+                        },
                        file_system_edits: [
                            MoveFile {
                                src: FileId(
@@ -1062,21 +1042,18 @@ mod outer { mod fo$0o; }
                RangeInfo {
                    range: 16..19,
                    info: SourceChange {
-                        source_file_edits: [
+                        source_file_edits: {
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                0,
-                                    0,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "bar",
-                                        Indel {
+                                        delete: 16..19,
-                                            insert: "bar",
+                                    },
-                                            delete: 16..19,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                        ],
+                        },
                        file_system_edits: [
                            MoveFile {
                                src: FileId(
@@ -1135,34 +1112,28 @@ pub mod foo$0;
                RangeInfo {
                    range: 8..11,
                    info: SourceChange {
-                        source_file_edits: [
+                        source_file_edits: {
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                0,
-                                    1,
+                            ): TextEdit {
-                                ),
+                                indels: [
-                                edit: TextEdit {
+                                    Indel {
-                                    indels: [
+                                        insert: "foo2",
-                                        Indel {
+                                        delete: 27..30,
-                                            insert: "foo2",
+                                    },
-                                            delete: 8..11,
+                                ],
-                                        },
-                                    ],
-                                },
                            },
-                            SourceFileEdit {
+                            FileId(
-                                file_id: FileId(
+                                1,
-                                    0,
+                            ): TextEdit {