Refactoring: always use compiler settings with de-configuration in tests

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinFixtureCompletionBaseTestCase.kt

@@ -11,8 +11,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.idea.caches.project.LibraryModificationTracker
 import org.jetbrains.kotlin.idea.test.CompilerTestDirectives
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.platform.TargetPlatform
 import java.io.File
 
@@ -30,9 +29,8 @@ abstract class KotlinFixtureCompletionBaseTestCase : KotlinLightCodeInsightFixtu
         setUpFixture(testPath)
 
         val fileText = FileUtil.loadFile(File(testPath), true)
-        val configured = configureCompilerOptions(fileText, project, module)
         try {
-
+            withCustomCompilerOptions(fileText, project, module) {
                 assertTrue("\"<caret>\" is missing in file \"$testPath\"", fileText.contains("<caret>"))
 
                 if (ExpectedCompletionUtils.shouldRunHighlightingBeforeCompletion(fileText)) {
@@ -47,10 +45,8 @@ abstract class KotlinFixtureCompletionBaseTestCase : KotlinLightCodeInsightFixtu
                     defaultInvocationCount(),
                     additionalValidDirectives = CompilerTestDirectives.ALL_COMPILER_TEST_DIRECTIVES
                 )
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
+        } finally {
             tearDownFixture()
         }
     }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/AbstractCompletionHandlerTests.kt

@@ -12,8 +12,7 @@ import org.jetbrains.kotlin.idea.completion.test.ExpectedCompletionUtils
 import org.jetbrains.kotlin.idea.completion.test.configureWithExtraFile
 import org.jetbrains.kotlin.idea.core.formatter.KotlinCodeStyleSettings
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.utils.addToStdlib.indexOfOrNull
 import java.io.File
@@ -36,11 +35,10 @@ abstract class AbstractCompletionHandlerTest(private val defaultCompletionType:
         val tempSettings = CodeStyle.getSettings(project).clone()
         CodeStyle.setTemporarySettings(project, tempSettings)
         val fileText = FileUtil.loadFile(File(testPath))
-        val configured = configureCompilerOptions(fileText, project, module)
         try {
+            withCustomCompilerOptions(fileText, project, module) {
                 assertTrue("\"<caret>\" is missing in file \"$testPath\"", fileText.contains("<caret>"))
 
-
                 val invocationCount = InTextDirectivesUtils.getPrefixedInt(fileText, INVOCATION_COUNT_PREFIX) ?: 1
                 val lookupString = InTextDirectivesUtils.findStringWithPrefixes(fileText, LOOKUP_STRING_PREFIX)
                 val itemText = InTextDirectivesUtils.findStringWithPrefixes(fileText, ELEMENT_TEXT_PREFIX)
@@ -75,12 +73,10 @@ abstract class AbstractCompletionHandlerTest(private val defaultCompletionType:
                     itemText,
                     tailText,
                     completionChars,
-                File(testPath).name + ".after"
+                    File(testPath).name + ".after",
                 )
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
+        } finally {
             CodeStyle.dropTemporarySettings(project)
             tearDownFixture()
         }

idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/AbstractCompletionWeigherTest.kt

@@ -10,8 +10,7 @@ import org.jetbrains.kotlin.idea.completion.test.RELATIVE_COMPLETION_TEST_DATA_B
 import org.jetbrains.kotlin.idea.completion.test.configureWithExtraFile
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.junit.Assert
 
@@ -26,18 +25,12 @@ abstract class AbstractCompletionWeigherTest(val completionType: CompletionType,
 
         val text = myFixture.editor.document.text
 
-        val configured = configureCompilerOptions(text, project, module)
-
         val items = InTextDirectivesUtils.findArrayWithPrefixes(text, "// ORDER:")
         Assert.assertTrue("""Some items should be defined with "// ORDER:" directive""", items.isNotEmpty())
 
-        try {
+        withCustomCompilerOptions(text, project, module) {
             myFixture.complete(completionType, InTextDirectivesUtils.getPrefixedInt(text, "// INVOCATION_COUNT:") ?: 1)
             myFixture.assertPreferredCompletionItems(InTextDirectivesUtils.getPrefixedInt(text, "// SELECTED:") ?: 0, *items)
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
-            }
         }
     }
 }

idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/KotlinLightCodeInsightFixtureTestCase.kt

@@ -228,7 +228,6 @@ abstract class KotlinLightCodeInsightFixtureTestCase : KotlinLightCodeInsightFix
 
 }
 
-
 object CompilerTestDirectives {
     const val LANGUAGE_VERSION_DIRECTIVE = "LANGUAGE_VERSION:"
     const val JVM_TARGET_DIRECTIVE = "JVM_TARGET:"
@@ -237,6 +236,17 @@ object CompilerTestDirectives {
     val ALL_COMPILER_TEST_DIRECTIVES = listOf(LANGUAGE_VERSION_DIRECTIVE, JVM_TARGET_DIRECTIVE, COMPILER_ARGUMENTS_DIRECTIVE)
 }
 
+fun <T> withCustomCompilerOptions(fileText: String, project: Project, module: Module, body: () -> T): T {
+    val configured = configureCompilerOptions(fileText, project, module)
+    try {
+        return body()
+    } finally {
+        if (configured) {
+            rollbackCompilerOptions(project, module)
+        }
+    }
+}
+
 fun configureCompilerOptions(fileText: String, project: Project, module: Module): Boolean {
     val version = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// $LANGUAGE_VERSION_DIRECTIVE ")
     val jvmTarget = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// $JVM_TARGET_DIRECTIVE ")
@@ -286,7 +296,7 @@ fun <T> configureRegistryAndRun(fileText: String, body: () -> T) {
     }
 }
 
-fun rollbackCompilerOptions(project: Project, module: Module) {
+private fun rollbackCompilerOptions(project: Project, module: Module) {
     configureLanguageAndApiVersion(project, module, LanguageVersion.LATEST_STABLE.versionString)
 
     val facetSettings = KotlinFacet.get(module)!!.configuration.settings

idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/AbstractPerformanceCompletionHandlerTests.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.idea.perf
 
-import org.jetbrains.kotlin.idea.completion.test.handlers.CompletionHandlerTestBase
 import com.intellij.application.options.CodeStyle
 import com.intellij.codeInsight.completion.CompletionType
 import com.intellij.openapi.application.runWriteAction
@@ -17,10 +16,10 @@ import org.jetbrains.kotlin.idea.completion.test.handlers.AbstractCompletionHand
 import org.jetbrains.kotlin.idea.completion.test.handlers.AbstractCompletionHandlerTest.Companion.INVOCATION_COUNT_PREFIX
 import org.jetbrains.kotlin.idea.completion.test.handlers.AbstractCompletionHandlerTest.Companion.LOOKUP_STRING_PREFIX
 import org.jetbrains.kotlin.idea.completion.test.handlers.AbstractCompletionHandlerTest.Companion.TAIL_TEXT_PREFIX
+import org.jetbrains.kotlin.idea.completion.test.handlers.CompletionHandlerTestBase
 import org.jetbrains.kotlin.idea.core.formatter.KotlinCodeStyleSettings
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.idea.testFramework.commitAllDocuments
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.utils.addToStdlib.indexOfOrNull
@@ -62,9 +61,9 @@ abstract class AbstractPerformanceCompletionHandlerTests(
 
         val tempSettings = CodeStyle.getSettings(project).clone()
         CodeStyle.setTemporarySettings(project, tempSettings)
-        val fileText = FileUtil.loadFile(File(testPath))
-        val configured = configureCompilerOptions(fileText, project, module)
         try {
+            val fileText = FileUtil.loadFile(File(testPath))
+            withCustomCompilerOptions(fileText, project, module) {
                 assertTrue("\"<caret>\" is missing in file \"$testPath\"", fileText.contains("<caret>"))
 
                 val invocationCount = InTextDirectivesUtils.getPrefixedInt(fileText, INVOCATION_COUNT_PREFIX) ?: 1
@@ -94,12 +93,10 @@ abstract class AbstractPerformanceCompletionHandlerTests(
                 }
 
                 doPerfTestWithTextLoaded(
-                testPath, completionType, invocationCount, lookupString, itemText, tailText, completionChars
+                    testPath, completionType, invocationCount, lookupString, itemText, tailText, completionChars,
                 )
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
+        } finally {
             CodeStyle.dropTemporarySettings(project)
             tearDownFixture()
         }

idea/tests/org/jetbrains/kotlin/checkers/AbstractFirPsiCheckerTest.kt

@@ -7,8 +7,7 @@ package org.jetbrains.kotlin.checkers
 
 import com.intellij.rt.execution.junit.FileComparisonFailure
 import org.jetbrains.kotlin.idea.fir.FirResolution
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import java.io.File
 
@@ -29,9 +28,9 @@ abstract class AbstractFirPsiCheckerTest : AbstractPsiCheckerTest() {
         checkWeakWarnings: Boolean
     ): Long {
         val file = file
-        val configured = configureCompilerOptions(file.text, project, module)
+        return withCustomCompilerOptions(file.text, project, module) {
             val doComparison = InTextDirectivesUtils.isDirectiveDefined(myFixture.file.text, "FIR_COMPARISON")
-        return try {
+            try {
                 myFixture.checkHighlighting(checkWarnings, checkInfos, checkWeakWarnings)
             } catch (e: FileComparisonFailure) {
                 if (doComparison) {
@@ -41,9 +40,6 @@ abstract class AbstractFirPsiCheckerTest : AbstractPsiCheckerTest() {
                     // Here we just check that we haven't crashed due to exception
                     0
                 }
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
         }
     }

idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java

@@ -62,7 +62,8 @@ public abstract class AbstractPsiCheckerTest extends KotlinLightCodeInsightFixtu
 
     protected long checkHighlighting(boolean checkWarnings, boolean checkInfos, boolean checkWeakWarnings) {
         PsiFile file = getFile();
-        boolean configured = KotlinLightCodeInsightFixtureTestCaseKt.configureCompilerOptions(file.getText(), getProject(), getModule());
+        return KotlinLightCodeInsightFixtureTestCaseKt
+                .withCustomCompilerOptions(file.getText(), getProject(), getModule(), () -> {
                     try {
                         if (file instanceof KtFile && ((KtFile) file).isScript() && myFixture instanceof JavaCodeInsightTestFixtureImpl) {
                             ((JavaCodeInsightTestFixtureImpl) myFixture).canChangeDocumentDuringHighlighting(true);
@@ -70,12 +71,10 @@ public abstract class AbstractPsiCheckerTest extends KotlinLightCodeInsightFixtu
                         return myFixture.checkHighlighting(checkWarnings, checkInfos, checkWeakWarnings);
                     }
                     catch (FileComparisonFailure e) {
-            throw new FileComparisonFailure(e.getMessage(), e.getExpected(), e.getActual(), new File(e.getFilePath()).getAbsolutePath());
+                        throw new FileComparisonFailure(e.getMessage(), e.getExpected(), e.getActual(),
-        } finally {
+                                                        new File(e.getFilePath()).getAbsolutePath());
-            if (configured) {
-                KotlinLightCodeInsightFixtureTestCaseKt.rollbackCompilerOptions(getProject(), getModule());
-            }
                     }
+                });
     }
 
     void checkResolveToDescriptor() {

idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInspectionTest.kt

@@ -18,7 +18,10 @@ import org.jdom.input.SAXBuilder
 import org.jetbrains.kotlin.formatter.FormatSettingsUtil
 import org.jetbrains.kotlin.idea.core.script.isScriptChangesNotifierDisabled
 import org.jetbrains.kotlin.idea.inspections.runInspection
-import org.jetbrains.kotlin.idea.test.*
+import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.TestFixtureExtension
+import org.jetbrains.kotlin.idea.test.configureRegistryAndRun
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.idea.versions.bundledRuntimeVersion
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -63,8 +66,7 @@ abstract class AbstractInspectionTest : KotlinLightCodeInsightFixtureTestCase()
 
         val fixtureClasses = InTextDirectivesUtils.findListWithPrefixes(options, "// FIXTURE_CLASS: ")
 
-        val configured = configureCompilerOptions(options, project, module)
+        withCustomCompilerOptions(options, project, module) {
-
             val inspectionsTestDir = optionsFile.parentFile!!
             val srcDir = inspectionsTestDir.parentFile!!
 
@@ -78,7 +80,8 @@ abstract class AbstractInspectionTest : KotlinLightCodeInsightFixtureTestCase()
             with(myFixture) {
                 testDataPath = "${KotlinTestUtils.getHomeDirectory()}/$srcDir"
 
-            val afterFiles = srcDir.listFiles { it -> it.name == "inspectionData" }?.single()?.listFiles { it -> it.extension == "after" }
+                val afterFiles =
+                    srcDir.listFiles { it -> it.name == "inspectionData" }?.single()?.listFiles { it -> it.extension == "after" }
                         ?: emptyArray()
                 val psiFiles = srcDir.walkTopDown().onEnter { it.name != "inspectionData" }.mapNotNull { file ->
                     when {
@@ -148,12 +151,10 @@ abstract class AbstractInspectionTest : KotlinLightCodeInsightFixtureTestCase()
 
                     } finally {
                         codeStyleSettings.clearCodeStyleSettings()
-                    if (configured) {
-                        rollbackCompilerOptions(project, module)
-                    }
                         fixtureClasses.forEach { TestFixtureExtension.unloadFixture(it) }
                     }
                 }
             }
         }
     }
+}

idea/tests/org/jetbrains/kotlin/idea/inspections/AbstractLocalInspectionTest.kt

@@ -19,8 +19,7 @@ import junit.framework.ComparisonFailure
 import junit.framework.TestCase
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
@@ -80,11 +79,9 @@ abstract class AbstractLocalInspectionTest : KotlinLightCodeInsightFixtureTestCa
         val fileText = FileUtil.loadFile(mainFile, true)
         TestCase.assertTrue("\"<caret>\" is missing in file \"$mainFile\"", fileText.contains("<caret>"))
 
-        val configured = configureCompilerOptions(fileText, project, module)
+        withCustomCompilerOptions(fileText, project, module) {
-
-        try {
             val minJavaVersion = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// MIN_JAVA_VERSION: ")
-            if (minJavaVersion != null && !SystemInfo.isJavaVersionAtLeast(minJavaVersion)) return
+            if (minJavaVersion != null && !SystemInfo.isJavaVersionAtLeast(minJavaVersion)) return@withCustomCompilerOptions
 
             if (file is KtFile && !InTextDirectivesUtils.isDirectiveDefined(fileText, "// SKIP_ERRORS_BEFORE")) {
                 DirectiveBasedActionUtils.checkForUnexpectedErrors(file as KtFile)
@@ -119,10 +116,6 @@ abstract class AbstractLocalInspectionTest : KotlinLightCodeInsightFixtureTestCa
             if (file is KtFile && !InTextDirectivesUtils.isDirectiveDefined(fileText, "// SKIP_ERRORS_AFTER")) {
                 DirectiveBasedActionUtils.checkForUnexpectedErrors(file as KtFile)
             }
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
-            }
         }
     }
 

idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractIntentionTest.kt

@@ -22,7 +22,10 @@ import com.intellij.refactoring.util.CommonRefactoringUtil
 import com.intellij.testFramework.PlatformTestUtil
 import junit.framework.ComparisonFailure
 import junit.framework.TestCase
-import org.jetbrains.kotlin.idea.test.*
+import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
+import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
+import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
 import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.psi.KtFile
@@ -98,15 +101,14 @@ abstract class AbstractIntentionTest : KotlinLightCodeInsightFixtureTestCase() {
         val pathToFiles = mapOf(*(sourceFilePaths zip psiFiles).toTypedArray())
 
         val fileText = FileUtil.loadFile(mainFile, true)
-        val configured = configureCompilerOptions(fileText, project, module)
+        withCustomCompilerOptions(fileText, project, module) {
-
             ConfigLibraryUtil.configureLibrariesByDirective(module, PlatformTestUtil.getCommunityPath(), fileText)
 
             try {
                 TestCase.assertTrue("\"<caret>\" is missing in file \"$mainFile\"", fileText.contains("<caret>"))
 
                 val minJavaVersion = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// MIN_JAVA_VERSION: ")
-            if (minJavaVersion != null && !SystemInfo.isJavaVersionAtLeast(minJavaVersion)) return
+                if (minJavaVersion != null && !SystemInfo.isJavaVersionAtLeast(minJavaVersion)) return@withCustomCompilerOptions
 
                 if (file is KtFile && !InTextDirectivesUtils.isDirectiveDefined(fileText, "// SKIP_ERRORS_BEFORE")) {
                     DirectiveBasedActionUtils.checkForUnexpectedErrors(file as KtFile)
@@ -119,8 +121,6 @@ abstract class AbstractIntentionTest : KotlinLightCodeInsightFixtureTestCase() {
                 }
             } finally {
                 ConfigLibraryUtil.unconfigureLibrariesByDirective(module, fileText)
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
         }
     }

idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt

@@ -15,7 +15,10 @@ import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.idea.test.*
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources
+import org.jetbrains.kotlin.idea.test.SdkAndMockLibraryProjectDescriptor
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
@@ -50,9 +53,7 @@ abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() {
 
         val file = myFixture.file as KtFile
 
-        val configured = configureCompilerOptions(file.text, project, myFixture.module)
+        withCustomCompilerOptions(file.text, project, myFixture.module) {
-
-        try {
             val lastChild = file.allChildren.filter { it !is PsiWhiteSpace }.last()
             val expectedResultText = when (lastChild.node.elementType) {
                 KtTokens.BLOCK_COMMENT -> lastChild.text.substring(2, lastChild.text.length - 2).trim()
@@ -89,10 +90,6 @@ abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() {
             }
 
             Assert.assertEquals(expectedResultText, parameterInfoUIContext.resultText)
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, myFixture.module)
-            }
         }
     }
 }

idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt.192

@@ -15,7 +15,10 @@ import com.intellij.testFramework.LightProjectDescriptor
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.idea.test.*
+import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources
+import org.jetbrains.kotlin.idea.test.SdkAndMockLibraryProjectDescriptor
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
@@ -50,9 +53,7 @@ abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() {
 
         val file = myFixture.file as KtFile
 
-        val configured = configureCompilerOptions(file.text, project, myFixture.module)
+        withCustomCompilerOptions(file.text, project, myFixture.module) {
-
-        try {
             val lastChild = file.allChildren.filter { it !is PsiWhiteSpace }.last()
             val expectedResultText = when (lastChild.node.elementType) {
                 KtTokens.BLOCK_COMMENT -> lastChild.text.substring(2, lastChild.text.length - 2).trim()
@@ -89,10 +90,6 @@ abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() {
             }
 
             Assert.assertEquals(expectedResultText, parameterInfoUIContext.resultText)
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, myFixture.module)
-            }
         }
     }
 }

idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.kt

@@ -31,8 +31,7 @@ import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.quickfix.utils.findInspectionFile
 import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.TestFiles
@@ -133,9 +132,10 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
         }
 
         configureMultiFileTest(subFiles, beforeFile)
-        val configured = configureCompilerOptions(multiFileText, project, module)
+        withCustomCompilerOptions(multiFileText, project, module) {
-
+            CommandProcessor.getInstance().executeCommand(
-        CommandProcessor.getInstance().executeCommand(project, {
+                project,
+                {
                     try {
                         val psiFile = file
 
@@ -148,7 +148,15 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
                             DirectiveBasedActionUtils.checkForUnexpectedErrors(psiFile)
                         }
 
-                doAction(text, file, editor, actionShouldBeAvailable, getTestName(false), this::availableActions, myFixture::doHighlighting)
+                        doAction(
+                            text,
+                            file,
+                            editor,
+                            actionShouldBeAvailable,
+                            getTestName(false),
+                            this::availableActions,
+                            myFixture::doHighlighting,
+                        )
 
                         val actualText = file.text
                         val afterText = StringBuilder(actualText).insert(editor.caretModel.offset, "<caret>").toString()
@@ -179,12 +187,12 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
                     } catch (e: Throwable) {
                         e.printStackTrace()
                         TestCase.fail(getTestName(true))
-            } finally {
-                if (configured) {
-                    rollbackCompilerOptions(project, myFixture.module)
                     }
+                },
+                "", "",
+            )
         }
-        }, "", "")
+
     }
 
     private fun doTest(beforeFileName: String) {
@@ -205,9 +213,10 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
 
         myFixture.configureByFiles(*testFiles.toTypedArray())
 
-        val configured = configureCompilerOptions(originalFileText, project, module)
+        withCustomCompilerOptions(originalFileText, project, module) {
-
+            CommandProcessor.getInstance().executeCommand(
-        CommandProcessor.getInstance().executeCommand(project, {
+                project,
+                {
                     try {
                         val psiFile = file
 
@@ -220,7 +229,15 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
                             DirectiveBasedActionUtils.checkForUnexpectedErrors(psiFile)
                         }
 
-                doAction(text, file, editor, actionShouldBeAvailable, beforeFileName, this::availableActions, myFixture::doHighlighting)
+                        doAction(
+                            text,
+                            file,
+                            editor,
+                            actionShouldBeAvailable,
+                            beforeFileName,
+                            this::availableActions,
+                            myFixture::doHighlighting,
+                        )
 
                         if (actionShouldBeAvailable) {
                             val afterFilePath = beforeFileName.replace(".before.Main.", ".after.")
@@ -232,7 +249,13 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
 
                             for (file in myFixture.file.containingDirectory.files) {
                                 val fileName = file.name
-                        if (fileName == myFixture.file.name || !fileName.startsWith(extraFileNamePrefix(myFixture.file.name))) continue
+                                if (fileName == myFixture.file.name || !fileName.startsWith(
+                                        extraFileNamePrefix(
+                                            myFixture.file
+                                                .name,
+                                        ),
+                                    )
+                                ) continue
 
                                 val extraFileFullPath = beforeFileName.replace(myFixture.file.name, fileName)
                                 val afterFile = File(extraFileFullPath.replace(".before.", ".after."))
@@ -250,12 +273,11 @@ abstract class AbstractQuickFixMultiFileTest : KotlinLightCodeInsightFixtureTest
                     } catch (e: Throwable) {
                         e.printStackTrace()
                         TestCase.fail(getTestName(true))
-            } finally {
-                if (configured) {
-                    rollbackCompilerOptions(project, module)
                     }
+                },
+                "", "",
+            )
         }
-        }, "", "")
     }
 
     private val availableActions: List<IntentionAction>

idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixTest.kt

@@ -54,10 +54,8 @@ abstract class AbstractQuickFixTest : KotlinLightCodeInsightFixtureTestCase(), Q
     @Throws(Exception::class)
     protected fun doTest(beforeFileName: String) {
         val beforeFileText = FileUtil.loadFile(File(beforeFileName))
-        val configured = configureCompilerOptions(beforeFileText, project, module)
+        withCustomCompilerOptions(beforeFileText, project, module) {
-
             val inspections = parseInspectionsToEnable(beforeFileName, beforeFileText).toTypedArray()
-
             try {
                 myFixture.enableInspections(*inspections)
 
@@ -65,8 +63,6 @@ abstract class AbstractQuickFixTest : KotlinLightCodeInsightFixtureTestCase(), Q
                 checkForUnexpectedErrors()
             } finally {
                 myFixture.disableInspections(*inspections)
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
         }
     }

idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/AbstractInlineTest.kt

@@ -18,8 +18,7 @@ import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import junit.framework.TestCase
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.KotlinTestUtils
@@ -41,13 +40,11 @@ abstract class AbstractInlineTest : KotlinLightCodeInsightFixtureTestCase() {
         val extraFilesToPsi = extraFiles.associateBy { fixture.configureByFile(it.name) }
         val file = myFixture.configureByFile(fileName())
 
-        val configured = configureCompilerOptions(file.text, project, module)
+        withCustomCompilerOptions(file.text, project, module) {
-
-        try {
             val afterFileExists = afterFile.exists()
 
             val targetElement =
-                TargetElementUtil.findTargetElement(myFixture.editor, ELEMENT_NAME_ACCEPTED or REFERENCED_ELEMENT_ACCEPTED) ?: return
+                TargetElementUtil.findTargetElement(myFixture.editor, ELEMENT_NAME_ACCEPTED or REFERENCED_ELEMENT_ACCEPTED) ?: return@withCustomCompilerOptions
 
             @Suppress("DEPRECATION")
             val handler = Extensions.getExtensions(InlineActionHandler.EP_NAME).firstOrNull { it.canInlineElement(targetElement) }
@@ -74,10 +71,6 @@ abstract class AbstractInlineTest : KotlinLightCodeInsightFixtureTestCase() {
             } else {
                 TestCase.assertFalse("No refactoring handler available", afterFileExists)
             }
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
-            }
         }
     }
 

idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt

@@ -336,7 +336,7 @@ abstract class AbstractExtractionTest : KotlinLightCodeInsightFixtureTestCase()
         val extraFilesToPsi = extraFiles.associateBy { fixture.configureByFile(it.name) }
         val fileText = FileUtil.loadFile(File(path), true)
 
-        val configured = configureCompilerOptions(fileText, project, module)
+        withCustomCompilerOptions(fileText, project, module) {
             ConfigLibraryUtil.configureLibrariesByDirective(module, PlatformTestUtil.getCommunityPath(), fileText)
 
             val addKotlinRuntime = InTextDirectivesUtils.findStringWithPrefixes(fileText, "// WITH_RUNTIME") != null
@@ -352,8 +352,6 @@ abstract class AbstractExtractionTest : KotlinLightCodeInsightFixtureTestCase()
                 if (addKotlinRuntime) {
                     ConfigLibraryUtil.unConfigureKotlinRuntimeAndSdk(module, PluginTestCaseBase.mockJdk())
                 }
-            if (configured) {
-                rollbackCompilerOptions(project, module)
             }
         }
     }

idea/tests/org/jetbrains/kotlin/idea/resolve/AbstractPartialBodyResolveTest.kt

@@ -11,11 +11,9 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.util.getDataFlowAwareTypes
 import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.configureCompilerOptions
+import org.jetbrains.kotlin.idea.test.withCustomCompilerOptions
-import org.jetbrains.kotlin.idea.test.rollbackCompilerOptions
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType
@@ -51,9 +49,7 @@ abstract class AbstractPartialBodyResolveTest : KotlinLightCodeInsightFixtureTes
 
     private fun dump(testPath: String, resolveMode: BodyResolveMode): String {
         myFixture.configureByText(KotlinFileType.INSTANCE, File(testPath).readText())
-        val configured = configureCompilerOptions(myFixture.file.text, project, module)
+        return withCustomCompilerOptions(myFixture.file.text, project, module) {
-
-        try {
             val file = myFixture.file as KtFile
             val editor = myFixture.editor
             val selectionModel = editor.selectionModel
@@ -121,11 +117,7 @@ abstract class AbstractPartialBodyResolveTest : KotlinLightCodeInsightFixtureTes
             Assert.assertEquals(target2.presentation(null), target1.presentation(null))
             Assert.assertEquals(type2.presentation(), type1.presentation())
 
-            return builder.toString()
+            builder.toString()
-        } finally {
-            if (configured) {
-                rollbackCompilerOptions(project, module)
-            }
         }
     }