5 files changed, 380 insertions, 12 deletions

diff --git a/crates/ide_assists/Cargo.toml b/crates/ide_assists/Cargo.toml
index dd9aa27c6..a83acb191 100644
--- a/crates/ide_assists/Cargo.toml
+++ b/crates/ide_assists/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2018"
 doctest = false
 
 [dependencies]
-cov-mark = "1.1"
+cov-mark = { version = "1.1", features = ["thread-local"] }
 rustc-hash = "1.1.0"
 itertools = "0.10.0"
 either = "1.6.1"
diff --git a/crates/ide_assists/src/handlers/apply_demorgan.rs b/crates/ide_assists/src/handlers/apply_demorgan.rs
index a1c339603..5c936a510 100644
--- a/crates/ide_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ide_assists/src/handlers/apply_demorgan.rs
@@ -1,3 +1,5 @@
+use std::collections::VecDeque;
+
 use syntax::ast::{self, AstNode};
 
 use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKind, Assists};
@@ -30,19 +32,52 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
         return None;
     }
 
-    let lhs = expr.lhs()?;
-    let lhs_range = lhs.syntax().text_range();
-    let not_lhs = invert_boolean_expression(&ctx.sema, lhs);
+    let mut expr = expr;
+
+    // Walk up the tree while we have the same binary operator
+    while let Some(parent_expr) = expr.syntax().parent().and_then(ast::BinExpr::cast) {
+        if let Some(parent_op) = expr.op_kind() {
+            if parent_op == op {
+                expr = parent_expr
+            }
+        }
+    }
+
+    let mut expr_stack = vec![expr.clone()];
+    let mut terms = Vec::new();
+    let mut op_ranges = Vec::new();
+
+    // Find all the children with the same binary operator
+    while let Some(expr) = expr_stack.pop() {
+        let mut traverse_bin_expr_arm = |expr| {
+            if let ast::Expr::BinExpr(bin_expr) = expr {
+                if let Some(expr_op) = bin_expr.op_kind() {
+                    if expr_op == op {
+                        expr_stack.push(bin_expr);
+                    } else {
+                        terms.push(ast::Expr::BinExpr(bin_expr));
+                    }
+                } else {
+                    terms.push(ast::Expr::BinExpr(bin_expr));
+                }
+            } else {
+                terms.push(expr);
+            }
+        };
 
-    let rhs = expr.rhs()?;
-    let rhs_range = rhs.syntax().text_range();
-    let not_rhs = invert_boolean_expression(&ctx.sema, rhs);
+        op_ranges.extend(expr.op_token().map(|t| t.text_range()));
+        traverse_bin_expr_arm(expr.lhs()?);
+        traverse_bin_expr_arm(expr.rhs()?);
+    }
 
     acc.add(
         AssistId("apply_demorgan", AssistKind::RefactorRewrite),
         "Apply De Morgan's law",
         op_range,
         |edit| {
+            terms.sort_by_key(|t| t.syntax().text_range().start());
+            let mut terms = VecDeque::from(terms);
+
             let paren_expr = expr.syntax().parent().and_then(|parent| ast::ParenExpr::cast(parent));
 
             let neg_expr = paren_expr
@@ -57,11 +92,18 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
                     }
                 });
 
-            edit.replace(op_range, opposite_op);
+            for op_range in op_ranges {
+                edit.replace(op_range, opposite_op);
+            }
 
             if let Some(paren_expr) = paren_expr {
-                edit.replace(lhs_range, not_lhs.syntax().text());
-                edit.replace(rhs_range, not_rhs.syntax().text());
+                for term in terms {
+                    let range = term.syntax().text_range();
+                    let not_term = invert_boolean_expression(&ctx.sema, term);
+
+                    edit.replace(range, not_term.syntax().text());
+                }
+
                 if let Some(neg_expr) = neg_expr {
                     cov_mark::hit!(demorgan_double_negation);
                     edit.replace(neg_expr.op_token().unwrap().text_range(), "");
@@ -70,8 +112,25 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
                     edit.replace(paren_expr.l_paren_token().unwrap().text_range(), "!(");
                 }
             } else {
-                edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
-                edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+                if let Some(lhs) = terms.pop_front() {
+                    let lhs_range = lhs.syntax().text_range();
+                    let not_lhs = invert_boolean_expression(&ctx.sema, lhs);
+
+                    edit.replace(lhs_range, format!("!({}", not_lhs.syntax().text()));
+                }
+
+                if let Some(rhs) = terms.pop_back() {
+                    let rhs_range = rhs.syntax().text_range();
+                    let not_rhs = invert_boolean_expression(&ctx.sema, rhs);
+
+                    edit.replace(rhs_range, format!("{})", not_rhs.syntax().text()));
+                }
+
+                for term in terms {
+                    let term_range = term.syntax().text_range();
+                    let not_term = invert_boolean_expression(&ctx.sema, term);
+                    edit.replace(term_range, not_term.syntax().text());
+                }
             }
         },
     )
@@ -180,6 +239,12 @@ fn f() {
     }
 
     #[test]
+    fn demorgan_multiple_terms() {
+        check_assist(apply_demorgan, "fn f() { x ||$0 y || z }", "fn f() { !(!x && !y && !z) }");
+        check_assist(apply_demorgan, "fn f() { x || y ||$0 z }", "fn f() { !(!x && !y && !z) }");
+    }
+
+    #[test]
     fn demorgan_doesnt_apply_with_cursor_not_on_op() {
         check_assist_not_applicable(apply_demorgan, "fn f() { $0 !x || !x }")
     }
diff --git a/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
new file mode 100644
index 000000000..b8834d283
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
@@ -0,0 +1,272 @@
+use hir::{known, HasSource, Name};
+use syntax::{
+    ast::{self, NameOwner},
+    AstNode,
+};
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+
+// Assist: generate_is_empty_from_len
+//
+// Generates is_empty implementation from the len method.
+//
+// ```
+// struct MyStruct { data: Vec<String> }
+//
+// impl MyStruct {
+//     p$0ub fn len(&self) -> usize {
+//         self.data.len()
+//     }
+// }
+// ```
+// ->
+// ```
+// struct MyStruct { data: Vec<String> }
+//
+// impl MyStruct {
+//     pub fn len(&self) -> usize {
+//         self.data.len()
+//     }
+//
+//     pub fn is_empty(&self) -> bool {
+//         self.len() == 0
+//     }
+// }
+// ```
+pub(crate) fn generate_is_empty_from_len(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let fn_node = ctx.find_node_at_offset::<ast::Fn>()?;
+    let fn_name = fn_node.name()?;
+
+    if fn_name.text() != "len" {
+        cov_mark::hit!(len_function_not_present);
+        return None;
+    }
+
+    if fn_node.param_list()?.params().next().is_some() {
+        cov_mark::hit!(len_function_with_parameters);
+        return None;
+    }
+
+    let impl_ = fn_node.syntax().ancestors().find_map(ast::Impl::cast)?;
+    let len_fn = get_impl_method(ctx, &impl_, &known::len)?;
+    if !len_fn.ret_type(ctx.sema.db).is_usize() {
+        cov_mark::hit!(len_fn_different_return_type);
+        return None;
+    }
+
+    if get_impl_method(ctx, &impl_, &known::is_empty).is_some() {
+        cov_mark::hit!(is_empty_already_implemented);
+        return None;
+    }
+
+    let node = len_fn.source(ctx.sema.db)?;
+    let range = node.syntax().value.text_range();
+
+    acc.add(
+        AssistId("generate_is_empty_from_len", AssistKind::Generate),
+        "Generate a is_empty impl from a len function",
+        range,
+        |builder| {
+            let code = r#"
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }"#
+            .to_string();
+            builder.insert(range.end(), code)
+        },
+    )
+}
+
+fn get_impl_method(
+    ctx: &AssistContext,
+    impl_: &ast::Impl,
+    fn_name: &Name,
+) -> Option<hir::Function> {
+    let db = ctx.sema.db;
+    let impl_def: hir::Impl = ctx.sema.to_def(impl_)?;
+
+    let scope = ctx.sema.scope(impl_.syntax());
+    let krate = impl_def.module(db).krate();
+    let ty = impl_def.target_ty(db);
+    let traits_in_scope = scope.traits_in_scope();
+    ty.iterate_method_candidates(db, krate, &traits_in_scope, Some(fn_name), |_, func| Some(func))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn len_function_not_present() {
+        cov_mark::check!(len_function_not_present);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn test(&self) -> usize {
+            self.data.len()
+        }
+    }
+"#,
+        );
+    }
+
+    #[test]
+    fn len_function_with_parameters() {
+        cov_mark::check!(len_function_with_parameters);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self, _i: bool) -> usize {
+        self.data.len()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn is_empty_already_implemented() {
+        cov_mark::check!(is_empty_already_implemented);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn len_fn_different_return_type() {
+        cov_mark::check!(len_fn_different_return_type);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> u32 {
+        self.data.len()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_is_empty() {
+        check_assist(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+"#,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiple_functions_in_impl() {
+        check_assist(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn new() -> Self {
+        Self { data: 0 }
+    }
+
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn work(&self) -> Option<usize> {
+
+    }
+}
+"#,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn new() -> Self {
+        Self { data: 0 }
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn work(&self) -> Option<usize> {
+
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiple_impls() {
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+
+impl MyStruct {
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index f1aab74d4..8c068a6c0 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -129,6 +129,7 @@ mod handlers {
     mod flip_trait_bound;
     mod generate_default_from_enum_variant;
     mod generate_default_from_new;
+    mod generate_is_empty_from_len;
     mod generate_derive;
     mod generate_enum_is_method;
     mod generate_enum_projection_method;
@@ -193,6 +194,7 @@ mod handlers {
             flip_trait_bound::flip_trait_bound,
             generate_default_from_enum_variant::generate_default_from_enum_variant,
             generate_default_from_new::generate_default_from_new,
+            generate_is_empty_from_len::generate_is_empty_from_len,
             generate_derive::generate_derive,
             generate_enum_is_method::generate_enum_is_method,
             generate_enum_projection_method::generate_enum_as_method,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 3f77edd8d..736027ff0 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -722,6 +722,35 @@ impl<T: Clone> Ctx<T> {
 }
 
 #[test]
+fn doctest_generate_is_empty_from_len() {
+    check_doc_test(
+        "generate_is_empty_from_len",
+        r#####"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+"#####,
+        r#####"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_generate_new() {
     check_doc_test(
         "generate_new",