From 960a45e4cc11309912823da0624b52343f295d31 Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Tue, 14 Apr 2015 19:17:35 +0300 Subject: [PATCH] Code simplifications --- .../kotlin/idea/JetBundle.properties | 6 -- .../ConvertNegatedBooleanSequenceIntention.kt | 34 +++++------ ...atedExpressionWithDemorgansLawIntention.kt | 57 ++++++++----------- 3 files changed, 38 insertions(+), 59 deletions(-) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties index cab183931c3..5ed888c1284 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties +++ b/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 diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt index c88082f04b4..5a9404568a4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedBooleanSequenceIntention.kt +++ b/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( - "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? { + private fun splitBooleanSequence(expression: JetBinaryExpression): List? { val itemList = LinkedList() 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 diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt index 0a1cecc49b6..dd87b97cd5d 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertNegatedExpressionWithDemorgansLawIntention.kt +++ b/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( - "convert.negated.expression.with.demorgans.law", javaClass() -) { +public class ConvertNegatedExpressionWithDemorgansLawIntention : JetSelfTargetingOffsetIndependentIntention(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? { - val itemList = LinkedList() + private fun splitBooleanSequence(expression: JetBinaryExpression): List? { + val result = LinkedList() 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 } }