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 cc996b01e77..62062cf7931 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties @@ -216,20 +216,8 @@ fold.if.to.call=Replace 'if' expression with method call fold.if.to.call.family=Replace 'if' Expression with Method Call fold.when.to.call=Replace 'when' expression with method call fold.when.to.call.family=Replace 'when' Expression with Method Call -unfold.assignment.to.if=Replace assignment with 'if' expression -unfold.assignment.to.if.family=Replace Assignment with 'if' Expression -unfold.property.to.if=Replace property initializer with 'if' expression -unfold.property.to.if.family=Replace Property Initializer with 'if' Expression -unfold.return.to.if=Replace return with 'if' expression -unfold.return.to.if.family=Replace Return with 'if' Expression unfold.call.to.if=Replace method call with 'if' expression unfold.call.to.if.family=Replace Method Call with 'if' Expression -unfold.assignment.to.when=Replace assignment with 'when' expression -unfold.assignment.to.when.family=Replace Assignment with 'when' Expression -unfold.property.to.when=Replace property initializer with 'when' expression -unfold.property.to.when.family=Replace Property Initializer with 'when' Expression -unfold.return.to.when=Replace return with 'when' expression -unfold.return.to.when.family=Replace Return with 'when' Expression unfold.call.to.when=Replace method call with 'when' expression unfold.call.to.when.family=Replace Method Call with 'when' Expression if.then.to.double.bang=Replace 'if' expression with '!!' expression diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt index 392c7271269..fd9c3dd2f9c 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/BranchedUnfoldingUtils.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.idea.intentions.branchedTransformations import com.intellij.openapi.editor.Editor import org.jetbrains.kotlin.idea.intentions.declarations.DeclarationUtils -import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.psi.* public object BranchedUnfoldingUtils { @@ -27,44 +26,6 @@ public object BranchedUnfoldingUtils { return JetPsiUtil.getOutermostLastBlockElement(expression, JetPsiUtil.ANY_JET_ELEMENT) as JetExpression } - public fun getUnfoldableExpressionKind(root: JetExpression?): UnfoldableKind? { - if (root == null) return null - - when (root) { - is JetBinaryExpression -> { - if (root.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return null - if (root.getLeft() == null) return null - - val rhs = root.getRight() - if (rhs is JetIfExpression) return UnfoldableKind.ASSIGNMENT_TO_IF - if (rhs is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(rhs)) { - return UnfoldableKind.ASSIGNMENT_TO_WHEN - } - } - - is JetReturnExpression -> { - val resultExpr = root.getReturnedExpression() - if (resultExpr is JetIfExpression) return UnfoldableKind.RETURN_TO_IF - if (resultExpr is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(resultExpr)) { - return UnfoldableKind.RETURN_TO_WHEN - } - } - - is JetProperty -> { - if (!root.isLocal()) return null - - val initializer = root.getInitializer() - - if (initializer is JetIfExpression) return UnfoldableKind.PROPERTY_TO_IF - if (initializer is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(initializer)) { - return UnfoldableKind.PROPERTY_TO_WHEN - } - } - } - - return null - } - public val UNFOLD_WITHOUT_CHECK: String = "Expression must be checked before unfolding" private fun assertNotNull(value: Any?) { diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/Transformer.java b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/Transformer.java deleted file mode 100644 index 375d7072843..00000000000 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/Transformer.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.idea.intentions.branchedTransformations; - -import com.intellij.openapi.editor.Editor; -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.psi.JetFile; - -public interface Transformer { - @NotNull - String getKey(); - void transform(@NotNull PsiElement element, @NotNull Editor editor, @NotNull JetFile file); -} diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/UnfoldableKind.java b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/UnfoldableKind.java deleted file mode 100644 index e8f4758d9aa..00000000000 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/UnfoldableKind.java +++ /dev/null @@ -1,76 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.idea.intentions.branchedTransformations; - -import com.intellij.openapi.editor.Editor; -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.psi.JetBinaryExpression; -import org.jetbrains.kotlin.psi.JetFile; -import org.jetbrains.kotlin.psi.JetProperty; -import org.jetbrains.kotlin.psi.JetReturnExpression; - -public enum UnfoldableKind implements Transformer { - ASSIGNMENT_TO_IF("unfold.assignment.to.if") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldAssignmentToIf((JetBinaryExpression) element, editor); - } - }, - PROPERTY_TO_IF("unfold.property.to.if") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldPropertyToIf((JetProperty) element, editor); - } - }, - RETURN_TO_IF("unfold.return.to.if") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldReturnToIf((JetReturnExpression) element); - } - }, - ASSIGNMENT_TO_WHEN("unfold.assignment.to.when") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldAssignmentToWhen((JetBinaryExpression) element, editor); - } - }, - PROPERTY_TO_WHEN("unfold.property.to.when") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldPropertyToWhen((JetProperty) element, editor); - } - }, - RETURN_TO_WHEN("unfold.return.to.when") { - @Override - public void transform(@NotNull PsiElement element, @NotNull Editor editor, JetFile file) { - BranchedUnfoldingUtils.INSTANCE$.unfoldReturnToWhen((JetReturnExpression) element); - } - }; - - private final String key; - - private UnfoldableKind(String key) { - this.key = key; - } - - @NotNull - @Override - public String getKey() { - return key; - } -} diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.kt index 4cea3b64312..69801ee1f57 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/UnfoldBranchedExpressionIntention.kt @@ -19,42 +19,74 @@ package org.jetbrains.kotlin.idea.intentions.branchedTransformations.intentions import com.intellij.openapi.editor.Editor import org.jetbrains.kotlin.idea.intentions.JetSelfTargetingOffsetIndependentIntention import org.jetbrains.kotlin.idea.intentions.branchedTransformations.BranchedUnfoldingUtils -import org.jetbrains.kotlin.idea.intentions.branchedTransformations.UnfoldableKind +import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.psi.* -public open class UnfoldBranchedExpressionIntention( - val kind: UnfoldableKind, elementType: Class -) : JetSelfTargetingOffsetIndependentIntention(kind.getKey(), elementType) { - override fun isApplicableTo(element: T): Boolean = BranchedUnfoldingUtils.getUnfoldableExpressionKind(element) == kind +public class UnfoldAssignmentToIfIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace assignment with 'if' expression") { + override fun isApplicableTo(element: JetBinaryExpression): Boolean { + if (element.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return false + if (element.getLeft() == null) return false + return element.getRight() is JetIfExpression + } - override fun applyTo(element: T, editor: Editor) { - val file = element.getContainingFile() - if (file is JetFile) { - kind.transform(element, editor, file) - } + override fun applyTo(element: JetBinaryExpression, editor: Editor) { + BranchedUnfoldingUtils.unfoldAssignmentToIf(element, editor) } } -public class UnfoldAssignmentToIfIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.ASSIGNMENT_TO_IF, javaClass() -) +public class UnfoldPropertyToIfIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace property initializer with 'if' expression") { + override fun isApplicableTo(element: JetProperty): Boolean { + if (!element.isLocal()) return false + return element.getInitializer() is JetIfExpression + } -public class UnfoldPropertyToIfIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.PROPERTY_TO_IF, javaClass() -) + override fun applyTo(element: JetProperty, editor: Editor) { + BranchedUnfoldingUtils.unfoldPropertyToIf(element, editor) + } +} -public class UnfoldAssignmentToWhenIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.ASSIGNMENT_TO_WHEN, javaClass() -) +public class UnfoldAssignmentToWhenIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace assignment with 'when' expression" ) { + override fun isApplicableTo(element: JetBinaryExpression): Boolean { + if (element.getOperationToken() !in JetTokens.ALL_ASSIGNMENTS) return false + if (element.getLeft() == null) return false + val right = element.getRight() + return right is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(right) + } -public class UnfoldPropertyToWhenIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.PROPERTY_TO_WHEN, javaClass() -) + override fun applyTo(element: JetBinaryExpression, editor: Editor) { + BranchedUnfoldingUtils.unfoldAssignmentToWhen(element, editor) + } +} -public class UnfoldReturnToIfIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.RETURN_TO_IF, javaClass() -) +public class UnfoldPropertyToWhenIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace property initializer with 'when' expression") { + override fun isApplicableTo(element: JetProperty): Boolean { + if (!element.isLocal()) return false + val initializer = element.getInitializer() + return initializer is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(initializer) + } -public class UnfoldReturnToWhenIntention : UnfoldBranchedExpressionIntention( - UnfoldableKind.RETURN_TO_WHEN, javaClass() -) + override fun applyTo(element: JetProperty, editor: Editor) { + BranchedUnfoldingUtils.unfoldPropertyToWhen(element, editor) + } +} + +public class UnfoldReturnToIfIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace return with 'if' expression") { + override fun isApplicableTo(element: JetReturnExpression): Boolean { + return element.getReturnedExpression() is JetIfExpression + } + + override fun applyTo(element: JetReturnExpression, editor: Editor) { + BranchedUnfoldingUtils.unfoldReturnToIf(element) + } +} + +public class UnfoldReturnToWhenIntention : JetSelfTargetingOffsetIndependentIntention(javaClass(), "Replace return with 'when' expression") { + override fun isApplicableTo(element: JetReturnExpression): Boolean { + val expr = element.getReturnedExpression() + return expr is JetWhenExpression && JetPsiUtil.checkWhenExpressionHasSingleElse(expr) + } + + override fun applyTo(element: JetReturnExpression, editor: Editor) { + BranchedUnfoldingUtils.unfoldReturnToWhen(element) + } +}