3 files changed, 80 insertions, 62 deletions

diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index ea722b91b..91e2f5c8c 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -69,6 +69,15 @@ mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     #[test]
+    fn invert_if_composite_condition() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f x == 3 || x == 4 || x == 5 { 1 } else { 3 * 2 } }",
+            "fn f() { if !(x == 3 || x == 4 || x == 5) { 3 * 2 } else { 1 } }",
+        )
+    }
+
+    #[test]
     fn invert_if_remove_inequality() {
         check_assist(
             invert_if,
diff --git a/crates/assists/src/handlers/reorder_fields.rs b/crates/assists/src/handlers/reorder_fields.rs
index 7c0f0f44e..fe5574242 100644
--- a/crates/assists/src/handlers/reorder_fields.rs
+++ b/crates/assists/src/handlers/reorder_fields.rs
@@ -4,6 +4,7 @@ use rustc_hash::FxHashMap;
 use hir::{Adt, ModuleDef, PathResolution, Semantics, Struct};
 use ide_db::RootDatabase;
 use syntax::{algo, ast, match_ast, AstNode, SyntaxKind, SyntaxKind::*, SyntaxNode};
+use test_utils::mark;
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -38,6 +39,7 @@ fn reorder<R: AstNode>(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     });
 
     if sorted_fields == fields {
+        mark::hit!(reorder_sorted_fields);
         return None;
     }
 
@@ -107,22 +109,25 @@ fn compute_fields_ranks(path: &ast::Path, ctx: &AssistContext) -> Option<FxHashM
 
 #[cfg(test)]
 mod tests {
+    use test_utils::mark;
+
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
     #[test]
-    fn not_applicable_if_sorted() {
+    fn reorder_sorted_fields() {
+        mark::check!(reorder_sorted_fields);
         check_assist_not_applicable(
             reorder_fields,
             r#"
-        struct Foo {
-            foo: i32,
-            bar: i32,
-        }
+struct Foo {
+    foo: i32,
+    bar: i32,
+}
 
-        const test: Foo = <|>Foo { foo: 0, bar: 0 };
-        "#,
+const test: Foo = <|>Foo { foo: 0, bar: 0 };
+"#,
         )
     }
 
@@ -131,9 +136,9 @@ mod tests {
         check_assist_not_applicable(
             reorder_fields,
             r#"
-        struct Foo {};
-        const test: Foo = <|>Foo {}
-        "#,
+struct Foo {};
+const test: Foo = <|>Foo {}
+"#,
         )
     }
 
@@ -142,13 +147,13 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-        struct Foo {foo: i32, bar: i32};
-        const test: Foo = <|>Foo {bar: 0, foo: 1}
-        "#,
+struct Foo {foo: i32, bar: i32};
+const test: Foo = <|>Foo {bar: 0, foo: 1}
+"#,
             r#"
-        struct Foo {foo: i32, bar: i32};
-        const test: Foo = Foo {foo: 1, bar: 0}
-        "#,
+struct Foo {foo: i32, bar: i32};
+const test: Foo = Foo {foo: 1, bar: 0}
+"#,
         )
     }
 
@@ -157,25 +162,25 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
 
-        fn f(f: Foo) -> {
-            match f {
-                <|>Foo { baz: 0, ref mut bar, .. } => (),
-                _ => ()
-            }
-        }
-        "#,
+fn f(f: Foo) -> {
+    match f {
+        <|>Foo { baz: 0, ref mut bar, .. } => (),
+        _ => ()
+    }
+}
+"#,
             r#"
-        struct Foo { foo: i64, bar: i64, baz: i64 }
+struct Foo { foo: i64, bar: i64, baz: i64 }
 
-        fn f(f: Foo) -> {
-            match f {
-                Foo { ref mut bar, baz: 0, .. } => (),
-                _ => ()
-            }
-        }
-        "#,
+fn f(f: Foo) -> {
+    match f {
+        Foo { ref mut bar, baz: 0, .. } => (),
+        _ => ()
+    }
+}
+"#,
         )
     }
 
@@ -184,39 +189,39 @@ mod tests {
         check_assist(
             reorder_fields,
             r#"
-            struct Foo {
-                foo: String,
-                bar: String,
-            }
+struct Foo {
+    foo: String,
+    bar: String,
+}
 
-            impl Foo {
-                fn new() -> Foo {
-                    let foo = String::new();
-                    <|>Foo {
-                        bar: foo.clone(),
-                        extra: "Extra field",
-                        foo,
-                    }
-                }
-            }
-            "#,
+impl Foo {
+    fn new() -> Foo {
+        let foo = String::new();
+        <|>Foo {
+            bar: foo.clone(),
+            extra: "Extra field",
+            foo,
+        }
+    }
+}
+"#,
             r#"
-            struct Foo {
-                foo: String,
-                bar: String,
-            }
+struct Foo {
+    foo: String,
+    bar: String,
+}
 
-            impl Foo {
-                fn new() -> Foo {
-                    let foo = String::new();
-                    Foo {
-                        foo,
-                        bar: foo.clone(),
-                        extra: "Extra field",
-                    }
-                }
-            }
-            "#,
+impl Foo {
+    fn new() -> Foo {
+        let foo = String::new();
+        Foo {
+            foo,
+            bar: foo.clone(),
+            extra: "Extra field",
+        }
+    }
+}
+"#,
         )
     }
 }
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 01f5c291f..f2cacf7c8 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -212,6 +212,10 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
         ast::Expr::BinExpr(bin) => match bin.op_kind()? {
             ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
             ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()),
+            // Parenthesize composite boolean expressions before prefixing `!`
+            ast::BinOp::BooleanAnd | ast::BinOp::BooleanOr => {
+                Some(make::expr_prefix(T![!], make::expr_paren(expr.clone())))
+            }
             _ => None,
         },
         ast::Expr::MethodCallExpr(mce) => {