Code simplifications

idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties

@@ -315,12 +315,6 @@ move.lambda.outside.parentheses=Move lambda expression out of parentheses
 move.lambda.outside.parentheses.family=Move Lambda Expression out of Parentheses
 replace.it.with.explicit.function.literal.param=Replace 'it' with explicit parameter
 replace.it.with.explicit.function.literal.param.family=Replace 'it' with Explicit Parameter
-convert.negated.boolean.sequence=Replace negated sequence with DeMorgan equivalent
-convert.negated.boolean.sequence.family=Replace Negated Sequence with DeMorgan Equivalent
-convert.negated.expression.with.demorgans.law=DeMorgan Law
-convert.negated.expression.with.demorgans.law.andToOr=Replace '\\&\\&' with '||'
-convert.negated.expression.with.demorgans.law.orToAnd=Replace '||' with '\\&\\&'
-convert.negated.expression.with.demorgans.law.family=DeMorgan Law
 split.if=Split into 2 if's
 split.if.family=Split If
 replace.with.operator.assign.intention=Replace with an operator-assign expression

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt

@@ -16,36 +16,29 @@
 
 package org.jetbrains.kotlin.idea.intentions
 
-import org.jetbrains.kotlin.psi.JetBinaryExpression
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetPrefixExpression
+import org.jetbrains.kotlin.lexer.JetSingleValueToken
 import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression
-import org.jetbrains.kotlin.psi.JetPsiUtil
+import org.jetbrains.kotlin.psi.*
 import java.util.LinkedList
 
 
 public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingOffsetIndependentIntention<JetBinaryExpression>(
-        "convert.negated.boolean.sequence", javaClass()) {
+        javaClass(), "Replace negated sequence with DeMorgan equivalent") {
 
     override fun isApplicableTo(element: JetBinaryExpression): Boolean {
         if (element.getParent() is JetBinaryExpression) return false // operate only on the longest sequence
-        val originalOperator = element.getOperationToken()
-
-        if (!(originalOperator == JetTokens.ANDAND || originalOperator == JetTokens.OROR)) {
-            return false
-        }
+        val opToken = element.getOperationToken()
+        if (opToken != JetTokens.ANDAND && opToken != JetTokens.OROR) return false
 
         return splitBooleanSequence(element) != null
     }
 
     override fun applyTo(element: JetBinaryExpression, editor: Editor) {
-        val operator = element.getOperationToken()
-        val operatorText = when(operator) {
+        val operatorText = when(element.getOperationToken()) {
             JetTokens.ANDAND -> JetTokens.OROR.getValue()
             JetTokens.OROR -> JetTokens.ANDAND.getValue()
-            else -> throw IllegalArgumentException("Invalid operator: '$operator'. Only expressions using '&&' or '||' can be converted.")
+            else -> throw IllegalArgumentException()
         }
 
         val elements = splitBooleanSequence(element)!!
@@ -64,22 +57,21 @@ public class ConvertNegatedBooleanSequenceIntention : JetSelfTargetingOffsetInde
         }
     }
 
-    fun splitBooleanSequence(expression: JetBinaryExpression): List<JetPrefixExpression>? {
+    private fun splitBooleanSequence(expression: JetBinaryExpression): List<JetPrefixExpression>? {
         val itemList = LinkedList<JetPrefixExpression>()
         val firstOperator = expression.getOperationToken()
-        var currentItem: JetBinaryExpression? = expression
 
+        var currentItem: JetBinaryExpression? = expression
         while (currentItem != null) {
             if (currentItem!!.getOperationToken() != firstOperator) return null //Boolean sequence must be homogenous
 
             val rightChild = currentItem!!.getRight() as? JetPrefixExpression ?: return null
             itemList.add(rightChild)
+
             val leftChild = currentItem!!.getLeft()
-            if (leftChild is JetPrefixExpression) {
-                itemList.add(leftChild as JetPrefixExpression)
-            }
-            else if (leftChild !is JetBinaryExpression) {
-                return null
+            when (leftChild) {
+                is JetPrefixExpression -> itemList.add(leftChild)
+                !is JetBinaryExpression -> return null
             }
 
             currentItem = leftChild as? JetBinaryExpression

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt

@@ -16,22 +16,14 @@
 
 package org.jetbrains.kotlin.idea.intentions
 
-import org.jetbrains.kotlin.psi.JetParenthesizedExpression
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetBinaryExpression
-import org.jetbrains.kotlin.lexer.JetTokens
-import org.jetbrains.kotlin.psi.JetPrefixExpression
-import org.jetbrains.kotlin.psi.JetPsiFactory
 import com.intellij.psi.impl.source.tree.PsiErrorElementImpl
-import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.psi.JetConstantExpression
-import org.jetbrains.kotlin.psi.JetSimpleNameExpression
+import org.jetbrains.kotlin.lexer.JetTokens
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.LinkedList
-import org.jetbrains.kotlin.idea.JetBundle
 
-public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingOffsetIndependentIntention<JetPrefixExpression>(
-        "convert.negated.expression.with.demorgans.law", javaClass()
-) {
+public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingOffsetIndependentIntention<JetPrefixExpression>(javaClass(), "DeMorgan Law") {
 
     override fun isApplicableTo(element: JetPrefixExpression): Boolean {
         val prefixOperator = element.getOperationReference().getReferencedNameElementType()
@@ -41,46 +33,47 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
         val baseExpression = parenthesizedExpression?.getExpression() as? JetBinaryExpression ?: return false
 
         when (baseExpression.getOperationToken()) {
-            JetTokens.ANDAND -> setText(JetBundle.message("convert.negated.expression.with.demorgans.law.andToOr"))
-            JetTokens.OROR -> setText(JetBundle.message("convert.negated.expression.with.demorgans.law.orToAnd"))
+            JetTokens.ANDAND -> setText("Replace '&&' with '||'")
+            JetTokens.OROR -> setText("Replace '||' with '&&'")
             else -> return false
         }
 
         val elements = splitBooleanSequence(baseExpression) ?: return false
-        return !(elements.any { x -> x is PsiErrorElementImpl })
+        return elements.none { it is PsiErrorElementImpl }
     }
 
     override fun applyTo(element: JetPrefixExpression, editor: Editor) {
         val parenthesizedExpression = element.getBaseExpression() as JetParenthesizedExpression
         val baseExpression = parenthesizedExpression.getExpression() as JetBinaryExpression
+
         val operatorText = when (baseExpression.getOperationToken()) {
             JetTokens.ANDAND -> JetTokens.OROR.getValue()
             JetTokens.OROR -> JetTokens.ANDAND.getValue()
-            else -> throw IllegalArgumentException(
-                    "Invalid operator: '${baseExpression.getOperationToken()}'. Only expressions using '&&' or '||' can be converted.")
+            else -> throw IllegalArgumentException()
         }
-        val elements = splitBooleanSequence(baseExpression)
-        val negatedElements = elements!!.map { exp -> handleSpecial(exp) }
-        val negatedExpression = negatedElements.subList(0, negatedElements.lastIndex).foldRight(
-                "${negatedElements.last()}", { negated, exp -> "$exp $operatorText $negated" })
 
-        val newExpression = JetPsiFactory(element).createExpression(negatedExpression)
+        val text = splitBooleanSequence(baseExpression)!!
+                .map { negatedExpressionText(it) }
+                .reverse()
+                .joinToString(operatorText)
+
+        val newExpression = JetPsiFactory(element).createExpression(text)
         element.replace(newExpression)
     }
 
-    fun handleSpecial(expression: JetExpression): String {
+    private fun negatedExpressionText(expression: JetExpression): String {
+        val text = expression.getText()
         return when (expression) {
-            is JetSimpleNameExpression, is JetConstantExpression, is JetPrefixExpression,
-            is JetParenthesizedExpression -> "!${expression.getText()}"
-            else -> "!(${expression.getText()})"
+            is JetSimpleNameExpression, is JetConstantExpression, is JetPrefixExpression, is JetParenthesizedExpression -> "!$text"
+            else -> "!($text)"
         }
     }
 
-    fun splitBooleanSequence(expression: JetBinaryExpression): List<JetExpression>? {
-        val itemList = LinkedList<JetExpression>()
+    private fun splitBooleanSequence(expression: JetBinaryExpression): List<JetExpression>? {
+        val result = LinkedList<JetExpression>()
         val firstOperator = expression.getOperationToken()
-        var currentItem: JetExpression? = expression
 
+        var currentItem: JetExpression? = expression
         while (currentItem as? JetBinaryExpression != null) {
             val remainingExpression = currentItem as JetBinaryExpression
             val operation = remainingExpression.getOperationToken()
@@ -90,12 +83,12 @@ public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetin
 
             val leftChild = remainingExpression.getLeft()
             val rightChild = remainingExpression.getRight()
-            itemList.add(rightChild as JetExpression)
+            result.add(rightChild)
             currentItem = leftChild
         }
 
-        if (currentItem != null) itemList.add(currentItem!!)
-        return itemList
+        result.addIfNotNull(currentItem)
+        return result
     }
 
 }