Extract runReadAction/runWriteAction utility functions

idea/src/org/jetbrains/jet/plugin/completion/handlers/GenerateLambda.kt

@@ -41,6 +41,7 @@ import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.plugin.completion.ExpectedInfos
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import org.jetbrains.jet.plugin.refactoring.runWriteAction
 
 fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange, lambdaType: JetType) {
     val explicitParameterTypes = needExplicitParameterTypes(context, placeholderRange, lambdaType)
@@ -54,7 +55,7 @@ fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange,
 
     context.setLaterRunnable {
         commandProcessor.executeCommand(context.getProject(), {
-            ApplicationManager.getApplication()!!.runWriteAction(Computable<Unit> {
+            runWriteAction {
                 try {
                     if (rangeMarker.isValid()) {
                         context.getDocument().deleteString(rangeMarker.getStartOffset(), rangeMarker.getEndOffset())
@@ -66,7 +67,7 @@ fun insertLambdaTemplate(context: InsertionContext, placeholderRange: TextRange,
                 finally {
                     rangeMarker.dispose()
                 }
-            })
+            }
         }, commandName, commandGroupId)
     }
 }

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluateExpressionCache.kt

@@ -30,8 +30,6 @@ import com.intellij.util.containers.MultiMap
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap
 import com.intellij.psi.search.GlobalSearchScope
-import com.intellij.openapi.application.ApplicationManager
-import org.jetbrains.jet.lang.psi.JetFile
 import com.intellij.psi.JavaPsiFacade
 import org.jetbrains.jet.lang.resolve.DescriptorUtils
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor
@@ -40,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaClassImpl
 import org.jetbrains.jet.lang.resolve.java.JvmClassName
 import org.jetbrains.jet.codegen.AsmUtil
 import org.apache.log4j.Logger
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 class KotlinEvaluateExpressionCache(val project: Project) {
 
@@ -101,7 +100,7 @@ class KotlinEvaluateExpressionCache(val project: Project) {
         val platformClasses = JavaToKotlinClassMap.getInstance().mapPlatformClass(jvmName)
         if (platformClasses.notEmpty) return platformClasses.first()
 
-        return ApplicationManager.getApplication()?.runReadAction<ClassDescriptor> {
+        return runReadAction {
             val classes = JavaPsiFacade.getInstance(project).findClasses(jvmName.asString(), GlobalSearchScope.allScope(project))
             if (classes.isEmpty()) null else JavaResolveExtension[project].resolveClass(JavaClassImpl(classes.first()))
         }

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -24,7 +24,6 @@ import com.intellij.debugger.engine.evaluation.expression.*
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils
 import org.jetbrains.jet.codegen.state.GenerationState
 import org.jetbrains.jet.codegen.ClassBuilderFactories
-import java.util.Collections
 import org.jetbrains.jet.codegen.KotlinCodegenFacade
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.testFramework.LightVirtualFile
@@ -59,10 +58,10 @@ import com.sun.jdi.ObjectReference
 import com.intellij.debugger.engine.SuspendContext
 import org.jetbrains.jet.plugin.debugger.evaluate.KotlinEvaluateExpressionCache.*
 import org.jetbrains.jet.lang.resolve.BindingContext
-import com.sun.jdi.StackFrame
 import com.sun.jdi.VirtualMachine
 import org.jetbrains.jet.codegen.AsmUtil
 import com.sun.jdi.InvalidStackFrameException
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 private val RECEIVER_NAME = "\$receiver"
 private val THIS_NAME = "this"
@@ -184,7 +183,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
         }
 
         private fun JetNamedFunction.getParametersForDebugger(): ParametersDescriptor {
-            return ApplicationManager.getApplication()?.runReadAction(Computable {
+            return runReadAction {
                 val parameters = ParametersDescriptor()
                 val bindingContext = getAnalysisResults().getBindingContext()
                 val descriptor = bindingContext[BindingContext.FUNCTION, this]
@@ -200,7 +199,7 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
                     }
                 }
                 parameters
-            })!!
+            }!!
         }
 
         private fun EvaluationContextImpl.getArgumentsForEval4j(parameterNames: List<String>, parameterTypes: Array<Type>): List<Value> {
@@ -208,39 +207,36 @@ class KotlinEvaluator(val codeFragment: JetCodeFragment,
         }
 
         private fun createClassFileFactory(codeFragment: JetCodeFragment, extractedFunction: JetNamedFunction): ClassFileFactory {
-            return ApplicationManager.getApplication()?.runReadAction(object : Computable<ClassFileFactory> {
+            return runReadAction {
-                override fun compute(): ClassFileFactory? {
+                val file = createFileForDebugger(codeFragment, extractedFunction)
-                    val file = createFileForDebugger(codeFragment, extractedFunction)
 
-                    checkForSyntacticErrors(file)
+                checkForSyntacticErrors(file)
 
-                    val analyzeExhaust = file.getAnalysisResults()
+                val analyzeExhaust = file.getAnalysisResults()
-                    if (analyzeExhaust.isError()) {
+                if (analyzeExhaust.isError()) {
-                        exception(analyzeExhaust.getError())
+                    exception(analyzeExhaust.getError())
-                    }
-
-                    val bindingContext = analyzeExhaust.getBindingContext()
-                    bindingContext.getDiagnostics().forEach {
-                        diagnostic ->
-                        if (diagnostic.getSeverity() == Severity.ERROR) {
-                            exception(DefaultErrorMessages.RENDERER.render(diagnostic))
-                        }
-                    }
-
-                    val state = GenerationState(
-                            file.getProject(),
-                            ClassBuilderFactories.BINARIES,
-                            analyzeExhaust.getModuleDescriptor(),
-                            bindingContext,
-                            listOf(file)
-                    )
-
-                    KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
-
-                    return state.getFactory()
                 }
-            })!!
 
+                val bindingContext = analyzeExhaust.getBindingContext()
+                bindingContext.getDiagnostics().forEach {
+                    diagnostic ->
+                    if (diagnostic.getSeverity() == Severity.ERROR) {
+                        exception(DefaultErrorMessages.RENDERER.render(diagnostic))
+                    }
+                }
+
+                val state = GenerationState(
+                        file.getProject(),
+                        ClassBuilderFactories.BINARIES,
+                        analyzeExhaust.getModuleDescriptor(),
+                        bindingContext,
+                        listOf(file)
+                )
+
+                KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
+
+                state.getFactory()
+            }!!
         }
 
         private fun exception(msg: String) = throw EvaluateExceptionUtil.createEvaluateException(msg)

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/extractFunctionForDebuggerUtil.kt

@@ -21,8 +21,6 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.jet.lang.psi.JetNamedFunction
 import org.jetbrains.jet.plugin.refactoring.extractFunction.AnalysisResult
 import org.jetbrains.jet.plugin.refactoring.extractFunction.AnalysisResult.ErrorMessage
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.util.Computable
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.plugin.codeInsight.CodeInsightUtils
 import org.jetbrains.jet.plugin.refactoring.createTempCopy
@@ -39,6 +37,7 @@ import org.jetbrains.jet.lang.psi.JetImportList
 import org.jetbrains.jet.lang.psi.JetPsiFactory
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.plugin.refactoring.extractFunction.ExtractionOptions
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 fun getFunctionForExtractedFragment(
         codeFragment: JetCodeFragment,
@@ -64,46 +63,46 @@ fun getFunctionForExtractedFragment(
         }.joinToString(", ")
     }
 
-    return ApplicationManager.getApplication()?.runReadAction(object: Computable<JetNamedFunction> {
+    fun generateFunction(): JetNamedFunction? {
-        override fun compute(): JetNamedFunction? {
+        checkForSyntacticErrors(codeFragment)
-            checkForSyntacticErrors(codeFragment)
 
-            val originalFile = breakpointFile as JetFile
+        val originalFile = breakpointFile as JetFile
 
-            val lineStart = CodeInsightUtils.getStartLineOffset(originalFile, breakpointLine)
+        val lineStart = CodeInsightUtils.getStartLineOffset(originalFile, breakpointLine)
-            if (lineStart == null) return null
+        if (lineStart == null) return null
 
-            val tmpFile = originalFile.createTempCopy { it }
+        val tmpFile = originalFile.createTempCopy { it }
-            tmpFile.skipVisibilityCheck = true
+        tmpFile.skipVisibilityCheck = true
 
-            val elementAtOffset = tmpFile.findElementAt(lineStart)
+        val elementAtOffset = tmpFile.findElementAt(lineStart)
-            if (elementAtOffset == null) return null
+        if (elementAtOffset == null) return null
 
-            val contextElement: PsiElement = CodeInsightUtils.getTopmostElementAtOffset(elementAtOffset, lineStart) ?: elementAtOffset
+        val contextElement: PsiElement = CodeInsightUtils.getTopmostElementAtOffset(elementAtOffset, lineStart) ?: elementAtOffset
 
-            addImportsToFile(codeFragment.importsAsImportList(), tmpFile)
+        addImportsToFile(codeFragment.importsAsImportList(), tmpFile)
 
-            val newDebugExpression = addDebugExpressionBeforeContextElement(codeFragment, contextElement)
+        val newDebugExpression = addDebugExpressionBeforeContextElement(codeFragment, contextElement)
-            if (newDebugExpression == null) return null
+        if (newDebugExpression == null) return null
 
-            val targetSibling = tmpFile.getDeclarations().firstOrNull()
+        val targetSibling = tmpFile.getDeclarations().firstOrNull()
-            if (targetSibling == null) return null
+        if (targetSibling == null) return null
 
-            val analysisResult = ExtractionData(
+        val analysisResult = ExtractionData(
-                    tmpFile, Collections.singletonList(newDebugExpression), targetSibling, ExtractionOptions(false)
+                tmpFile, Collections.singletonList(newDebugExpression), targetSibling, ExtractionOptions(false)
-            ).performAnalysis()
+        ).performAnalysis()
-            if (analysisResult.status != Status.SUCCESS) {
+        if (analysisResult.status != Status.SUCCESS) {
-                throw EvaluateExceptionUtil.createEvaluateException(getErrorMessageForExtractFunctionResult(analysisResult))
+            throw EvaluateExceptionUtil.createEvaluateException(getErrorMessageForExtractFunctionResult(analysisResult))
-            }
-
-            val validationResult = analysisResult.descriptor!!.validate()
-            if (!validationResult.conflicts.isEmpty()) {
-                throw EvaluateExceptionUtil.createEvaluateException("Following declarations are unavailable in debug scope: ${validationResult.conflicts.keySet()?.map { it.getText() }?.makeString(",")}")
-            }
-
-            return validationResult.descriptor.generateFunction(true)
         }
-    })
+
+        val validationResult = analysisResult.descriptor!!.validate()
+        if (!validationResult.conflicts.isEmpty()) {
+            throw EvaluateExceptionUtil.createEvaluateException("Following declarations are unavailable in debug scope: ${validationResult.conflicts.keySet()?.map { it.getText() }?.makeString(",")}")
+        }
+
+        return validationResult.descriptor.generateFunction(true)
+    }
+
+    return runReadAction { generateFunction() }
 }
 
 private fun addImportsToFile(newImportList: JetImportList?, tmpFile: JetFile) {

idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinFindClassUsagesHandler.kt

@@ -19,30 +19,24 @@ package org.jetbrains.jet.plugin.findUsages.handlers
 import com.intellij.find.findUsages.AbstractFindUsagesDialog
 import com.intellij.find.findUsages.FindUsagesOptions
 import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.util.Computable
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiReference
 import com.intellij.psi.search.PsiElementProcessor
 import com.intellij.psi.search.PsiElementProcessorAdapter
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.asJava.LightClassUtil
 import org.jetbrains.jet.lang.psi.JetClassOrObject
 import org.jetbrains.jet.plugin.findUsages.KotlinClassFindUsagesOptions
 import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinFindClassUsagesDialog
 import org.jetbrains.jet.plugin.search.declarationsSearch.HierarchySearchRequest
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchRequest
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.jet.plugin.search.declarationsSearch.searchInheritors
 import org.jetbrains.jet.plugin.findUsages.toSearchTarget
 import org.jetbrains.jet.plugin.findUsages.toClassHelper
 import org.jetbrains.jet.plugin.findUsages.toClassDeclarationsHelper
 import org.jetbrains.jet.plugin.search.usagesSearch.search
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 public class KotlinFindClassUsagesHandler(
         jetClass: JetClassOrObject,
@@ -81,7 +75,7 @@ public class KotlinFindClassUsagesHandler(
 
         val classOrObject = element as JetClassOrObject
 
-        return ApplicationManager.getApplication()!!.runReadAction<Boolean> {
+        return runReadAction {
             val target = kotlinOptions.toSearchTarget(classOrObject, true)
             val classUsages = kotlinOptions.toClassHelper().newRequest(target).search()
             val declarationUsages = kotlinOptions.toClassDeclarationsHelper().newRequest(target).search()

idea/src/org/jetbrains/jet/plugin/findUsages/handlers/KotlinTypeParameterFindUsagesHandler.kt

@@ -19,22 +19,16 @@ package org.jetbrains.jet.plugin.findUsages.handlers
 import com.intellij.find.findUsages.AbstractFindUsagesDialog
 import com.intellij.find.findUsages.FindUsagesOptions
 import com.intellij.openapi.actionSystem.DataContext
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.util.Computable
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiReference
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.Processor
-import org.jetbrains.annotations.Nullable
 import org.jetbrains.jet.lang.psi.JetNamedDeclaration
 import org.jetbrains.jet.plugin.findUsages.KotlinFindUsagesHandlerFactory
 import org.jetbrains.jet.plugin.findUsages.dialogs.KotlinTypeParameterFindUsagesDialog
 import org.jetbrains.jet.plugin.search.usagesSearch.DefaultSearchHelper
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearch
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchRequest
-import org.jetbrains.jet.plugin.search.usagesSearch.UsagesSearchTarget
 import org.jetbrains.jet.plugin.findUsages.toSearchTarget
 import org.jetbrains.jet.plugin.search.usagesSearch.search
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 public class KotlinTypeParameterFindUsagesHandler(
         element: JetNamedDeclaration,
@@ -49,7 +43,7 @@ public class KotlinTypeParameterFindUsagesHandler(
     }
 
     protected override fun searchReferences(element: PsiElement, processor: Processor<UsageInfo>, options: FindUsagesOptions): Boolean {
-        return ApplicationManager.getApplication()!!.runReadAction<Boolean> {
+        return runReadAction {
             val target = options.toSearchTarget(element as JetNamedDeclaration, true)
             val request = DefaultSearchHelper<JetNamedDeclaration>().newRequest(target)
             request.search().all {ref -> KotlinFindUsagesHandler.processUsage(processor, ref)}

idea/src/org/jetbrains/jet/plugin/refactoring/jetRefactoringUtil.kt

@@ -174,10 +174,16 @@ public fun Project.checkConflictsInteractively(conflicts: MultiMap<PsiElement, S
     onAccept()
 }
 
+public fun runReadAction<T: Any>(action: () -> T?): T? {
+    return ApplicationManager.getApplication()?.runReadAction<T>(action)
+}
+
+public fun runWriteAction<T: Any>(action: () -> T?): T? {
+    return ApplicationManager.getApplication()?.runWriteAction<T>(action)
+}
+
 public fun Project.executeWriteCommand(name: String, command: () -> Unit) {
-    CommandProcessor.getInstance()!!.executeCommand(
+    CommandProcessor.getInstance().executeCommand(this, { runWriteAction(command) }, name, null)
-            this, { ApplicationManager.getApplication()!!.runWriteAction(command) }, name, null
-    )
 }
 
 public fun <T : PsiElement> getPsiElementPopup(

idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinFunctionProcessor.kt

@@ -17,24 +17,16 @@
 package org.jetbrains.jet.plugin.refactoring.rename;
 
 import com.intellij.openapi.editor.Editor
-import com.intellij.psi.PsiCompiledElement
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.refactoring.rename.RenamePsiElementProcessor
 import com.intellij.psi.search.SearchScope
-import com.intellij.psi.search.searches.OverridingMethodsSearch
-import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.jet.asJava.LightClassUtil
 import org.jetbrains.jet.lang.psi.JetNamedFunction
-import com.intellij.openapi.util.Computable
-import com.intellij.psi.PsiMirrorElement
-import com.intellij.psi.SyntheticElement
-import com.intellij.refactoring.util.RefactoringUtil
-import com.intellij.refactoring.rename.RenameProcessor
 import com.intellij.refactoring.rename.RenameJavaMethodProcessor
-import com.intellij.psi.PsiNamedElement
 import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod
 import kotlin.properties.Delegates
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 public class RenameKotlinFunctionProcessor : RenamePsiElementProcessor() {
     private val javaMethodProcessorInstance by Delegates.lazy {
@@ -70,7 +62,7 @@ public class RenameKotlinFunctionProcessor : RenamePsiElementProcessor() {
 
     private fun wrapPsiMethod(element: PsiElement?): PsiMethod? = when (element) {
         is KotlinLightMethod -> element
-        is JetNamedFunction -> ApplicationManager.getApplication()!!.runReadAction(Computable { LightClassUtil.getLightClassMethod(element) })
+        is JetNamedFunction -> runReadAction { LightClassUtil.getLightClassMethod(element) }
         else -> throw IllegalStateException("Can't be for element $element there because of canProcessElement()")
     }
 }

idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt

@@ -23,8 +23,6 @@ import com.intellij.psi.search.SearchScope
 import com.intellij.openapi.application.ApplicationManager
 import org.jetbrains.jet.asJava.LightClassUtil
 import com.intellij.psi.search.searches.OverridingMethodsSearch
-import com.intellij.openapi.util.Computable
-import org.jetbrains.jet.asJava.LightClassUtil.PropertyAccessorsPsiMethods
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.SyntheticElement
 import com.intellij.refactoring.util.RefactoringUtil
@@ -36,15 +34,14 @@ import com.intellij.refactoring.listeners.RefactoringElementListener
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.jet.lexer.JetTokens
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
-import org.jetbrains.jet.lang.resolve.BindingContextUtils
 import org.jetbrains.jet.lang.resolve.BindingContext
 import org.jetbrains.jet.lang.psi.JetClassOrObject
 import com.intellij.openapi.ui.Messages
-import org.jetbrains.jet.lang.resolve.OverridingUtil
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
 import org.jetbrains.jet.asJava.namedUnwrappedElement
 import org.jetbrains.jet.lang.resolve.OverrideResolver
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
     override fun canProcessElement(element: PsiElement): Boolean = element.namedUnwrappedElement is JetProperty
@@ -86,9 +83,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
         val jetProperty = element?.namedUnwrappedElement as? JetProperty
         if (jetProperty == null) throw IllegalStateException("Can't be for element $element there because of canProcessElement()")
 
-        val propertyMethods = ApplicationManager.getApplication()!!.runReadAction(Computable<PropertyAccessorsPsiMethods> {
+        val propertyMethods = runReadAction { LightClassUtil.getLightClassPropertyMethods(jetProperty) }!!
-            LightClassUtil.getLightClassPropertyMethods(jetProperty)
-        })!!
 
         for (propertyMethod in propertyMethods) {
             addRenameElements(propertyMethod, jetProperty.getName(), newName, allRenames, scope)

idea/tests/org/jetbrains/jet/plugin/debugger/AbstractKotlinSteppingTest.kt

@@ -25,8 +25,8 @@ import com.intellij.debugger.DebuggerManagerEx
 import com.intellij.debugger.ui.breakpoints.LineBreakpoint
 import com.intellij.debugger.actions.MethodSmartStepTarget
 import com.intellij.debugger.engine.BasicStepMethodFilter
-import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.util.Computable
+import org.jetbrains.jet.plugin.refactoring.runReadAction
 
 abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestCase() {
 
@@ -86,7 +86,7 @@ abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestCase() {
 
         val line = (breakpoint as LineBreakpoint).getLineIndex()
 
-        return ApplicationManager.getApplication()?.runReadAction(Computable {
+        return runReadAction {
             val containingFile = breakpoint.getPsiFile()
             if (containingFile == null) throw AssertionError("Couldn't find file for breakpoint at the line $line")
 
@@ -101,6 +101,6 @@ abstract class AbstractKotlinSteppingTest : KotlinDebuggerTestCase() {
                     else -> BasicStepMethodFilter(stepTarget.getMethod(), stepTarget.getCallingExpressionLines())
                 }
             }
-        })!!
+        }!!
     }
 }

idea/tests/org/jetbrains/jet/plugin/refactoring/move/AbstractJetMoveTest.kt

@@ -58,23 +58,22 @@ import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.MoveKo
 import org.jetbrains.jet.plugin.refactoring.move.moveTopLevelDeclarations.JetFileKotlinMoveTarget
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.plugin.search.allScope
+import org.jetbrains.jet.plugin.refactoring.runWriteAction
 
 public abstract class AbstractJetMoveTest : MultiFileTestCase() {
     protected fun doTest(path: String) {
         fun extractCaretOffset(doc: Document): Int {
-            return ApplicationManager.getApplication()!!.runWriteAction(
+            return runWriteAction {
-                    Computable<Int> {
+                val text = StringBuilder(doc.getText())
-                        val text = StringBuilder(doc.getText())
+                val offset = text.indexOf("<caret>")
-                        val offset = text.indexOf("<caret>")
 
-                        if (offset >= 0) {
+                if (offset >= 0) {
-                            text.delete(offset, offset + "<caret>".length)
+                    text.delete(offset, offset + "<caret>".length)
-                            doc.setText(text.toString())
+                    doc.setText(text.toString())
-                        }
+                }
 
-                        offset
+                offset
-                    }
+            }!!
-            )!!
         }
 
         val config = JsonParser().parse(FileUtil.loadFile(File(path), true)) as JsonObject

idea/tests/org/jetbrains/jet/plugin/run/RunConfigurationTest.kt

@@ -43,6 +43,7 @@ import com.intellij.openapi.module.Module
 import java.io.File
 import com.intellij.openapi.roots.ModuleRootModificationUtil
 import org.jetbrains.jet.plugin.search.allScope
+import org.jetbrains.jet.plugin.refactoring.runWriteAction
 
 class RunConfigurationTest: CodeInsightTestCase() {
     override fun getProject() = myProject!!
@@ -61,9 +62,7 @@ class RunConfigurationTest: CodeInsightTestCase() {
     fun testDependencyModuleClasspath() {
         val dependencyModuleSrcDir = configureModule(moduleDirPath("module"), getProject().getBaseDir()!!).src
 
-        val moduleWithDependencyDir = ApplicationManager.getApplication()!!.runWriteAction(Computable<VirtualFile> {
+        val moduleWithDependencyDir = runWriteAction { getProject().getBaseDir()!!.createChildDirectory(this, "moduleWithDependency") }!!
-            getProject().getBaseDir()!!.createChildDirectory(this, "moduleWithDependency")
-        })!!
 
         val moduleWithDependency = createModule("moduleWithDependency")
         ModuleRootModificationUtil.setModuleSdk(moduleWithDependency, getTestProjectJdk())
@@ -101,7 +100,7 @@ class RunConfigurationTest: CodeInsightTestCase() {
             PsiTestUtil.addSourceRoot(getModule(), testDir, true)
         }
 
-        val (srcOutDir, testOutDir) = ApplicationManager.getApplication()!!.runWriteAction(Computable<Pair<VirtualFile, VirtualFile>> {
+        val (srcOutDir, testOutDir) = runWriteAction {
             val outDir = outputParentDir.createChildDirectory(this, "out")
             val srcOutDir = outDir.createChildDirectory(this, "production")
             val testOutDir = outDir.createChildDirectory(this, "test")
@@ -110,7 +109,7 @@ class RunConfigurationTest: CodeInsightTestCase() {
             PsiTestUtil.setCompilerOutputPath(configModule, testOutDir.getUrl(), true)
 
             Pair(srcOutDir, testOutDir)
-        })!!
+        }!!
 
         PsiDocumentManager.getInstance(getProject()).commitAllDocuments()