New Intention Action: Invert If Condition

Inverts the conditional expression in an if expression.
2014-05-12 19:39:32 +04:00
parent aa20af3cf3
commit 5550924dc5
35 changed files with 486 additions and 1 deletions
@@ -412,6 +412,7 @@ fun main(args: Array<String>) {
            model("intentions/convertIfToAssert", testMethod = "doTestConvertIfWithThrowToAssertIntention")
            model("intentions/makeTypeExplicitInLambda", testMethod = "doTestMakeTypeExplicitInLambda")
            model("intentions/makeTypeImplicitInLambda", testMethod = "doTestMakeTypeImplicitInLambda")
            model("intentions/invertIfCondition", testMethod = "doTestInvertIfCondition")
            model("intentions/convertToForEachLoop", testMethod = "doTestConvertToForEachLoop")
            model("intentions/convertToForEachFunctionCall", testMethod = "doTestConvertToForEachFunctionCall")
        }
@@ -0,0 +1,5 @@
 if (<spot>foo()</spot>) {
    baz()
 } else {
    bar()
 }
@@ -0,0 +1,5 @@
 if (!foo()) {
    bar()
 } else {
    baz()
 }
@@ -0,0 +1,5 @@
 <html>
 <body>
 This intention inverts the conditional expression in an 'if' expression.
 </body>
 </html>
@@ -741,6 +741,11 @@
        level="WARNING"
        />
    <intentionAction>
      <className>org.jetbrains.jet.plugin.intentions.InvertIfConditionIntention</className>
      <category>Kotlin</category>
    </intentionAction>
    <project.converterProvider implementation="org.jetbrains.jet.plugin.converters.JetRunConfigurationSettingsFormatConverterProvider"/>
  </extensions>
@@ -312,6 +312,8 @@ make.type.explicit.in.lambda=Make types explicit in lambda
 make.type.explicit.in.lambda.family=Make Types Explicit In Lambda
 make.type.implicit.in.lambda=Make types implicit in lambda (may break code)
 make.type.implicit.in.lambda.family=Make Types Implicit In Lambda (May Break Code)
 invert.if.condition=Invert If Condition
 invert.if.condition.family=Invert If Condition
 convert.to.for.each.loop.intention=Replace with a for each loop
 convert.to.for.each.loop.intention.family=Replace with a For Each Loop
 convert.to.for.each.function.call.intention=Replace with a forEach function call
@@ -0,0 +1,170 @@
 /*
 * Copyright 2010-2014 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
 import org.jetbrains.jet.lang.psi.JetIfExpression
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.psi.JetUnaryExpression
 import org.jetbrains.jet.lang.psi.JetBinaryExpression
 import org.jetbrains.jet.lexer.JetTokens
 import org.jetbrains.jet.lexer.JetToken
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.jet.lang.psi.JetConstantExpression
 import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.jet.lang.psi.JetPsiUtil
 import org.jetbrains.jet.lang.psi.JetParenthesizedExpression
 import com.sun.javaws.exceptions.InvalidArgumentException
 import org.jetbrains.jet.lexer.JetSingleValueToken
 import org.jetbrains.jet.lexer.JetKeywordToken
 import org.jetbrains.jet.lang.psi.psiUtil.getParentByType
 import org.jetbrains.jet.lang.psi.JetElement
 import org.jetbrains.jet.lang.psi.JetForExpression
 import org.jetbrains.jet.lang.psi.JetNamedFunction
 import org.jetbrains.jet.lang.psi.JetBlockExpression
 public class InvertIfConditionIntention : JetSelfTargetingIntention<JetIfExpression>("invert.if.condition", javaClass()) {
    fun checkForNegation(element: JetUnaryExpression): Boolean {
        return element.getOperationReference().getReferencedName().equals("!")
    }
    override fun isApplicableTo(element: JetIfExpression): Boolean {
        val condition = element.getCondition()
        val thenBranch = element.getThen()
        return condition != null && thenBranch != null && when (condition) {
            is JetUnaryExpression -> {
                when {
                    checkForNegation(condition) -> {
                        val baseExpression = condition.getBaseExpression()
                        when (baseExpression) {
                            is JetParenthesizedExpression -> baseExpression.getExpression() != null
                            else -> condition.getBaseExpression() != null
                        }
                    }
                    else -> true
                }
            }
            is JetBinaryExpression -> {
                condition.getOperationToken() != null && condition.getLeft() != null && condition.getRight() != null
            }
            else -> true
        }
    }
    override fun applyTo(element: JetIfExpression, editor: Editor) {
        fun isNegatableOperator(token: IElementType): Boolean {
            return token in array(JetTokens.EQEQ, JetTokens.EXCLEQ, JetTokens.EQEQEQ, JetTokens.EXCLEQEQEQ, JetTokens.IS_KEYWORD, JetTokens.NOT_IS, JetTokens.IN_KEYWORD, JetTokens.NOT_IN, JetTokens.LT, JetTokens.LTEQ, JetTokens.GT, JetTokens.GTEQ)
        }
        fun getNegatedOperator(token: IElementType): JetToken {
            return when {
                token == JetTokens.EQEQ -> JetTokens.EXCLEQ
                token == JetTokens.EXCLEQ -> JetTokens.EQEQ
                token == JetTokens.EQEQEQ -> JetTokens.EXCLEQEQEQ
                token == JetTokens.EXCLEQEQEQ -> JetTokens.EQEQEQ
                token == JetTokens.IS_KEYWORD -> JetTokens.NOT_IS
                token == JetTokens.NOT_IS -> JetTokens.IS_KEYWORD
                token == JetTokens.IN_KEYWORD -> JetTokens.NOT_IN
                token == JetTokens.NOT_IN -> JetTokens.IN_KEYWORD
                token == JetTokens.LT -> JetTokens.GTEQ
                token == JetTokens.LTEQ -> JetTokens.GT
                token == JetTokens.GT -> JetTokens.LTEQ
                token == JetTokens.GTEQ -> JetTokens.LT
                else -> throw InvalidArgumentException(array("The token, \"${token.toString()}\", does not have a negated equivalent."))
            }
        }
        fun getTokenText(token: JetToken): String {
            return when (token) {
                is JetSingleValueToken -> token.getValue()
                is JetKeywordToken -> token.getValue()
                else -> throw InvalidArgumentException(array("The token, ${token.toString()}, does not have an applicable string value."))
            }
        }
        fun negateExpressionText(element: JetExpression): String {
            val negatedParenthesizedExpressionText = "!(${element.getText()})"
            val possibleNewExpression = JetPsiFactory.createExpression(element.getProject(), negatedParenthesizedExpressionText) as JetUnaryExpression
            val innerExpression = possibleNewExpression.getBaseExpression() as JetParenthesizedExpression
            return when {
                JetPsiUtil.areParenthesesUseless(innerExpression) -> "!${element.getText()}"
                else -> negatedParenthesizedExpressionText
            }
        }
        fun getNegation(element: JetExpression): JetExpression {
            return JetPsiFactory.createExpression(element.getProject(), when (element) {
                is JetBinaryExpression -> {
                    val operator = element.getOperationToken()!!
                    when {
                        isNegatableOperator(operator) -> "${element.getLeft()!!.getText()} ${getTokenText(getNegatedOperator(operator))} ${element.getRight()!!.getText()}"
                        else -> negateExpressionText(element)
                    }
                }
                is JetConstantExpression -> {
                    when {
                        element.textMatches("true") -> "false"
                        element.textMatches("false") -> "true"
                        else -> negateExpressionText(element)
                    }
                }
                else -> negateExpressionText(element)
            })
        }
        fun removeNegation(element: JetUnaryExpression): JetExpression {
            val baseExpression = element.getBaseExpression()!!
            return when (baseExpression) {
                is JetParenthesizedExpression -> baseExpression.getExpression()!!
                else -> baseExpression
            }
        }
        fun getFinalExpressionOfFunction(element: JetNamedFunction): JetExpression? {
            val body = element.getBodyExpression()
            return when (body) {
                is JetBlockExpression -> body.getStatements().last() as JetExpression
                else -> body
            }
        }
        val condition = element.getCondition()!!
        val replacementCondition = when (condition) {
            is JetUnaryExpression -> {
                when {
                    checkForNegation(condition) -> removeNegation(condition)
                    else -> getNegation(condition)
                }
            }
            else -> getNegation(condition)
        }
        val thenBranch = element.getThen()
        val elseBranch = element.getElse() ?: JetPsiFactory.createEmptyBody(element.getProject())
        element.replace(JetPsiFactory.createIf(element.getProject(), replacementCondition, when (elseBranch) {
            is JetIfExpression -> JetPsiFactory.wrapInABlock(elseBranch)
            else -> elseBranch
        }, if (thenBranch is JetBlockExpression && thenBranch.getStatements().isEmpty()) null else thenBranch))
    }
 }
@@ -0,0 +1,4 @@
 fun main() {
    val a = -1
    val t = <caret>if (a > 0) a else -a
 }
@@ -0,0 +1,4 @@
 fun main() {
    val a = -1
    val t = if (a <= 0) -a else a
 }
@@ -0,0 +1,11 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    <caret>if (foo() && foo()) {
        foo()
    } else {
        foo()
    }
 }
@@ -0,0 +1,11 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    if (!(foo() && foo())) {
        foo()
    } else {
        foo()
    }
 }
@@ -0,0 +1,7 @@
 fun main() {
    <caret>if (true) {
    } else {
    }
 }
@@ -0,0 +1,5 @@
 fun main() {
    if (false) {
    }
 }
@@ -0,0 +1,10 @@
 fun main() {
    val a = 10
    <caret>if (a > 0)
        a
    else if (a < -5)
        a + 1
    else
        a + 2
 }
@@ -0,0 +1,10 @@
 fun main() {
    val a = 10
    if (a <= 0) {
        if (a < -5)
            a + 1
        else
            a + 2
    } else a
 }
@@ -0,0 +1,11 @@
 // WITH_RUNTIME
 fun main() {
    val list = 1..4
    for (x in list) {
        <caret>if (x == 2) {
            list
        }
        list.equals(list)
    }
 }
@@ -0,0 +1,12 @@
 // WITH_RUNTIME
 fun main() {
    val list = 1..4
    for (x in list) {
        if (x != 2) {
        } else {
            list
        }
        list.equals(list)
    }
 }
@@ -0,0 +1,9 @@
 fun foo(): Int {
    val x = 0
    <caret>if (x == 1) {
        x + 1
    }
    return x
 }
@@ -0,0 +1,10 @@
 fun foo(): Int {
    val x = 0
    if (x != 1) {
    } else {
        x + 1
    }
    return x
 }
@@ -0,0 +1,10 @@
 // WITH_RUNTIME
 fun main() {
    val list = 1..4
    for (x in list) {
        <caret>if (x == 2) {
            list
        }
    }
 }
@@ -0,0 +1,11 @@
 // WITH_RUNTIME
 fun main() {
    val list = 1..4
    for (x in list) {
        if (x != 2) {
        } else {
            list
        }
    }
 }
@@ -0,0 +1,8 @@
 fun foo(): Int {
    val x = 0
    <caret>if (x == 1)
        return x + 1
    return 0
 }
@@ -0,0 +1,8 @@
 fun foo(): Int {
    val x = 0
    if (x != 1) {
    } else return x + 1
    return 0
 }
@@ -0,0 +1,5 @@
 fun main() {
    <caret>if (true == false) {
    }
 }
@@ -0,0 +1,4 @@
 fun main() {
    if (true != false) {
    }
 }
@@ -0,0 +1,9 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    <caret>if (!foo()) {
    }
 }
@@ -0,0 +1,8 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    if (foo()) {
    }
 }
@@ -0,0 +1,9 @@
 fun foo(): Int {
    val a = 10
    return <caret>if (a > 0) {
        a
    } else {
        a + 1
    }
 }
@@ -0,0 +1,9 @@
 fun foo(): Int {
    val a = 10
    return if (a <= 0) {
        a + 1
    } else {
        a
    }
 }
@@ -0,0 +1,9 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    <caret>if (foo()) {
    }
 }
@@ -0,0 +1,8 @@
 fun foo(): Boolean {
    return true
 }
 fun main() {
    <caret>if (!foo()) {
    }
 }
@@ -0,0 +1,6 @@
 fun foo(): Int {
    val a = 1
    val t = <caret>if (a > 1) a else return 0
    return t
 }
@@ -0,0 +1,6 @@
 fun foo(): Int {
    val a = 1
    val t = if (a <= 1) return 0 else a
    return t
 }
@@ -258,6 +258,10 @@ public abstract class AbstractCodeTransformationTest extends LightCodeInsightTes
        doTestIntention(path, new SimplifyBooleanWithConstantsIntention());
    }
    public void doTestInvertIfCondition(@NotNull String path) throws Exception {
        doTestIntention(path, new InvertIfConditionIntention());
    }
    public void doTestMakeTypeExplicitInLambda(@NotNull String path) throws Exception {
        doTestIntention(path, new MakeTypeExplicitInLambdaIntention());
    }
@@ -30,7 +30,7 @@ import org.jetbrains.jet.plugin.intentions.AbstractCodeTransformationTest;
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
@SuppressWarnings("all")
-@InnerTestClasses({CodeTransformationTestGenerated.DoubleBangToIfThen.class, CodeTransformationTestGenerated.IfThenToDoubleBang.class, CodeTransformationTestGenerated.ElvisToIfThen.class, CodeTransformationTestGenerated.IfThenToElvis.class, CodeTransformationTestGenerated.SafeAccessToIfThen.class, CodeTransformationTestGenerated.IfThenToSafeAccess.class, CodeTransformationTestGenerated.IfToAssignment.class, CodeTransformationTestGenerated.IfToReturn.class, CodeTransformationTestGenerated.IfToReturnAsymmetrically.class, CodeTransformationTestGenerated.WhenToAssignment.class, CodeTransformationTestGenerated.WhenToReturn.class, CodeTransformationTestGenerated.AssignmentToIf.class, CodeTransformationTestGenerated.AssignmentToWhen.class, CodeTransformationTestGenerated.PropertyToIf.class, CodeTransformationTestGenerated.PropertyToWhen.class, CodeTransformationTestGenerated.ReturnToIf.class, CodeTransformationTestGenerated.ReturnToWhen.class, CodeTransformationTestGenerated.IfToWhen.class, CodeTransformationTestGenerated.WhenToIf.class, CodeTransformationTestGenerated.Flatten.class, CodeTransformationTestGenerated.Merge.class, CodeTransformationTestGenerated.IntroduceSubject.class, CodeTransformationTestGenerated.EliminateSubject.class, CodeTransformationTestGenerated.Split.class, CodeTransformationTestGenerated.Join.class, CodeTransformationTestGenerated.ConvertMemberToExtension.class, CodeTransformationTestGenerated.ReconstructedType.class, CodeTransformationTestGenerated.RemoveUnnecessaryParentheses.class, CodeTransformationTestGenerated.ReplaceWithDotQualifiedMethodCall.class, CodeTransformationTestGenerated.ReplaceWithInfixFunctionCall.class, CodeTransformationTestGenerated.RemoveCurlyBracesFromTemplate.class, CodeTransformationTestGenerated.MoveLambdaInsideParentheses.class, CodeTransformationTestGenerated.MoveLambdaOutsideParentheses.class, CodeTransformationTestGenerated.ReplaceExplicitFunctionLiteralParamWithIt.class, CodeTransformationTestGenerated.ReplaceItWithExplicitFunctionLiteralParam.class, CodeTransformationTestGenerated.RemoveBraces.class, CodeTransformationTestGenerated.AddBraces.class, CodeTransformationTestGenerated.ReplaceGetIntention.class, CodeTransformationTestGenerated.ReplaceContainsIntention.class, CodeTransformationTestGenerated.ReplaceBinaryInfixIntention.class, CodeTransformationTestGenerated.ReplaceUnaryPrefixIntention.class, CodeTransformationTestGenerated.ReplaceInvokeIntention.class, CodeTransformationTestGenerated.SimplifyNegatedBinaryExpressionIntention.class, CodeTransformationTestGenerated.ConvertNegatedBooleanSequence.class, CodeTransformationTestGenerated.ConvertNegatedExpressionWithDemorgansLaw.class, CodeTransformationTestGenerated.SwapBinaryExpression.class, CodeTransformationTestGenerated.SplitIf.class, CodeTransformationTestGenerated.ReplaceWithOperatorAssign.class, CodeTransformationTestGenerated.ReplaceWithTraditionalAssignment.class, CodeTransformationTestGenerated.SimplifyBooleanWithConstants.class, CodeTransformationTestGenerated.InsertExplicitTypeArguments.class, CodeTransformationTestGenerated.RemoveExplicitTypeArguments.class, CodeTransformationTestGenerated.ConvertAssertToIf.class, CodeTransformationTestGenerated.ConvertIfToAssert.class, CodeTransformationTestGenerated.MakeTypeExplicitInLambda.class, CodeTransformationTestGenerated.MakeTypeImplicitInLambda.class, CodeTransformationTestGenerated.ConvertToForEachLoop.class, CodeTransformationTestGenerated.ConvertToForEachFunctionCall.class})
+@InnerTestClasses({CodeTransformationTestGenerated.DoubleBangToIfThen.class, CodeTransformationTestGenerated.IfThenToDoubleBang.class, CodeTransformationTestGenerated.ElvisToIfThen.class, CodeTransformationTestGenerated.IfThenToElvis.class, CodeTransformationTestGenerated.SafeAccessToIfThen.class, CodeTransformationTestGenerated.IfThenToSafeAccess.class, CodeTransformationTestGenerated.IfToAssignment.class, CodeTransformationTestGenerated.IfToReturn.class, CodeTransformationTestGenerated.IfToReturnAsymmetrically.class, CodeTransformationTestGenerated.WhenToAssignment.class, CodeTransformationTestGenerated.WhenToReturn.class, CodeTransformationTestGenerated.AssignmentToIf.class, CodeTransformationTestGenerated.AssignmentToWhen.class, CodeTransformationTestGenerated.PropertyToIf.class, CodeTransformationTestGenerated.PropertyToWhen.class, CodeTransformationTestGenerated.ReturnToIf.class, CodeTransformationTestGenerated.ReturnToWhen.class, CodeTransformationTestGenerated.IfToWhen.class, CodeTransformationTestGenerated.WhenToIf.class, CodeTransformationTestGenerated.Flatten.class, CodeTransformationTestGenerated.Merge.class, CodeTransformationTestGenerated.IntroduceSubject.class, CodeTransformationTestGenerated.EliminateSubject.class, CodeTransformationTestGenerated.Split.class, CodeTransformationTestGenerated.Join.class, CodeTransformationTestGenerated.ConvertMemberToExtension.class, CodeTransformationTestGenerated.ReconstructedType.class, CodeTransformationTestGenerated.RemoveUnnecessaryParentheses.class, CodeTransformationTestGenerated.ReplaceWithDotQualifiedMethodCall.class, CodeTransformationTestGenerated.ReplaceWithInfixFunctionCall.class, CodeTransformationTestGenerated.RemoveCurlyBracesFromTemplate.class, CodeTransformationTestGenerated.MoveLambdaInsideParentheses.class, CodeTransformationTestGenerated.MoveLambdaOutsideParentheses.class, CodeTransformationTestGenerated.ReplaceExplicitFunctionLiteralParamWithIt.class, CodeTransformationTestGenerated.ReplaceItWithExplicitFunctionLiteralParam.class, CodeTransformationTestGenerated.RemoveBraces.class, CodeTransformationTestGenerated.AddBraces.class, CodeTransformationTestGenerated.ReplaceGetIntention.class, CodeTransformationTestGenerated.ReplaceContainsIntention.class, CodeTransformationTestGenerated.ReplaceBinaryInfixIntention.class, CodeTransformationTestGenerated.ReplaceUnaryPrefixIntention.class, CodeTransformationTestGenerated.ReplaceInvokeIntention.class, CodeTransformationTestGenerated.SimplifyNegatedBinaryExpressionIntention.class, CodeTransformationTestGenerated.ConvertNegatedBooleanSequence.class, CodeTransformationTestGenerated.ConvertNegatedExpressionWithDemorgansLaw.class, CodeTransformationTestGenerated.SwapBinaryExpression.class, CodeTransformationTestGenerated.SplitIf.class, CodeTransformationTestGenerated.ReplaceWithOperatorAssign.class, CodeTransformationTestGenerated.ReplaceWithTraditionalAssignment.class, CodeTransformationTestGenerated.SimplifyBooleanWithConstants.class, CodeTransformationTestGenerated.InsertExplicitTypeArguments.class, CodeTransformationTestGenerated.RemoveExplicitTypeArguments.class, CodeTransformationTestGenerated.ConvertAssertToIf.class, CodeTransformationTestGenerated.ConvertIfToAssert.class, CodeTransformationTestGenerated.MakeTypeExplicitInLambda.class, CodeTransformationTestGenerated.MakeTypeImplicitInLambda.class, CodeTransformationTestGenerated.InvertIfCondition.class, CodeTransformationTestGenerated.ConvertToForEachLoop.class, CodeTransformationTestGenerated.ConvertToForEachFunctionCall.class})
 public class CodeTransformationTestGenerated extends AbstractCodeTransformationTest {
    @TestMetadata("idea/testData/intentions/branched/doubleBangToIfThen")
    public static class DoubleBangToIfThen extends AbstractCodeTransformationTest {
@@ -4140,6 +4140,79 @@ public class CodeTransformationTestGenerated extends AbstractCodeTransformationT
    }
    @TestMetadata("idea/testData/intentions/invertIfCondition")
    public static class InvertIfCondition extends AbstractCodeTransformationTest {
        public void testAllFilesPresentInInvertIfCondition() throws Exception {
            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("idea/testData/intentions/invertIfCondition"), Pattern.compile("^(.+)\\.kt$"), true);
        }
        @TestMetadata("assignedToValue.kt")
        public void testAssignedToValue() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/assignedToValue.kt");
        }
        @TestMetadata("binaryExpression.kt")
        public void testBinaryExpression() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/binaryExpression.kt");
        }
        @TestMetadata("booleanLiteral.kt")
        public void testBooleanLiteral() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/booleanLiteral.kt");
        }
        @TestMetadata("branchingIfStatements.kt")
        public void testBranchingIfStatements() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/branchingIfStatements.kt");
        }
        @TestMetadata("forLoopWithMultipleExpressions.kt")
        public void testForLoopWithMultipleExpressions() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/forLoopWithMultipleExpressions.kt");
        }
        @TestMetadata("functionWithReturnExpression.kt")
        public void testFunctionWithReturnExpression() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/functionWithReturnExpression.kt");
        }
        @TestMetadata("ifExpressionInsideForLoop.kt")
        public void testIfExpressionInsideForLoop() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/ifExpressionInsideForLoop.kt");
        }
        @TestMetadata("ifExpressionWithReturn.kt")
        public void testIfExpressionWithReturn() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/ifExpressionWithReturn.kt");
        }
        @TestMetadata("invertableOperator.kt")
        public void testInvertableOperator() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/invertableOperator.kt");
        }
        @TestMetadata("negatedExpression.kt")
        public void testNegatedExpression() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/negatedExpression.kt");
        }
        @TestMetadata("returnIfExpression.kt")
        public void testReturnIfExpression() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/returnIfExpression.kt");
        }
        @TestMetadata("simple.kt")
        public void testSimple() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/simple.kt");
        }
        @TestMetadata("valueAndReturnBranches.kt")
        public void testValueAndReturnBranches() throws Exception {
            doTestInvertIfCondition("idea/testData/intentions/invertIfCondition/valueAndReturnBranches.kt");
        }
    }
    @TestMetadata("idea/testData/intentions/convertToForEachLoop")
    public static class ConvertToForEachLoop extends AbstractCodeTransformationTest {
        public void testAllFilesPresentInConvertToForEachLoop() throws Exception {
@@ -4299,6 +4372,7 @@ public class CodeTransformationTestGenerated extends AbstractCodeTransformationT
        suite.addTestSuite(ConvertIfToAssert.class);
        suite.addTestSuite(MakeTypeExplicitInLambda.class);
        suite.addTestSuite(MakeTypeImplicitInLambda.class);
        suite.addTestSuite(InvertIfCondition.class);
        suite.addTestSuite(ConvertToForEachLoop.class);
        suite.addTestSuite(ConvertToForEachFunctionCall.class);
        return suite;