Use of Kotlin wrapper methods instead of Application.runReadAction/runWriteAction and CommandProcessor.executeCommand

2015-04-07 23:08:31 +03:00
parent 00660bc59e
commit ff4ff78307
21 changed files with 90 additions and 110 deletions
@@ -32,13 +32,13 @@ public fun Project.executeWriteCommand(name: String, command: () -> Unit) {
    CommandProcessor.getInstance().executeCommand(this, { runWriteAction(command) }, name, null)
 }

-public fun Project.executeCommand(name: String, command: () -> Unit) {
-    CommandProcessor.getInstance().executeCommand(this, command, name, null)
+public fun Project.executeCommand(name: String, groupId: Any? = null, command: () -> Unit) {
+    CommandProcessor.getInstance().executeCommand(this, command, name, groupId)
 }

-public fun <T> Project.executeWriteCommand(name: String, command: () -> T): T {
+public fun <T> Project.executeWriteCommand(name: String, groupId: Any? = null, command: () -> T): T {
    var result: T = null as T
-    CommandProcessor.getInstance().executeCommand(this, { result = runWriteAction(command) }, name, null)
+    CommandProcessor.getInstance().executeCommand(this, { result = runWriteAction(command) }, name, groupId)
    [suppress("USELESS_CAST")]
    return result as T
 }
@@ -31,6 +31,8 @@ import org.jetbrains.kotlin.idea.completion.ExpectedInfos
 import org.jetbrains.kotlin.idea.core.refactoring.EmptyValidator
 import org.jetbrains.kotlin.idea.core.refactoring.JetNameSuggester
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
+import org.jetbrains.kotlin.idea.util.application.executeCommand
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.JetExpression
 import org.jetbrains.kotlin.psi.JetFile
@@ -42,27 +44,25 @@ fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange,

    // we start template later to not interfere with insertion of tail type
    val commandProcessor = CommandProcessor.getInstance()
-    val commandName = commandProcessor.getCurrentCommandName()
+    val commandName = commandProcessor.getCurrentCommandName()!!
    val commandGroupId = commandProcessor.getCurrentCommandGroupId()

    val rangeMarker = context.getDocument().createRangeMarker(placeholderRange)

    context.setLaterRunnable {
-        commandProcessor.executeCommand(context.getProject(), {
-            runWriteAction {
-                try {
-                    if (rangeMarker.isValid()) {
-                        context.getDocument().deleteString(rangeMarker.getStartOffset(), rangeMarker.getEndOffset())
-                        context.getEditor().getCaretModel().moveToOffset(rangeMarker.getStartOffset())
-                        val template = buildTemplate(lambdaType, explicitParameterTypes, context.getProject())
-                        TemplateManager.getInstance(context.getProject()).startTemplate(context.getEditor(), template)
-                    }
-                }
-                finally {
-                    rangeMarker.dispose()
+        context.getProject().executeWriteCommand(commandName, groupId = commandGroupId) {
+            try {
+                if (rangeMarker.isValid()) {
+                    context.getDocument().deleteString(rangeMarker.getStartOffset(), rangeMarker.getEndOffset())
+                    context.getEditor().getCaretModel().moveToOffset(rangeMarker.getStartOffset())
+                    val template = buildTemplate(lambdaType, explicitParameterTypes, context.getProject())
+                    TemplateManager.getInstance(context.getProject()).startTemplate(context.getEditor(), template)
                }
            }
-        }, commandName, commandGroupId)
+            finally {
+                rangeMarker.dispose()
+            }
+        }
    }
 }

@@ -88,7 +88,6 @@ public class JavaToKotlinAction : AnAction() {
            CommandProcessor.getInstance().markCurrentCommandAsGlobal(project)

            val newFiles = saveResults(javaFiles, converterResult!!.results.map { it!!.text /*conversion of a file always succeeds*/ })
-            deleteFiles(javaFiles)

            externalCodeUpdate?.invoke()

@@ -133,31 +132,16 @@ public class JavaToKotlinAction : AnAction() {
    private fun saveResults(javaFiles: List<PsiJavaFile>, convertedTexts: List<String>): List<VirtualFile> {
        val result = ArrayList<VirtualFile>()
        for ((psiFile, text) in javaFiles.zip(convertedTexts)) {
-            result.addIfNotNull(saveConversionResult(psiFile.getVirtualFile(), text, psiFile.getProject()))
-        }
-        return result
-    }
-
-    private fun saveConversionResult(javaFile: VirtualFile, text: String, project: Project): VirtualFile? {
-        try {
-            val kotlinFile = javaFile.copy(this, javaFile.getParent(), javaFile.getNameWithoutExtension() + ".kt")
-            kotlinFile.setBinaryContent(CharsetToolkit.getUtf8Bytes(text))
-            return kotlinFile
-        }
-        catch (e: IOException) {
-            MessagesEx.error(project, e.getMessage()).showLater()
-            return null
-        }
-    }
-
-    private fun deleteFiles(javaFiles: List<PsiJavaFile>) {
-        for (psiFile in javaFiles) {
+            val virtualFile = psiFile.getVirtualFile()
            try {
-                psiFile.getVirtualFile()?.delete(this)
+                virtualFile.rename(null, virtualFile.getNameWithoutExtension() + ".kt")
+                virtualFile.setBinaryContent(CharsetToolkit.getUtf8Bytes(text))
+                result.add(virtualFile)
            }
            catch (e: IOException) {
                MessagesEx.error(psiFile.getProject(), e.getMessage()).showLater()
            }
        }
+        return result
    }
 }
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.idea.imports.importableFqNameSafe
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
 import org.jetbrains.kotlin.idea.JetDescriptorIconProvider
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand

 /**
 * Automatically adds import directive to the file for resolving reference.
@@ -159,23 +160,19 @@ public class JetAddImportAction(
        protected fun addImport(element: PsiElement, project: Project, selectedVariant: Variant) {
            PsiDocumentManager.getInstance(project).commitAllDocuments()

-            CommandProcessor.getInstance().executeCommand(project, object : Runnable {
-                override fun run() {
-                    ApplicationManager.getApplication().runWriteAction {
-                        val file = element.getContainingFile() as JetFile
-                        val descriptor = selectedVariant.descriptorToImport
-                        // for class or package we use ShortenReferences because we not necessary insert an import but may want to insert partly qualified name
-                        if (descriptor is ClassDescriptor || descriptor is PackageViewDescriptor) {
-                            val fqName = descriptor.importableFqNameSafe
-                            val reference = element.getReference() as JetSimpleNameReference
-                            reference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
-                        }
-                        else {
-                            ImportInsertHelper.getInstance(project).importDescriptor(file, descriptor)
-                        }
-                    }
+            project.executeWriteCommand(QuickFixBundle.message("add.import")) {
+                val file = element.getContainingFile() as JetFile
+                val descriptor = selectedVariant.descriptorToImport
+                // for class or package we use ShortenReferences because we not necessary insert an import but may want to insert partly qualified name
+                if (descriptor is ClassDescriptor || descriptor is PackageViewDescriptor) {
+                    val fqName = descriptor.importableFqNameSafe
+                    val reference = element.getReference() as JetSimpleNameReference
+                    reference.bindToFqName(fqName, JetSimpleNameReference.ShorteningMode.FORCED_SHORTENING)
                }
-            }, QuickFixBundle.message("add.import"), null)
+                else {
+                    ImportInsertHelper.getInstance(project).importDescriptor(file, descriptor)
+                }
+            }
        }
    }
 }
@@ -37,6 +37,7 @@ import com.intellij.psi.PsiManager
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.siblings
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
@@ -53,10 +54,8 @@ public class CheckPartialBodyResolveAction : AnAction() {
        val project = CommonDataKeys.PROJECT.getData(e.getDataContext())!!

        ProgressManager.getInstance().runProcessWithProgressSynchronously(
-                Runnable {
-                    ApplicationManager.getApplication().runReadAction {
-                        checkResolve(selectedFiles, project)
-                    }
+                {
+                    runReadAction { checkResolve(selectedFiles, project) }
                },
                "Checking Partial Body Resolve",
                true,
@@ -45,6 +45,7 @@ import org.jetbrains.kotlin.idea.references.JetMultiReference
 import org.jetbrains.kotlin.idea.references.JetReference
 import org.jetbrains.kotlin.idea.references.JetSimpleNameReference
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.elementsInRange
@@ -218,9 +219,9 @@ public class KotlinCopyPasteReferenceProcessor() : CopyPastePostProcessor<Kotlin
        val selectedReferencesToRestore = showRestoreReferencesDialog(project, referencesPossibleToRestore)
        if (selectedReferencesToRestore.isEmpty()) return

-        ApplicationManager.getApplication()!!.runWriteAction(Runnable {
+        runWriteAction {
            restoreReferences(selectedReferencesToRestore, file)
-        })
+        }
    }

    private fun findReferencesToRestore(file: PsiFile, blockStart: Int, referenceData: Array<out KotlinReferenceData>): List<ReferenceToRestoreData> {
@@ -22,6 +22,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.codeInsight.shorten.*
+import org.jetbrains.kotlin.idea.util.application.runWriteAction

 public class KotlinShortenReferencesRefactoringHelper: RefactoringHelper<Any> {
    override fun prepareOperation(usages: Array<out UsageInfo>?): Any? {
@@ -33,8 +34,6 @@ public class KotlinShortenReferencesRefactoringHelper: RefactoringHelper<Any> {
    }

    override fun performOperation(project: Project, operationData: Any?) {
-        ApplicationManager.getApplication()!!.runWriteAction {
-            performDelayedShortening(project)
-        }
+        runWriteAction { performDelayedShortening(project) }
    }
 }
@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
 import org.jetbrains.kotlin.idea.references.JetReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -156,7 +157,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
            // check if no changes to imports required
            if (oldImports.size() == sortedImportsToGenerate.size() && oldImports.map { it.getImportPath() } == sortedImportsToGenerate) return

-            ApplicationManager.getApplication()!!.runWriteAction(Runnable {
+            runWriteAction {
                val importList = file.getImportList()!!
                val psiFactory = JetPsiFactory(file.getProject())
                for (importPath in sortedImportsToGenerate) {
@@ -167,7 +168,7 @@ public class KotlinImportOptimizer() : ImportOptimizer {
                for (import in oldImports) {
                    import.delete()
                }
-            })
+            }
        }

        private fun detectDescriptorsToImport(): Set<DeclarationDescriptor> {
@@ -38,6 +38,7 @@ import com.intellij.util.io.ZipUtil
 import com.intellij.ide.actions.ShowFilePathAction
 import com.intellij.util.WaitForProgressToShow
 import com.intellij.openapi.application.ApplicationManager
+import org.jetbrains.kotlin.idea.util.application.runReadAction

 public class CreateIncrementalCompilationBackup: AnAction("Create backup for debugging Kotlin incremental compilation") {
    companion object {
@@ -71,7 +72,7 @@ public class CreateIncrementalCompilationBackup: AnAction("Create backup for deb
    }

    private fun createPatches(backupDir: File, project: Project, indicator: ProgressIndicator) {
-        ApplicationManager.getApplication()!!.runReadAction(Runnable {
+        runReadAction {
            val localHistoryImpl = LocalHistoryImpl.getInstanceImpl()!!
            val gateway = localHistoryImpl.getGateway()!!
            val localHistoryFacade = localHistoryImpl.getFacade()
@@ -105,7 +106,7 @@ public class CreateIncrementalCompilationBackup: AnAction("Create backup for deb
                    }
                }
            }
-        })
+        }
    }

    private fun copyLogs(backupDir: File, indicator: ProgressIndicator) {
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.chooseContainerElementIfNecessary
+import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.psi.*
 import java.util.Collections
 import java.util.HashSet
@@ -111,7 +112,7 @@ public class CreateCallableFromUsageFix(

        fun runBuilder(placement: CallablePlacement) {
            callableBuilder.placement = placement
-            CommandProcessor.getInstance().executeCommand(project, { callableBuilder.build() }, getText(), null)
+            project.executeCommand(getText()) { callableBuilder.build() }
        }

        if (callableInfo is SecondaryConstructorInfo) {
@@ -40,6 +40,7 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.core.refactoring.getOrCreateKotlinFile
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
+import org.jetbrains.kotlin.idea.util.application.executeCommand

 enum class ClassKind(val keyword: String, val description: String) {
    PLAIN_CLASS: ClassKind("class", "class")
@@ -124,7 +125,7 @@ public class CreateClassFromUsageFix(
                    Collections.singletonList(constructorInfo), element as JetElement, file, editor, false, kind == PLAIN_CLASS || kind == TRAIT
            ).createBuilder()
            builder.placement = CallablePlacement.NoReceiver(targetParent)
-            CommandProcessor.getInstance().executeCommand(project, { builder.build() }, getText(), null)
+            project.executeCommand(getText()) { builder.build() }
        }
    }
 }
@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.idea.quickfix.JetSingleIntentionActionFactory
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
+import org.jetbrains.kotlin.idea.util.application.executeCommand
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAssignmentByLHS
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedElement
@@ -72,7 +73,7 @@ object CreateLocalVariableActionFactory: JetSingleIntentionActionFactory() {

                with (CallableBuilderConfiguration(propertyInfo.singletonOrEmptyList(), originalElement, file, editor).createBuilder()) {
                    placement = CallablePlacement.NoReceiver(actualContainer)
-                    CommandProcessor.getInstance().executeCommand(project, { build() }, getText(), null)
+                    project.executeCommand(getText()) { build() }
                }
            }
        }
@@ -36,6 +36,7 @@ import com.intellij.CommonBundle
 import com.intellij.refactoring.RefactoringBundle
 import org.jetbrains.kotlin.resolve.OverrideResolver
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
+import org.jetbrains.kotlin.idea.util.application.runWriteAction

 public trait JetChangeSignatureConfiguration {
    fun configure(originalDescriptor: JetMethodDescriptor, bindingContext: BindingContext): JetMethodDescriptor
@@ -109,9 +110,9 @@ public class JetChangeSignature(project: Project,
    }

    private fun performRefactoringSilently(dialog: JetChangeSignatureDialog) {
-        ApplicationManager.getApplication()!!.runWriteAction {
+        runWriteAction {
            dialog.createRefactoringProcessor().run()
-            Disposer.dispose(dialog.getDisposable()!!)
+            Disposer.dispose(dialog.getDisposable())
        }
    }

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.idea.intentions.ReplaceItWithExplicitFunctionLiteral
 import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.refactoring.rename.inplace.VariableInplaceRenameHandler
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand

 public class RenameKotlinImplicitLambdaParameter: VariableInplaceRenameHandler() {
    override fun isAvailable(element: PsiElement?, editor: Editor, file: PsiFile): Boolean {
@@ -39,14 +40,9 @@ public class RenameKotlinImplicitLambdaParameter: VariableInplaceRenameHandler()

    override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
        val intention = ReplaceItWithExplicitFunctionLiteralParamIntention()
-        CommandProcessor.getInstance().executeCommand(
-                project,
-                { ApplicationManager.getApplication()!!.runWriteAction(Runnable {
-                    intention.invoke(project, editor, file)
-                }) },
-                "Convert 'it' to explicit lambda parameter",
-                ""
-        )
+        project.executeWriteCommand("Convert 'it' to explicit lambda parameter") {
+            intention.invoke(project, editor, file)
+        }
    }

    override fun invoke(project: Project, elements: Array<out PsiElement>, dataContext: DataContext?) {
@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.idea.decompiler.navigation.JetSourceNavigationHelper
 import org.jetbrains.kotlin.idea.stubindex.JetSuperClassIndex
 import org.jetbrains.kotlin.idea.search.fileScope
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope
+import org.jetbrains.kotlin.idea.util.application.runReadAction

 public open class KotlinDirectInheritorsSearcher() : QueryExecutorBase<PsiClass, DirectClassInheritorsSearch.SearchParameters>(true) {
    public override fun processQuery(queryParameters: DirectClassInheritorsSearch.SearchParameters, consumer: Processor<PsiClass>) {
@@ -43,7 +44,7 @@ public open class KotlinDirectInheritorsSearcher() : QueryExecutorBase<PsiClass,

        if (scope == null) return

-        ApplicationManager.getApplication()?.runReadAction {
+        runReadAction {
            val noLibrarySourceScope = JetSourceFilterScope.kotlinSourceAndClassFiles(scope, baseClass.getProject())
            JetSuperClassIndex.getInstance().get(name, baseClass.getProject(), noLibrarySourceScope).stream()
                    .map { candidate -> JetSourceNavigationHelper.getOriginalPsiClassOrCreateLightClass(candidate)}
@@ -22,6 +22,7 @@ import com.intellij.openapi.command.CommandProcessor
 import org.jetbrains.kotlin.idea.JetLightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.JetWithJdkAndRuntimeLightProjectDescriptor
 import org.jetbrains.kotlin.idea.core.formatter.JetCodeStyleSettings
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
@@ -55,11 +56,9 @@ public abstract class AbstractImportsTest : JetLightCodeInsightFixtureTestCase()
            codeInsightSettings.OPTIMIZE_IMPORTS_ON_THE_FLY = InTextDirectivesUtils.getPrefixedBoolean(file.getText(), "// OPTIMIZE_IMPORTS:") ?: false
            codeStyleSettings.NAME_COUNT_TO_USE_STAR_IMPORT = InTextDirectivesUtils.getPrefixedInt(file.getText(), "// NAME_COUNT_TO_USE_STAR_IMPORT:") ?: nameCountToUseStarImportDefault

-            CommandProcessor.getInstance().executeCommand(getProject(), {
-                ApplicationManager.getApplication()!!.runWriteAction {
-                    doTest(file)
-                }
-            }, null, null)
+            getProject().executeWriteCommand("") {
+                doTest(file)
+            }

            fixture.checkResultByFile(testPath + ".after")
        }
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.*
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.impl.PsiModificationTrackerImpl
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.test.JetTestUtils
 import kotlin.test.fail

@@ -55,7 +56,7 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck
    fun doTestWithImport(filePath: String) {
        myFixture.configureByCodeFragment(filePath)

-        ApplicationManager.getApplication()?.runWriteAction {
+        runWriteAction {
            val fileText = FileUtil.loadFile(File(filePath), true)
            val file = myFixture.getFile() as JetFile
            InTextDirectivesUtils.findListWithPrefixes(fileText, "// IMPORT: ").forEach {
@@ -63,6 +63,7 @@ import com.intellij.debugger.SourcePosition
 import com.intellij.debugger.engine.SourcePositionProvider
 import com.intellij.debugger.engine.evaluation.TextWithImports
 import com.intellij.debugger.ui.impl.watch.WatchItemDescriptor
+import org.jetbrains.kotlin.idea.util.application.runReadAction
 import java.util.regex.Matcher
 import java.util.regex.Pattern

@@ -322,7 +323,7 @@ public abstract class AbstractKotlinEvaluateExpressionTest : KotlinDebuggerTestB
    }

    private fun SuspendContextImpl.evaluate(text: String, codeFragmentKind: CodeFragmentKind, expectedResult: String) {
-        ApplicationManager.getApplication()?.runReadAction {
+        runReadAction {
            val sourcePosition = ContextUtil.getSourcePosition(this)
            val contextElement = ContextUtil.getContextElement(sourcePosition)!!
            Assert.assertTrue("KotlinCodeFragmentFactory should be accepted for context element otherwise default evaluator will be called. ContextElement = ${contextElement.getText()}",
@@ -152,6 +152,7 @@ public abstract class AbstractIntentionTest extends KotlinCodeInsightTestCase {
                ApplicationPackage.executeWriteCommand(
                        getProject(),
                        intentionAction.getText(),
+                        null,
                        new Function0<Object>() {
                            @Override
                            public Object invoke() {
@@ -43,6 +43,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getReceiverExpression
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.idea.JetFileType
 import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.kotlin.idea.util.application.executeWriteCommand

 public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtureTestCase() {
    override fun getTestDataPath() = JetTestUtils.getHomeDirectory()
@@ -106,17 +107,12 @@ public abstract class AbstractPartialBodyResolveTest : JetLightCodeInsightFixtur
                .filter { !it.parents(withItself = false).any { it in set } } // do not include skipped statements which are inside other skipped statement
                .sortBy { it.getTextOffset() }

-        CommandProcessor.getInstance().executeCommand(
-                {
-                    ApplicationManager.getApplication().runWriteAction {
-                        for (statement in skippedStatements) {
-                            statement.replace(JetPsiFactory(getProject()).createComment("/* STATEMENT DELETED: ${statement.compactPresentation()} */"))
-                        }
-                    }
-                },
-                "",
-                null
-        )
+        myFixture.getProject().executeWriteCommand("") {
+            for (statement in skippedStatements) {
+                statement.replace(JetPsiFactory(getProject()).createComment("/* STATEMENT DELETED: ${statement.compactPresentation()} */"))
+            }
+        }
+
        val fileText = file.getText()
        if (selectionModel.hasSelection()) {
            val start = selectionModel.getSelectionStart()
@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess
+import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.test.JetTestUtils

 public abstract class AbstractJavaToKotlinConverterTest : LightCodeInsightFixtureTestCase() {
@@ -54,19 +55,17 @@ public abstract class AbstractJavaToKotlinConverterTest : LightCodeInsightFixtur
    }

    protected fun addFile(text: String, fileName: String, dirName: String): VirtualFile {
-        return ApplicationManager.getApplication()!!.runWriteAction(object: Computable<VirtualFile> {
-            override fun compute(): VirtualFile? {
-                val root = LightPlatformTestCase.getSourceRoot()!!
-                val virtualDir = root.findChild(dirName) ?: root.createChildDirectory(null, dirName)
-                val virtualFile = virtualDir.createChildData(null, fileName)
-                virtualFile.getOutputStream(null)!!.writer().use { it.write(text) }
-                return virtualFile
-            }
-        })
+        return runWriteAction {
+            val root = LightPlatformTestCase.getSourceRoot()!!
+            val virtualDir = root.findChild(dirName) ?: root.createChildDirectory(null, dirName)
+            val virtualFile = virtualDir.createChildData(null, fileName)
+            virtualFile.getOutputStream(null)!!.writer().use { it.write(text) }
+            virtualFile
+        }
    }

    protected fun deleteFile(virtualFile: VirtualFile) {
-        ApplicationManager.getApplication()!!.runWriteAction { virtualFile.delete(this) }
+        runWriteAction { virtualFile.delete(this) }
    }

    protected fun addErrorsDump(jetFile: JetFile): String {