48 files changed, 16758 insertions, 0 deletions

diff --git a/crates/assists/Cargo.toml b/crates/assists/Cargo.toml
new file mode 100644
index 000000000..a560a35c7
--- /dev/null
+++ b/crates/assists/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "assists"
+version = "0.0.0"
+license = "MIT OR Apache-2.0"
+authors = ["rust-analyzer developers"]
+edition = "2018"
+
+[lib]
+doctest = false
+
+[dependencies]
+rustc-hash = "1.1.0"
+itertools = "0.9.0"
+either = "1.5.3"
+
+stdx = { path = "../stdx" }
+syntax = { path = "../syntax" }
+text_edit = { path = "../text_edit" }
+profile = { path = "../profile" }
+base_db = { path = "../base_db" }
+ide_db = { path = "../ide_db" }
+hir = { path = "../hir" }
+test_utils = { path = "../test_utils" }
diff --git a/crates/assists/src/assist_config.rs b/crates/assists/src/assist_config.rs
new file mode 100644
index 000000000..cda2abfb9
--- /dev/null
+++ b/crates/assists/src/assist_config.rs
@@ -0,0 +1,30 @@
+//! Settings for tweaking assists.
+//!
+//! The fun thing here is `SnippetCap` -- this type can only be created in this
+//! module, and we use to statically check that we only produce snippet
+//! assists if we are allowed to.
+
+use crate::AssistKind;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AssistConfig {
+    pub snippet_cap: Option<SnippetCap>,
+    pub allowed: Option<Vec<AssistKind>>,
+}
+
+impl AssistConfig {
+    pub fn allow_snippets(&mut self, yes: bool) {
+        self.snippet_cap = if yes { Some(SnippetCap { _private: () }) } else { None }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct SnippetCap {
+    _private: (),
+}
+
+impl Default for AssistConfig {
+    fn default() -> Self {
+        AssistConfig { snippet_cap: Some(SnippetCap { _private: () }), allowed: None }
+    }
+}
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
new file mode 100644
index 000000000..79574b9ac
--- /dev/null
+++ b/crates/assists/src/assist_context.rs
@@ -0,0 +1,291 @@
+//! See `AssistContext`
+
+use std::mem;
+
+use algo::find_covering_element;
+use base_db::{FileId, FileRange};
+use hir::Semantics;
+use ide_db::{
+    source_change::{SourceChange, SourceFileEdit},
+    RootDatabase,
+};
+use syntax::{
+    algo::{self, find_node_at_offset, SyntaxRewriter},
+    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange, TextSize,
+    TokenAtOffset,
+};
+use text_edit::{TextEdit, TextEditBuilder};
+
+use crate::{
+    assist_config::{AssistConfig, SnippetCap},
+    Assist, AssistId, AssistKind, GroupLabel, ResolvedAssist,
+};
+
+/// `AssistContext` allows to apply an assist or check if it could be applied.
+///
+/// Assists use a somewhat over-engineered approach, given the current needs.
+/// The assists workflow consists of two phases. In the first phase, a user asks
+/// for the list of available assists. In the second phase, the user picks a
+/// particular assist and it gets applied.
+///
+/// There are two peculiarities here:
+///
+/// * first, we ideally avoid computing more things then necessary to answer "is
+///   assist applicable" in the first phase.
+/// * second, when we are applying assist, we don't have a guarantee that there
+///   weren't any changes between the point when user asked for assists and when
+///   they applied a particular assist. So, when applying assist, we need to do
+///   all the checks from scratch.
+///
+/// To avoid repeating the same code twice for both "check" and "apply"
+/// functions, we use an approach reminiscent of that of Django's function based
+/// views dealing with forms. Each assist receives a runtime parameter,
+/// `resolve`. It first check if an edit is applicable (potentially computing
+/// info required to compute the actual edit). If it is applicable, and
+/// `resolve` is `true`, it then computes the actual edit.
+///
+/// So, to implement the original assists workflow, we can first apply each edit
+/// with `resolve = false`, and then applying the selected edit again, with
+/// `resolve = true` this time.
+///
+/// Note, however, that we don't actually use such two-phase logic at the
+/// moment, because the LSP API is pretty awkward in this place, and it's much
+/// easier to just compute the edit eagerly :-)
+pub(crate) struct AssistContext<'a> {
+    pub(crate) config: &'a AssistConfig,
+    pub(crate) sema: Semantics<'a, RootDatabase>,
+    pub(crate) frange: FileRange,
+    source_file: SourceFile,
+}
+
+impl<'a> AssistContext<'a> {
+    pub(crate) fn new(
+        sema: Semantics<'a, RootDatabase>,
+        config: &'a AssistConfig,
+        frange: FileRange,
+    ) -> AssistContext<'a> {
+        let source_file = sema.parse(frange.file_id);
+        AssistContext { config, sema, frange, source_file }
+    }
+
+    pub(crate) fn db(&self) -> &RootDatabase {
+        self.sema.db
+    }
+
+    pub(crate) fn source_file(&self) -> &SourceFile {
+        &self.source_file
+    }
+
+    // NB, this ignores active selection.
+    pub(crate) fn offset(&self) -> TextSize {
+        self.frange.range.start()
+    }
+
+    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
+        self.source_file.syntax().token_at_offset(self.offset())
+    }
+    pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
+        self.token_at_offset().find(|it| it.kind() == kind)
+    }
+    pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
+        find_node_at_offset(self.source_file.syntax(), self.offset())
+    }
+    pub(crate) fn find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
+        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)
+    }
+    // FIXME: remove
+    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement {
+        find_covering_element(self.source_file.syntax(), range)
+    }
+}
+
+pub(crate) struct Assists {
+    resolve: bool,
+    file: FileId,
+    buf: Vec<(Assist, Option<SourceChange>)>,
+    allowed: Option<Vec<AssistKind>>,
+}
+
+impl Assists {
+    pub(crate) fn new_resolved(ctx: &AssistContext) -> Assists {
+        Assists {
+            resolve: true,
+            file: ctx.frange.file_id,
+            buf: Vec::new(),
+            allowed: ctx.config.allowed.clone(),
+        }
+    }
+
+    pub(crate) fn new_unresolved(ctx: &AssistContext) -> Assists {
+        Assists {
+            resolve: false,
+            file: ctx.frange.file_id,
+            buf: Vec::new(),
+            allowed: ctx.config.allowed.clone(),
+        }
+    }
+
+    pub(crate) fn finish_unresolved(self) -> Vec<Assist> {
+        assert!(!self.resolve);
+        self.finish()
+            .into_iter()
+            .map(|(label, edit)| {
+                assert!(edit.is_none());
+                label
+            })
+            .collect()
+    }
+
+    pub(crate) fn finish_resolved(self) -> Vec<ResolvedAssist> {
+        assert!(self.resolve);
+        self.finish()
+            .into_iter()
+            .map(|(label, edit)| ResolvedAssist { assist: label, source_change: edit.unwrap() })
+            .collect()
+    }
+
+    pub(crate) fn add(
+        &mut self,
+        id: AssistId,
+        label: impl Into<String>,
+        target: TextRange,
+        f: impl FnOnce(&mut AssistBuilder),
+    ) -> Option<()> {
+        if !self.is_allowed(&id) {
+            return None;
+        }
+        let label = Assist::new(id, label.into(), None, target);
+        self.add_impl(label, f)
+    }
+
+    pub(crate) fn add_group(
+        &mut self,
+        group: &GroupLabel,
+        id: AssistId,
+        label: impl Into<String>,
+        target: TextRange,
+        f: impl FnOnce(&mut AssistBuilder),
+    ) -> Option<()> {
+        if !self.is_allowed(&id) {
+            return None;
+        }
+
+        let label = Assist::new(id, label.into(), Some(group.clone()), target);
+        self.add_impl(label, f)
+    }
+
+    fn add_impl(&mut self, label: Assist, f: impl FnOnce(&mut AssistBuilder)) -> Option<()> {
+        let source_change = if self.resolve {
+            let mut builder = AssistBuilder::new(self.file);
+            f(&mut builder);
+            Some(builder.finish())
+        } else {
+            None
+        };
+
+        self.buf.push((label, source_change));
+        Some(())
+    }
+
+    fn finish(mut self) -> Vec<(Assist, Option<SourceChange>)> {
+        self.buf.sort_by_key(|(label, _edit)| label.target.len());
+        self.buf
+    }
+
+    fn is_allowed(&self, id: &AssistId) -> bool {
+        match &self.allowed {
+            Some(allowed) => allowed.iter().any(|kind| kind.contains(id.1)),
+            None => true,
+        }
+    }
+}
+
+pub(crate) struct AssistBuilder {
+    edit: TextEditBuilder,
+    file_id: FileId,
+    is_snippet: bool,
+    change: SourceChange,
+}
+
+impl AssistBuilder {
+    pub(crate) fn new(file_id: FileId) -> AssistBuilder {
+        AssistBuilder {
+            edit: TextEdit::builder(),
+            file_id,
+            is_snippet: false,
+            change: SourceChange::default(),
+        }
+    }
+
+    pub(crate) fn edit_file(&mut self, file_id: FileId) {
+        self.file_id = file_id;
+    }
+
+    fn commit(&mut self) {
+        let edit = mem::take(&mut self.edit).finish();
+        if !edit.is_empty() {
+            let new_edit = SourceFileEdit { file_id: self.file_id, edit };
+            assert!(!self.change.source_file_edits.iter().any(|it| it.file_id == new_edit.file_id));
+            self.change.source_file_edits.push(new_edit);
+        }
+    }
+
+    /// Remove specified `range` of text.
+    pub(crate) fn delete(&mut self, range: TextRange) {
+        self.edit.delete(range)
+    }
+    /// Append specified `text` at the given `offset`
+    pub(crate) fn insert(&mut self, offset: TextSize, text: impl Into<String>) {
+        self.edit.insert(offset, text.into())
+    }
+    /// Append specified `snippet` at the given `offset`
+    pub(crate) fn insert_snippet(
+        &mut self,
+        _cap: SnippetCap,
+        offset: TextSize,
+        snippet: impl Into<String>,
+    ) {
+        self.is_snippet = true;
+        self.insert(offset, snippet);
+    }
+    /// Replaces specified `range` of text with a given string.
+    pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
+        self.edit.replace(range, replace_with.into())
+    }
+    /// Replaces specified `range` of text with a given `snippet`.
+    pub(crate) fn replace_snippet(
+        &mut self,
+        _cap: SnippetCap,
+        range: TextRange,
+        snippet: impl Into<String>,
+    ) {
+        self.is_snippet = true;
+        self.replace(range, snippet);
+    }
+    pub(crate) fn replace_ast<N: AstNode>(&mut self, old: N, new: N) {
+        algo::diff(old.syntax(), new.syntax()).into_text_edit(&mut self.edit)
+    }
+    pub(crate) fn rewrite(&mut self, rewriter: SyntaxRewriter) {
+        let node = rewriter.rewrite_root().unwrap();
+        let new = rewriter.rewrite(&node);
+        algo::diff(&node, &new).into_text_edit(&mut self.edit);
+    }
+
+    // FIXME: kill this API
+    /// Get access to the raw `TextEditBuilder`.
+    pub(crate) fn text_edit_builder(&mut self) -> &mut TextEditBuilder {
+        &mut self.edit
+    }
+
+    fn finish(mut self) -> SourceChange {
+        self.commit();
+        let mut change = mem::take(&mut self.change);
+        if self.is_snippet {
+            change.is_snippet = true;
+        }
+        change
+    }
+}
diff --git a/crates/assists/src/ast_transform.rs b/crates/assists/src/ast_transform.rs
new file mode 100644
index 000000000..4c41c16d8
--- /dev/null
+++ b/crates/assists/src/ast_transform.rs
@@ -0,0 +1,206 @@
+//! `AstTransformer`s are functions that replace nodes in an AST and can be easily combined.
+use rustc_hash::FxHashMap;
+
+use hir::{HirDisplay, PathResolution, SemanticsScope};
+use syntax::{
+    algo::SyntaxRewriter,
+    ast::{self, AstNode},
+};
+
+pub trait AstTransform<'a> {
+    fn get_substitution(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode>;
+
+    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a>;
+    fn or<T: AstTransform<'a> + 'a>(self, other: T) -> Box<dyn AstTransform<'a> + 'a>
+    where
+        Self: Sized + 'a,
+    {
+        self.chain_before(Box::new(other))
+    }
+}
+
+struct NullTransformer;
+
+impl<'a> AstTransform<'a> for NullTransformer {
+    fn get_substitution(&self, _node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode> {
+        None
+    }
+    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
+        other
+    }
+}
+
+pub struct SubstituteTypeParams<'a> {
+    source_scope: &'a SemanticsScope<'a>,
+    substs: FxHashMap<hir::TypeParam, ast::Type>,
+    previous: Box<dyn AstTransform<'a> + 'a>,
+}
+
+impl<'a> SubstituteTypeParams<'a> {
+    pub fn for_trait_impl(
+        source_scope: &'a SemanticsScope<'a>,
+        // FIXME: there's implicit invariant that `trait_` and  `source_scope` match...
+        trait_: hir::Trait,
+        impl_def: ast::Impl,
+    ) -> SubstituteTypeParams<'a> {
+        let substs = get_syntactic_substs(impl_def).unwrap_or_default();
+        let generic_def: hir::GenericDef = trait_.into();
+        let substs_by_param: FxHashMap<_, _> = generic_def
+            .params(source_scope.db)
+            .into_iter()
+            // this is a trait impl, so we need to skip the first type parameter -- this is a bit hacky
+            .skip(1)
+            // The actual list of trait type parameters may be longer than the one
+            // used in the `impl` block due to trailing default type parameters.
+            // For that case we extend the `substs` with an empty iterator so we
+            // can still hit those trailing values and check if they actually have
+            // a default type. If they do, go for that type from `hir` to `ast` so
+            // the resulting change can be applied correctly.
+            .zip(substs.into_iter().map(Some).chain(std::iter::repeat(None)))
+            .filter_map(|(k, v)| match v {
+                Some(v) => Some((k, v)),
+                None => {
+                    let default = k.default(source_scope.db)?;
+                    Some((
+                        k,
+                        ast::make::ty(
+                            &default
+                                .display_source_code(source_scope.db, source_scope.module()?.into())
+                                .ok()?,
+                        ),
+                    ))
+                }
+            })
+            .collect();
+        return SubstituteTypeParams {
+            source_scope,
+            substs: substs_by_param,
+            previous: Box::new(NullTransformer),
+        };
+
+        // FIXME: It would probably be nicer if we could get this via HIR (i.e. get the
+        // trait ref, and then go from the types in the substs back to the syntax).
+        fn get_syntactic_substs(impl_def: ast::Impl) -> Option<Vec<ast::Type>> {
+            let target_trait = impl_def.trait_()?;
+            let path_type = match target_trait {
+                ast::Type::PathType(path) => path,
+                _ => return None,
+            };
+            let generic_arg_list = path_type.path()?.segment()?.generic_arg_list()?;
+
+            let mut result = Vec::new();
+            for generic_arg in generic_arg_list.generic_args() {
+                match generic_arg {
+                    ast::GenericArg::TypeArg(type_arg) => result.push(type_arg.ty()?),
+                    ast::GenericArg::AssocTypeArg(_)
+                    | ast::GenericArg::LifetimeArg(_)
+                    | ast::GenericArg::ConstArg(_) => (),
+                }
+            }
+
+            Some(result)
+        }
+    }
+    fn get_substitution_inner(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode> {
+        let type_ref = ast::Type::cast(node.clone())?;
+        let path = match &type_ref {
+            ast::Type::PathType(path_type) => path_type.path()?,
+            _ => return None,
+        };
+        // FIXME: use `hir::Path::from_src` instead.
+        #[allow(deprecated)]
+        let path = hir::Path::from_ast(path)?;
+        let resolution = self.source_scope.resolve_hir_path(&path)?;
+        match resolution {
+            hir::PathResolution::TypeParam(tp) => Some(self.substs.get(&tp)?.syntax().clone()),
+            _ => None,
+        }
+    }
+}
+
+impl<'a> AstTransform<'a> for SubstituteTypeParams<'a> {
+    fn get_substitution(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode> {
+        self.get_substitution_inner(node).or_else(|| self.previous.get_substitution(node))
+    }
+    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
+        Box::new(SubstituteTypeParams { previous: other, ..self })
+    }
+}
+
+pub struct QualifyPaths<'a> {
+    target_scope: &'a SemanticsScope<'a>,
+    source_scope: &'a SemanticsScope<'a>,
+    previous: Box<dyn AstTransform<'a> + 'a>,
+}
+
+impl<'a> QualifyPaths<'a> {
+    pub fn new(target_scope: &'a SemanticsScope<'a>, source_scope: &'a SemanticsScope<'a>) -> Self {
+        Self { target_scope, source_scope, previous: Box::new(NullTransformer) }
+    }
+
+    fn get_substitution_inner(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode> {
+        // FIXME handle value ns?
+        let from = self.target_scope.module()?;
+        let p = ast::Path::cast(node.clone())?;
+        if p.segment().and_then(|s| s.param_list()).is_some() {
+            // don't try to qualify `Fn(Foo) -> Bar` paths, they are in prelude anyway
+            return None;
+        }
+        // FIXME: use `hir::Path::from_src` instead.
+        #[allow(deprecated)]
+        let hir_path = hir::Path::from_ast(p.clone());
+        let resolution = self.source_scope.resolve_hir_path(&hir_path?)?;
+        match resolution {
+            PathResolution::Def(def) => {
+                let found_path = from.find_use_path(self.source_scope.db.upcast(), def)?;
+                let mut path = path_to_ast(found_path);
+
+                let type_args = p
+                    .segment()
+                    .and_then(|s| s.generic_arg_list())
+                    .map(|arg_list| apply(self, arg_list));
+                if let Some(type_args) = type_args {
+                    let last_segment = path.segment().unwrap();
+                    path = path.with_segment(last_segment.with_type_args(type_args))
+                }
+
+                Some(path.syntax().clone())
+            }
+            PathResolution::Local(_)
+            | PathResolution::TypeParam(_)
+            | PathResolution::SelfType(_) => None,
+            PathResolution::Macro(_) => None,
+            PathResolution::AssocItem(_) => None,
+        }
+    }
+}
+
+pub fn apply<'a, N: AstNode>(transformer: &dyn AstTransform<'a>, node: N) -> N {
+    SyntaxRewriter::from_fn(|element| match element {
+        syntax::SyntaxElement::Node(n) => {
+            let replacement = transformer.get_substitution(&n)?;
+            Some(replacement.into())
+        }
+        _ => None,
+    })
+    .rewrite_ast(&node)
+}
+
+impl<'a> AstTransform<'a> for QualifyPaths<'a> {
+    fn get_substitution(&self, node: &syntax::SyntaxNode) -> Option<syntax::SyntaxNode> {
+        self.get_substitution_inner(node).or_else(|| self.previous.get_substitution(node))
+    }
+    fn chain_before(self, other: Box<dyn AstTransform<'a> + 'a>) -> Box<dyn AstTransform<'a> + 'a> {
+        Box::new(QualifyPaths { previous: other, ..self })
+    }
+}
+
+pub(crate) fn path_to_ast(path: hir::ModPath) -> ast::Path {
+    let parse = ast::SourceFile::parse(&path.to_string());
+    parse
+        .tree()
+        .syntax()
+        .descendants()
+        .find_map(ast::Path::cast)
+        .unwrap_or_else(|| panic!("failed to parse path {:?}, `{}`", path, path))
+}
diff --git a/crates/assists/src/handlers/add_custom_impl.rs b/crates/assists/src/handlers/add_custom_impl.rs
new file mode 100644
index 000000000..8757fa33f
--- /dev/null
+++ b/crates/assists/src/handlers/add_custom_impl.rs
@@ -0,0 +1,208 @@
+use itertools::Itertools;
+use syntax::{
+    ast::{self, AstNode},
+    Direction, SmolStr,
+    SyntaxKind::{IDENT, WHITESPACE},
+    TextRange, TextSize,
+};
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+
+// Assist: add_custom_impl
+//
+// Adds impl block for derived trait.
+//
+// ```
+// #[derive(Deb<|>ug, Display)]
+// struct S;
+// ```
+// ->
+// ```
+// #[derive(Display)]
+// struct S;
+//
+// impl Debug for S {
+//     $0
+// }
+// ```
+pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let attr = ctx.find_node_at_offset::<ast::Attr>()?;
+    let input = attr.token_tree()?;
+
+    let attr_name = attr
+        .syntax()
+        .descendants_with_tokens()
+        .filter(|t| t.kind() == IDENT)
+        .find_map(|i| i.into_token())
+        .filter(|t| *t.text() == "derive")?
+        .text()
+        .clone();
+
+    let trait_token =
+        ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?;
+
+    let annotated = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?;
+    let annotated_name = annotated.syntax().text().to_string();
+    let start_offset = annotated.syntax().parent()?.text_range().end();
+
+    let label =
+        format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name);
+
+    let target = attr.syntax().text_range();
+    acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| {
+        let new_attr_input = input
+            .syntax()
+            .descendants_with_tokens()
+            .filter(|t| t.kind() == IDENT)
+            .filter_map(|t| t.into_token().map(|t| t.text().clone()))
+            .filter(|t| t != trait_token.text())
+            .collect::<Vec<SmolStr>>();
+        let has_more_derives = !new_attr_input.is_empty();
+
+        if has_more_derives {
+            let new_attr_input = format!("({})", new_attr_input.iter().format(", "));
+            builder.replace(input.syntax().text_range(), new_attr_input);
+        } else {
+            let attr_range = attr.syntax().text_range();
+            builder.delete(attr_range);
+
+            let line_break_range = attr
+                .syntax()
+                .next_sibling_or_token()
+                .filter(|t| t.kind() == WHITESPACE)
+                .map(|t| t.text_range())
+                .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0)));
+            builder.delete(line_break_range);
+        }
+
+        match ctx.config.snippet_cap {
+            Some(cap) => {
+                builder.insert_snippet(
+                    cap,
+                    start_offset,
+                    format!("\n\nimpl {} for {} {{\n    $0\n}}", trait_token, annotated_name),
+                );
+            }
+            None => {
+                builder.insert(
+                    start_offset,
+                    format!("\n\nimpl {} for {} {{\n\n}}", trait_token, annotated_name),
+                );
+            }
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn add_custom_impl_for_unique_input() {
+        check_assist(
+            add_custom_impl,
+            "
+#[derive(Debu<|>g)]
+struct Foo {
+    bar: String,
+}
+            ",
+            "
+struct Foo {
+    bar: String,
+}
+
+impl Debug for Foo {
+    $0
+}
+            ",
+        )
+    }
+
+    #[test]
+    fn add_custom_impl_for_with_visibility_modifier() {
+        check_assist(
+            add_custom_impl,
+            "
+#[derive(Debug<|>)]
+pub struct Foo {
+    bar: String,
+}
+            ",
+            "
+pub struct Foo {
+    bar: String,
+}
+
+impl Debug for Foo {
+    $0
+}
+            ",
+        )
+    }
+
+    #[test]
+    fn add_custom_impl_when_multiple_inputs() {
+        check_assist(
+            add_custom_impl,
+            "
+#[derive(Display, Debug<|>, Serialize)]
+struct Foo {}
+            ",
+            "
+#[derive(Display, Serialize)]
+struct Foo {}
+
+impl Debug for Foo {
+    $0
+}
+            ",
+        )
+    }
+
+    #[test]
+    fn test_ignore_derive_macro_without_input() {
+        check_assist_not_applicable(
+            add_custom_impl,
+            "
+#[derive(<|>)]
+struct Foo {}
+            ",
+        )
+    }
+
+    #[test]
+    fn test_ignore_if_cursor_on_param() {
+        check_assist_not_applicable(
+            add_custom_impl,
+            "
+#[derive<|>(Debug)]
+struct Foo {}
+            ",
+        );
+
+        check_assist_not_applicable(
+            add_custom_impl,
+            "
+#[derive(Debug)<|>]
+struct Foo {}
+            ",
+        )
+    }
+
+    #[test]
+    fn test_ignore_if_not_derive() {
+        check_assist_not_applicable(
+            add_custom_impl,
+            "
+#[allow(non_camel_<|>case_types)]
+struct Foo {}
+            ",
+        )
+    }
+}
diff --git a/crates/assists/src/handlers/add_explicit_type.rs b/crates/assists/src/handlers/add_explicit_type.rs
new file mode 100644
index 000000000..563cbf505
--- /dev/null
+++ b/crates/assists/src/handlers/add_explicit_type.rs
@@ -0,0 +1,211 @@
+use hir::HirDisplay;
+use syntax::{
+    ast::{self, AstNode, LetStmt, NameOwner},
+    TextRange,
+};
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: add_explicit_type
+//
+// Specify type for a let binding.
+//
+// ```
+// fn main() {
+//     let x<|> = 92;
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     let x: i32 = 92;
+// }
+// ```
+pub(crate) fn add_explicit_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let let_stmt = ctx.find_node_at_offset::<LetStmt>()?;
+    let module = ctx.sema.scope(let_stmt.syntax()).module()?;
+    let expr = let_stmt.initializer()?;
+    // Must be a binding
+    let pat = match let_stmt.pat()? {
+        ast::Pat::IdentPat(bind_pat) => bind_pat,
+        _ => return None,
+    };
+    let pat_range = pat.syntax().text_range();
+    // The binding must have a name
+    let name = pat.name()?;
+    let name_range = name.syntax().text_range();
+    let stmt_range = let_stmt.syntax().text_range();
+    let eq_range = let_stmt.eq_token()?.text_range();
+    // Assist should only be applicable if cursor is between 'let' and '='
+    let let_range = TextRange::new(stmt_range.start(), eq_range.start());
+    let cursor_in_range = let_range.contains_range(ctx.frange.range);
+    if !cursor_in_range {
+        return None;
+    }
+    // Assist not applicable if the type has already been specified
+    // and it has no placeholders
+    let ascribed_ty = let_stmt.ty();
+    if let Some(ty) = &ascribed_ty {
+        if ty.syntax().descendants().find_map(ast::InferType::cast).is_none() {
+            return None;
+        }
+    }
+    // Infer type
+    let ty = ctx.sema.type_of_expr(&expr)?;
+
+    if ty.contains_unknown() || ty.is_closure() {
+        return None;
+    }
+
+    let inferred_type = ty.display_source_code(ctx.db(), module.into()).ok()?;
+    acc.add(
+        AssistId("add_explicit_type", AssistKind::RefactorRewrite),
+        format!("Insert explicit type `{}`", inferred_type),
+        pat_range,
+        |builder| match ascribed_ty {
+            Some(ascribed_ty) => {
+                builder.replace(ascribed_ty.syntax().text_range(), inferred_type);
+            }
+            None => {
+                builder.insert(name_range.end(), format!(": {}", inferred_type));
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    #[test]
+    fn add_explicit_type_target() {
+        check_assist_target(add_explicit_type, "fn f() { let a<|> = 1; }", "a");
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_simple_expr() {
+        check_assist(add_explicit_type, "fn f() { let a<|> = 1; }", "fn f() { let a: i32 = 1; }");
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_underscore() {
+        check_assist(
+            add_explicit_type,
+            "fn f() { let a<|>: _ = 1; }",
+            "fn f() { let a: i32 = 1; }",
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_nested_underscore() {
+        check_assist(
+            add_explicit_type,
+            r#"
+            enum Option<T> {
+                Some(T),
+                None
+            }
+
+            fn f() {
+                let a<|>: Option<_> = Option::Some(1);
+            }"#,
+            r#"
+            enum Option<T> {
+                Some(T),
+                None
+            }
+
+            fn f() {
+                let a: Option<i32> = Option::Some(1);
+            }"#,
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_macro_call() {
+        check_assist(
+            add_explicit_type,
+            r"macro_rules! v { () => {0u64} } fn f() { let a<|> = v!(); }",
+            r"macro_rules! v { () => {0u64} } fn f() { let a: u64 = v!(); }",
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_works_for_macro_call_recursive() {
+        check_assist(
+            add_explicit_type,
+            r#"macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a<|> = v!(); }"#,
+            r#"macro_rules! u { () => {0u64} } macro_rules! v { () => {u!()} } fn f() { let a: u64 = v!(); }"#,
+        );
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_ty_not_inferred() {
+        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|> = None; }");
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_ty_already_specified() {
+        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|>: i32 = 1; }");
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_specified_ty_is_tuple() {
+        check_assist_not_applicable(add_explicit_type, "fn f() { let a<|>: (i32, i32) = (3, 4); }");
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_cursor_after_equals() {
+        check_assist_not_applicable(
+            add_explicit_type,
+            "fn f() {let a =<|> match 1 {2 => 3, 3 => 5};}",
+        )
+    }
+
+    #[test]
+    fn add_explicit_type_not_applicable_if_cursor_before_let() {
+        check_assist_not_applicable(
+            add_explicit_type,
+            "fn f() <|>{let a = match 1 {2 => 3, 3 => 5};}",
+        )
+    }
+
+    #[test]
+    fn closure_parameters_are_not_added() {
+        check_assist_not_applicable(
+            add_explicit_type,
+            r#"
+fn main() {
+    let multiply_by_two<|> = |i| i * 3;
+    let six = multiply_by_two(2);
+}"#,
+        )
+    }
+
+    #[test]
+    fn default_generics_should_not_be_added() {
+        check_assist(
+            add_explicit_type,
+            r#"
+struct Test<K, T = u8> {
+    k: K,
+    t: T,
+}
+
+fn main() {
+    let test<|> = Test { t: 23u8, k: 33 };
+}"#,
+            r#"
+struct Test<K, T = u8> {
+    k: K,
+    t: T,
+}
+
+fn main() {
+    let test: Test<i32> = Test { t: 23u8, k: 33 };
+}"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/add_missing_impl_members.rs b/crates/assists/src/handlers/add_missing_impl_members.rs
new file mode 100644
index 000000000..81b61ebf8
--- /dev/null
+++ b/crates/assists/src/handlers/add_missing_impl_members.rs
@@ -0,0 +1,711 @@
+use hir::HasSource;
+use syntax::{
+    ast::{
+        self,
+        edit::{self, AstNodeEdit, IndentLevel},
+        make, AstNode, NameOwner,
+    },
+    SmolStr,
+};
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
+    utils::{get_missing_assoc_items, render_snippet, resolve_target_trait, Cursor},
+    AssistId, AssistKind,
+};
+
+#[derive(PartialEq)]
+enum AddMissingImplMembersMode {
+    DefaultMethodsOnly,
+    NoDefaultMethods,
+}
+
+// Assist: add_impl_missing_members
+//
+// Adds scaffold for required impl members.
+//
+// ```
+// trait Trait<T> {
+//     Type X;
+//     fn foo(&self) -> T;
+//     fn bar(&self) {}
+// }
+//
+// impl Trait<u32> for () {<|>
+//
+// }
+// ```
+// ->
+// ```
+// trait Trait<T> {
+//     Type X;
+//     fn foo(&self) -> T;
+//     fn bar(&self) {}
+// }
+//
+// impl Trait<u32> for () {
+//     fn foo(&self) -> u32 {
+//         ${0:todo!()}
+//     }
+//
+// }
+// ```
+pub(crate) fn add_missing_impl_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    add_missing_impl_members_inner(
+        acc,
+        ctx,
+        AddMissingImplMembersMode::NoDefaultMethods,
+        "add_impl_missing_members",
+        "Implement missing members",
+    )
+}
+
+// Assist: add_impl_default_members
+//
+// Adds scaffold for overriding default impl members.
+//
+// ```
+// trait Trait {
+//     Type X;
+//     fn foo(&self);
+//     fn bar(&self) {}
+// }
+//
+// impl Trait for () {
+//     Type X = ();
+//     fn foo(&self) {}<|>
+//
+// }
+// ```
+// ->
+// ```
+// trait Trait {
+//     Type X;
+//     fn foo(&self);
+//     fn bar(&self) {}
+// }
+//
+// impl Trait for () {
+//     Type X = ();
+//     fn foo(&self) {}
+//     $0fn bar(&self) {}
+//
+// }
+// ```
+pub(crate) fn add_missing_default_members(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    add_missing_impl_members_inner(
+        acc,
+        ctx,
+        AddMissingImplMembersMode::DefaultMethodsOnly,
+        "add_impl_default_members",
+        "Implement default members",
+    )
+}
+
+fn add_missing_impl_members_inner(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+    mode: AddMissingImplMembersMode,
+    assist_id: &'static str,
+    label: &'static str,
+) -> Option<()> {
+    let _p = profile::span("add_missing_impl_members_inner");
+    let impl_def = ctx.find_node_at_offset::<ast::Impl>()?;
+    let impl_item_list = impl_def.assoc_item_list()?;
+
+    let trait_ = resolve_target_trait(&ctx.sema, &impl_def)?;
+
+    let def_name = |item: &ast::AssocItem| -> Option<SmolStr> {
+        match item {
+            ast::AssocItem::Fn(def) => def.name(),
+            ast::AssocItem::TypeAlias(def) => def.name(),
+            ast::AssocItem::Const(def) => def.name(),
+            ast::AssocItem::MacroCall(_) => None,
+        }
+        .map(|it| it.text().clone())
+    };
+
+    let missing_items = get_missing_assoc_items(&ctx.sema, &impl_def)
+        .iter()
+        .map(|i| match i {
+            hir::AssocItem::Function(i) => ast::AssocItem::Fn(i.source(ctx.db()).value),
+            hir::AssocItem::TypeAlias(i) => ast::AssocItem::TypeAlias(i.source(ctx.db()).value),
+            hir::AssocItem::Const(i) => ast::AssocItem::Const(i.source(ctx.db()).value),
+        })
+        .filter(|t| def_name(&t).is_some())
+        .filter(|t| match t {
+            ast::AssocItem::Fn(def) => match mode {
+                AddMissingImplMembersMode::DefaultMethodsOnly => def.body().is_some(),
+                AddMissingImplMembersMode::NoDefaultMethods => def.body().is_none(),
+            },
+            _ => mode == AddMissingImplMembersMode::NoDefaultMethods,
+        })
+        .collect::<Vec<_>>();
+
+    if missing_items.is_empty() {
+        return None;
+    }
+
+    let target = impl_def.syntax().text_range();
+    acc.add(AssistId(assist_id, AssistKind::QuickFix), label, target, |builder| {
+        let n_existing_items = impl_item_list.assoc_items().count();
+        let source_scope = ctx.sema.scope_for_def(trait_);
+        let target_scope = ctx.sema.scope(impl_item_list.syntax());
+        let ast_transform = QualifyPaths::new(&target_scope, &source_scope)
+            .or(SubstituteTypeParams::for_trait_impl(&source_scope, trait_, impl_def));
+        let items = missing_items
+            .into_iter()
+            .map(|it| ast_transform::apply(&*ast_transform, it))
+            .map(|it| match it {
+                ast::AssocItem::Fn(def) => ast::AssocItem::Fn(add_body(def)),
+                ast::AssocItem::TypeAlias(def) => ast::AssocItem::TypeAlias(def.remove_bounds()),
+                _ => it,
+            })
+            .map(|it| edit::remove_attrs_and_docs(&it));
+        let new_impl_item_list = impl_item_list.append_items(items);
+        let first_new_item = new_impl_item_list.assoc_items().nth(n_existing_items).unwrap();
+
+        let original_range = impl_item_list.syntax().text_range();
+        match ctx.config.snippet_cap {
+            None => builder.replace(original_range, new_impl_item_list.to_string()),
+            Some(cap) => {
+                let mut cursor = Cursor::Before(first_new_item.syntax());
+                let placeholder;
+                if let ast::AssocItem::Fn(func) = &first_new_item {
+                    if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) {
+                        if m.syntax().text() == "todo!()" {
+                            placeholder = m;
+                            cursor = Cursor::Replace(placeholder.syntax());
+                        }
+                    }
+                }
+                builder.replace_snippet(
+                    cap,
+                    original_range,
+                    render_snippet(cap, new_impl_item_list.syntax(), cursor),
+                )
+            }
+        };
+    })
+}
+
+fn add_body(fn_def: ast::Fn) -> ast::Fn {
+    if fn_def.body().is_some() {
+        return fn_def;
+    }
+    let body = make::block_expr(None, Some(make::expr_todo())).indent(IndentLevel(1));
+    fn_def.with_body(body)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn test_add_missing_impl_members() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo {
+    type Output;
+
+    const CONST: usize = 42;
+
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
+
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+<|>
+}"#,
+            r#"
+trait Foo {
+    type Output;
+
+    const CONST: usize = 42;
+
+    fn foo(&self);
+    fn bar(&self);
+    fn baz(&self);
+}
+
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+    $0type Output;
+    const CONST: usize = 42;
+    fn foo(&self) {
+        todo!()
+    }
+    fn baz(&self) {
+        todo!()
+    }
+
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_copied_overriden_members() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo {
+    fn foo(&self);
+    fn bar(&self) -> bool { true }
+    fn baz(&self) -> u32 { 42 }
+}
+
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+<|>
+}"#,
+            r#"
+trait Foo {
+    fn foo(&self);
+    fn bar(&self) -> bool { true }
+    fn baz(&self) -> u32 { 42 }
+}
+
+struct S;
+
+impl Foo for S {
+    fn bar(&self) {}
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_empty_impl_def() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn fill_in_type_params_1() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl Foo<u32> for S { <|> }"#,
+            r#"
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl Foo<u32> for S {
+    fn foo(&self, t: u32) -> &u32 {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn fill_in_type_params_2() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl<U> Foo<U> for S { <|> }"#,
+            r#"
+trait Foo<T> { fn foo(&self, t: T) -> &T; }
+struct S;
+impl<U> Foo<U> for S {
+    fn foo(&self, t: U) -> &U {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_cursor_after_empty_impl_def() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {}<|>"#,
+            r#"
+trait Foo { fn foo(&self); }
+struct S;
+impl Foo for S {
+    fn foo(&self) {
+        ${0:todo!()}
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_qualify_path_1() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub struct Bar;
+    trait Foo { fn foo(&self, bar: Bar); }
+}
+struct S;
+impl foo::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub struct Bar;
+    trait Foo { fn foo(&self, bar: Bar); }
+}
+struct S;
+impl foo::Foo for S {
+    fn foo(&self, bar: foo::Bar) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_path_generic() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    trait Foo { fn foo(&self, bar: Bar<u32>); }
+}
+struct S;
+impl foo::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    trait Foo { fn foo(&self, bar: Bar<u32>); }
+}
+struct S;
+impl foo::Foo for S {
+    fn foo(&self, bar: foo::Bar<u32>) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_path_and_substitute_param() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    trait Foo<T> { fn foo(&self, bar: Bar<T>); }
+}
+struct S;
+impl foo::Foo<u32> for S { <|> }"#,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    trait Foo<T> { fn foo(&self, bar: Bar<T>); }
+}
+struct S;
+impl foo::Foo<u32> for S {
+    fn foo(&self, bar: foo::Bar<u32>) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_substitute_param_no_qualify() {
+        // when substituting params, the substituted param should not be qualified!
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    trait Foo<T> { fn foo(&self, bar: T); }
+    pub struct Param;
+}
+struct Param;
+struct S;
+impl foo::Foo<Param> for S { <|> }"#,
+            r#"
+mod foo {
+    trait Foo<T> { fn foo(&self, bar: T); }
+    pub struct Param;
+}
+struct Param;
+struct S;
+impl foo::Foo<Param> for S {
+    fn foo(&self, bar: Param) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_path_associated_item() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    impl Bar<T> { type Assoc = u32; }
+    trait Foo { fn foo(&self, bar: Bar<u32>::Assoc); }
+}
+struct S;
+impl foo::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    impl Bar<T> { type Assoc = u32; }
+    trait Foo { fn foo(&self, bar: Bar<u32>::Assoc); }
+}
+struct S;
+impl foo::Foo for S {
+    fn foo(&self, bar: foo::Bar<u32>::Assoc) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_path_nested() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    pub struct Baz;
+    trait Foo { fn foo(&self, bar: Bar<Baz>); }
+}
+struct S;
+impl foo::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub struct Bar<T>;
+    pub struct Baz;
+    trait Foo { fn foo(&self, bar: Bar<Baz>); }
+}
+struct S;
+impl foo::Foo for S {
+    fn foo(&self, bar: foo::Bar<foo::Baz>) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_qualify_path_fn_trait_notation() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+mod foo {
+    pub trait Fn<Args> { type Output; }
+    trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
+}
+struct S;
+impl foo::Foo for S { <|> }"#,
+            r#"
+mod foo {
+    pub trait Fn<Args> { type Output; }
+    trait Foo { fn foo(&self, bar: dyn Fn(u32) -> i32); }
+}
+struct S;
+impl foo::Foo for S {
+    fn foo(&self, bar: dyn Fn(u32) -> i32) {
+        ${0:todo!()}
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_empty_trait() {
+        check_assist_not_applicable(
+            add_missing_impl_members,
+            r#"
+trait Foo;
+struct S;
+impl Foo for S { <|> }"#,
+        )
+    }
+
+    #[test]
+    fn test_ignore_unnamed_trait_members_and_default_methods() {
+        check_assist_not_applicable(
+            add_missing_impl_members,
+            r#"
+trait Foo {
+    fn (arg: u32);
+    fn valid(some: u32) -> bool { false }
+}
+struct S;
+impl Foo for S { <|> }"#,
+        )
+    }
+
+    #[test]
+    fn test_with_docstring_and_attrs() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+#[doc(alias = "test alias")]
+trait Foo {
+    /// doc string
+    type Output;
+
+    #[must_use]
+    fn foo(&self);
+}
+struct S;
+impl Foo for S {}<|>"#,
+            r#"
+#[doc(alias = "test alias")]
+trait Foo {
+    /// doc string
+    type Output;
+
+    #[must_use]
+    fn foo(&self);
+}
+struct S;
+impl Foo for S {
+    $0type Output;
+    fn foo(&self) {
+        todo!()
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_default_methods() {
+        check_assist(
+            add_missing_default_members,
+            r#"
+trait Foo {
+    type Output;
+
+    const CONST: usize = 42;
+
+    fn valid(some: u32) -> bool { false }
+    fn foo(some: u32) -> bool;
+}
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo {
+    type Output;
+
+    const CONST: usize = 42;
+
+    fn valid(some: u32) -> bool { false }
+    fn foo(some: u32) -> bool;
+}
+struct S;
+impl Foo for S {
+    $0fn valid(some: u32) -> bool { false }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generic_single_default_parameter() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S { <|> }"#,
+            r#"
+trait Foo<T = Self> {
+    fn bar(&self, other: &T);
+}
+
+struct S;
+impl Foo for S {
+    fn bar(&self, other: &Self) {
+        ${0:todo!()}
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generic_default_parameter_is_second() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> { <|> }"#,
+            r#"
+trait Foo<T1, T2 = Self> {
+    fn bar(&self, this: &T1, that: &T2);
+}
+
+struct S<T>;
+impl Foo<T> for S<T> {
+    fn bar(&self, this: &T, that: &Self) {
+        ${0:todo!()}
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_assoc_type_bounds_are_removed() {
+        check_assist(
+            add_missing_impl_members,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+
+impl Tr for ()<|> {
+}"#,
+            r#"
+trait Tr {
+    type Ty: Copy + 'static;
+}
+
+impl Tr for () {
+    $0type Ty;
+}"#,
+        )
+    }
+}
diff --git a/crates/assists/src/handlers/add_turbo_fish.rs b/crates/assists/src/handlers/add_turbo_fish.rs
new file mode 100644
index 000000000..f4f997d8e
--- /dev/null
+++ b/crates/assists/src/handlers/add_turbo_fish.rs
@@ -0,0 +1,164 @@
+use ide_db::defs::{classify_name_ref, Definition, NameRefClass};
+use syntax::{ast, AstNode, SyntaxKind, T};
+use test_utils::mark;
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+
+// Assist: add_turbo_fish
+//
+// Adds `::<_>` to a call of a generic method or function.
+//
+// ```
+// fn make<T>() -> T { todo!() }
+// fn main() {
+//     let x = make<|>();
+// }
+// ```
+// ->
+// ```
+// fn make<T>() -> T { todo!() }
+// fn main() {
+//     let x = make::<${0:_}>();
+// }
+// ```
+pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let ident = ctx.find_token_at_offset(SyntaxKind::IDENT).or_else(|| {
+        let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
+        if arg_list.args().count() > 0 {
+            return None;
+        }
+        mark::hit!(add_turbo_fish_after_call);
+        arg_list.l_paren_token()?.prev_token().filter(|it| it.kind() == SyntaxKind::IDENT)
+    })?;
+    let next_token = ident.next_token()?;
+    if next_token.kind() == T![::] {
+        mark::hit!(add_turbo_fish_one_fish_is_enough);
+        return None;
+    }
+    let name_ref = ast::NameRef::cast(ident.parent())?;
+    let def = match classify_name_ref(&ctx.sema, &name_ref)? {
+        NameRefClass::Definition(def) => def,
+        NameRefClass::ExternCrate(_) | NameRefClass::FieldShorthand { .. } => return None,
+    };
+    let fun = match def {
+        Definition::ModuleDef(hir::ModuleDef::Function(it)) => it,
+        _ => return None,
+    };
+    let generics = hir::GenericDef::Function(fun).params(ctx.sema.db);
+    if generics.is_empty() {
+        mark::hit!(add_turbo_fish_non_generic);
+        return None;
+    }
+    acc.add(
+        AssistId("add_turbo_fish", AssistKind::RefactorRewrite),
+        "Add `::<>`",
+        ident.text_range(),
+        |builder| match ctx.config.snippet_cap {
+            Some(cap) => builder.insert_snippet(cap, ident.text_range().end(), "::<${0:_}>"),
+            None => builder.insert(ident.text_range().end(), "::<_>"),
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+    use test_utils::mark;
+
+    #[test]
+    fn add_turbo_fish_function() {
+        check_assist(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make<|>();
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make::<${0:_}>();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn add_turbo_fish_after_call() {
+        mark::check!(add_turbo_fish_after_call);
+        check_assist(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make()<|>;
+}
+"#,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make::<${0:_}>();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn add_turbo_fish_method() {
+        check_assist(
+            add_turbo_fish,
+            r#"
+struct S;
+impl S {
+    fn make<T>(&self) -> T {}
+}
+fn main() {
+    S.make<|>();
+}
+"#,
+            r#"
+struct S;
+impl S {
+    fn make<T>(&self) -> T {}
+}
+fn main() {
+    S.make::<${0:_}>();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn add_turbo_fish_one_fish_is_enough() {
+        mark::check!(add_turbo_fish_one_fish_is_enough);
+        check_assist_not_applicable(
+            add_turbo_fish,
+            r#"
+fn make<T>() -> T {}
+fn main() {
+    make<|>::<()>();
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn add_turbo_fish_non_generic() {
+        mark::check!(add_turbo_fish_non_generic);
+        check_assist_not_applicable(
+            add_turbo_fish,
+            r#"
+fn make() -> () {}
+fn main() {
+    make<|>();
+}
+"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/apply_demorgan.rs b/crates/assists/src/handlers/apply_demorgan.rs
new file mode 100644
index 000000000..1a6fdafda
--- /dev/null
+++ b/crates/assists/src/handlers/apply_demorgan.rs
@@ -0,0 +1,93 @@
+use syntax::ast::{self, AstNode};
+
+use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: apply_demorgan
+//
+// Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law].
+// This transforms expressions of the form `!l || !r` into `!(l && r)`.
+// This also works with `&&`. This assist can only be applied with the cursor
+// on either `||` or `&&`, with both operands being a negation of some kind.
+// This means something of the form `!x` or `x != y`.
+//
+// ```
+// fn main() {
+//     if x != 4 ||<|> !y {}
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     if !(x == 4 && y) {}
+// }
+// ```
+pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
+    let op = expr.op_kind()?;
+    let op_range = expr.op_token()?.text_range();
+    let opposite_op = opposite_logic_op(op)?;
+    let cursor_in_range = op_range.contains_range(ctx.frange.range);
+    if !cursor_in_range {
+        return None;
+    }
+
+    let lhs = expr.lhs()?;
+    let lhs_range = lhs.syntax().text_range();
+    let not_lhs = invert_boolean_expression(lhs);
+
+    let rhs = expr.rhs()?;
+    let rhs_range = rhs.syntax().text_range();
+    let not_rhs = invert_boolean_expression(rhs);
+
+    acc.add(
+        AssistId("apply_demorgan", AssistKind::RefactorRewrite),
+        "Apply De Morgan's law",
+        op_range,
+        |edit| {
+            edit.replace(op_range, opposite_op);
+            edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+            edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+        },
+    )
+}
+
+// Return the opposite text for a given logical operator, if it makes sense
+fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
+    match kind {
+        ast::BinOp::BooleanOr => Some("&&"),
+        ast::BinOp::BooleanAnd => Some("||"),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    #[test]
+    fn demorgan_turns_and_into_or() {
+        check_assist(apply_demorgan, "fn f() { !x &&<|> !x }", "fn f() { !(x || x) }")
+    }
+
+    #[test]
+    fn demorgan_turns_or_into_and() {
+        check_assist(apply_demorgan, "fn f() { !x ||<|> !x }", "fn f() { !(x && x) }")
+    }
+
+    #[test]
+    fn demorgan_removes_inequality() {
+        check_assist(apply_demorgan, "fn f() { x != x ||<|> !x }", "fn f() { !(x == x && x) }")
+    }
+
+    #[test]
+    fn demorgan_general_case() {
+        check_assist(apply_demorgan, "fn f() { x ||<|> x }", "fn f() { !(!x && !x) }")
+    }
+
+    #[test]
+    fn demorgan_doesnt_apply_with_cursor_not_on_op() {
+        check_assist_not_applicable(apply_demorgan, "fn f() { <|> !x || !x }")
+    }
+}
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
new file mode 100644
index 000000000..cce789972
--- /dev/null
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -0,0 +1,1088 @@
+use std::collections::BTreeSet;
+
+use either::Either;
+use hir::{
+    AsAssocItem, AssocItemContainer, ModPath, Module, ModuleDef, PathResolution, Semantics, Trait,
+    Type,
+};
+use ide_db::{imports_locator, RootDatabase};
+use rustc_hash::FxHashSet;
+use syntax::{
+    ast::{self, AstNode},
+    SyntaxNode,
+};
+
+use crate::{
+    utils::insert_use_statement, AssistContext, AssistId, AssistKind, Assists, GroupLabel,
+};
+
+// Assist: auto_import
+//
+// If the name is unresolved, provides all possible imports for it.
+//
+// ```
+// fn main() {
+//     let map = HashMap<|>::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+// ->
+// ```
+// use std::collections::HashMap;
+//
+// fn main() {
+//     let map = HashMap::new();
+// }
+// # pub mod std { pub mod collections { pub struct HashMap { } } }
+// ```
+pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let auto_import_assets = AutoImportAssets::new(ctx)?;
+    let proposed_imports = auto_import_assets.search_for_imports(ctx);
+    if proposed_imports.is_empty() {
+        return None;
+    }
+
+    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
+    let group = auto_import_assets.get_import_group_message();
+    for import in proposed_imports {
+        acc.add_group(
+            &group,
+            AssistId("auto_import", AssistKind::QuickFix),
+            format!("Import `{}`", &import),
+            range,
+            |builder| {
+                insert_use_statement(
+                    &auto_import_assets.syntax_under_caret,
+                    &import,
+                    ctx,
+                    builder.text_edit_builder(),
+                );
+            },
+        );
+    }
+    Some(())
+}
+
+#[derive(Debug)]
+struct AutoImportAssets {
+    import_candidate: ImportCandidate,
+    module_with_name_to_import: Module,
+    syntax_under_caret: SyntaxNode,
+}
+
+impl AutoImportAssets {
+    fn new(ctx: &AssistContext) -> Option<Self> {
+        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
+            Self::for_regular_path(path_under_caret, &ctx)
+        } else {
+            Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
+        }
+    }
+
+    fn for_method_call(method_call: ast::MethodCallExpr, ctx: &AssistContext) -> Option<Self> {
+        let syntax_under_caret = method_call.syntax().to_owned();
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
+        Some(Self {
+            import_candidate: ImportCandidate::for_method_call(&ctx.sema, &method_call)?,
+            module_with_name_to_import,
+            syntax_under_caret,
+        })
+    }
+
+    fn for_regular_path(path_under_caret: ast::Path, ctx: &AssistContext) -> Option<Self> {
+        let syntax_under_caret = path_under_caret.syntax().to_owned();
+        if syntax_under_caret.ancestors().find_map(ast::Use::cast).is_some() {
+            return None;
+        }
+
+        let module_with_name_to_import = ctx.sema.scope(&syntax_under_caret).module()?;
+        Some(Self {
+            import_candidate: ImportCandidate::for_regular_path(&ctx.sema, &path_under_caret)?,
+            module_with_name_to_import,
+            syntax_under_caret,
+        })
+    }
+
+    fn get_search_query(&self) -> &str {
+        match &self.import_candidate {
+            ImportCandidate::UnqualifiedName(name) => name,
+            ImportCandidate::QualifierStart(qualifier_start) => qualifier_start,
+            ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => trait_assoc_item_name,
+            ImportCandidate::TraitMethod(_, trait_method_name) => trait_method_name,
+        }
+    }
+
+    fn get_import_group_message(&self) -> GroupLabel {
+        let name = match &self.import_candidate {
+            ImportCandidate::UnqualifiedName(name) => format!("Import {}", name),
+            ImportCandidate::QualifierStart(qualifier_start) => {
+                format!("Import {}", qualifier_start)
+            }
+            ImportCandidate::TraitAssocItem(_, trait_assoc_item_name) => {
+                format!("Import a trait for item {}", trait_assoc_item_name)
+            }
+            ImportCandidate::TraitMethod(_, trait_method_name) => {
+                format!("Import a trait for method {}", trait_method_name)
+            }
+        };
+        GroupLabel(name)
+    }
+
+    fn search_for_imports(&self, ctx: &AssistContext) -> BTreeSet<ModPath> {
+        let _p = profile::span("auto_import::search_for_imports");
+        let db = ctx.db();
+        let current_crate = self.module_with_name_to_import.krate();
+        imports_locator::find_imports(&ctx.sema, current_crate, &self.get_search_query())
+            .into_iter()
+            .filter_map(|candidate| match &self.import_candidate {
+                ImportCandidate::TraitAssocItem(assoc_item_type, _) => {
+                    let located_assoc_item = match candidate {
+                        Either::Left(ModuleDef::Function(located_function)) => located_function
+                            .as_assoc_item(db)
+                            .map(|assoc| assoc.container(db))
+                            .and_then(Self::assoc_to_trait),
+                        Either::Left(ModuleDef::Const(located_const)) => located_const
+                            .as_assoc_item(db)
+                            .map(|assoc| assoc.container(db))
+                            .and_then(Self::assoc_to_trait),
+                        _ => None,
+                    }?;
+
+                    let mut trait_candidates = FxHashSet::default();
+                    trait_candidates.insert(located_assoc_item.into());
+
+                    assoc_item_type
+                        .iterate_path_candidates(
+                            db,
+                            current_crate,
+                            &trait_candidates,
+                            None,
+                            |_, assoc| Self::assoc_to_trait(assoc.container(db)),
+                        )
+                        .map(ModuleDef::from)
+                        .map(Either::Left)
+                }
+                ImportCandidate::TraitMethod(function_callee, _) => {
+                    let located_assoc_item =
+                        if let Either::Left(ModuleDef::Function(located_function)) = candidate {
+                            located_function
+                                .as_assoc_item(db)
+                                .map(|assoc| assoc.container(db))
+                                .and_then(Self::assoc_to_trait)
+                        } else {
+                            None
+                        }?;
+
+                    let mut trait_candidates = FxHashSet::default();
+                    trait_candidates.insert(located_assoc_item.into());
+
+                    function_callee
+                        .iterate_method_candidates(
+                            db,
+                            current_crate,
+                            &trait_candidates,
+                            None,
+                            |_, function| {
+                                Self::assoc_to_trait(function.as_assoc_item(db)?.container(db))
+                            },
+                        )
+                        .map(ModuleDef::from)
+                        .map(Either::Left)
+                }
+                _ => Some(candidate),
+            })
+            .filter_map(|candidate| match candidate {
+                Either::Left(module_def) => {
+                    self.module_with_name_to_import.find_use_path(db, module_def)
+                }
+                Either::Right(macro_def) => {
+                    self.module_with_name_to_import.find_use_path(db, macro_def)
+                }
+            })
+            .filter(|use_path| !use_path.segments.is_empty())
+            .take(20)
+            .collect::<BTreeSet<_>>()
+    }
+
+    fn assoc_to_trait(assoc: AssocItemContainer) -> Option<Trait> {
+        if let AssocItemContainer::Trait(extracted_trait) = assoc {
+            Some(extracted_trait)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug)]
+enum ImportCandidate {
+    /// Simple name like 'HashMap'
+    UnqualifiedName(String),
+    /// First part of the qualified name.
+    /// For 'std::collections::HashMap', that will be 'std'.
+    QualifierStart(String),
+    /// A trait associated function (with no self parameter) or associated constant.
+    /// For 'test_mod::TestEnum::test_function', `Type` is the `test_mod::TestEnum` expression type
+    /// and `String` is the `test_function`
+    TraitAssocItem(Type, String),
+    /// A trait method with self parameter.
+    /// For 'test_enum.test_method()', `Type` is the `test_enum` expression type
+    /// and `String` is the `test_method`
+    TraitMethod(Type, String),
+}
+
+impl ImportCandidate {
+    fn for_method_call(
+        sema: &Semantics<RootDatabase>,
+        method_call: &ast::MethodCallExpr,
+    ) -> Option<Self> {
+        if sema.resolve_method_call(method_call).is_some() {
+            return None;
+        }
+        Some(Self::TraitMethod(
+            sema.type_of_expr(&method_call.expr()?)?,
+            method_call.name_ref()?.syntax().to_string(),
+        ))
+    }
+
+    fn for_regular_path(
+        sema: &Semantics<RootDatabase>,
+        path_under_caret: &ast::Path,
+    ) -> Option<Self> {
+        if sema.resolve_path(path_under_caret).is_some() {
+            return None;
+        }
+
+        let segment = path_under_caret.segment()?;
+        if let Some(qualifier) = path_under_caret.qualifier() {
+            let qualifier_start = qualifier.syntax().descendants().find_map(ast::NameRef::cast)?;
+            let qualifier_start_path =
+                qualifier_start.syntax().ancestors().find_map(ast::Path::cast)?;
+            if let Some(qualifier_start_resolution) = sema.resolve_path(&qualifier_start_path) {
+                let qualifier_resolution = if qualifier_start_path == qualifier {
+                    qualifier_start_resolution
+                } else {
+                    sema.resolve_path(&qualifier)?
+                };
+                if let PathResolution::Def(ModuleDef::Adt(assoc_item_path)) = qualifier_resolution {
+                    Some(ImportCandidate::TraitAssocItem(
+                        assoc_item_path.ty(sema.db),
+                        segment.syntax().to_string(),
+                    ))
+                } else {
+                    None
+                }
+            } else {
+                Some(ImportCandidate::QualifierStart(qualifier_start.syntax().to_string()))
+            }
+        } else {
+            Some(ImportCandidate::UnqualifiedName(
+                segment.syntax().descendants().find_map(ast::NameRef::cast)?.syntax().to_string(),
+            ))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    #[test]
+    fn applicable_when_found_an_import() {
+        check_assist(
+            auto_import,
+            r"
+            <|>PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_an_import_in_macros() {
+        check_assist(
+            auto_import,
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(PubStruct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn auto_imports_are_merged() {
+        check_assist(
+            auto_import,
+            r"
+            use PubMod::PubStruct1;
+
+            struct Test {
+                test: Pub<|>Struct2<u8>,
+            }
+
+            pub mod PubMod {
+                pub struct PubStruct1;
+                pub struct PubStruct2<T> {
+                    _t: T,
+                }
+            }
+            ",
+            r"
+            use PubMod::{PubStruct2, PubStruct1};
+
+            struct Test {
+                test: PubStruct2<u8>,
+            }
+
+            pub mod PubMod {
+                pub struct PubStruct1;
+                pub struct PubStruct2<T> {
+                    _t: T,
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn applicable_when_found_multiple_imports() {
+        check_assist(
+            auto_import,
+            r"
+            PubSt<|>ruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod3::PubStruct;
+
+            PubStruct
+
+            pub mod PubMod1 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod2 {
+                pub struct PubStruct;
+            }
+            pub mod PubMod3 {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_already_imported_types() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            use PubMod::PubStruct;
+
+            PubStruct<|>
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_types_with_private_paths() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            PrivateStruct<|>
+
+            pub mod PubMod {
+                struct PrivateStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_when_no_imports_found() {
+        check_assist_not_applicable(
+            auto_import,
+            "
+            PubStruct<|>",
+        );
+    }
+
+    #[test]
+    fn not_applicable_in_import_statements() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            use PubStruct<|>;
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }",
+        );
+    }
+
+    #[test]
+    fn function_import() {
+        check_assist(
+            auto_import,
+            r"
+            test_function<|>
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+            r"
+            use PubMod::test_function;
+
+            test_function
+
+            pub mod PubMod {
+                pub fn test_function() {};
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn macro_import() {
+        check_assist(
+            auto_import,
+            r"
+//- /lib.rs crate:crate_with_macro
+#[macro_export]
+macro_rules! foo {
+    () => ()
+}
+
+//- /main.rs crate:main deps:crate_with_macro
+fn main() {
+    foo<|>
+}
+",
+            r"use crate_with_macro::foo;
+
+fn main() {
+    foo
+}
+",
+        );
+    }
+
+    #[test]
+    fn auto_import_target() {
+        check_assist_target(
+            auto_import,
+            r"
+            struct AssistInfo {
+                group_label: Option<<|>GroupLabel>,
+            }
+
+            mod m { pub struct GroupLabel; }
+            ",
+            "GroupLabel",
+        )
+    }
+
+    #[test]
+    fn not_applicable_when_path_start_is_imported() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            pub mod mod1 {
+                pub mod mod2 {
+                    pub mod mod3 {
+                        pub struct TestStruct;
+                    }
+                }
+            }
+
+            use mod1::mod2;
+            fn main() {
+                mod2::mod3::TestStruct<|>
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_function() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            pub mod test_mod {
+                pub fn test_function() {}
+            }
+
+            use test_mod::test_function;
+            fn main() {
+                test_function<|>
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_struct_function() {
+        check_assist(
+            auto_import,
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    pub fn test_function() {}
+                }
+            }
+
+            fn main() {
+                TestStruct::test_function<|>
+            }
+            ",
+            r"
+            use test_mod::TestStruct;
+
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    pub fn test_function() {}
+                }
+            }
+
+            fn main() {
+                TestStruct::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_struct_const() {
+        check_assist(
+            auto_import,
+            r"
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                TestStruct::TEST_CONST<|>
+            }
+            ",
+            r"
+            use test_mod::TestStruct;
+
+            mod test_mod {
+                pub struct TestStruct {}
+                impl TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                TestStruct::TEST_CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn associated_trait_function() {
+        check_assist(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::test_function<|>
+            }
+            ",
+            r"
+            use test_mod::TestTrait;
+
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_function() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub trait TestTrait2 {
+                    fn test_function();
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    fn test_function() {}
+                }
+                impl TestTrait for TestEnum {
+                    fn test_function() {}
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                test_mod::TestEnum::test_function<|>;
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn associated_trait_const() {
+        check_assist(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::TEST_CONST<|>
+            }
+            ",
+            r"
+            use test_mod::TestTrait;
+
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            fn main() {
+                test_mod::TestStruct::TEST_CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_const() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    const TEST_CONST: u8;
+                }
+                pub trait TestTrait2 {
+                    const TEST_CONST: f64;
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    const TEST_CONST: f64 = 42.0;
+                }
+                impl TestTrait for TestEnum {
+                    const TEST_CONST: u8 = 42;
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                test_mod::TestEnum::TEST_CONST<|>;
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn trait_method() {
+        check_assist(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            ",
+            r"
+            use test_mod::TestTrait;
+
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+
+            fn main() {
+                let test_struct = test_mod::TestStruct {};
+                test_struct.test_method()
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn trait_method_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_method()
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::test_func<|>tion
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                dep::test_mod::TestStruct::test_function
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_const_cross_crate() {
+        check_assist(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                dep::test_mod::TestStruct::CONST<|>
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    const CONST: bool;
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    const CONST: bool = true;
+                }
+            }
+            ",
+            r"
+            use dep::test_mod::TestTrait;
+
+            fn main() {
+                dep::test_mod::TestStruct::CONST
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn assoc_fn_as_method_cross_crate() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_func<|>tion()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                pub trait TestTrait {
+                    fn test_function();
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_function() {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn private_trait_cross_crate() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            //- /main.rs crate:main deps:dep
+            fn main() {
+                let test_struct = dep::test_mod::TestStruct {};
+                test_struct.test_meth<|>od()
+            }
+            //- /dep.rs crate:dep
+            pub mod test_mod {
+                trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub struct TestStruct {}
+                impl TestTrait for TestStruct {
+                    fn test_method(&self) {}
+                }
+            }
+            ",
+        );
+    }
+
+    #[test]
+    fn not_applicable_for_imported_trait_for_method() {
+        check_assist_not_applicable(
+            auto_import,
+            r"
+            mod test_mod {
+                pub trait TestTrait {
+                    fn test_method(&self);
+                }
+                pub trait TestTrait2 {
+                    fn test_method(&self);
+                }
+                pub enum TestEnum {
+                    One,
+                    Two,
+                }
+                impl TestTrait2 for TestEnum {
+                    fn test_method(&self) {}
+                }
+                impl TestTrait for TestEnum {
+                    fn test_method(&self) {}
+                }
+            }
+
+            use test_mod::TestTrait2;
+            fn main() {
+                let one = test_mod::TestEnum::One;
+                one.test<|>_method();
+            }
+            ",
+        )
+    }
+
+    #[test]
+    fn dep_import() {
+        check_assist(
+            auto_import,
+            r"
+//- /lib.rs crate:dep
+pub struct Struct;
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    Struct<|>
+}
+",
+            r"use dep::Struct;
+
+fn main() {
+    Struct
+}
+",
+        );
+    }
+
+    #[test]
+    fn whole_segment() {
+        // Tests that only imports whose last segment matches the identifier get suggested.
+        check_assist(
+            auto_import,
+            r"
+//- /lib.rs crate:dep
+pub mod fmt {
+    pub trait Display {}
+}
+
+pub fn panic_fmt() {}
+
+//- /main.rs crate:main deps:dep
+struct S;
+
+impl f<|>mt::Display for S {}
+",
+            r"use dep::fmt;
+
+struct S;
+
+impl fmt::Display for S {}
+",
+        );
+    }
+
+    #[test]
+    fn macro_generated() {
+        // Tests that macro-generated items are suggested from external crates.
+        check_assist(
+            auto_import,
+            r"
+//- /lib.rs crate:dep
+macro_rules! mac {
+    () => {
+        pub struct Cheese;
+    };
+}
+
+mac!();
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    Cheese<|>;
+}
+",
+            r"use dep::Cheese;
+
+fn main() {
+    Cheese;
+}
+",
+        );
+    }
+
+    #[test]
+    fn casing() {
+        // Tests that differently cased names don't interfere and we only suggest the matching one.
+        check_assist(
+            auto_import,
+            r"
+//- /lib.rs crate:dep
+pub struct FMT;
+pub struct fmt;
+
+//- /main.rs crate:main deps:dep
+fn main() {
+    FMT<|>;
+}
+",
+            r"use dep::FMT;
+
+fn main() {
+    FMT;
+}
+",
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/change_return_type_to_result.rs b/crates/assists/src/handlers/change_return_type_to_result.rs
new file mode 100644
index 000000000..be480943c
--- /dev/null
+++ b/crates/assists/src/handlers/change_return_type_to_result.rs
@@ -0,0 +1,998 @@
+use std::iter;
+
+use syntax::{
+    ast::{self, make, BlockExpr, Expr, LoopBodyOwner},
+    AstNode, SyntaxNode,
+};
+use test_utils::mark;
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: change_return_type_to_result
+//
+// Change the function's return type to Result.
+//
+// ```
+// fn foo() -> i32<|> { 42i32 }
+// ```
+// ->
+// ```
+// fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }
+// ```
+pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
+    // FIXME: extend to lambdas as well
+    let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?;
+
+    let type_ref = &ret_type.ty()?;
+    let ret_type_str = type_ref.syntax().text().to_string();
+    let first_part_ret_type = ret_type_str.splitn(2, '<').next();
+    if let Some(ret_type_first_part) = first_part_ret_type {
+        if ret_type_first_part.ends_with("Result") {
+            mark::hit!(change_return_type_to_result_simple_return_type_already_result);
+            return None;
+        }
+    }
+
+    let block_expr = &fn_def.body()?;
+
+    acc.add(
+        AssistId("change_return_type_to_result", AssistKind::RefactorRewrite),
+        "Wrap return type in Result",
+        type_ref.syntax().text_range(),
+        |builder| {
+            let mut tail_return_expr_collector = TailReturnCollector::new();
+            tail_return_expr_collector.collect_jump_exprs(block_expr, false);
+            tail_return_expr_collector.collect_tail_exprs(block_expr);
+
+            for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap {
+                let ok_wrapped = make::expr_call(
+                    make::expr_path(make::path_unqualified(make::path_segment(make::name_ref(
+                        "Ok",
+                    )))),
+                    make::arg_list(iter::once(ret_expr_arg.clone())),
+                );
+                builder.replace_ast(ret_expr_arg, ok_wrapped);
+            }
+
+            match ctx.config.snippet_cap {
+                Some(cap) => {
+                    let snippet = format!("Result<{}, ${{0:_}}>", type_ref);
+                    builder.replace_snippet(cap, type_ref.syntax().text_range(), snippet)
+                }
+                None => builder
+                    .replace(type_ref.syntax().text_range(), format!("Result<{}, _>", type_ref)),
+            }
+        },
+    )
+}
+
+struct TailReturnCollector {
+    exprs_to_wrap: Vec<ast::Expr>,
+}
+
+impl TailReturnCollector {
+    fn new() -> Self {
+        Self { exprs_to_wrap: vec![] }
+    }
+    /// Collect all`return` expression
+    fn collect_jump_exprs(&mut self, block_expr: &BlockExpr, collect_break: bool) {
+        let statements = block_expr.statements();
+        for stmt in statements {
+            let expr = match &stmt {
+                ast::Stmt::ExprStmt(stmt) => stmt.expr(),
+                ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+                ast::Stmt::Item(_) => continue,
+            };
+            if let Some(expr) = &expr {
+                self.handle_exprs(expr, collect_break);
+            }
+        }
+
+        // Browse tail expressions for each block
+        if let Some(expr) = block_expr.expr() {
+            if let Some(last_exprs) = get_tail_expr_from_block(&expr) {
+                for last_expr in last_exprs {
+                    let last_expr = match last_expr {
+                        NodeType::Node(expr) => expr,
+                        NodeType::Leaf(expr) => expr.syntax().clone(),
+                    };
+
+                    if let Some(last_expr) = Expr::cast(last_expr.clone()) {
+                        self.handle_exprs(&last_expr, collect_break);
+                    } else if let Some(expr_stmt) = ast::Stmt::cast(last_expr) {
+                        let expr_stmt = match &expr_stmt {
+                            ast::Stmt::ExprStmt(stmt) => stmt.expr(),
+                            ast::Stmt::LetStmt(stmt) => stmt.initializer(),
+                            ast::Stmt::Item(_) => None,
+                        };
+                        if let Some(expr) = &expr_stmt {
+                            self.handle_exprs(expr, collect_break);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn handle_exprs(&mut self, expr: &Expr, collect_break: bool) {
+        match expr {
+            Expr::BlockExpr(block_expr) => {
+                self.collect_jump_exprs(&block_expr, collect_break);
+            }
+            Expr::ReturnExpr(ret_expr) => {
+                if let Some(ret_expr_arg) = &ret_expr.expr() {
+                    self.exprs_to_wrap.push(ret_expr_arg.clone());
+                }
+            }
+            Expr::BreakExpr(break_expr) if collect_break => {
+                if let Some(break_expr_arg) = &break_expr.expr() {
+                    self.exprs_to_wrap.push(break_expr_arg.clone());
+                }
+            }
+            Expr::IfExpr(if_expr) => {
+                for block in if_expr.blocks() {
+                    self.collect_jump_exprs(&block, collect_break);
+                }
+            }
+            Expr::LoopExpr(loop_expr) => {
+                if let Some(block_expr) = loop_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::ForExpr(for_expr) => {
+                if let Some(block_expr) = for_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::WhileExpr(while_expr) => {
+                if let Some(block_expr) = while_expr.loop_body() {
+                    self.collect_jump_exprs(&block_expr, collect_break);
+                }
+            }
+            Expr::MatchExpr(match_expr) => {
+                if let Some(arm_list) = match_expr.match_arm_list() {
+                    arm_list.arms().filter_map(|match_arm| match_arm.expr()).for_each(|expr| {
+                        self.handle_exprs(&expr, collect_break);
+                    });
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn collect_tail_exprs(&mut self, block: &BlockExpr) {
+        if let Some(expr) = block.expr() {
+            self.handle_exprs(&expr, true);
+            self.fetch_tail_exprs(&expr);
+        }
+    }
+
+    fn fetch_tail_exprs(&mut self, expr: &Expr) {
+        if let Some(exprs) = get_tail_expr_from_block(expr) {
+            for node_type in &exprs {
+                match node_type {
+                    NodeType::Leaf(expr) => {
+                        self.exprs_to_wrap.push(expr.clone());
+                    }
+                    NodeType::Node(expr) => {
+                        if let Some(last_expr) = Expr::cast(expr.clone()) {
+                            self.fetch_tail_exprs(&last_expr);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+enum NodeType {
+    Leaf(ast::Expr),
+    Node(SyntaxNode),
+}
+
+/// Get a tail expression inside a block
+fn get_tail_expr_from_block(expr: &Expr) -> Option<Vec<NodeType>> {
+    match expr {
+        Expr::IfExpr(if_expr) => {
+            let mut nodes = vec![];
+            for block in if_expr.blocks() {
+                if let Some(block_expr) = block.expr() {
+                    if let Some(tail_exprs) = get_tail_expr_from_block(&block_expr) {
+                        nodes.extend(tail_exprs);
+                    }
+                } else if let Some(last_expr) = block.syntax().last_child() {
+                    nodes.push(NodeType::Node(last_expr));
+                } else {
+                    nodes.push(NodeType::Node(block.syntax().clone()));
+                }
+            }
+            Some(nodes)
+        }
+        Expr::LoopExpr(loop_expr) => {
+            loop_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::ForExpr(for_expr) => {
+            for_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::WhileExpr(while_expr) => {
+            while_expr.syntax().last_child().map(|lc| vec![NodeType::Node(lc)])
+        }
+        Expr::BlockExpr(block_expr) => {
+            block_expr.expr().map(|lc| vec![NodeType::Node(lc.syntax().clone())])
+        }
+        Expr::MatchExpr(match_expr) => {
+            let arm_list = match_expr.match_arm_list()?;
+            let arms: Vec<NodeType> = arm_list
+                .arms()
+                .filter_map(|match_arm| match_arm.expr())
+                .map(|expr| match expr {
+                    Expr::ReturnExpr(ret_expr) => NodeType::Node(ret_expr.syntax().clone()),
+                    Expr::BreakExpr(break_expr) => NodeType::Node(break_expr.syntax().clone()),
+                    _ => match expr.syntax().last_child() {
+                        Some(last_expr) => NodeType::Node(last_expr),
+                        None => NodeType::Node(expr.syntax().clone()),
+                    },
+                })
+                .collect();
+
+            Some(arms)
+        }
+        Expr::BreakExpr(expr) => expr.expr().map(|e| vec![NodeType::Leaf(e)]),
+        Expr::ReturnExpr(ret_expr) => Some(vec![NodeType::Node(ret_expr.syntax().clone())]),
+
+        Expr::CallExpr(_)
+        | Expr::Literal(_)
+        | Expr::TupleExpr(_)
+        | Expr::ArrayExpr(_)
+        | Expr::ParenExpr(_)
+        | Expr::PathExpr(_)
+        | Expr::RecordExpr(_)
+        | Expr::IndexExpr(_)
+        | Expr::MethodCallExpr(_)
+        | Expr::AwaitExpr(_)
+        | Expr::CastExpr(_)
+        | Expr::RefExpr(_)
+        | Expr::PrefixExpr(_)
+        | Expr::RangeExpr(_)
+        | Expr::BinExpr(_)
+        | Expr::MacroCall(_)
+        | Expr::BoxExpr(_) => Some(vec![NodeType::Leaf(expr.clone())]),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn change_return_type_to_result_simple() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i3<|>2 {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_return_type() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_return_type_bad_cursor() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> i32 {
+                let test = "test";<|>
+                return 42i32;
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_return_type_already_result_std() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> std::result::Result<i32<|>, String> {
+                let test = "test";
+                return 42i32;
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_return_type_already_result() {
+        mark::check!(change_return_type_to_result_simple_return_type_already_result);
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() -> Result<i32<|>, String> {
+                let test = "test";
+                return 42i32;
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_cursor() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> <|>i32 {
+                let test = "test";
+                return 42i32;
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                return Ok(42i32);
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -><|> i32 {
+                let test = "test";
+                42i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                Ok(42i32)
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_only() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                42i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                Ok(42i32)
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                if true {
+                    42i32
+                } else {
+                    24i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    Ok(42i32)
+                } else {
+                    Ok(24i32)
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_nested_if() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                if true {
+                    if false {
+                        1
+                    } else {
+                        2
+                    }
+                } else {
+                    24i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1)
+                    } else {
+                        Ok(2)
+                    }
+                } else {
+                    Ok(24i32)
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_await() {
+        check_assist(
+            change_return_type_to_result,
+            r#"async fn foo() -> i<|>32 {
+                if true {
+                    if false {
+                        1.await
+                    } else {
+                        2.await
+                    }
+                } else {
+                    24i32.await
+                }
+            }"#,
+            r#"async fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1.await)
+                    } else {
+                        Ok(2.await)
+                    }
+                } else {
+                    Ok(24i32.await)
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_array() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> [i32;<|> 3] {
+                [1, 2, 3]
+            }"#,
+            r#"fn foo() -> Result<[i32; 3], ${0:_}> {
+                Ok([1, 2, 3])
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_cast() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -<|>> i32 {
+                if true {
+                    if false {
+                        1 as i32
+                    } else {
+                        2 as i32
+                    }
+                } else {
+                    24 as i32
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                if true {
+                    if false {
+                        Ok(1 as i32)
+                    } else {
+                        Ok(2 as i32)
+                    }
+                } else {
+                    Ok(24 as i32)
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                match my_var {
+                    5 => 42i32,
+                    _ => 24i32,
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                match my_var {
+                    5 => Ok(42i32),
+                    _ => Ok(24i32),
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_loop_with_tail() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                loop {
+                    println!("test");
+                    5
+                }
+
+                my_var
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                loop {
+                    println!("test");
+                    5
+                }
+
+                Ok(my_var)
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_loop_in_let_stmt() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = let x = loop {
+                    break 1;
+                };
+
+                my_var
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = let x = loop {
+                    break 1;
+                };
+
+                Ok(my_var)
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match_return_expr() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                let res = match my_var {
+                    5 => 42i32,
+                    _ => return 24i32,
+                };
+
+                res
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                let res = match my_var {
+                    5 => 42i32,
+                    _ => return Ok(24i32),
+                };
+
+                Ok(res)
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                let res = if my_var == 5 {
+                    42i32
+                } else {
+                    return 24i32;
+                };
+
+                res
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                let res = if my_var == 5 {
+                    42i32
+                } else {
+                    return Ok(24i32);
+                };
+
+                Ok(res)
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_match_deeper() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let my_var = 5;
+                match my_var {
+                    5 => {
+                        if true {
+                            42i32
+                        } else {
+                            25i32
+                        }
+                    },
+                    _ => {
+                        let test = "test";
+                        if test == "test" {
+                            return bar();
+                        }
+                        53i32
+                    },
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let my_var = 5;
+                match my_var {
+                    5 => {
+                        if true {
+                            Ok(42i32)
+                        } else {
+                            Ok(25i32)
+                        }
+                    },
+                    _ => {
+                        let test = "test";
+                        if test == "test" {
+                            return Ok(bar());
+                        }
+                        Ok(53i32)
+                    },
+                }
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_tail_block_like_early_return() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i<|>32 {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                53i32
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                Ok(53i32)
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_closure() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -><|> u32 {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+
+
+                    if true_closure() {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+
+
+                    if true_closure() {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+
+                Ok(the_field)
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+
+
+                    if true_closure() {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+                let t = None;
+
+                t.unwrap_or_else(|| the_field)
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                let true_closure = || {
+                    return true;
+                };
+                if the_field < 5 {
+                    let mut i = 0;
+
+
+                    if true_closure() {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+                let t = None;
+
+                Ok(t.unwrap_or_else(|| the_field))
+            }"#,
+        );
+    }
+
+    #[test]
+    fn change_return_type_to_result_simple_with_weird_forms() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                let mut i = 0;
+                loop {
+                    if i == 1 {
+                        break 55;
+                    }
+                    i += 1;
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                let mut i = 0;
+                loop {
+                    if i == 1 {
+                        break Ok(55);
+                    }
+                    i += 1;
+                }
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i32<|> {
+                let test = "test";
+                if test == "test" {
+                    return 24i32;
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break 55;
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                if test == "test" {
+                    return Ok(24i32);
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break Ok(55);
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() -> i3<|>2 {
+                let test = "test";
+                let other = 5;
+                if test == "test" {
+                    let res = match other {
+                        5 => 43,
+                        _ => return 56,
+                    };
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break 55;
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+            r#"fn foo() -> Result<i32, ${0:_}> {
+                let test = "test";
+                let other = 5;
+                if test == "test" {
+                    let res = match other {
+                        5 => 43,
+                        _ => return Ok(56),
+                    };
+                }
+                let mut i = 0;
+                loop {
+                    loop {
+                        if i == 1 {
+                            break Ok(55);
+                        }
+                        i += 1;
+                    }
+                }
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    loop {
+                        if i > 5 {
+                            return 55u32;
+                        }
+                        i += 3;
+                    }
+
+                    match i {
+                        5 => return 99,
+                        _ => return 0,
+                    };
+                }
+
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+                    loop {
+                        if i > 5 {
+                            return Ok(55u32);
+                        }
+                        i += 3;
+                    }
+
+                    match i {
+                        5 => return Ok(99),
+                        _ => return Ok(0),
+                    };
+                }
+
+                Ok(the_field)
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u3<|>2 {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    match i {
+                        5 => return 99,
+                        _ => return 0,
+                    }
+                }
+
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    match i {
+                        5 => return Ok(99),
+                        _ => return Ok(0),
+                    }
+                }
+
+                Ok(the_field)
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> u32<|> {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    if i == 5 {
+                        return 99
+                    } else {
+                        return 0
+                    }
+                }
+
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    if i == 5 {
+                        return Ok(99)
+                    } else {
+                        return Ok(0)
+                    }
+                }
+
+                Ok(the_field)
+            }"#,
+        );
+
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo(the_field: u32) -> <|>u32 {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    if i == 5 {
+                        return 99;
+                    } else {
+                        return 0;
+                    }
+                }
+
+                the_field
+            }"#,
+            r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> {
+                if the_field < 5 {
+                    let mut i = 0;
+
+                    if i == 5 {
+                        return Ok(99);
+                    } else {
+                        return Ok(0);
+                    }
+                }
+
+                Ok(the_field)
+            }"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/change_visibility.rs b/crates/assists/src/handlers/change_visibility.rs
new file mode 100644
index 000000000..32dc05378
--- /dev/null
+++ b/crates/assists/src/handlers/change_visibility.rs
@@ -0,0 +1,200 @@
+use syntax::{
+    ast::{self, NameOwner, VisibilityOwner},
+    AstNode,
+    SyntaxKind::{CONST, ENUM, FN, MODULE, STATIC, STRUCT, TRAIT, VISIBILITY},
+    T,
+};
+use test_utils::mark;
+
+use crate::{utils::vis_offset, AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: change_visibility
+//
+// Adds or changes existing visibility specifier.
+//
+// ```
+// <|>fn frobnicate() {}
+// ```
+// ->
+// ```
+// pub(crate) fn frobnicate() {}
+// ```
+pub(crate) fn change_visibility(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    if let Some(vis) = ctx.find_node_at_offset::<ast::Visibility>() {
+        return change_vis(acc, vis);
+    }
+    add_vis(acc, ctx)
+}
+
+fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let item_keyword = ctx.token_at_offset().find(|leaf| {
+        matches!(
+            leaf.kind(),
+            T![const] | T![static] | T![fn] | T![mod] | T![struct] | T![enum] | T![trait]
+        )
+    });
+
+    let (offset, target) = if let Some(keyword) = item_keyword {
+        let parent = keyword.parent();
+        let def_kws = vec![CONST, STATIC, FN, MODULE, STRUCT, ENUM, TRAIT];
+        // Parent is not a definition, can't add visibility
+        if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
+            return None;
+        }
+        // Already have visibility, do nothing
+        if parent.children().any(|child| child.kind() == VISIBILITY) {
+            return None;
+        }
+        (vis_offset(&parent), keyword.text_range())
+    } else if let Some(field_name) = ctx.find_node_at_offset::<ast::Name>() {
+        let field = field_name.syntax().ancestors().find_map(ast::RecordField::cast)?;
+        if field.name()? != field_name {
+            mark::hit!(change_visibility_field_false_positive);
+            return None;
+        }
+        if field.visibility().is_some() {
+            return None;
+        }
+        (vis_offset(field.syntax()), field_name.syntax().text_range())
+    } else if let Some(field) = ctx.find_node_at_offset::<ast::TupleField>() {
+        if field.visibility().is_some() {
+            return None;
+        }
+        (vis_offset(field.syntax()), field.syntax().text_range())
+    } else {
+        return None;
+    };
+
+    acc.add(
+        AssistId("change_visibility", AssistKind::RefactorRewrite),
+        "Change visibility to pub(crate)",
+        target,
+        |edit| {
+            edit.insert(offset, "pub(crate) ");
+        },
+    )
+}
+
+fn change_vis(acc: &mut Assists, vis: ast::Visibility) -> Option<()> {
+    if vis.syntax().text() == "pub" {
+        let target = vis.syntax().text_range();
+        return acc.add(
+            AssistId("change_visibility", AssistKind::RefactorRewrite),
+            "Change Visibility to pub(crate)",
+            target,
+            |edit| {
+                edit.replace(vis.syntax().text_range(), "pub(crate)");
+            },
+        );
+    }
+    if vis.syntax().text() == "pub(crate)" {
+        let target = vis.syntax().text_range();
+        return acc.add(
+            AssistId("change_visibility", AssistKind::RefactorRewrite),
+            "Change visibility to pub",
+            target,
+            |edit| {
+                edit.replace(vis.syntax().text_range(), "pub");
+            },
+        );
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::mark;
+
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+
+    use super::*;
+
+    #[test]
+    fn change_visibility_adds_pub_crate_to_items() {
+        check_assist(change_visibility, "<|>fn foo() {}", "pub(crate) fn foo() {}");
+        check_assist(change_visibility, "f<|>n foo() {}", "pub(crate) fn foo() {}");
+        check_assist(change_visibility, "<|>struct Foo {}", "pub(crate) struct Foo {}");
+        check_assist(change_visibility, "<|>mod foo {}", "pub(crate) mod foo {}");
+        check_assist(change_visibility, "<|>trait Foo {}", "pub(crate) trait Foo {}");
+        check_assist(change_visibility, "m<|>od {}", "pub(crate) mod {}");
+        check_assist(change_visibility, "unsafe f<|>n foo() {}", "pub(crate) unsafe fn foo() {}");
+    }
+
+    #[test]
+    fn change_visibility_works_with_struct_fields() {
+        check_assist(
+            change_visibility,
+            r"struct S { <|>field: u32 }",
+            r"struct S { pub(crate) field: u32 }",
+        );
+        check_assist(change_visibility, r"struct S ( <|>u32 )", r"struct S ( pub(crate) u32 )");
+    }
+
+    #[test]
+    fn change_visibility_field_false_positive() {
+        mark::check!(change_visibility_field_false_positive);
+        check_assist_not_applicable(
+            change_visibility,
+            r"struct S { field: [(); { let <|>x = ();}] }",
+        )
+    }
+
+    #[test]
+    fn change_visibility_pub_to_pub_crate() {
+        check_assist(change_visibility, "<|>pub fn foo() {}", "pub(crate) fn foo() {}")
+    }
+
+    #[test]
+    fn change_visibility_pub_crate_to_pub() {
+        check_assist(change_visibility, "<|>pub(crate) fn foo() {}", "pub fn foo() {}")
+    }
+
+    #[test]
+    fn change_visibility_const() {
+        check_assist(change_visibility, "<|>const FOO = 3u8;", "pub(crate) const FOO = 3u8;");
+    }
+
+    #[test]
+    fn change_visibility_static() {
+        check_assist(change_visibility, "<|>static FOO = 3u8;", "pub(crate) static FOO = 3u8;");
+    }
+
+    #[test]
+    fn change_visibility_handles_comment_attrs() {
+        check_assist(
+            change_visibility,
+            r"
+            /// docs
+
+            // comments
+
+            #[derive(Debug)]
+            <|>struct Foo;
+            ",
+            r"
+            /// docs
+
+            // comments
+
+            #[derive(Debug)]
+            pub(crate) struct Foo;
+            ",
+        )
+    }
+
+    #[test]
+    fn not_applicable_for_enum_variants() {
+        check_assist_not_applicable(
+            change_visibility,
+            r"mod foo { pub enum Foo {Foo1} }
+              fn main() { foo::Foo::Foo1<|> } ",
+        );
+    }
+
+    #[test]
+    fn change_visibility_target() {
+        check_assist_target(change_visibility, "<|>fn foo() {}", "fn");
+        check_assist_target(change_visibility, "pub(crate)<|> fn foo() {}", "pub(crate)");
+        check_assist_target(change_visibility, "struct S { <|>field: u32 }", "field");
+    }
+}
diff --git a/crates/assists/src/handlers/early_return.rs b/crates/assists/src/handlers/early_return.rs
new file mode 100644
index 000000000..7fd78e9d4
--- /dev/null
+++ b/crates/assists/src/handlers/early_return.rs
@@ -0,0 +1,515 @@
+use std::{iter::once, ops::RangeInclusive};
+
+use syntax::{
+    algo::replace_children,
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
+    AstNode,
+    SyntaxKind::{FN, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
+    SyntaxNode,
+};
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    utils::invert_boolean_expression,
+    AssistId, AssistKind,
+};
+
+// Assist: convert_to_guarded_return
+//
+// Replace a large conditional with a guarded return.
+//
+// ```
+// fn main() {
+//     <|>if cond {
+//         foo();
+//         bar();
+//     }
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     if !cond {
+//         return;
+//     }
+//     foo();
+//     bar();
+// }
+// ```
+pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
+    if if_expr.else_branch().is_some() {
+        return None;
+    }
+
+    let cond = if_expr.condition()?;
+
+    // Check if there is an IfLet that we can handle.
+    let if_let_pat = match cond.pat() {
+        None => None, // No IfLet, supported.
+        Some(ast::Pat::TupleStructPat(pat)) if pat.fields().count() == 1 => {
+            let path = pat.path()?;
+            match path.qualifier() {
+                None => {
+                    let bound_ident = pat.fields().next().unwrap();
+                    Some((path, bound_ident))
+                }
+                Some(_) => return None,
+            }
+        }
+        Some(_) => return None, // Unsupported IfLet.
+    };
+
+    let cond_expr = cond.expr()?;
+    let then_block = if_expr.then_branch()?;
+
+    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;
+
+    if parent_block.expr()? != if_expr.clone().into() {
+        return None;
+    }
+
+    // check for early return and continue
+    let first_in_then_block = then_block.syntax().first_child()?;
+    if ast::ReturnExpr::can_cast(first_in_then_block.kind())
+        || ast::ContinueExpr::can_cast(first_in_then_block.kind())
+        || first_in_then_block
+            .children()
+            .any(|x| ast::ReturnExpr::can_cast(x.kind()) || ast::ContinueExpr::can_cast(x.kind()))
+    {
+        return None;
+    }
+
+    let parent_container = parent_block.syntax().parent()?;
+
+    let early_expression: ast::Expr = match parent_container.kind() {
+        WHILE_EXPR | LOOP_EXPR => make::expr_continue(),
+        FN => make::expr_return(),
+        _ => return None,
+    };
+
+    if then_block.syntax().first_child_or_token().map(|t| t.kind() == L_CURLY).is_none() {
+        return None;
+    }
+
+    then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
+
+    let target = if_expr.syntax().text_range();
+    acc.add(
+        AssistId("convert_to_guarded_return", AssistKind::RefactorRewrite),
+        "Convert to guarded return",
+        target,
+        |edit| {
+            let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
+            let new_block = match if_let_pat {
+                None => {
+                    // If.
+                    let new_expr = {
+                        let then_branch =
+                            make::block_expr(once(make::expr_stmt(early_expression).into()), None);
+                        let cond = invert_boolean_expression(cond_expr);
+                        make::expr_if(make::condition(cond, None), then_branch)
+                            .indent(if_indent_level)
+                    };
+                    replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
+                }
+                Some((path, bound_ident)) => {
+                    // If-let.
+                    let match_expr = {
+                        let happy_arm = {
+                            let pat = make::tuple_struct_pat(
+                                path,
+                                once(make::ident_pat(make::name("it")).into()),
+                            );
+                            let expr = {
+                                let name_ref = make::name_ref("it");
+                                let segment = make::path_segment(name_ref);
+                                let path = make::path_unqualified(segment);
+                                make::expr_path(path)
+                            };
+                            make::match_arm(once(pat.into()), expr)
+                        };
+
+                        let sad_arm = make::match_arm(
+                            // FIXME: would be cool to use `None` or `Err(_)` if appropriate
+                            once(make::wildcard_pat().into()),
+                            early_expression,
+                        );
+
+                        make::expr_match(cond_expr, make::match_arm_list(vec![happy_arm, sad_arm]))
+                    };
+
+                    let let_stmt = make::let_stmt(
+                        make::ident_pat(make::name(&bound_ident.syntax().to_string())).into(),
+                        Some(match_expr),
+                    );
+                    let let_stmt = let_stmt.indent(if_indent_level);
+                    replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
+                }
+            };
+            edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
+
+            fn replace(
+                new_expr: &SyntaxNode,
+                then_block: &ast::BlockExpr,
+                parent_block: &ast::BlockExpr,
+                if_expr: &ast::IfExpr,
+            ) -> SyntaxNode {
+                let then_block_items = then_block.dedent(IndentLevel(1));
+                let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
+                let end_of_then =
+                    if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
+                        end_of_then.prev_sibling_or_token().unwrap()
+                    } else {
+                        end_of_then
+                    };
+                let mut then_statements = new_expr.children_with_tokens().chain(
+                    then_block_items
+                        .syntax()
+                        .children_with_tokens()
+                        .skip(1)
+                        .take_while(|i| *i != end_of_then),
+                );
+                replace_children(
+                    &parent_block.syntax(),
+                    RangeInclusive::new(
+                        if_expr.clone().syntax().clone().into(),
+                        if_expr.syntax().clone().into(),
+                    ),
+                    &mut then_statements,
+                )
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn convert_inside_fn() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                bar();
+                if<|> true {
+                    foo();
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                if !true {
+                    return;
+                }
+                foo();
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_let_inside_fn() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main(n: Option<String>) {
+                bar();
+                if<|> let Some(n) = n {
+                    foo(n);
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+            r#"
+            fn main(n: Option<String>) {
+                bar();
+                let n = match n {
+                    Some(it) => it,
+                    _ => return,
+                };
+                foo(n);
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_if_let_result() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> let Ok(x) = Err(92) {
+                    foo(x);
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                let x = match Err(92) {
+                    Ok(it) => it,
+                    _ => return,
+                };
+                foo(x);
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_let_ok_inside_fn() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main(n: Option<String>) {
+                bar();
+                if<|> let Ok(n) = n {
+                    foo(n);
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+            r#"
+            fn main(n: Option<String>) {
+                bar();
+                let n = match n {
+                    Ok(it) => it,
+                    _ => return,
+                };
+                foo(n);
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_inside_while() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                while true {
+                    if<|> true {
+                        foo();
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                while true {
+                    if !true {
+                        continue;
+                    }
+                    foo();
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_let_inside_while() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                while true {
+                    if<|> let Some(n) = n {
+                        foo(n);
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                while true {
+                    let n = match n {
+                        Some(it) => it,
+                        _ => continue,
+                    };
+                    foo(n);
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_inside_loop() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                loop {
+                    if<|> true {
+                        foo();
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                loop {
+                    if !true {
+                        continue;
+                    }
+                    foo();
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_let_inside_loop() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                loop {
+                    if<|> let Some(n) = n {
+                        foo(n);
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                loop {
+                    let n = match n {
+                        Some(it) => it,
+                        _ => continue,
+                    };
+                    foo(n);
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_already_converted_if() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    return;
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_already_converted_loop() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                loop {
+                    if<|> true {
+                        continue;
+                    }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_return() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    return
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_else_branch() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    foo();
+                } else {
+                    bar()
+                }
+            }
+            "#,
+        );