diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.java b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.java deleted file mode 100644 index b01d4678138..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.java +++ /dev/null @@ -1,162 +0,0 @@ -package org.jetbrains.jet.plugin.intentions.branchedTransformations; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lexer.JetTokens; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -import static org.jetbrains.jet.lang.psi.JetPsiUnparsingUtils.*; - -public class IfWhenUtils { - - public static final String TRANSFORM_WITHOUT_CHECK = - "Expression must be checked before applying transformation"; - - private IfWhenUtils() { - } - - public static boolean checkIfToWhen(@NotNull JetIfExpression ifExpression) { - return ifExpression.getThen() != null; - } - - public static boolean checkWhenToIf(@NotNull JetWhenExpression whenExpression) { - return !whenExpression.getEntries().isEmpty(); - } - - private static void assertNotNull(JetExpression expression) { - assert expression != null : TRANSFORM_WITHOUT_CHECK; - } - - private static List splitExpressionToOrBranches(@Nullable JetExpression expression) { - if (expression == null) return Collections.emptyList(); - - final List branches = new ArrayList(); - - expression.accept( - new JetVisitorVoid() { - @Override - public void visitBinaryExpression(JetBinaryExpression expression) { - if (expression.getOperationToken() == JetTokens.OROR) { - JetExpression left = expression.getLeft(); - JetExpression right = expression.getRight(); - - if (left != null) { - left.accept(this); - } - - if (right != null) { - right.accept(this); - } - } else { - visitExpression(expression); - } - } - - @Override - public void visitParenthesizedExpression(JetParenthesizedExpression expression) { - JetExpression baseExpression = expression.getExpression(); - - if (baseExpression != null) { - baseExpression.accept(this); - } - } - - @Override - public void visitExpression(JetExpression expression) { - branches.add(expression); - } - } - ); - - return branches; - } - - public static void transformIfToWhen(@NotNull JetIfExpression ifExpression) { - JetPsiFactory.WhenBuilder builder = new JetPsiFactory.WhenBuilder(); - - JetIfExpression currIfExpression = ifExpression; - do { - JetExpression condition = currIfExpression.getCondition(); - JetExpression thenBranch = currIfExpression.getThen(); - JetExpression elseBranch = currIfExpression.getElse(); - - assertNotNull(thenBranch); - - List orBranches = splitExpressionToOrBranches(condition); - - if (orBranches.isEmpty()) { - builder.condition(""); - } else { - for (JetExpression orBranch : orBranches) { - builder.condition(orBranch); - } - } - - builder.branchExpression(thenBranch); - - if (elseBranch instanceof JetIfExpression) { - currIfExpression = (JetIfExpression) elseBranch; - } - else { - currIfExpression = null; - if (elseBranch != null) { - builder.elseEntry(elseBranch); - } - } - } while (currIfExpression != null); - - JetWhenExpression whenExpression = builder.toExpression(ifExpression.getProject()); - if (BranchedTransformationsPackage.canIntroduceSubject(whenExpression)) { - whenExpression = BranchedTransformationsPackage.introduceSubject(whenExpression); - } - - ifExpression.replace(whenExpression); - } - - private static String combineWhenConditions(JetWhenCondition[] conditions, JetExpression subject) { - int n = conditions.length; - if (n == 0) return ""; - - JetWhenCondition condition = conditions[0]; - assert condition != null : TRANSFORM_WITHOUT_CHECK; - - StringBuilder sb = new StringBuilder(); - - String text = BranchedTransformationsPackage.toExpressionText(condition, subject); - if (n > 1) { - text = parenthesizeTextIfNeeded(text); - } - sb.append(text); - - for (int i = 1; i < n; i++) { - JetWhenCondition currCondition = conditions[i]; - assert currCondition != null : TRANSFORM_WITHOUT_CHECK; - - sb.append(" || ").append(parenthesizeTextIfNeeded(BranchedTransformationsPackage.toExpressionText(currCondition, subject))); - } - - return sb.toString(); - } - - public static void transformWhenToIf(@NotNull JetWhenExpression whenExpression) { - JetPsiFactory.IfChainBuilder builder = new JetPsiFactory.IfChainBuilder(); - - List entries = whenExpression.getEntries(); - for (JetWhenEntry entry : entries) { - JetExpression branch = entry.getExpression(); - - if (entry.isElse()) { - builder.elseBranch(branch); - } else { - String branchConditionText = combineWhenConditions(entry.getConditions(), whenExpression.getSubjectExpression()); - builder.ifBranch(branchConditionText, JetPsiUtil.getText(branch)); - } - } - - whenExpression.replace(builder.toExpression(whenExpression.getProject())); - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.kt b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.kt new file mode 100644 index 00000000000..5bcec481cf3 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/IfWhenUtils.kt @@ -0,0 +1,123 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.plugin.intentions.branchedTransformations + +import org.jetbrains.annotations.Nullable +import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.lexer.JetTokens +import java.util.ArrayList +import java.util.Collections +import org.jetbrains.jet.lang.psi.JetPsiUnparsingUtils.* + +public fun JetIfExpression.canTransformToWhen(): Boolean = getThen() != null + +public fun JetWhenExpression.canTransformToIf(): Boolean = !getEntries().isEmpty() + +public fun JetIfExpression.transformToWhen() { + fun JetExpression.splitToOrBranches(): List { + val branches = ArrayList() + accept( + object : JetVisitorVoid() { + public override fun visitBinaryExpression(expression: JetBinaryExpression) { + if (expression.getOperationToken() == JetTokens.OROR) { + expression.getLeft()?.accept(this) + expression.getRight()?.accept(this) + } + else { + visitExpression(expression) + } + } + + public override fun visitParenthesizedExpression(expression: JetParenthesizedExpression) { + expression.getExpression()?.accept(this) + } + + public override fun visitExpression(expression: JetExpression) { + branches.add(expression) + } + } + ) + return branches + } + + fun branchIterator(ifExpression: JetIfExpression): Iterator = object: Iterator { + private var expression: JetIfExpression? = ifExpression + + override fun next(): JetIfExpression { + val current = expression!! + expression = current.getElse()?.let { next -> if (next is JetIfExpression) next else null } + return current + } + + override fun hasNext(): Boolean = expression != null + } + + val builder = JetPsiFactory.WhenBuilder() + branchIterator(this).forEach { ifExpression -> + ifExpression.getCondition()?.let { condition -> + val orBranches = condition.splitToOrBranches() + if (orBranches.isEmpty()) { + builder.condition("") + } + else { + orBranches.forEach { branch -> builder.condition(branch) } + } + } + + builder.branchExpression(ifExpression.getThen()) + + ifExpression.getElse()?.let { elseBranch -> + if (elseBranch !is JetIfExpression) { + builder.elseEntry(elseBranch) + } + } + } + + val whenExpression = builder.toExpression(getProject()).let { whenExpression -> + if (whenExpression.canIntroduceSubject()) whenExpression.introduceSubject() else whenExpression + } + replace(whenExpression) +} + +public fun JetWhenExpression.transformToIf() { + fun combineWhenConditions(conditions: Array, subject: JetExpression?): String { + return when (conditions.size) { + 0 -> "" + 1 -> conditions[0].toExpressionText(subject) + else -> { + conditions + .map { condition -> parenthesizeTextIfNeeded(condition.toExpressionText(subject)) } + .makeString(separator = " || ") + } + } + } + + val builder = JetPsiFactory.IfChainBuilder() + + for (entry in getEntries()) { + val branch = entry.getExpression() + if (entry.isElse()) { + builder.elseBranch(branch) + } + else { + val branchConditionText = combineWhenConditions(entry.getConditions(), getSubjectExpression()) + builder.ifBranch(branchConditionText, JetPsiUtil.getText(branch)) + } + } + + replace(builder.toExpression(getProject())) +} diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.kt index 6989b683b79..e9520acd9d7 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/IfToWhenIntention.kt @@ -17,15 +17,15 @@ package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention -import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils import org.jetbrains.jet.lang.psi.JetWhenExpression import org.jetbrains.jet.lang.psi.JetIfExpression import com.intellij.openapi.editor.Editor +import org.jetbrains.jet.plugin.intentions.branchedTransformations.* public class IfToWhenIntention : JetSelfTargetingIntention("if.to.when", javaClass()) { - override fun isApplicableTo(element: JetIfExpression): Boolean = IfWhenUtils.checkIfToWhen(element) + override fun isApplicableTo(element: JetIfExpression): Boolean = element.canTransformToWhen() override fun applyTo(element: JetIfExpression, editor: Editor) { - IfWhenUtils.transformIfToWhen(element) + element.transformToWhen() } } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.kt b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.kt index eb0242058a1..09f9e67263f 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.kt +++ b/idea/src/org/jetbrains/jet/plugin/intentions/branchedTransformations/intentions/WhenToIfIntention.kt @@ -17,15 +17,15 @@ package org.jetbrains.jet.plugin.intentions.branchedTransformations.intentions import org.jetbrains.jet.plugin.intentions.JetSelfTargetingIntention -import org.jetbrains.jet.plugin.intentions.branchedTransformations.IfWhenUtils import org.jetbrains.jet.lang.psi.JetWhenExpression import org.jetbrains.jet.lang.psi.JetIfExpression import com.intellij.openapi.editor.Editor +import org.jetbrains.jet.plugin.intentions.branchedTransformations.* public class WhenToIfIntention : JetSelfTargetingIntention("if.to.when", javaClass()) { - override fun isApplicableTo(element: JetWhenExpression): Boolean = IfWhenUtils.checkWhenToIf(element) + override fun isApplicableTo(element: JetWhenExpression): Boolean = element.canTransformToIf() override fun applyTo(element: JetWhenExpression, editor: Editor) { - IfWhenUtils.transformWhenToIf(element) + element.transformToIf() } }