From e769a54502648011ede7d7434e0a16a8ab740c56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?L=C3=BAc=C3=A1s=20Meier?= <cronokirby@gmail.com>
Date: Thu, 3 Oct 2019 22:48:35 +0200
Subject: Create an assist for applying De Morgan's law

Fixes #1807

This assist can transform expressions of the form `!x || !y` into
`!(x && y)`. This also works with `&&`.

This assist will only trigger if the cursor is on the central logical
operator.

The main limitation of this current implementation is that both operands
need to be an explicit negation, either of the form `!x`, or `x != y`.
More operands could be accepted, but this would complicate the implementation
quite a bit.
---
 crates/ra_assists/src/assists/apply_demorgan.rs | 115 ++++++++++++++++++++++++
 1 file changed, 115 insertions(+)
 create mode 100644 crates/ra_assists/src/assists/apply_demorgan.rs

(limited to 'crates/ra_assists/src/assists')

diff --git a/crates/ra_assists/src/assists/apply_demorgan.rs b/crates/ra_assists/src/assists/apply_demorgan.rs
new file mode 100644
index 000000000..e4a8657ca
--- /dev/null
+++ b/crates/ra_assists/src/assists/apply_demorgan.rs
@@ -0,0 +1,115 @@
+//! This contains the functions associated with the demorgan assist.
+//! This assist transforms boolean expressions of the form `!a || !b` into
+//! `!(a && b)`.
+use hir::db::HirDatabase;
+use ra_syntax::SyntaxNode;
+use ra_syntax::ast::{AstNode, BinExpr, BinOp, Expr, PrefixOp};
+
+use crate::{Assist, AssistCtx, AssistId};
+
+// Return the opposite text for a given logical operator, if it makes sense
+fn opposite_logic_op(kind: BinOp) -> Option<&'static str> {
+    match kind {
+        BinOp::BooleanOr => Some("&&"),
+        BinOp::BooleanAnd => Some("||"),
+        _ => None,
+    }
+}
+
+// This function tries to undo unary negation, or inequality
+fn undo_negation(node: SyntaxNode) -> Option<String> {
+    match Expr::cast(node)? {
+        Expr::BinExpr(bin) => match bin.op_kind()? {
+            BinOp::NegatedEqualityTest => {
+                let lhs = bin.lhs()?.syntax().text();
+                let rhs = bin.rhs()?.syntax().text();
+                Some(format!("{} == {}", lhs, rhs))
+            }
+            _ => None
+        }
+        Expr::PrefixExpr(pe) => match pe.op_kind()? {
+            PrefixOp::Not => {
+                let child = pe.expr()?.syntax().text();
+                Some(String::from(child))
+            }
+            _ => None
+        }
+        _ => None
+    }
+}
+
+/// Assist for applying demorgan's law
+///
+/// This transforms expressions of the form `!l || !r` into `!(l && r)`.
+/// This also works with `&&`. This assist can only be applied with the cursor
+/// on either `||` or `&&`, with both operands being a negation of some kind.
+/// This means something of the form `!x` or `x != y`.
+pub(crate) fn apply_demorgan(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let expr = ctx.node_at_offset::<BinExpr>()?;
+    let op = expr.op_kind()?;
+    let op_range = expr.op_token()?.text_range();
+    let opposite_op = opposite_logic_op(op)?;
+    let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
+    if !cursor_in_range {
+        return None;
+    }
+    let lhs = expr.lhs()?.syntax().clone();
+    let lhs_range = lhs.text_range();
+    let rhs = expr.rhs()?.syntax().clone();
+    let rhs_range = rhs.text_range();
+    let not_lhs = undo_negation(lhs)?;
+    let not_rhs = undo_negation(rhs)?;
+
+
+    ctx.add_action(AssistId("apply_demorgan"), "apply demorgan's law", |edit| {
+        edit.target(op_range);
+        edit.replace(op_range, opposite_op);
+        edit.replace(lhs_range, format!("!({}", not_lhs));
+        edit.replace(rhs_range, format!("{})", not_rhs));
+    });
+    ctx.build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+
+    #[test]
+    fn demorgan_turns_and_into_or() {
+        check_assist(
+            apply_demorgan,
+            "fn f() { !x &&<|> !x }",
+            "fn f() { !(x ||<|> x) }"
+        )
+    }
+
+    #[test]
+    fn demorgan_turns_or_into_and() {
+        check_assist(
+            apply_demorgan,
+            "fn f() { !x ||<|> !x }",
+            "fn f() { !(x &&<|> x) }"
+        )
+    }
+
+    #[test]
+    fn demorgan_removes_inequality() {
+        check_assist(
+            apply_demorgan,
+            "fn f() { x != x ||<|> !x }",
+            "fn f() { !(x == x &&<|> x) }"
+        )
+    }
+
+    #[test]
+    fn demorgan_doesnt_apply_with_cursor_not_on_op() {
+        check_assist_not_applicable(apply_demorgan, "fn f() { <|> !x || !x }")
+    }
+
+    #[test]
+    fn demorgan_doesnt_apply_when_operands_arent_negated_already() {
+        check_assist_not_applicable(apply_demorgan, "fn f() { x ||<|> x }")
+    }
+}
-- 
cgit v1.2.3