11 files changed, 181 insertions, 48 deletions

diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index d665837a2..bd5bba646 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -1,8 +1,11 @@
+use ide_db::helpers::{
+    insert_use::{insert_use, ImportScope},
+    mod_path_to_ast,
+};
 use syntax::ast;
 
 use crate::{
     utils::import_assets::{ImportAssets, ImportCandidate},
-    utils::{insert_use, mod_path_to_ast, ImportScope},
     AssistContext, AssistId, AssistKind, Assists, GroupLabel,
 };
 
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index cac77c49b..d85767b4e 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -2,6 +2,10 @@ use std::iter;
 
 use either::Either;
 use hir::{AsName, EnumVariant, Module, ModuleDef, Name};
+use ide_db::helpers::{
+    insert_use::{insert_use, ImportScope},
+    mod_path_to_ast,
+};
 use ide_db::{defs::Definition, search::Reference, RootDatabase};
 use rustc_hash::{FxHashMap, FxHashSet};
 use syntax::{
@@ -10,10 +14,7 @@ use syntax::{
     SourceFile, SyntaxElement, SyntaxNode, T,
 };
 
-use crate::{
-    utils::{insert_use, mod_path_to_ast, ImportScope},
-    AssistContext, AssistId, AssistKind, Assists,
-};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: extract_struct_from_enum_variant
 //
@@ -236,10 +237,9 @@ fn update_reference(
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        tests::{check_assist, check_assist_not_applicable},
-        utils::FamousDefs,
-    };
+    use ide_db::helpers::FamousDefs;
+
+    use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
diff --git a/crates/assists/src/handlers/fill_match_arms.rs b/crates/assists/src/handlers/fill_match_arms.rs
index eda45f5b3..ef12ef0cf 100644
--- a/crates/assists/src/handlers/fill_match_arms.rs
+++ b/crates/assists/src/handlers/fill_match_arms.rs
@@ -1,13 +1,14 @@
 use std::iter;
 
 use hir::{Adt, HasSource, ModuleDef, Semantics};
+use ide_db::helpers::{mod_path_to_ast, FamousDefs};
 use ide_db::RootDatabase;
 use itertools::Itertools;
 use syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
 use test_utils::mark;
 
 use crate::{
-    utils::{mod_path_to_ast, render_snippet, Cursor, FamousDefs},
+    utils::{render_snippet, Cursor},
     AssistContext, AssistId, AssistKind, Assists,
 };
 
@@ -212,12 +213,10 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
 
 #[cfg(test)]
 mod tests {
+    use ide_db::helpers::FamousDefs;
     use test_utils::mark;
 
-    use crate::{
-        tests::{check_assist, check_assist_not_applicable, check_assist_target},
-        utils::FamousDefs,
-    };
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
     use super::fill_match_arms;
 
diff --git a/crates/assists/src/handlers/generate_from_impl_for_enum.rs b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
index 674e5a175..3c374e5d9 100644
--- a/crates/assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,8 +1,9 @@
+use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
 use syntax::ast::{self, AstNode, NameOwner};
 use test_utils::mark;
 
-use crate::{utils::FamousDefs, AssistContext, AssistId, AssistKind, Assists};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: generate_from_impl_for_enum
 //
diff --git a/crates/assists/src/handlers/ignore_test.rs b/crates/assists/src/handlers/ignore_test.rs
index d2339184f..5096a0005 100644
--- a/crates/assists/src/handlers/ignore_test.rs
+++ b/crates/assists/src/handlers/ignore_test.rs
@@ -1,4 +1,7 @@
-use syntax::{ast, AstNode};
+use syntax::{
+    ast::{self, AttrsOwner},
+    AstNode, AstToken,
+};
 
 use crate::{utils::test_related_attribute, AssistContext, AssistId, AssistKind, Assists};
 
@@ -25,10 +28,76 @@ pub(crate) fn ignore_test(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     let func = attr.syntax().parent().and_then(ast::Fn::cast)?;
     let attr = test_related_attribute(&func)?;
 
-    acc.add(
-        AssistId("ignore_test", AssistKind::None),
-        "Ignore this test",
-        attr.syntax().text_range(),
-        |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
-    )
+    match has_ignore_attribute(&func) {
+        None => acc.add(
+            AssistId("ignore_test", AssistKind::None),
+            "Ignore this test",
+            attr.syntax().text_range(),
+            |builder| builder.insert(attr.syntax().text_range().end(), &format!("\n#[ignore]")),
+        ),
+        Some(ignore_attr) => acc.add(
+            AssistId("unignore_test", AssistKind::None),
+            "Re-enable this test",
+            ignore_attr.syntax().text_range(),
+            |builder| {
+                builder.delete(ignore_attr.syntax().text_range());
+                let whitespace = ignore_attr
+                    .syntax()
+                    .next_sibling_or_token()
+                    .and_then(|x| x.into_token())
+                    .and_then(ast::Whitespace::cast);
+                if let Some(whitespace) = whitespace {
+                    builder.delete(whitespace.syntax().text_range());
+                }
+            },
+        ),
+    }
+}
+
+fn has_ignore_attribute(fn_def: &ast::Fn) -> Option<ast::Attr> {
+    fn_def.attrs().find_map(|attr| {
+        if attr.path()?.syntax().text() == "ignore" {
+            Some(attr)
+        } else {
+            None
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ignore_test;
+    use crate::tests::check_assist;
+
+    #[test]
+    fn test_base_case() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            #[ignore]
+            fn test() {}
+            "#,
+        )
+    }
+
+    #[test]
+    fn test_unignore() {
+        check_assist(
+            ignore_test,
+            r#"
+            #[test<|>]
+            #[ignore]
+            fn test() {}
+            "#,
+            r#"
+            #[test]
+            fn test() {}
+            "#,
+        )
+    }
 }
diff --git a/crates/assists/src/handlers/infer_function_return_type.rs b/crates/assists/src/handlers/infer_function_return_type.rs
index 520d07ae0..aa584eb03 100644
--- a/crates/assists/src/handlers/infer_function_return_type.rs
+++ b/crates/assists/src/handlers/infer_function_return_type.rs
@@ -17,7 +17,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // fn foo() -> i32 { 42i32 }
 // ```
 pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let (tail_expr, builder_edit_pos, wrap_expr) = extract_tail(ctx)?;
+    let (fn_type, tail_expr, builder_edit_pos) = extract_tail(ctx)?;
     let module = ctx.sema.scope(tail_expr.syntax()).module()?;
     let ty = ctx.sema.type_of_expr(&tail_expr)?;
     if ty.is_unit() {
@@ -27,7 +27,10 @@ pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext)
 
     acc.add(
         AssistId("infer_function_return_type", AssistKind::RefactorRewrite),
-        "Add this function's return type",
+        match fn_type {
+            FnType::Function => "Add this function's return type",
+            FnType::Closure { .. } => "Add this closure's return type",
+        },
         tail_expr.syntax().text_range(),
         |builder| {
             match builder_edit_pos {
@@ -38,7 +41,7 @@ pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext)
                     builder.replace(text_range, &format!("-> {}", ty))
                 }
             }
-            if wrap_expr {
+            if let FnType::Closure { wrap_expr: true } = fn_type {
                 mark::hit!(wrap_closure_non_block_expr);
                 // `|x| x` becomes `|x| -> T x` which is invalid, so wrap it in a block
                 builder.replace(tail_expr.syntax().text_range(), &format!("{{{}}}", tail_expr));
@@ -72,8 +75,13 @@ fn ret_ty_to_action(ret_ty: Option<ast::RetType>, insert_pos: TextSize) -> Optio
     }
 }
 
-fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool)> {
-    let (tail_expr, return_type_range, action, wrap_expr) =
+enum FnType {
+    Function,
+    Closure { wrap_expr: bool },
+}
+
+fn extract_tail(ctx: &AssistContext) -> Option<(FnType, ast::Expr, InsertOrReplace)> {
+    let (fn_type, tail_expr, return_type_range, action) =
         if let Some(closure) = ctx.find_node_at_offset::<ast::ClosureExpr>() {
             let rpipe_pos = closure.param_list()?.syntax().last_token()?.text_range().end();
             let action = ret_ty_to_action(closure.ret_type(), rpipe_pos)?;
@@ -86,7 +94,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
             };
 
             let ret_range = TextRange::new(rpipe_pos, body_start);
-            (tail_expr, ret_range, action, wrap_expr)
+            (FnType::Closure { wrap_expr }, tail_expr, ret_range, action)
         } else {
             let func = ctx.find_node_at_offset::<ast::Fn>()?;
             let rparen_pos = func.param_list()?.r_paren_token()?.text_range().end();
@@ -97,7 +105,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
 
             let ret_range_end = body.l_curly_token()?.text_range().start();
             let ret_range = TextRange::new(rparen_pos, ret_range_end);
-            (tail_expr, ret_range, action, false)
+            (FnType::Function, tail_expr, ret_range, action)
         };
     let frange = ctx.frange.range;
     if return_type_range.contains_range(frange) {
@@ -109,7 +117,7 @@ fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool
     } else {
         return None;
     }
-    Some((tail_expr, action, wrap_expr))
+    Some((fn_type, tail_expr, action))
 }
 
 #[cfg(test)]
diff --git a/crates/assists/src/handlers/merge_imports.rs b/crates/assists/src/handlers/merge_imports.rs
index fd9c9e03c..b7e853994 100644
--- a/crates/assists/src/handlers/merge_imports.rs
+++ b/crates/assists/src/handlers/merge_imports.rs
@@ -1,3 +1,4 @@
+use ide_db::helpers::insert_use::{try_merge_imports, try_merge_trees, MergeBehaviour};
 use syntax::{
     algo::{neighbor, SyntaxRewriter},
     ast, AstNode,
@@ -5,10 +6,7 @@ use syntax::{
 
 use crate::{
     assist_context::{AssistContext, Assists},
-    utils::{
-        insert_use::{try_merge_imports, try_merge_trees},
-        next_prev, MergeBehaviour,
-    },
+    utils::next_prev,
     AssistId, AssistKind,
 };
 
diff --git a/crates/assists/src/handlers/qualify_path.rs b/crates/assists/src/handlers/qualify_path.rs
index d5bc4e574..6f9810fe8 100644
--- a/crates/assists/src/handlers/qualify_path.rs
+++ b/crates/assists/src/handlers/qualify_path.rs
@@ -1,6 +1,7 @@
 use std::iter;
 
 use hir::AsName;
+use ide_db::helpers::mod_path_to_ast;
 use ide_db::RootDatabase;
 use syntax::{
     ast,
@@ -12,7 +13,6 @@ use test_utils::mark;
 use crate::{
     assist_context::{AssistContext, Assists},
     utils::import_assets::{ImportAssets, ImportCandidate},
-    utils::mod_path_to_ast,
     AssistId, AssistKind, GroupLabel,
 };
 
diff --git a/crates/assists/src/handlers/remove_dbg.rs b/crates/assists/src/handlers/remove_dbg.rs
index 9731344b8..eae6367c1 100644
--- a/crates/assists/src/handlers/remove_dbg.rs
+++ b/crates/assists/src/handlers/remove_dbg.rs
@@ -1,6 +1,6 @@
 use syntax::{
     ast::{self, AstNode},
-    SyntaxElement, SyntaxKind, TextRange, TextSize, T,
+    match_ast, SyntaxElement, SyntaxKind, TextRange, TextSize, T,
 };
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -49,12 +49,29 @@ fn adjusted_macro_contents(macro_call: &ast::MacroCall) -> Option<String> {
         macro_text_with_brackets.len() - TextSize::of(')'),
     ));
 
-    let is_leaf = macro_call.syntax().next_sibling().is_none();
-    Some(if !is_leaf && needs_parentheses_around_macro_contents(contents) {
-        format!("({})", macro_text_in_brackets)
-    } else {
-        macro_text_in_brackets.to_string()
-    })
+    Some(
+        if !is_leaf_or_control_flow_expr(macro_call)
+            && needs_parentheses_around_macro_contents(contents)
+        {
+            format!("({})", macro_text_in_brackets)
+        } else {
+            macro_text_in_brackets.to_string()
+        },
+    )
+}
+
+fn is_leaf_or_control_flow_expr(macro_call: &ast::MacroCall) -> bool {
+    macro_call.syntax().next_sibling().is_none()
+        || match macro_call.syntax().parent() {
+            Some(parent) => match_ast! {
+                match parent {
+                    ast::Condition(_it) => true,
+                    ast::MatchExpr(_it) => true,
+                    _ => false,
+                }
+            },
+            None => false,
+        }
 }
 
 /// Verifies that the given macro_call actually matches the given name
@@ -361,4 +378,44 @@ fn main() {
             r#"let res = (foo..=bar).foo();"#,
         );
     }
+
+    #[test]
+    fn test_remove_dbg_followed_by_block() {
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    if <|>dbg!(x || y) {}
+}"#,
+            r#"fn foo() {
+    if x || y {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    while let foo = <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    while let foo = &x {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    if let foo = <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    if let foo = &x {}
+}"#,
+        );
+        check_assist(
+            remove_dbg,
+            r#"fn foo() {
+    match <|>dbg!(&x) {}
+}"#,
+            r#"fn foo() {
+    match &x {}
+}"#,
+        );
+    }
 }
diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
index 453a6cebf..4d6a1956b 100644
--- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
+++ b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs
@@ -1,3 +1,4 @@
+use ide_db::helpers::mod_path_to_ast;
 use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
@@ -10,8 +11,7 @@ use syntax::{
 use crate::{
     assist_context::{AssistBuilder, AssistContext, Assists},
     utils::{
-        add_trait_assoc_items_to_impl, filter_assoc_items, mod_path_to_ast, render_snippet, Cursor,
-        DefaultMethods,
+        add_trait_assoc_items_to_impl, filter_assoc_items, render_snippet, Cursor, DefaultMethods,
     },
     AssistId, AssistKind,
 };
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index a66db9ae3..8bdf9eea5 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -1,10 +1,8 @@
+use ide_db::helpers::insert_use::{insert_use, ImportScope};
 use syntax::{algo::SyntaxRewriter, ast, match_ast, AstNode, SyntaxNode};
 use test_utils::mark;
 
-use crate::{
-    utils::{insert_use, ImportScope},
-    AssistContext, AssistId, AssistKind, Assists,
-};
+use crate::{AssistContext, AssistId, AssistKind, Assists};
 
 // Assist: replace_qualified_name_with_use
 //