11 files changed, 1329 insertions, 305 deletions

diff --git a/crates/ide_assists/src/handlers/auto_import.rs b/crates/ide_assists/src/handlers/auto_import.rs
index 5ccd7f7a2..49aa70f74 100644
--- a/crates/ide_assists/src/handlers/auto_import.rs
+++ b/crates/ide_assists/src/handlers/auto_import.rs
@@ -934,4 +934,37 @@ fn main() {
 ",
         );
     }
+
+    #[test]
+    fn inner_items() {
+        check_assist(
+            auto_import,
+            r#"
+mod baz {
+    pub struct Foo {}
+}
+
+mod bar {
+    fn bar() {
+        Foo$0;
+        println!("Hallo");
+    }
+}
+"#,
+            r#"
+mod baz {
+    pub struct Foo {}
+}
+
+mod bar {
+    use crate::baz::Foo;
+
+    fn bar() {
+        Foo;
+        println!("Hallo");
+    }
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index 5fdc8bf38..5f80a40c8 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -75,7 +75,8 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option
     let insert_after = scope_for_fn_insertion(&body, anchor)?;
     let module = ctx.sema.scope(&insert_after).module()?;
 
-    let vars_defined_in_body_and_outlive = vars_defined_in_body_and_outlive(ctx, &body);
+    let vars_defined_in_body_and_outlive =
+        vars_defined_in_body_and_outlive(ctx, &body, &node.parent().as_ref().unwrap_or(&node));
     let ret_ty = body_return_ty(ctx, &body)?;
 
     // FIXME: we compute variables that outlive here just to check `never!` condition
@@ -257,7 +258,7 @@ struct Function {
     control_flow: ControlFlow,
     ret_ty: RetType,
     body: FunctionBody,
-    vars_defined_in_body_and_outlive: Vec<Local>,
+    vars_defined_in_body_and_outlive: Vec<OutlivedLocal>,
 }
 
 #[derive(Debug)]
@@ -296,9 +297,9 @@ impl Function {
             RetType::Expr(ty) => FunType::Single(ty.clone()),
             RetType::Stmt => match self.vars_defined_in_body_and_outlive.as_slice() {
                 [] => FunType::Unit,
-                [var] => FunType::Single(var.ty(ctx.db())),
+                [var] => FunType::Single(var.local.ty(ctx.db())),
                 vars => {
-                    let types = vars.iter().map(|v| v.ty(ctx.db())).collect();
+                    let types = vars.iter().map(|v| v.local.ty(ctx.db())).collect();
                     FunType::Tuple(types)
                 }
             },
@@ -562,6 +563,12 @@ impl HasTokenAtOffset for FunctionBody {
     }
 }
 
+#[derive(Debug)]
+struct OutlivedLocal {
+    local: Local,
+    mut_usage_outside_body: bool,
+}
+
 /// Try to guess what user wants to extract
 ///
 /// We have basically have two cases:
@@ -592,7 +599,12 @@ fn extraction_target(node: &SyntaxNode, selection_range: TextRange) -> Option<Fu
     // we have selected a few statements in a block
     // so covering_element returns the whole block
     if node.kind() == BLOCK_EXPR {
-        let body = FunctionBody::from_range(node.clone(), selection_range);
+        // Extract the full statements.
+        let statements_range = node
+            .children()
+            .filter(|c| selection_range.intersect(c.text_range()).is_some())
+            .fold(selection_range, |acc, c| acc.cover(c.text_range()));
+        let body = FunctionBody::from_range(node.clone(), statements_range);
         if body.is_some() {
             return body;
         }
@@ -603,7 +615,8 @@ fn extraction_target(node: &SyntaxNode, selection_range: TextRange) -> Option<Fu
     // so we try to expand covering_element to parent and repeat the previous
     if let Some(parent) = node.parent() {
         if parent.kind() == BLOCK_EXPR {
-            let body = FunctionBody::from_range(parent, selection_range);
+            // Extract the full statement.
+            let body = FunctionBody::from_range(parent, node.text_range());
             if body.is_some() {
                 return body;
             }
@@ -707,10 +720,10 @@ fn has_exclusive_usages(ctx: &AssistContext, usages: &LocalUsages, body: &Functi
         .any(|reference| reference_is_exclusive(reference, body, ctx))
 }
 
-/// checks if this reference requires `&mut` access inside body
+/// checks if this reference requires `&mut` access inside node
 fn reference_is_exclusive(
     reference: &FileReference,
-    body: &FunctionBody,
+    node: &dyn HasTokenAtOffset,
     ctx: &AssistContext,
 ) -> bool {
     // we directly modify variable with set: `n = 0`, `n += 1`
@@ -719,7 +732,7 @@ fn reference_is_exclusive(
     }
 
     // we take `&mut` reference to variable: `&mut v`
-    let path = match path_element_of_reference(body, reference) {
+    let path = match path_element_of_reference(node, reference) {
         Some(path) => path,
         None => return false,
     };
@@ -729,6 +742,14 @@ fn reference_is_exclusive(
 
 /// checks if this expr requires `&mut` access, recurses on field access
 fn expr_require_exclusive_access(ctx: &AssistContext, expr: &ast::Expr) -> Option<bool> {
+    match expr {
+        ast::Expr::MacroCall(_) => {
+            // FIXME: expand macro and check output for mutable usages of the variable?
+            return None;
+        }
+        _ => (),
+    }
+
     let parent = expr.syntax().parent()?;
 
     if let Some(bin_expr) = ast::BinExpr::cast(parent.clone()) {
@@ -787,7 +808,7 @@ impl HasTokenAtOffset for SyntaxNode {
     }
 }
 
-/// find relevant `ast::PathExpr` for reference
+/// find relevant `ast::Expr` for reference
 ///
 /// # Preconditions
 ///
@@ -804,7 +825,11 @@ fn path_element_of_reference(
         stdx::never!(false, "cannot find path parent of variable usage: {:?}", token);
         None
     })?;
-    stdx::always!(matches!(path, ast::Expr::PathExpr(_)));
+    stdx::always!(
+        matches!(path, ast::Expr::PathExpr(_) | ast::Expr::MacroCall(_)),
+        "unexpected expression type for variable usage: {:?}",
+        path
+    );
     Some(path)
 }
 
@@ -820,10 +845,16 @@ fn vars_defined_in_body(body: &FunctionBody, ctx: &AssistContext) -> Vec<Local>
 }
 
 /// list local variables defined inside `body` that should be returned from extracted function
-fn vars_defined_in_body_and_outlive(ctx: &AssistContext, body: &FunctionBody) -> Vec<Local> {
-    let mut vars_defined_in_body = vars_defined_in_body(&body, ctx);
-    vars_defined_in_body.retain(|var| var_outlives_body(ctx, body, var));
+fn vars_defined_in_body_and_outlive(
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    parent: &SyntaxNode,
+) -> Vec<OutlivedLocal> {
+    let vars_defined_in_body = vars_defined_in_body(&body, ctx);
     vars_defined_in_body
+        .into_iter()
+        .filter_map(|var| var_outlives_body(ctx, body, var, parent))
+        .collect()
 }
 
 /// checks if the relevant local was defined before(outside of) body
@@ -843,11 +874,23 @@ fn either_syntax(value: &Either<ast::IdentPat, ast::SelfParam>) -> &SyntaxNode {
     }
 }
 
-/// checks if local variable is used after(outside of) body
-fn var_outlives_body(ctx: &AssistContext, body: &FunctionBody, var: &Local) -> bool {
-    let usages = LocalUsages::find(ctx, *var);
+/// returns usage details if local variable is used after(outside of) body
+fn var_outlives_body(
+    ctx: &AssistContext,
+    body: &FunctionBody,
+    var: Local,
+    parent: &SyntaxNode,
+) -> Option<OutlivedLocal> {
+    let usages = LocalUsages::find(ctx, var);
     let has_usages = usages.iter().any(|reference| body.preceedes_range(reference.range));
-    has_usages
+    if !has_usages {
+        return None;
+    }
+    let has_mut_usages = usages
+        .iter()
+        .filter(|reference| body.preceedes_range(reference.range))
+        .any(|reference| reference_is_exclusive(reference, parent, ctx));
+    Some(OutlivedLocal { local: var, mut_usage_outside_body: has_mut_usages })
 }
 
 fn body_return_ty(ctx: &AssistContext, body: &FunctionBody) -> Option<RetType> {
@@ -927,16 +970,25 @@ fn format_replacement(ctx: &AssistContext, fun: &Function, indent: IndentLevel)
     let mut buf = String::new();
     match fun.vars_defined_in_body_and_outlive.as_slice() {
         [] => {}
-        [var] => format_to!(buf, "let {} = ", var.name(ctx.db()).unwrap()),
+        [var] => {
+            format_to!(buf, "let {}{} = ", mut_modifier(var), var.local.name(ctx.db()).unwrap())
+        }
         [v0, vs @ ..] => {
             buf.push_str("let (");
-            format_to!(buf, "{}", v0.name(ctx.db()).unwrap());
+            format_to!(buf, "{}{}", mut_modifier(v0), v0.local.name(ctx.db()).unwrap());
             for var in vs {
-                format_to!(buf, ", {}", var.name(ctx.db()).unwrap());
+                format_to!(buf, ", {}{}", mut_modifier(var), var.local.name(ctx.db()).unwrap());
             }
             buf.push_str(") = ");
         }
     }
+    fn mut_modifier(var: &OutlivedLocal) -> &'static str {
+        if var.mut_usage_outside_body {
+            "mut "
+        } else {
+            ""
+        }
+    }
     format_to!(buf, "{}", expr);
     if fun.ret_ty.is_unit()
         && (!fun.vars_defined_in_body_and_outlive.is_empty() || !expr.is_block_like())
@@ -1175,9 +1227,19 @@ fn make_body(
         FunctionBody::Expr(expr) => {
             let expr = rewrite_body_segment(ctx, &fun.params, &handler, expr.syntax());
             let expr = ast::Expr::cast(expr).unwrap();
-            let expr = expr.dedent(old_indent).indent(IndentLevel(1));
+            match expr {
+                ast::Expr::BlockExpr(block) => {
+                    // If the extracted expression is itself a block, there is no need to wrap it inside another block.
+                    let block = block.dedent(old_indent);
+                    // Recreate the block for formatting consistency with other extracted functions.
+                    make::block_expr(block.statements(), block.tail_expr())
+                }
+                _ => {
+                    let expr = expr.dedent(old_indent).indent(IndentLevel(1));
 
-            make::block_expr(Vec::new(), Some(expr))
+                    make::block_expr(Vec::new(), Some(expr))
+                }
+            }
         }
         FunctionBody::Span { parent, text_range } => {
             let mut elements: Vec<_> = parent
@@ -1199,10 +1261,10 @@ fn make_body(
                 match fun.vars_defined_in_body_and_outlive.as_slice() {
                     [] => {}
                     [var] => {
-                        tail_expr = Some(path_expr_from_local(ctx, *var));
+                        tail_expr = Some(path_expr_from_local(ctx, var.local));
                     }
                     vars => {
-                        let exprs = vars.iter().map(|var| path_expr_from_local(ctx, *var));
+                        let exprs = vars.iter().map(|var| path_expr_from_local(ctx, var.local));
                         let expr = make::expr_tuple(exprs);
                         tail_expr = Some(expr);
                     }
@@ -1492,7 +1554,7 @@ fn foo() {
 }
 
 fn $0fun_name() -> i32 {
-    { 1 + 1 }
+    1 + 1
 }"#,
         );
     }
@@ -1739,6 +1801,60 @@ fn $0fun_name() -> i32 {
     }
 
     #[test]
+    fn extract_partial_block_single_line() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    let n = 1;
+    let mut v = $0n * n;$0
+    v += 1;
+}"#,
+            r#"
+fn foo() {
+    let n = 1;
+    let mut v = fun_name(n);
+    v += 1;
+}
+
+fn $0fun_name(n: i32) -> i32 {
+    let mut v = n * n;
+    v
+}"#,
+        );
+    }
+
+    #[test]
+    fn extract_partial_block() {
+        check_assist(
+            extract_function,
+            r#"
+fn foo() {
+    let m = 2;
+    let n = 1;
+    let mut v = m $0* n;
+    let mut w = 3;$0
+    v += 1;
+    w += 1;
+}"#,
+            r#"
+fn foo() {
+    let m = 2;
+    let n = 1;
+    let (mut v, mut w) = fun_name(m, n);
+    v += 1;
+    w += 1;
+}
+
+fn $0fun_name(m: i32, n: i32) -> (i32, i32) {
+    let mut v = m * n;
+    let mut w = 3;
+    (v, w)
+}"#,
+        );
+    }
+
+    #[test]
     fn argument_form_expr() {
         check_assist(
             extract_function,
@@ -2111,6 +2227,30 @@ fn $0fun_name(n: i32) -> i32 {
     }
 
     #[test]
+    fn variable_defined_inside_and_used_after_mutably_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let mut k = n * n;$0
+    k += 1;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let mut k = fun_name(n);
+    k += 1;
+}
+
+fn $0fun_name(n: i32) -> i32 {
+    let mut k = n * n;
+    k
+}",
+        );
+    }
+
+    #[test]
     fn two_variables_defined_inside_and_used_after_no_ret() {
         check_assist(
             extract_function,
@@ -2137,6 +2277,38 @@ fn $0fun_name(n: i32) -> (i32, i32) {
     }
 
     #[test]
+    fn multi_variables_defined_inside_and_used_after_mutably_no_ret() {
+        check_assist(
+            extract_function,
+            r"
+fn foo() {
+    let n = 1;
+    $0let mut k = n * n;
+    let mut m = k + 2;
+    let mut o = m + 3;
+    o += 1;$0
+    k += o;
+    m = 1;
+}",
+            r"
+fn foo() {
+    let n = 1;
+    let (mut k, mut m, o) = fun_name(n);
+    k += o;
+    m = 1;
+}
+
+fn $0fun_name(n: i32) -> (i32, i32, i32) {
+    let mut k = n * n;
+    let mut m = k + 2;
+    let mut o = m + 3;
+    o += 1;
+    (k, m, o)
+}",
+        );
+    }
+
+    #[test]
     fn nontrivial_patterns_define_variables() {
         check_assist(
             extract_function,
@@ -2364,17 +2536,15 @@ fn foo() {
 }
 
 fn $0fun_name(n: &mut i32) {
-    {
-        *n += *n;
-        bar(*n);
-        bar(*n+1);
-        bar(*n**n);
-        bar(&*n);
-        n.inc();
-        let v = n;
-        *v = v.succ();
-        n.succ();
-    }
+    *n += *n;
+    bar(*n);
+    bar(*n+1);
+    bar(*n**n);
+    bar(&*n);
+    n.inc();
+    let v = n;
+    *v = v.succ();
+    n.succ();
 }",
         );
     }
@@ -3372,4 +3542,36 @@ fn foo() -> Result<(), i64> {
 }"##,
         );
     }
+
+    #[test]
+    fn param_usage_in_macro() {
+        check_assist(
+            extract_function,
+            r"
+macro_rules! m {
+    ($val:expr) => { $val };
+}
+
+fn foo() {
+    let n = 1;
+    $0let k = n * m!(n);$0
+    let m = k + 1;
+}",
+            r"
+macro_rules! m {
+    ($val:expr) => { $val };
+}
+
+fn foo() {
+    let n = 1;
+    let k = fun_name(n);
+    let m = k + 1;
+}
+
+fn $0fun_name(n: i32) -> i32 {
+    let k = n * m!(n);
+    k
+}",
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/extract_variable.rs b/crates/ide_assists/src/handlers/extract_variable.rs
index 7a32483dc..136b9a55b 100644
--- a/crates/ide_assists/src/handlers/extract_variable.rs
+++ b/crates/ide_assists/src/handlers/extract_variable.rs
@@ -2,7 +2,8 @@ use stdx::format_to;
 use syntax::{
     ast::{self, AstNode},
     SyntaxKind::{
-        BLOCK_EXPR, BREAK_EXPR, CLOSURE_EXPR, COMMENT, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR,
+        BLOCK_EXPR, BREAK_EXPR, CLOSURE_EXPR, COMMENT, LOOP_EXPR, MATCH_ARM, MATCH_GUARD,
+        PATH_EXPR, RETURN_EXPR,
     },
     SyntaxNode,
 };
@@ -147,9 +148,18 @@ impl Anchor {
             }
 
             if let Some(parent) = node.parent() {
-                if parent.kind() == MATCH_ARM || parent.kind() == CLOSURE_EXPR {
+                if parent.kind() == CLOSURE_EXPR {
+                    cov_mark::hit!(test_extract_var_in_closure_no_block);
                     return Some(Anchor::WrapInBlock(node));
                 }
+                if parent.kind() == MATCH_ARM {
+                    if node.kind() == MATCH_GUARD {
+                        cov_mark::hit!(test_extract_var_in_match_guard);
+                    } else {
+                        cov_mark::hit!(test_extract_var_in_match_arm_no_block);
+                        return Some(Anchor::WrapInBlock(node));
+                    }
+                }
             }
 
             if let Some(stmt) = ast::Stmt::cast(node.clone()) {
@@ -280,9 +290,10 @@ fn foo() {
 
     #[test]
     fn test_extract_var_in_match_arm_no_block() {
+        cov_mark::check!(test_extract_var_in_match_arm_no_block);
         check_assist(
             extract_variable,
-            "
+            r#"
 fn main() {
     let x = true;
     let tuple = match x {
@@ -290,8 +301,8 @@ fn main() {
         _ => (0, false)
     };
 }
-",
-            "
+"#,
+            r#"
 fn main() {
     let x = true;
     let tuple = match x {
@@ -299,7 +310,7 @@ fn main() {
         _ => (0, false)
     };
 }
-",
+"#,
         );
     }
 
@@ -307,7 +318,7 @@ fn main() {
     fn test_extract_var_in_match_arm_with_block() {
         check_assist(
             extract_variable,
-            "
+            r#"
 fn main() {
     let x = true;
     let tuple = match x {
@@ -318,8 +329,8 @@ fn main() {
         _ => (0, false)
     };
 }
-",
-            "
+"#,
+            r#"
 fn main() {
     let x = true;
     let tuple = match x {
@@ -331,24 +342,50 @@ fn main() {
         _ => (0, false)
     };
 }
-",
+"#,
+        );
+    }
+
+    #[test]
+    fn test_extract_var_in_match_guard() {
+        cov_mark::check!(test_extract_var_in_match_guard);
+        check_assist(
+            extract_variable,
+            r#"
+fn main() {
+    match () {
+        () if $010 > 0$0 => 1
+        _ => 2
+    };
+}
+"#,
+            r#"
+fn main() {
+    let $0var_name = 10 > 0;
+    match () {
+        () if var_name => 1
+        _ => 2
+    };
+}
+"#,
         );
     }
 
     #[test]
     fn test_extract_var_in_closure_no_block() {
+        cov_mark::check!(test_extract_var_in_closure_no_block);
         check_assist(
             extract_variable,
-            "
+            r#"
 fn main() {
     let lambda = |x: u32| $0x * 2$0;
 }
-",
-            "
+"#,
+            r#"
 fn main() {
     let lambda = |x: u32| { let $0var_name = x * 2; var_name };
 }
-",
+"#,
         );
     }
 
@@ -356,16 +393,16 @@ fn main() {
     fn test_extract_var_in_closure_with_block() {
         check_assist(
             extract_variable,
-            "
+            r#"
 fn main() {
     let lambda = |x: u32| { $0x * 2$0 };
 }
-",
-            "
+"#,
+            r#"
 fn main() {
     let lambda = |x: u32| { let $0var_name = x * 2; var_name };
 }
-",
+"#,
         );
     }
 
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index 878b3a3fa..be927cc1c 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -1,5 +1,6 @@
 use std::iter;
 
+use either::Either;
 use hir::{Adt, HasSource, ModuleDef, Semantics};
 use ide_db::helpers::{mod_path_to_ast, FamousDefs};
 use ide_db::RootDatabase;
@@ -7,7 +8,7 @@ use itertools::Itertools;
 use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 
 use crate::{
-    utils::{does_pat_match_variant, render_snippet, Cursor},
+    utils::{self, render_snippet, Cursor},
     AssistContext, AssistId, AssistKind, Assists,
 };
 
@@ -48,6 +49,18 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
         }
     }
 
+    let top_lvl_pats: Vec<_> = arms
+        .iter()
+        .filter_map(ast::MatchArm::pat)
+        .flat_map(|pat| match pat {
+            // Special case OrPat as separate top-level pats
+            Pat::OrPat(or_pat) => Either::Left(or_pat.pats()),
+            _ => Either::Right(iter::once(pat)),
+        })
+        // Exclude top level wildcards so that they are expanded by this assist, retains status quo in #8129.
+        .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
+        .collect();
+
     let module = ctx.sema.scope(expr.syntax()).module()?;
 
     let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
@@ -56,27 +69,20 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
         let mut variants = variants
             .into_iter()
             .filter_map(|variant| build_pat(ctx.db(), module, variant))
-            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
+            .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect::<Vec<_>>();
-        if Some(enum_def) == FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option() {
+        if Some(enum_def)
+            == FamousDefs(&ctx.sema, Some(module.krate()))
+                .core_option_Option()
+                .map(|x| lift_enum(x))
+        {
             // Match `Some` variant first.
             cov_mark::hit!(option_order);
             variants.reverse()
         }
         variants
     } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
-        // Partial fill not currently supported for tuple of enums.
-        if !arms.is_empty() {
-            return None;
-        }
-
-        // We do not currently support filling match arms for a tuple
-        // containing a single enum.
-        if enum_defs.len() < 2 {
-            return None;
-        }
-
         // When calculating the match arms for a tuple of enums, we want
         // to create a match arm for each possible combination of enum
         // values. The `multi_cartesian_product` method transforms
@@ -91,7 +97,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
                     variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
                 ast::Pat::from(make::tuple_pat(patterns))
             })
-            .filter(|variant_pat| is_variant_missing(&mut arms, variant_pat))
+            .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
             .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
             .collect()
     } else {
@@ -134,61 +140,114 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     )
 }
 
-fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
-    existing_arms.iter().filter_map(|arm| arm.pat()).all(|pat| {
-        // Special casee OrPat as separate top-level pats
-        let top_level_pats: Vec<Pat> = match pat {
-            Pat::OrPat(pats) => pats.pats().collect::<Vec<_>>(),
-            _ => vec![pat],
-        };
+fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
+    !existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
+}
 
-        !top_level_pats.iter().any(|pat| does_pat_match_variant(pat, var))
-    })
+// Fixme: this is still somewhat limited, use hir_ty::diagnostics::match_check?
+fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
+    match (pat, var) {
+        (Pat::WildcardPat(_), _) => true,
+        (Pat::TuplePat(tpat), Pat::TuplePat(tvar)) => {
+            tpat.fields().zip(tvar.fields()).all(|(p, v)| does_pat_match_variant(&p, &v))
+        }
+        _ => utils::does_pat_match_variant(pat, var),
+    }
+}
+
+#[derive(Eq, PartialEq, Clone)]
+enum ExtendedEnum {
+    Bool,
+    Enum(hir::Enum),
+}
+
+#[derive(Eq, PartialEq, Clone)]
+enum ExtendedVariant {
+    True,
+    False,
+    Variant(hir::Variant),
+}
+
+fn lift_enum(e: hir::Enum) -> ExtendedEnum {
+    ExtendedEnum::Enum(e)
+}
+
+impl ExtendedEnum {
+    fn variants(&self, db: &RootDatabase) -> Vec<ExtendedVariant> {
+        match self {
+            ExtendedEnum::Enum(e) => {
+                e.variants(db).into_iter().map(|x| ExtendedVariant::Variant(x)).collect::<Vec<_>>()
+            }
+            ExtendedEnum::Bool => {
+                Vec::<ExtendedVariant>::from([ExtendedVariant::True, ExtendedVariant::False])
+            }
+        }
+    }
 }
 
-fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<hir::Enum> {
+fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<ExtendedEnum> {
     sema.type_of_expr(&expr)?.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
-        Some(Adt::Enum(e)) => Some(e),
-        _ => None,
+        Some(Adt::Enum(e)) => Some(ExtendedEnum::Enum(e)),
+        _ => {
+            if ty.is_bool() {
+                Some(ExtendedEnum::Bool)
+            } else {
+                None
+            }
+        }
     })
 }
 
 fn resolve_tuple_of_enum_def(
     sema: &Semantics<RootDatabase>,
     expr: &ast::Expr,
-) -> Option<Vec<hir::Enum>> {
+) -> Option<Vec<ExtendedEnum>> {
     sema.type_of_expr(&expr)?
         .tuple_fields(sema.db)
         .iter()
         .map(|ty| {
             ty.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
-                Some(Adt::Enum(e)) => Some(e),
+                Some(Adt::Enum(e)) => Some(lift_enum(e)),
                 // For now we only handle expansion for a tuple of enums. Here
                 // we map non-enum items to None and rely on `collect` to
                 // convert Vec<Option<hir::Enum>> into Option<Vec<hir::Enum>>.
-                _ => None,
+                _ => {
+                    if ty.is_bool() {
+                        Some(ExtendedEnum::Bool)
+                    } else {
+                        None
+                    }
+                }
             })
         })
         .collect()
 }
 
-fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::Variant) -> Option<ast::Pat> {
-    let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
+fn build_pat(db: &RootDatabase, module: hir::Module, var: ExtendedVariant) -> Option<ast::Pat> {
+    match var {
+        ExtendedVariant::Variant(var) => {
+            let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
+
+            // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
+            let pat: ast::Pat = match var.source(db)?.value.kind() {
+                ast::StructKind::Tuple(field_list) => {
+                    let pats =
+                        iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
+                    make::tuple_struct_pat(path, pats).into()
+                }
+                ast::StructKind::Record(field_list) => {
+                    let pats =
+                        field_list.fields().map(|f| make::ident_pat(f.name().unwrap()).into());
+                    make::record_pat(path, pats).into()
+                }
+                ast::StructKind::Unit => make::path_pat(path),
+            };
 
-    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
-    let pat: ast::Pat = match var.source(db)?.value.kind() {
-        ast::StructKind::Tuple(field_list) => {
-            let pats = iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
-            make::tuple_struct_pat(path, pats).into()
-        }
-        ast::StructKind::Record(field_list) => {
-            let pats = field_list.fields().map(|f| make::ident_pat(f.name().unwrap()).into());
-            make::record_pat(path, pats).into()
+            Some(pat)
         }
-        ast::StructKind::Unit => make::path_pat(path),
-    };
-
-    Some(pat)
+        ExtendedVariant::True => Some(ast::Pat::from(make::literal_pat("true"))),
+        ExtendedVariant::False => Some(ast::Pat::from(make::literal_pat("false"))),
+    }
 }
 
 #[cfg(test)]
@@ -221,6 +280,21 @@ mod tests {
     }
 
     #[test]
+    fn all_boolean_match_arms_provided() {
+        check_assist_not_applicable(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                    true => {}
+                    false => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
     fn tuple_of_non_enum() {
         // for now this case is not handled, although it potentially could be
         // in the future
@@ -236,6 +310,113 @@ mod tests {
     }
 
     #[test]
+    fn fill_match_arms_boolean() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match a {
+                    $0true => {}
+                    false => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn partial_fill_boolean() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match a$0 {
+                    true => {}
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match a {
+                    true => {}
+                    $0false => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn all_boolean_tuple_arms_provided() {
+        check_assist_not_applicable(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                    (true, true) => {}
+                    (true, false) => {}
+                    (false, true) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn fill_boolean_tuple() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match (a, a) {
+                    $0(true, true) => {}
+                    (true, false) => {}
+                    (false, true) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
+    fn partial_fill_boolean_tuple() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            fn foo(a: bool) {
+                match (a, a)$0 {
+                    (false, true) => {}
+                }
+            }
+            "#,
+            r#"
+            fn foo(a: bool) {
+                match (a, a) {
+                    (false, true) => {}
+                    $0(true, true) => {}
+                    (true, false) => {}
+                    (false, false) => {}
+                }
+            }
+            "#,
+        )
+    }
+
+    #[test]
     fn partial_fill_record_tuple() {
         check_assist(
             fill_match_arms,
@@ -473,20 +654,81 @@ fn main() {
 
     #[test]
     fn fill_match_arms_tuple_of_enum_partial() {
-        check_assist_not_applicable(
+        check_assist(
             fill_match_arms,
             r#"
-            enum A { One, Two }
-            enum B { One, Two }
+enum A { One, Two }
+enum B { One, Two }
 
-            fn main() {
-                let a = A::One;
-                let b = B::One;
-                match (a$0, b) {
-                    (A::Two, B::One) => {}
-                }
-            }
-            "#,
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a$0, b) {
+        (A::Two, B::One) => {}
+    }
+}
+"#,
+            r#"
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+    let a = A::One;
+    let b = B::One;
+    match (a, b) {
+        (A::Two, B::One) => {}
+        $0(A::One, B::One) => {}
+        (A::One, B::Two) => {}
+        (A::Two, B::Two) => {}
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fill_match_arms_tuple_of_enum_partial_with_wildcards() {
+        let ra_fixture = r#"
+fn main() {
+    let a = Some(1);
+    let b = Some(());
+    match (a$0, b) {
+        (Some(_), _) => {}
+        (None, Some(_)) => {}
+    }
+}
+"#;
+        check_assist(
+            fill_match_arms,
+            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
+            r#"
+fn main() {
+    let a = Some(1);
+    let b = Some(());
+    match (a, b) {
+        (Some(_), _) => {}
+        (None, Some(_)) => {}
+        $0(None, None) => {}
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn fill_match_arms_partial_with_deep_pattern() {
+        // Fixme: cannot handle deep patterns
+        let ra_fixture = r#"
+fn main() {
+    match $0Some(true) {
+        Some(true) => {}
+        None => {}
+    }
+}
+"#;
+        check_assist_not_applicable(
+            fill_match_arms,
+            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
         );
     }
 
@@ -514,10 +756,7 @@ fn main() {
 
     #[test]
     fn fill_match_arms_single_element_tuple_of_enum() {
-        // For now we don't hande the case of a single element tuple, but
-        // we could handle this in the future if `make::tuple_pat` allowed
-        // creating a tuple with a single pattern.
-        check_assist_not_applicable(
+        check_assist(
             fill_match_arms,
             r#"
             enum A { One, Two }
@@ -528,6 +767,17 @@ fn main() {
                 }
             }
             "#,
+            r#"
+            enum A { One, Two }
+
+            fn main() {
+                let a = A::One;
+                match (a, ) {
+                    $0(A::One,) => {}
+                    (A::Two,) => {}
+                }
+            }
+            "#,
         );
     }
 
diff --git a/crates/ide_assists/src/handlers/flip_comma.rs b/crates/ide_assists/src/handlers/flip_comma.rs
index 7f5e75d34..99be5e090 100644
--- a/crates/ide_assists/src/handlers/flip_comma.rs
+++ b/crates/ide_assists/src/handlers/flip_comma.rs
@@ -66,26 +66,12 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
     fn flip_comma_before_punct() {
         // See https://github.com/rust-analyzer/rust-analyzer/issues/1619
         // "Flip comma" assist shouldn't be applicable to the last comma in enum or struct
         // declaration body.
-        check_assist_target(
-            flip_comma,
-            "pub enum Test { \
-             A,$0 \
-             }",
-            ",",
-        );
-
-        check_assist_target(
-            flip_comma,
-            "pub struct Test { \
-             foo: usize,$0 \
-             }",
-            ",",
-        );
+        check_assist_not_applicable(flip_comma, "pub enum Test { A,$0 }");
+        check_assist_not_applicable(flip_comma, "pub struct Test { foo: usize,$0 }");
     }
 
     #[test]
diff --git a/crates/ide_assists/src/handlers/generate_deref.rs b/crates/ide_assists/src/handlers/generate_deref.rs
new file mode 100644
index 000000000..4998ff7a4
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_deref.rs
@@ -0,0 +1,227 @@
+use std::fmt::Display;
+
+use ide_db::{helpers::FamousDefs, RootDatabase};
+use syntax::{
+    ast::{self, NameOwner},
+    AstNode, SyntaxNode,
+};
+
+use crate::{
+    assist_context::{AssistBuilder, AssistContext, Assists},
+    utils::generate_trait_impl_text,
+    AssistId, AssistKind,
+};
+
+// Assist: generate_deref
+//
+// Generate `Deref` impl using the given struct field.
+//
+// ```
+// struct A;
+// struct B {
+//    $0a: A
+// }
+// ```
+// ->
+// ```
+// struct A;
+// struct B {
+//    a: A
+// }
+//
+// impl std::ops::Deref for B {
+//     type Target = A;
+//
+//     fn deref(&self) -> &Self::Target {
+//         &self.a
+//     }
+// }
+// ```
+pub(crate) fn generate_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_record_deref(acc, ctx).or_else(|| generate_tuple_deref(acc, ctx))
+}
+
+fn generate_record_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let field = ctx.find_node_at_offset::<ast::RecordField>()?;
+
+    if existing_deref_impl(&ctx.sema, &strukt).is_some() {
+        cov_mark::hit!(test_add_record_deref_impl_already_exists);
+        return None;
+    }
+
+    let field_type = field.ty()?;
+    let field_name = field.name()?;
+    let target = field.syntax().text_range();
+    acc.add(
+        AssistId("generate_deref", AssistKind::Generate),
+        format!("Generate `Deref` impl using `{}`", field_name),
+        target,
+        |edit| generate_edit(edit, strukt, field_type.syntax(), field_name.syntax()),
+    )
+}
+
+fn generate_tuple_deref(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
+    let field = ctx.find_node_at_offset::<ast::TupleField>()?;
+    let field_list = ctx.find_node_at_offset::<ast::TupleFieldList>()?;
+    let field_list_index =
+        field_list.syntax().children().into_iter().position(|s| &s == field.syntax())?;
+
+    if existing_deref_impl(&ctx.sema, &strukt).is_some() {
+        cov_mark::hit!(test_add_field_deref_impl_already_exists);
+        return None;
+    }
+
+    let field_type = field.ty()?;
+    let target = field.syntax().text_range();
+    acc.add(
+        AssistId("generate_deref", AssistKind::Generate),
+        format!("Generate `Deref` impl using `{}`", field.syntax()),
+        target,
+        |edit| generate_edit(edit, strukt, field_type.syntax(), field_list_index),
+    )
+}
+
+fn generate_edit(
+    edit: &mut AssistBuilder,
+    strukt: ast::Struct,
+    field_type_syntax: &SyntaxNode,
+    field_name: impl Display,
+) {
+    let start_offset = strukt.syntax().text_range().end();
+    let impl_code = format!(
+        r#"    type Target = {0};
+
+    fn deref(&self) -> &Self::Target {{
+        &self.{1}
+    }}"#,
+        field_type_syntax, field_name
+    );
+    let strukt_adt = ast::Adt::Struct(strukt);
+    let deref_impl = generate_trait_impl_text(&strukt_adt, "std::ops::Deref", &impl_code);
+    edit.insert(start_offset, deref_impl);
+}
+
+fn existing_deref_impl(
+    sema: &'_ hir::Semantics<'_, RootDatabase>,
+    strukt: &ast::Struct,
+) -> Option<()> {
+    let strukt = sema.to_def(strukt)?;
+    let krate = strukt.module(sema.db).krate();
+
+    let deref_trait = FamousDefs(sema, Some(krate)).core_ops_Deref()?;
+    let strukt_type = strukt.ty(sema.db);
+
+    if strukt_type.impls_trait(sema.db, deref_trait, &[]) {
+        Some(())
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn test_generate_record_deref() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B { $0a: A }"#,
+            r#"struct A { }
+struct B { a: A }
+
+impl std::ops::Deref for B {
+    type Target = A;
+
+    fn deref(&self) -> &Self::Target {
+        &self.a
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_field_deref_idx_0() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B($0A);"#,
+            r#"struct A { }
+struct B(A);
+
+impl std::ops::Deref for B {
+    type Target = A;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn test_generate_field_deref_idx_1() {
+        check_assist(
+            generate_deref,
+            r#"struct A { }
+struct B(u8, $0A);"#,
+            r#"struct A { }
+struct B(u8, A);
+
+impl std::ops::Deref for B {
+    type Target = A;
+
+    fn deref(&self) -> &Self::Target {
+        &self.1
+    }
+}"#,
+        );
+    }
+
+    fn check_not_applicable(ra_fixture: &str) {
+        let fixture = format!(
+            "//- /main.rs crate:main deps:core,std\n{}\n{}",
+            ra_fixture,
+            FamousDefs::FIXTURE
+        );
+        check_assist_not_applicable(generate_deref, &fixture)
+    }
+
+    #[test]
+    fn test_generate_record_deref_not_applicable_if_already_impl() {
+        cov_mark::check!(test_add_record_deref_impl_already_exists);
+        check_not_applicable(
+            r#"struct A { }
+struct B { $0a: A }
+
+impl std::ops::Deref for B {
+    type Target = A;
+
+    fn deref(&self) -> &Self::Target {
+        &self.a
+    }
+}"#,
+        )
+    }
+
+    #[test]
+    fn test_generate_field_deref_not_applicable_if_already_impl() {
+        cov_mark::check!(test_add_field_deref_impl_already_exists);
+        check_not_applicable(
+            r#"struct A { }
+struct B($0A)
+
+impl std::ops::Deref for B {
+    type Target = A;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}"#,
+        )
+    }
+}
diff --git a/crates/ide_assists/src/handlers/inline_local_variable.rs b/crates/ide_assists/src/handlers/inline_local_variable.rs
index ea1466dc8..f5dafc8cb 100644
--- a/crates/ide_assists/src/handlers/inline_local_variable.rs
+++ b/crates/ide_assists/src/handlers/inline_local_variable.rs
@@ -1,7 +1,9 @@
-use ide_db::{defs::Definition, search::FileReference};
+use either::Either;
+use hir::PathResolution;
+use ide_db::{base_db::FileId, defs::Definition, search::FileReference};
 use rustc_hash::FxHashMap;
 use syntax::{
-    ast::{self, AstNode, AstToken},
+    ast::{self, AstNode, AstToken, NameOwner},
     TextRange,
 };
 
@@ -27,44 +29,28 @@ use crate::{
 // }
 // ```
 pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
-    let bind_pat = match let_stmt.pat()? {
-        ast::Pat::IdentPat(pat) => pat,
-        _ => return None,
-    };
-    if bind_pat.mut_token().is_some() {
-        cov_mark::hit!(test_not_inline_mut_variable);
-        return None;
-    }
-    if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
-        cov_mark::hit!(not_applicable_outside_of_bind_pat);
-        return None;
-    }
+    let InlineData { let_stmt, delete_let, replace_usages, target } =
+        inline_let(ctx).or_else(|| inline_usage(ctx))?;
     let initializer_expr = let_stmt.initializer()?;
 
-    let def = ctx.sema.to_def(&bind_pat)?;
-    let def = Definition::Local(def);
-    let usages = def.usages(&ctx.sema).all();
-    if usages.is_empty() {
-        cov_mark::hit!(test_not_applicable_if_variable_unused);
-        return None;
-    };
-
-    let delete_range = if let Some(whitespace) = let_stmt
-        .syntax()
-        .next_sibling_or_token()
-        .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
-    {
-        TextRange::new(
-            let_stmt.syntax().text_range().start(),
-            whitespace.syntax().text_range().end(),
-        )
+    let delete_range = if delete_let {
+        if let Some(whitespace) = let_stmt
+            .syntax()
+            .next_sibling_or_token()
+            .and_then(|it| ast::Whitespace::cast(it.as_token()?.clone()))
+        {
+            Some(TextRange::new(
+                let_stmt.syntax().text_range().start(),
+                whitespace.syntax().text_range().end(),
+            ))
+        } else {
+            Some(let_stmt.syntax().text_range())
+        }
     } else {
-        let_stmt.syntax().text_range()
+        None
     };
 
-    let wrap_in_parens = usages
-        .references
+    let wrap_in_parens = replace_usages
         .iter()
         .map(|(&file_id, refs)| {
             refs.iter()
@@ -114,14 +100,20 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
     let init_str = initializer_expr.syntax().text().to_string();
     let init_in_paren = format!("({})", &init_str);
 
-    let target = bind_pat.syntax().text_range();
+    let target = match target {
+        ast::NameOrNameRef::Name(it) => it.syntax().text_range(),
+        ast::NameOrNameRef::NameRef(it) => it.syntax().text_range(),
+    };
+
     acc.add(
         AssistId("inline_local_variable", AssistKind::RefactorInline),
         "Inline variable",
         target,
         move |builder| {
-            builder.delete(delete_range);
-            for (file_id, references) in usages.references {
+            if let Some(range) = delete_range {
+                builder.delete(range);
+            }
+            for (file_id, references) in replace_usages {
                 for (&should_wrap, reference) in wrap_in_parens[&file_id].iter().zip(references) {
                     let replacement =
                         if should_wrap { init_in_paren.clone() } else { init_str.clone() };
@@ -140,6 +132,81 @@ pub(crate) fn inline_local_variable(acc: &mut Assists, ctx: &AssistContext) -> O
     )
 }
 
+struct InlineData {
+    let_stmt: ast::LetStmt,
+    delete_let: bool,
+    target: ast::NameOrNameRef,
+    replace_usages: FxHashMap<FileId, Vec<FileReference>>,
+}
+
+fn inline_let(ctx: &AssistContext) -> Option<InlineData> {
+    let let_stmt = ctx.find_node_at_offset::<ast::LetStmt>()?;
+    let bind_pat = match let_stmt.pat()? {
+        ast::Pat::IdentPat(pat) => pat,
+        _ => return None,
+    };
+    if bind_pat.mut_token().is_some() {
+        cov_mark::hit!(test_not_inline_mut_variable);
+        return None;
+    }
+    if !bind_pat.syntax().text_range().contains_inclusive(ctx.offset()) {
+        cov_mark::hit!(not_applicable_outside_of_bind_pat);
+        return None;
+    }
+
+    let def = ctx.sema.to_def(&bind_pat)?;
+    let def = Definition::Local(def);
+    let usages = def.usages(&ctx.sema).all();
+    if usages.is_empty() {
+        cov_mark::hit!(test_not_applicable_if_variable_unused);
+        return None;
+    };
+
+    Some(InlineData {
+        let_stmt,
+        delete_let: true,
+        target: ast::NameOrNameRef::Name(bind_pat.name()?),
+        replace_usages: usages.references,
+    })
+}
+
+fn inline_usage(ctx: &AssistContext) -> Option<InlineData> {
+    let path_expr = ctx.find_node_at_offset::<ast::PathExpr>()?;
+    let path = path_expr.path()?;
+    let name = match path.as_single_segment()?.kind()? {
+        ast::PathSegmentKind::Name(name) => name,
+        _ => return None,
+    };
+
+    let local = match ctx.sema.resolve_path(&path)? {
+        PathResolution::Local(local) => local,
+        _ => return None,
+    };
+
+    let bind_pat = match local.source(ctx.db()).value {
+        Either::Left(ident) => ident,
+        _ => return None,
+    };
+
+    let let_stmt = ast::LetStmt::cast(bind_pat.syntax().parent()?)?;
+
+    let def = Definition::Local(local);
+    let mut usages = def.usages(&ctx.sema).all();
+
+    let delete_let = usages.references.values().map(|v| v.len()).sum::<usize>() == 1;
+
+    for references in usages.references.values_mut() {
+        references.retain(|reference| reference.name.as_name_ref() == Some(&name));
+    }
+
+    Some(InlineData {
+        let_stmt,
+        delete_let,
+        target: ast::NameOrNameRef::NameRef(name),
+        replace_usages: usages.references,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
@@ -726,4 +793,84 @@ fn main() {
 ",
         )
     }
+
+    #[test]
+    fn works_on_local_usage() {
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    let xyz = 0;
+    xyz$0;
+}
+"#,
+            r#"
+fn f() {
+    0;
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn does_not_remove_let_when_multiple_usages() {
+        check_assist(
+            inline_local_variable,
+            r#"
+fn f() {
+    let xyz = 0;
+    xyz$0;
+    xyz;
+}
+"#,
+            r#"
+fn f() {
+    let xyz = 0;
+    0;
+    xyz;
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn not_applicable_with_non_ident_pattern() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+fn main() {
+    let (x, y) = (0, 1);
+    x$0;
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn not_applicable_on_local_usage_in_macro() {
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+macro_rules! m {
+    ($i:ident) => { $i }
+}
+fn f() {
+    let xyz = 0;
+    m!(xyz$0); // replacing it would break the macro
+}
+"#,
+        );
+        check_assist_not_applicable(
+            inline_local_variable,
+            r#"
+macro_rules! m {
+    ($i:ident) => { $i }
+}
+fn f() {
+    let xyz$0 = 0;
+    m!(xyz); // replacing it would break the macro
+}
+"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
index 02782eb6d..9f4f71d6c 100644
--- a/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/ide_assists/src/handlers/introduce_named_lifetime.rs
@@ -1,7 +1,8 @@
 use rustc_hash::FxHashSet;
 use syntax::{
-    ast::{self, GenericParamsOwner, NameOwner},
-    AstNode, TextRange, TextSize,
+    ast::{self, edit_in_place::GenericParamsOwnerEdit, make, GenericParamsOwner},
+    ted::{self, Position},
+    AstNode, TextRange,
 };
 
 use crate::{assist_context::AssistBuilder, AssistContext, AssistId, AssistKind, Assists};
@@ -37,10 +38,12 @@ static ASSIST_LABEL: &str = "Introduce named lifetime";
 pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let lifetime =
         ctx.find_node_at_offset::<ast::Lifetime>().filter(|lifetime| lifetime.text() == "'_")?;
+    let lifetime_loc = lifetime.lifetime_ident_token()?.text_range();
+
     if let Some(fn_def) = lifetime.syntax().ancestors().find_map(ast::Fn::cast) {
-        generate_fn_def_assist(acc, &fn_def, lifetime.lifetime_ident_token()?.text_range())
+        generate_fn_def_assist(acc, fn_def, lifetime_loc, lifetime)
     } else if let Some(impl_def) = lifetime.syntax().ancestors().find_map(ast::Impl::cast) {
-        generate_impl_def_assist(acc, &impl_def, lifetime.lifetime_ident_token()?.text_range())
+        generate_impl_def_assist(acc, impl_def, lifetime_loc, lifetime)
     } else {
         None
     }
@@ -49,26 +52,26 @@ pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -
 /// Generate the assist for the fn def case
 fn generate_fn_def_assist(
     acc: &mut Assists,
-    fn_def: &ast::Fn,
+    fn_def: ast::Fn,
     lifetime_loc: TextRange,
+    lifetime: ast::Lifetime,
 ) -> Option<()> {
     let param_list: ast::ParamList = fn_def.param_list()?;
-    let new_lifetime_param = generate_unique_lifetime_param_name(&fn_def.generic_param_list())?;
-    let end_of_fn_ident = fn_def.name()?.ident_token()?.text_range().end();
+    let new_lifetime_param = generate_unique_lifetime_param_name(fn_def.generic_param_list())?;
     let self_param =
         // use the self if it's a reference and has no explicit lifetime
         param_list.self_param().filter(|p| p.lifetime().is_none() && p.amp_token().is_some());
     // compute the location which implicitly has the same lifetime as the anonymous lifetime
     let loc_needing_lifetime = if let Some(self_param) = self_param {
         // if we have a self reference, use that
-        Some(self_param.name()?.syntax().text_range().start())
+        Some(NeedsLifetime::SelfParam(self_param))
     } else {
         // otherwise, if there's a single reference parameter without a named liftime, use that
         let fn_params_without_lifetime: Vec<_> = param_list
             .params()
             .filter_map(|param| match param.ty() {
                 Some(ast::Type::RefType(ascribed_type)) if ascribed_type.lifetime().is_none() => {
-                    Some(ascribed_type.amp_token()?.text_range().end())
+                    Some(NeedsLifetime::RefType(ascribed_type))
                 }
                 _ => None,
             })
@@ -81,30 +84,46 @@ fn generate_fn_def_assist(
         }
     };
     acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        add_lifetime_param(fn_def, builder, end_of_fn_ident, new_lifetime_param);
-        builder.replace(lifetime_loc, format!("'{}", new_lifetime_param));
-        loc_needing_lifetime.map(|loc| builder.insert(loc, format!("'{} ", new_lifetime_param)));
+        let fn_def = builder.make_ast_mut(fn_def);
+        let lifetime = builder.make_ast_mut(lifetime);
+        let loc_needing_lifetime =
+            loc_needing_lifetime.and_then(|it| it.make_mut(builder).to_position());
+
+        add_lifetime_param(fn_def.get_or_create_generic_param_list(), new_lifetime_param);
+        ted::replace(
+            lifetime.syntax(),
+            make_ast_lifetime(new_lifetime_param).clone_for_update().syntax(),
+        );
+        loc_needing_lifetime.map(|position| {
+            ted::insert(position, make_ast_lifetime(new_lifetime_param).clone_for_update().syntax())
+        });
     })
 }
 
 /// Generate the assist for the impl def case
 fn generate_impl_def_assist(
     acc: &mut Assists,
-    impl_def: &ast::Impl,
+    impl_def: ast::Impl,
     lifetime_loc: TextRange,
+    lifetime: ast::Lifetime,
 ) -> Option<()> {
-    let new_lifetime_param = generate_unique_lifetime_param_name(&impl_def.generic_param_list())?;
-    let end_of_impl_kw = impl_def.impl_token()?.text_range().end();
+    let new_lifetime_param = generate_unique_lifetime_param_name(impl_def.generic_param_list())?;
     acc.add(AssistId(ASSIST_NAME, AssistKind::Refactor), ASSIST_LABEL, lifetime_loc, |builder| {
-        add_lifetime_param(impl_def, builder, end_of_impl_kw, new_lifetime_param);
-        builder.replace(lifetime_loc, format!("'{}", new_lifetime_param));
+        let impl_def = builder.make_ast_mut(impl_def);
+        let lifetime = builder.make_ast_mut(lifetime);
+
+        add_lifetime_param(impl_def.get_or_create_generic_param_list(), new_lifetime_param);
+        ted::replace(
+            lifetime.syntax(),
+            make_ast_lifetime(new_lifetime_param).clone_for_update().syntax(),
+        );
     })
 }
 
 /// Given a type parameter list, generate a unique lifetime parameter name
 /// which is not in the list
 fn generate_unique_lifetime_param_name(
-    existing_type_param_list: &Option<ast::GenericParamList>,
+    existing_type_param_list: Option<ast::GenericParamList>,
 ) -> Option<char> {
     match existing_type_param_list {
         Some(type_params) => {
@@ -118,25 +137,37 @@ fn generate_unique_lifetime_param_name(
     }
 }
 
-/// Add the lifetime param to `builder`. If there are type parameters in `type_params_owner`, add it to the end. Otherwise
-/// add new type params brackets with the lifetime parameter at `new_type_params_loc`.
-fn add_lifetime_param<TypeParamsOwner: ast::GenericParamsOwner>(
-    type_params_owner: &TypeParamsOwner,
-    builder: &mut AssistBuilder,
-    new_type_params_loc: TextSize,
-    new_lifetime_param: char,
-) {
-    match type_params_owner.generic_param_list() {
-        // add the new lifetime parameter to an existing type param list
-        Some(type_params) => {
-            builder.insert(
-                (u32::from(type_params.syntax().text_range().end()) - 1).into(),
-                format!(", '{}", new_lifetime_param),
-            );
+fn add_lifetime_param(type_params: ast::GenericParamList, new_lifetime_param: char) {
+    let generic_param =
+        make::generic_param(format!("'{}", new_lifetime_param), None).clone_for_update();
+    type_params.add_generic_param(generic_param);
+}
+
+fn make_ast_lifetime(new_lifetime_param: char) -> ast::Lifetime {
+    make::generic_param(format!("'{}", new_lifetime_param), None)
+        .syntax()
+        .descendants()
+        .find_map(ast::Lifetime::cast)
+        .unwrap()
+}
+
+enum NeedsLifetime {
+    SelfParam(ast::SelfParam),
+    RefType(ast::RefType),
+}
+
+impl NeedsLifetime {
+    fn make_mut(self, builder: &mut AssistBuilder) -> Self {
+        match self {
+            Self::SelfParam(it) => Self::SelfParam(builder.make_ast_mut(it)),
+            Self::RefType(it) => Self::RefType(builder.make_ast_mut(it)),
         }
-        // create a new type param list containing only the new lifetime parameter
-        None => {
-            builder.insert(new_type_params_loc, format!("<'{}>", new_lifetime_param));
+    }
+
+    fn to_position(self) -> Option<Position> {
+        match self {
+            Self::SelfParam(it) => Some(Position::after(it.amp_token()?)),
+            Self::RefType(it) => Some(Position::after(it.amp_token()?)),
         }
     }
 }
@@ -312,4 +343,13 @@ mod tests {
             r#"fn my_fun<'other, 'a>(self, f: &'a Foo, b: &'other Bar) -> X<'a>"#,
         );
     }
+
+    #[test]
+    fn test_function_add_lifetime_to_self_ref_mut() {
+        check_assist(
+            introduce_named_lifetime,
+            r#"fn foo(&mut self) -> &'_$0 ()"#,
+            r#"fn foo<'a>(&'a mut self) -> &'a ()"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/remove_dbg.rs b/crates/ide_assists/src/handlers/remove_dbg.rs
index 6114091f2..c8226550f 100644
--- a/crates/ide_assists/src/handlers/remove_dbg.rs
+++ b/crates/ide_assists/src/handlers/remove_dbg.rs
@@ -1,5 +1,5 @@
 use syntax::{
-    ast::{self, AstNode},
+    ast::{self, AstNode, AstToken},
     match_ast, SyntaxElement, TextRange, TextSize, T,
 };
 
@@ -24,7 +24,39 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let macro_call = ctx.find_node_at_offset::<ast::MacroCall>()?;
     let new_contents = adjusted_macro_contents(&macro_call)?;
 
-    let macro_text_range = macro_call.syntax().text_range();
+    let parent = macro_call.syntax().parent();
+
+    let macro_text_range = if let Some(it) = parent.as_ref() {
+        if new_contents.is_empty() {
+            match_ast! {
+                match it {
+                    ast::BlockExpr(_it) => {
+                        macro_call.syntax()
+                            .prev_sibling_or_token()
+                            .and_then(whitespace_start)
+                            .map(|start| TextRange::new(start, macro_call.syntax().text_range().end()))
+                            .unwrap_or(macro_call.syntax().text_range())
+                    },
+                    ast::ExprStmt(it) => {
+                        let start = it
+                            .syntax()
+                            .prev_sibling_or_token()
+                            .and_then(whitespace_start)
+                            .unwrap_or(it.syntax().text_range().start());
+                        let end = it.syntax().text_range().end();
+
+                        TextRange::new(start, end)
+                    },
+                    _ => macro_call.syntax().text_range()
+                }
+            }
+        } else {
+            macro_call.syntax().text_range()
+        }
+    } else {
+        macro_call.syntax().text_range()
+    };
+
     let macro_end = if macro_call.semicolon_token().is_some() {
         macro_text_range.end() - TextSize::of(';')
     } else {
@@ -36,11 +68,22 @@ pub(crate) fn remove_dbg(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
         "Remove dbg!()",
         macro_text_range,
         |builder| {
-            builder.replace(TextRange::new(macro_text_range.start(), macro_end), new_contents);
+            builder.replace(
+                TextRange::new(macro_text_range.start(), macro_end),
+                if new_contents.is_empty() && parent.and_then(ast::LetStmt::cast).is_some() {
+                    ast::make::expr_unit().to_string()
+                } else {
+                    new_contents
+                },
+            );
         },
     )
 }
 
+fn whitespace_start(it: SyntaxElement) -> Option<TextSize> {
+    Some(it.into_token().and_then(ast::Whitespace::cast)?.syntax().text_range().start())
+}
+
 fn adjusted_macro_contents(macro_call: &ast::MacroCall) -> Option<String> {
     let contents = get_valid_macrocall_contents(&macro_call, "dbg")?;
     let macro_text_with_brackets = macro_call.token_tree()?.syntax().text();
@@ -94,15 +137,11 @@ fn get_valid_macrocall_contents(
     let mut contents_between_brackets = children_with_tokens.collect::<Vec<_>>();
     let last_child = contents_between_brackets.pop()?;
 
-    if contents_between_brackets.is_empty() {
-        None
-    } else {
-        match (first_child.kind(), last_child.kind()) {
-            (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => {
-                Some(contents_between_brackets)
-            }
-            _ => None,
+    match (first_child.kind(), last_child.kind()) {
+        (T!['('], T![')']) | (T!['['], T![']']) | (T!['{'], T!['}']) => {
+            Some(contents_between_brackets)
         }
+        _ => None,
     }
 }
 
@@ -418,4 +457,48 @@ fn main() {
 }"#,
         );
     }
+
+    #[test]
+    fn test_remove_empty_dbg() {
+        check_assist(remove_dbg, r#"fn foo() { $0dbg!(); }"#, r#"fn foo() { }"#);
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    $0dbg!();
+}
+"#,
+            r#"
+fn foo() {
+}
+"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let test = $0dbg!();
+}"#,
+            r#"
+fn foo() {
+    let test = ();
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"
+fn foo() {
+    let t = {
+        println!("Hello, world");
+        $0dbg!()
+    };
+}"#,
+            r#"
+fn foo() {
+    let t = {
+        println!("Hello, world");
+    };
+}"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/reorder_fields.rs b/crates/ide_assists/src/handlers/reorder_fields.rs
index 383ca6c47..1a95135ca 100644
--- a/crates/ide_assists/src/handlers/reorder_fields.rs
+++ b/crates/ide_assists/src/handlers/reorder_fields.rs
@@ -1,6 +1,8 @@
+use either::Either;
+use itertools::Itertools;
 use rustc_hash::FxHashMap;
 
-use syntax::{algo, ast, match_ast, AstNode, SyntaxKind::*, SyntaxNode};
+use syntax::{ast, ted, AstNode};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -22,60 +24,70 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 pub(crate) fn reorder_fields(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let record = ctx
         .find_node_at_offset::<ast::RecordExpr>()
-        .map(|it| it.syntax().clone())
-        .or_else(|| ctx.find_node_at_offset::<ast::RecordPat>().map(|it| it.syntax().clone()))?;
-
-    let path = record.children().find_map(ast::Path::cast)?;
+        .map(Either::Left)
+        .or_else(|| ctx.find_node_at_offset::<ast::RecordPat>().map(Either::Right))?;
 
+    let path = record.as_ref().either(|it| it.path(), |it| it.path())?;
     let ranks = compute_fields_ranks(&path, &ctx)?;
+    let get_rank_of_field =
+        |of: Option<_>| *ranks.get(&of.unwrap_or_default()).unwrap_or(&usize::MAX);
 
-    let fields: Vec<SyntaxNode> = {
-        let field_kind = match record.kind() {
-            RECORD_EXPR => RECORD_EXPR_FIELD,
-            RECORD_PAT => RECORD_PAT_FIELD,
-            _ => {
-                stdx::never!();
-                return None;
-            }
-        };
-        record.children().flat_map(|n| n.children()).filter(|n| n.kind() == field_kind).collect()
+    let field_list = match &record {
+        Either::Left(it) => Either::Left(it.record_expr_field_list()?),
+        Either::Right(it) => Either::Right(it.record_pat_field_list()?),
     };
-
-    let sorted_fields = {
-        let mut fields = fields.clone();
-        fields.sort_by_key(|node| *ranks.get(&get_field_name(node)).unwrap_or(&usize::max_value()));
-        fields
+    let fields = match field_list {
+        Either::Left(it) => Either::Left((
+            it.fields()
+                .sorted_unstable_by_key(|field| {
+                    get_rank_of_field(field.field_name().map(|it| it.to_string()))
+                })
+                .collect::<Vec<_>>(),
+            it,
+        )),
+        Either::Right(it) => Either::Right((
+            it.fields()
+                .sorted_unstable_by_key(|field| {
+                    get_rank_of_field(field.field_name().map(|it| it.to_string()))
+                })
+                .collect::<Vec<_>>(),
+            it,
+        )),
     };
 
-    if sorted_fields == fields {
+    let is_sorted = fields.as_ref().either(
+        |(sorted, field_list)| field_list.fields().zip(sorted).all(|(a, b)| a == *b),
+        |(sorted, field_list)| field_list.fields().zip(sorted).all(|(a, b)| a == *b),
+    );
+    if is_sorted {
         cov_mark::hit!(reorder_sorted_fields);
         return None;
     }
-
-    let target = record.text_range();
+    let target = record.as_ref().either(AstNode::syntax, AstNode::syntax).text_range();
     acc.add(
         AssistId("reorder_fields", AssistKind::RefactorRewrite),
         "Reorder record fields",
         target,
-        |edit| {
-            let mut rewriter = algo::SyntaxRewriter::default();
-            for (old, new) in fields.iter().zip(&sorted_fields) {
-                rewriter.replace(old, new);
+        |builder| match fields {
+            Either::Left((sorted, field_list)) => {
+                replace(builder.make_ast_mut(field_list).fields(), sorted)
+            }
+            Either::Right((sorted, field_list)) => {
+                replace(builder.make_ast_mut(field_list).fields(), sorted)
             }
-            edit.rewrite(rewriter);
         },
     )
 }
 
-fn get_field_name(node: &SyntaxNode) -> String {
-    let res = match_ast! {
-        match node {
-            ast::RecordExprField(field) => field.field_name().map(|it| it.to_string()),
-            ast::RecordPatField(field) => field.field_name().map(|it| it.to_string()),
-            _ => None,
-        }
-    };
-    res.unwrap_or_default()
+fn replace<T: AstNode + PartialEq>(
+    fields: impl Iterator<Item = T>,
+    sorted_fields: impl IntoIterator<Item = T>,
+) {
+    fields.zip(sorted_fields).filter(|(field, sorted)| field != sorted).for_each(
+        |(field, sorted_field)| {
+            ted::replace(field.syntax(), sorted_field.syntax().clone_for_update());
+        },
+    );
 }
 
 fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashMap<String, usize>> {
@@ -86,7 +98,7 @@ fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
 
     let res = strukt
         .fields(ctx.db())
-        .iter()
+        .into_iter()
         .enumerate()
         .map(|(idx, field)| (field.name(ctx.db()).to_string(), idx))
         .collect();
@@ -137,7 +149,6 @@ const test: Foo = Foo { foo: 1, bar: 0 };
 "#,
         )
     }
-
     #[test]
     fn reorder_struct_pattern() {
         check_assist(
diff --git a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
index f872d20c8..694d897d1 100644
--- a/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/ide_assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -5,7 +5,6 @@ use itertools::Itertools;
 use syntax::{
     ast::{self, make, AstNode, NameOwner},
     SyntaxKind::{IDENT, WHITESPACE},
-    TextSize,
 };
 
 use crate::{
@@ -43,32 +42,28 @@ pub(crate) fn replace_derive_with_manual_impl(
     ctx: &AssistContext,
 ) -> Option<()> {
     let attr = ctx.find_node_at_offset::<ast::Attr>()?;
+    let (name, args) = attr.as_simple_call()?;
+    if name != "derive" {
+        return None;
+    }
 
-    let has_derive = attr
-        .syntax()
-        .descendants_with_tokens()
-        .filter(|t| t.kind() == IDENT)
-        .find_map(syntax::NodeOrToken::into_token)
-        .filter(|t| t.text() == "derive")
-        .is_some();
-    if !has_derive {
+    if !args.syntax().text_range().contains(ctx.offset()) {
+        cov_mark::hit!(outside_of_attr_args);
         return None;
     }
 
-    let trait_token = ctx.token_at_offset().find(|t| t.kind() == IDENT && t.text() != "derive")?;
-    let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text())));
+    let trait_token = args.syntax().token_at_offset(ctx.offset()).find(|t| t.kind() == IDENT)?;
+    let trait_name = trait_token.text();
 
     let adt = attr.syntax().parent().and_then(ast::Adt::cast)?;
-    let annotated_name = adt.name()?;
-    let insert_pos = adt.syntax().text_range().end();
 
-    let current_module = ctx.sema.scope(annotated_name.syntax()).module()?;
+    let current_module = ctx.sema.scope(adt.syntax()).module()?;
     let current_crate = current_module.krate();
 
     let found_traits = items_locator::items_with_name(
         &ctx.sema,
         current_crate,
-        NameToImport::Exact(trait_token.text().to_string()),
+        NameToImport::Exact(trait_name.to_string()),
         items_locator::AssocItemSearch::Exclude,
         Some(items_locator::DEFAULT_QUERY_SEARCH_LIMIT),
     )
@@ -86,10 +81,11 @@ pub(crate) fn replace_derive_with_manual_impl(
 
     let mut no_traits_found = true;
     for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) {
-        add_assist(acc, ctx, &attr, &trait_path, Some(trait_), &adt, &annotated_name, insert_pos)?;
+        add_assist(acc, ctx, &attr, &args, &trait_path, Some(trait_), &adt)?;
     }
     if no_traits_found {
-        add_assist(acc, ctx, &attr, &trait_path, None, &adt, &annotated_name, insert_pos)?;
+        let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_name)));
+        add_assist(acc, ctx, &attr, &args, &trait_path, None, &adt)?;
     }
     Some(())
 }
@@ -98,15 +94,14 @@ fn add_assist(
     acc: &mut Assists,
     ctx: &AssistContext,
     attr: &ast::Attr,
+    input: &ast::TokenTree,
     trait_path: &ast::Path,
     trait_: Option<hir::Trait>,
     adt: &ast::Adt,
-    annotated_name: &ast::Name,
-    insert_pos: TextSize,
 ) -> Option<()> {
     let target = attr.syntax().text_range();
-    let input = attr.token_tree()?;
-    let label = format!("Convert to manual  `impl {} for {}`", trait_path, annotated_name);
+    let annotated_name = adt.name()?;
+    let label = format!("Convert to manual `impl {} for {}`", trait_path, annotated_name);
     let trait_name = trait_path.segment().and_then(|seg| seg.name_ref())?;
 
     acc.add(
@@ -114,8 +109,9 @@ fn add_assist(
         label,
         target,
         |builder| {
+            let insert_pos = adt.syntax().text_range().end();
             let impl_def_with_items =
-                impl_def_from_trait(&ctx.sema, annotated_name, trait_, trait_path);
+                impl_def_from_trait(&ctx.sema, &annotated_name, trait_, trait_path);
             update_attribute(builder, &input, &trait_name, &attr);
             let trait_path = format!("{}", trait_path);
             match (ctx.config.snippet_cap, impl_def_with_items) {
@@ -216,7 +212,7 @@ mod tests {
     fn add_custom_impl_debug() {
         check_assist(
             replace_derive_with_manual_impl,
-            "
+            r#"
 mod fmt {
     pub struct Error;
     pub type Result = Result<(), Error>;
@@ -230,8 +226,8 @@ mod fmt {
 struct Foo {
     bar: String,
 }
-",
-            "
+"#,
+            r#"
 mod fmt {
     pub struct Error;
     pub type Result = Result<(), Error>;
@@ -250,14 +246,14 @@ impl fmt::Debug for Foo {
         ${0:todo!()}
     }
 }
-",
+"#,
         )
     }
     #[test]
     fn add_custom_impl_all() {
         check_assist(
             replace_derive_with_manual_impl,
-            "
+            r#"
 mod foo {
     pub trait Bar {
         type Qux;
@@ -272,8 +268,8 @@ mod foo {
 struct Foo {
     bar: String,
 }
-",
-            "
+"#,
+            r#"
 mod foo {
     pub trait Bar {
         type Qux;
@@ -299,20 +295,20 @@ impl foo::Bar for Foo {
         todo!()
     }
 }
-",
+"#,
         )
     }
     #[test]
     fn add_custom_impl_for_unique_input() {
         check_assist(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debu$0g)]
 struct Foo {
     bar: String,
 }
-            ",
-            "
+            "#,
+            r#"
 struct Foo {
     bar: String,
 }
@@ -320,7 +316,7 @@ struct Foo {
 impl Debug for Foo {
     $0
 }
-            ",
+            "#,
         )
     }
 
@@ -328,13 +324,13 @@ impl Debug for Foo {
     fn add_custom_impl_for_with_visibility_modifier() {
         check_assist(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debug$0)]
 pub struct Foo {
     bar: String,
 }
-            ",
-            "
+            "#,
+            r#"
 pub struct Foo {
     bar: String,
 }
@@ -342,7 +338,7 @@ pub struct Foo {
 impl Debug for Foo {
     $0
 }
-            ",
+            "#,
         )
     }
 
@@ -350,18 +346,18 @@ impl Debug for Foo {
     fn add_custom_impl_when_multiple_inputs() {
         check_assist(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Display, Debug$0, Serialize)]
 struct Foo {}
-            ",
-            "
+            "#,
+            r#"
 #[derive(Display, Serialize)]
 struct Foo {}
 
 impl Debug for Foo {
     $0
 }
-            ",
+            "#,
         )
     }
 
@@ -369,10 +365,10 @@ impl Debug for Foo {
     fn test_ignore_derive_macro_without_input() {
         check_assist_not_applicable(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive($0)]
 struct Foo {}
-            ",
+            "#,
         )
     }
 
@@ -380,18 +376,18 @@ struct Foo {}
     fn test_ignore_if_cursor_on_param() {
         check_assist_not_applicable(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive$0(Debug)]
 struct Foo {}
-            ",
+            "#,
         );
 
         check_assist_not_applicable(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[derive(Debug)$0]
 struct Foo {}
-            ",
+            "#,
         )
     }
 
@@ -399,10 +395,22 @@ struct Foo {}
     fn test_ignore_if_not_derive() {
         check_assist_not_applicable(
             replace_derive_with_manual_impl,
-            "
+            r#"
 #[allow(non_camel_$0case_types)]
 struct Foo {}
-            ",
+            "#,
         )
     }
+
+    #[test]
+    fn works_at_start_of_file() {
+        cov_mark::check!(outside_of_attr_args);
+        check_assist_not_applicable(
+            replace_derive_with_manual_impl,
+            r#"
+$0#[derive(Debug)]
+struct S;
+            "#,
+        );
+    }
 }