Reformat jps-plugin module

Original commit: 455fe7fe61

jps/jps-plugin/src/org/jetbrains/jps/builders/java/dependencyView/NullabilityAnnotationsTracker.kt

@@ -25,7 +25,9 @@ import org.jetbrains.kotlin.load.java.NULLABLE_ANNOTATIONS
 import java.util.*
 
 internal class NullabilityAnnotationsTracker : AnnotationsChangeTracker() {
-    private val annotations = (NULLABLE_ANNOTATIONS + JAVAX_NONNULL_ANNOTATION + NOT_NULL_ANNOTATIONS).mapTo(HashSet()) { it.internalNameWithoutInnerClasses }.toTypedArray()
+    private val annotations =
+        (NULLABLE_ANNOTATIONS + JAVAX_NONNULL_ANNOTATION + NOT_NULL_ANNOTATIONS).mapTo(HashSet()) { it.internalNameWithoutInnerClasses }
+            .toTypedArray()
 
     override fun methodAnnotationsChanged(
         context: DependencyContext,
@@ -48,7 +50,11 @@ internal class NullabilityAnnotationsTracker : AnnotationsChangeTracker() {
         return handleNullAnnotationsChanges(context, field, annotationsDiff.addedOrRemoved())
     }
 
-    private fun handleNullAnnotationsChanges(context: NamingContext, protoMember: ProtoMember, annotations: Sequence<TypeRepr.ClassType>): Set<Recompile> {
+    private fun handleNullAnnotationsChanges(
+        context: NamingContext,
+        protoMember: ProtoMember,
+        annotations: Sequence<TypeRepr.ClassType>
+    ): Set<Recompile> {
         val nullabilityAnnotations = TIntHashSet(this.annotations.toIntArray { context.get(it) })
         val changedNullAnnotation = annotations.firstOrNull { nullabilityAnnotations.contains(it.className) }
 
@@ -68,6 +74,6 @@ internal class NullabilityAnnotationsTracker : AnnotationsChangeTracker() {
     private fun <T> Difference.Specifier<T, Difference>.addedOrRemoved(): Sequence<T> =
         added().asSequence() + removed().asSequence()
 
-    private inline fun <T> Array<T>.toIntArray(fn: (T)->Int): IntArray =
+    private inline fun <T> Array<T>.toIntArray(fn: (T) -> Int): IntArray =
         IntArray(size) { i -> fn(get(i)) }
 }

jps/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/CompilerRunnerUtil.java

@@ -125,5 +125,4 @@ public class CompilerRunnerUtil {
 
         return null;
     }
-
 }

jps/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/JpsCompilerServicesFacadeImpl.kt

@@ -28,15 +28,18 @@ import java.io.Serializable
 internal class JpsCompilerServicesFacadeImpl(
     private val env: JpsCompilerEnvironment,
     port: Int = SOCKET_ANY_FREE_PORT
-) : CompilerCallbackServicesFacadeServer(env.services.get(IncrementalCompilationComponents::class.java),
+) : CompilerCallbackServicesFacadeServer(
+    env.services.get(IncrementalCompilationComponents::class.java),
     env.services.get(LookupTracker::class.java),
     env.services.get(CompilationCanceledStatus::class.java),
-                                         port),
+    port
+),
     JpsCompilerServicesFacade {
 
     override fun report(category: Int, severity: Int, message: String?, attachment: Serializable?) {
         env.messageCollector.reportFromDaemon(
             { outFile, srcFiles -> env.outputItemsCollector.add(srcFiles, outFile) },
-                category, severity, message, attachment)
+            category, severity, message, attachment
+        )
     }
 }

jps/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/JpsKotlinCompilerRunner.kt

@@ -39,13 +39,12 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
 
     private var compilerSettings: CompilerSettings? = null
 
-    private inline fun withCompilerSettings(settings: CompilerSettings, fn: ()->Unit) {
+    private inline fun withCompilerSettings(settings: CompilerSettings, fn: () -> Unit) {
         val old = compilerSettings
         try {
             compilerSettings = settings
             fn()
-        }
+        } finally {
-        finally {
             compilerSettings = old
         }
     }
@@ -55,14 +54,14 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
         private var _jpsCompileServiceSession: CompileServiceSession? = null
 
         @Synchronized
-        private fun getOrCreateDaemonConnection(newConnection: ()-> CompileServiceSession?): CompileServiceSession? {
+        private fun getOrCreateDaemonConnection(newConnection: () -> CompileServiceSession?): CompileServiceSession? {
             // TODO: consider adding state "ping" to the daemon interface
             if (_jpsCompileServiceSession == null || _jpsCompileServiceSession!!.compileService.getDaemonOptions() !is CompileService.CallResult.Good<DaemonOptions>) {
-                _jpsCompileServiceSession?. let {
+                _jpsCompileServiceSession?.let {
                     try {
                         it.compileService.releaseCompileSession(it.sessionId)
+                    } catch (_: Throwable) {
                     }
-                    catch (_: Throwable) {}
                 }
                 _jpsCompileServiceSession = newConnection()
             }
@@ -126,8 +125,7 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
         return if (isDaemonEnabled()) {
             val daemonExitCode = compileWithDaemon(compilerClassName, compilerArgs, environment)
             daemonExitCode ?: fallbackCompileStrategy(compilerArgs, compilerClassName, environment)
-        }
+        } else {
-        else {
             fallbackCompileStrategy(compilerArgs, compilerClassName, environment)
         }
     }
@@ -154,8 +152,15 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
         val (daemon, sessionId) = connection
         val compilerMode = CompilerMode.JPS_COMPILER
         val verbose = compilerArgs.verbose
-        val options = CompilationOptions(compilerMode, targetPlatform, reportCategories(verbose), reportSeverity(verbose), requestedCompilationResults = emptyArray())
+        val options = CompilationOptions(
-        val res = daemon.compile(sessionId, withAdditionalCompilerArgs(compilerArgs), options, JpsCompilerServicesFacadeImpl(environment), null)
+            compilerMode,
+            targetPlatform,
+            reportCategories(verbose),
+            reportSeverity(verbose),
+            requestedCompilationResults = emptyArray()
+        )
+        val res =
+            daemon.compile(sessionId, withAdditionalCompilerArgs(compilerArgs), options, JpsCompilerServicesFacadeImpl(environment), null)
         // TODO: consider implementing connection retry, instead of fallback here
         return res.takeUnless { it is CompileService.CallResult.Dying }?.let { exitCodeFromProcessExitCode(it.get()) }
     }
@@ -170,8 +175,7 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
         val categories =
             if (!verbose) {
                 arrayOf(ReportCategory.COMPILER_MESSAGE, ReportCategory.EXCEPTION)
-            }
+            } else {
-            else {
                 ReportCategory.values()
             }
 
@@ -182,8 +186,7 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
     private fun reportSeverity(verbose: Boolean): Int =
         if (!verbose) {
             ReportSeverity.INFO.code
-            }
+        } else {
-            else {
             ReportSeverity.DEBUG.code
         }
 
@@ -227,7 +230,13 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
         }
     }
 
-    private fun setupK2JsArguments(_outputFile: File, sourceFiles: Collection<File>, _libraries: List<String>, _friendModules: List<String>, settings: K2JSCompilerArguments) {
+    private fun setupK2JsArguments(
+        _outputFile: File,
+        sourceFiles: Collection<File>,
+        _libraries: List<String>,
+        _friendModules: List<String>,
+        settings: K2JSCompilerArguments
+    ) {
         with(settings) {
             noStdlib = true
             freeArgs = sourceFiles.map { it.path }.toMutableList()
@@ -249,7 +258,7 @@ class JpsKotlinCompilerRunner : KotlinCompilerRunner<JpsCompilerEnvironment>() {
             val libPath = CompilerRunnerUtil.getLibPath(environment.kotlinPaths, environment.messageCollector)
             val compilerPath = File(libPath, "kotlin-compiler.jar")
             val toolsJarPath = CompilerRunnerUtil.getJdkToolsJar()
-                val compilerId = CompilerId.makeCompilerId(listOfNotNull(compilerPath, toolsJarPath) )
+            val compilerId = CompilerId.makeCompilerId(listOfNotNull(compilerPath, toolsJarPath))
             val daemonOptions = configureDaemonOptions()
 
             val clientFlagFile = KotlinCompilerClient.getOrCreateClientFlagFile(daemonOptions)

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/FSOperationsHelper.kt

@@ -53,8 +53,7 @@ class FSOperationsHelper(
 
         if (recursively) {
             FSOperations.markDirtyRecursively(compileContext, CompilationRound.NEXT, chunk, ::shouldMark)
-        }
+        } else {
-        else {
             FSOperations.markDirty(compileContext, CompilationRound.NEXT, chunk, ::shouldMark)
         }
     }
@@ -67,7 +66,7 @@ class FSOperationsHelper(
         markFilesImpl(files) { it !in excludeFiles && it.exists() && moduleBasedFilter.accept(it) }
     }
 
-    private inline fun markFilesImpl(files: Iterable<File>, shouldMark: (File)->Boolean) {
+    private inline fun markFilesImpl(files: Iterable<File>, shouldMark: (File) -> Boolean) {
         val filesToMark = files.filterTo(HashSet(), shouldMark)
 
         if (filesToMark.isEmpty()) return
@@ -85,7 +84,7 @@ class FSOperationsHelper(
     private class ModulesBasedFileFilter(
         private val context: CompileContext,
         chunk: ModuleChunk
-    ): Mappings.DependentFilesFilter {
+    ) : Mappings.DependentFilesFilter {
         private val chunkTargets = chunk.targets
         private val buildRootIndex = context.projectDescriptor.buildRootIndex
         private val buildTargetIndex = context.projectDescriptor.buildTargetIndex

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsJsModuleUtils.kt

@@ -70,24 +70,25 @@ object JpsJsModuleUtils {
 
     @JvmStatic
     fun getOutputMetaFile(module: JpsModule, isTests: Boolean): File {
-        val moduleBuildTarget = ModuleBuildTarget(module, if (isTests) JavaModuleBuildTargetType.TEST else JavaModuleBuildTargetType.PRODUCTION)
+        val moduleBuildTarget =
+            ModuleBuildTarget(module, if (isTests) JavaModuleBuildTargetType.TEST else JavaModuleBuildTargetType.PRODUCTION)
         val outputDir = KotlinBuilderModuleScriptGenerator.getOutputDirSafe(moduleBuildTarget)
         return getOutputMetaFile(outputDir, module.name, isTests)
     }
 
     @JvmStatic
-    fun getOutputFile(outputDir: File, moduleName: String, isTests: Boolean)
+    fun getOutputFile(outputDir: File, moduleName: String, isTests: Boolean) =
-            = File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.JS_EXT)
+        File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.JS_EXT)
 
     @JvmStatic
-    fun getOutputMetaFile(outputDir: File, moduleName: String, isTests: Boolean)
+    fun getOutputMetaFile(outputDir: File, moduleName: String, isTests: Boolean) =
-            = File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.META_JS_SUFFIX)
+        File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.META_JS_SUFFIX)
 
     private fun suffix(isTests: Boolean) = if (isTests) "_test" else ""
 }
 
 val JpsModule.hasProductionSourceRoot
-    get() = sourceRoots.any { it.rootType == JavaSourceRootType.SOURCE}
+    get() = sourceRoots.any { it.rootType == JavaSourceRootType.SOURCE }
 
 val JpsModule.hasTestSourceRoot
-    get() = sourceRoots.any { it.rootType == JavaSourceRootType.TEST_SOURCE}
+    get() = sourceRoots.any { it.rootType == JavaSourceRootType.TEST_SOURCE }

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsUtils.java

@@ -37,7 +37,9 @@ import java.util.concurrent.ConcurrentHashMap;
 class JpsUtils {
     private static final Map<ModuleBuildTarget, Boolean> IS_KOTLIN_JS_MODULE_CACHE = new ConcurrentHashMap<ModuleBuildTarget, Boolean>();
     private static final Map<String, Boolean> IS_KOTLIN_JS_STDLIB_JAR_CACHE = new ConcurrentHashMap<String, Boolean>();
-    private JpsUtils() {}
+
+    private JpsUtils() {
+    }
 
     @NotNull
     static JpsJavaDependenciesEnumerator getAllDependencies(@NotNull ModuleBuildTarget target) {
@@ -66,8 +68,12 @@ class JpsUtils {
 
                 Boolean cachedValue = IS_KOTLIN_JS_STDLIB_JAR_CACHE.get(url);
                 if (cachedValue != null) {
-                    if (cachedValue.booleanValue()) return true;
+                    if (cachedValue.booleanValue()) {
-                    else continue;
+                        return true;
+                    }
+                    else {
+                        continue;
+                    }
                 }
 
                 boolean isKotlinJavascriptStdLibrary = LibraryUtils.isKotlinJavascriptStdLibrary(JpsPathUtil.urlToFile(url));

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt

@@ -29,7 +29,6 @@ import org.jetbrains.jps.builders.java.JavaBuilderUtil
 import org.jetbrains.jps.builders.java.JavaSourceRootDescriptor
 import org.jetbrains.jps.incremental.*
 import org.jetbrains.jps.incremental.ModuleLevelBuilder.ExitCode.*
-import org.jetbrains.jps.incremental.fs.CompilationRound
 import org.jetbrains.jps.incremental.java.JavaBuilder
 import org.jetbrains.jps.incremental.messages.BuildMessage
 import org.jetbrains.jps.incremental.messages.CompilerMessage
@@ -70,10 +69,11 @@ import java.io.File
 import java.io.IOException
 import java.net.URI
 import java.util.*
+import kotlin.collections.HashSet
 
 class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
     companion object {
-        @JvmField val KOTLIN_BUILDER_NAME: String = "Kotlin Builder"
+        const val KOTLIN_BUILDER_NAME: String = "Kotlin Builder"
 
         val LOG = Logger.getInstance("#org.jetbrains.kotlin.jps.build.KotlinBuilder")
         const val JVM_BUILD_META_INFO_FILE_NAME = "jvm-build-meta-info.txt"
@@ -176,16 +176,17 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
                 val lastBuildMetaInfo =
                     try {
                         JvmBuildMetaInfo.deserializeFromString(file.readText()) ?: continue
-                        }
+                    } catch (e: Exception) {
-                        catch (e: Exception) {
                         LOG.error("Could not deserialize jvm build meta info", e)
                         continue
                     }
 
                 val lastBuildLangVersion = LanguageVersion.fromVersionString(lastBuildMetaInfo.languageVersionString)
                 val lastBuildApiVersion = ApiVersion.parse(lastBuildMetaInfo.apiVersionString)
-                val currentLangVersion = args.languageVersion?.let { LanguageVersion.fromVersionString(it) } ?: LanguageVersion.LATEST_STABLE
+                val currentLangVersion =
-                val currentApiVersion = args.apiVersion?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(currentLangVersion)
+                    args.languageVersion?.let { LanguageVersion.fromVersionString(it) } ?: LanguageVersion.LATEST_STABLE
+                val currentApiVersion =
+                    args.apiVersion?.let { ApiVersion.parse(it) } ?: ApiVersion.createByLanguageVersion(currentLangVersion)
 
                 val reasonToRebuild = when {
                     currentLangVersion != lastBuildLangVersion -> {
@@ -235,18 +236,16 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
 
             val actualExitCode = if (proposedExitCode == OK && fsOperations.hasMarkedDirty) ADDITIONAL_PASS_REQUIRED else proposedExitCode
 
-            LOG.debug("Build result: " + actualExitCode)
+            LOG.debug("Build result: $actualExitCode")
 
             context.testingContext?.buildLogger?.buildFinished(actualExitCode)
 
             return actualExitCode
-        }
+        } catch (e: StopBuildException) {
-        catch (e: StopBuildException) {
+            LOG.info("Caught exception: $e")
-            LOG.info("Caught exception: " + e)
             throw e
-        }
+        } catch (e: Throwable) {
-        catch (e: Throwable) {
+            LOG.info("Caught exception: $e")
-            LOG.info("Caught exception: " + e)
             MessageCollectorUtil.reportException(messageCollector, e)
             return ABORT
         }
@@ -279,8 +278,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
                 targets.forEach { rebuildAfterCacheVersionChanged[it] = true }
                 return CHUNK_REBUILD_REQUIRED
             }
-        }
+        } else {
-        else {
             if (isChunkRebuilding) {
                 targets.forEach { hasKotlin[it] = false }
             }
@@ -311,8 +309,10 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         LOG.debug("Compiling files: ${filesToCompile.values()}")
 
         val start = System.nanoTime()
-        val outputItemCollector = doCompileModuleChunk(allCompiledFiles, chunk, commonArguments, context, dirtyFilesHolder,
+        val outputItemCollector = doCompileModuleChunk(
-                                                       environment, filesToCompile, incrementalCaches, project)
+            allCompiledFiles, chunk, commonArguments, context, dirtyFilesHolder,
+            environment, filesToCompile, incrementalCaches, project
+        )
 
         statisticsLogger.registerStatistic(chunk, System.nanoTime() - start)
 
@@ -324,8 +324,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         if (compilationErrors) {
             LOG.info("Compiled with errors")
             return ABORT
-        }
+        } else {
-        else {
             LOG.info("Compiled successfully")
         }
 
@@ -478,11 +477,15 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
 
         for (argumentProvider in ServiceLoader.load(KotlinJpsCompilerArgumentsProvider::class.java)) {
             // appending to pluginOptions
-            commonArguments.pluginOptions = concatenate(commonArguments.pluginOptions,
+            commonArguments.pluginOptions = concatenate(
-                                                        argumentProvider.getExtraArguments(representativeTarget, context))
+                commonArguments.pluginOptions,
+                argumentProvider.getExtraArguments(representativeTarget, context)
+            )
             // appending to classpath
-            commonArguments.pluginClasspaths = concatenate(commonArguments.pluginClasspaths,
+            commonArguments.pluginClasspaths = concatenate(
-                                                           argumentProvider.getClasspath(representativeTarget, context))
+                commonArguments.pluginClasspaths,
+                argumentProvider.getClasspath(representativeTarget, context)
+            )
 
             LOG.debug("Plugin loaded: ${argumentProvider::class.java.simpleName}")
         }
@@ -511,8 +514,10 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
     ): JpsCompilerEnvironment? {
         val compilerServices = with(Services.Builder()) {
             register(LookupTracker::class.java, lookupTracker)
-            register(IncrementalCompilationComponents::class.java,
+            register(
-                     IncrementalCompilationComponentsImpl(incrementalCaches.mapKeys { TargetId(it.key) }))
+                IncrementalCompilationComponents::class.java,
+                IncrementalCompilationComponentsImpl(incrementalCaches.mapKeys { TargetId(it.key) })
+            )
             register(CompilationCanceledStatus::class.java, object : CompilationCanceledStatus {
                 override fun checkCanceled() {
                     if (context.cancelStatus.isCanceled) throw CompilationCanceledException()
@@ -523,8 +528,10 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
 
         val paths = computeKotlinPathsForJpsPlugin()
         if (paths == null || !paths.homePath.exists()) {
-            messageCollector.report(ERROR, "Cannot find kotlinc home. Make sure the plugin is properly installed, " +
+            messageCollector.report(
-                                           "or specify $JPS_KOTLIN_HOME_PROPERTY system property")
+                ERROR, "Cannot find kotlinc home. Make sure the plugin is properly installed, " +
+                        "or specify $JPS_KOTLIN_HOME_PROPERTY system property"
+            )
             return null
         }
 
@@ -567,16 +574,20 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         if (chunk.targets.size > 1) {
             for (target in chunk.targets) {
                 for (file in KotlinSourceFileCollector.getAllKotlinSourceFiles(target)) {
-                    sourceToTarget.put(file, target)
+                    sourceToTarget[file] = target
                 }
             }
         }
 
         val representativeTarget = chunk.representativeTarget()
         fun SimpleOutputItem.target() =
-                sourceFiles.firstOrNull()?.let { sourceToTarget[it] } ?:
+            sourceFiles.firstOrNull()?.let { sourceToTarget[it] } ?: chunk.targets.singleOrNull {
-                chunk.targets.singleOrNull { it.outputDir?.let { outputFile.startsWith(it) } ?: false } ?:
+                it.outputDir?.let {
-                representativeTarget
+                    outputFile.startsWith(
+                        it
+                    )
+                } ?: false
+            } ?: representativeTarget
 
         return outputItemCollector.outputs.groupBy(SimpleOutputItem::target, SimpleOutputItem::toGeneratedFile)
     }
@@ -646,7 +657,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         dirtyFilesHolder: DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget>,
         filesToCompile: MultiMap<ModuleBuildTarget, File>
     ) {
-        if (lookupTracker !is LookupTrackerImpl) throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker::class.java}")
+        if (lookupTracker !is LookupTrackerImpl)
+            throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker::class.java}")
 
         val removedFiles = chunk.targets.flatMap { KotlinSourceFileCollector.getRemovedKotlinFiles(dirtyFilesHolder, it) }
         dataManager.withLookupStorage { lookupStorage ->
@@ -656,7 +668,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
     }
 
     // if null is returned, nothing was done
-    private fun compileToJs(chunk: ModuleChunk,
+    private fun compileToJs(
+        chunk: ModuleChunk,
         commonArguments: CommonCompilerArguments,
         environment: JpsCompilerEnvironment,
         project: JpsProject
@@ -698,8 +711,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         // If prefix is not specified (empty) in UI, we want to produce paths relative to source maps location
         val sourceRoots = if (k2JsArguments.sourceMapPrefix.isNullOrBlank()) {
             emptyList()
-        }
+        } else {
-        else {
             representativeModule.contentRootsList.urls
                 .map { URI.create(it) }
                 .filter { it.scheme == "file" }
@@ -712,8 +724,10 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         }
 
         val compilerRunner = JpsKotlinCompilerRunner()
-        compilerRunner.runK2JsCompiler(commonArguments, k2JsArguments, compilerSettings, environment, sourceFiles, sourceRoots,
+        compilerRunner.runK2JsCompiler(
-                                       libraries, friendPaths, outputFile)
+            commonArguments, k2JsArguments, compilerSettings, environment, sourceFiles, sourceRoots,
+            libraries, friendPaths, outputFile
+        )
         return environment.outputItemsCollector
     }
 
@@ -726,13 +740,16 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
             val outputLibraryRuntimeDirectory = File(outputDir, compilerSettings.outputDirectoryForJsLibraryFiles).absolutePath
             val libraryFilesToCopy = arrayListOf<String>()
             JpsJsModuleUtils.getLibraryFiles(representativeTarget, libraryFilesToCopy)
-            JsLibraryUtils.copyJsFilesFromLibraries(libraryFilesToCopy, outputLibraryRuntimeDirectory,
+            JsLibraryUtils.copyJsFilesFromLibraries(
-                                                    copySourceMap = k2jsCompilerSettings.sourceMap)
+                libraryFilesToCopy, outputLibraryRuntimeDirectory,
+                copySourceMap = k2jsCompilerSettings.sourceMap
+            )
         }
     }
 
     // if null is returned, nothing was done
-    private fun compileToJvm(allCompiledFiles: MutableSet<File>,
+    private fun compileToJvm(
+        allCompiledFiles: MutableSet<File>,
         chunk: ModuleChunk,
         commonArguments: CommonCompilerArguments,
         context: CompileContext,
@@ -763,7 +780,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
             }
         }
 
-        val moduleFile = KotlinBuilderModuleScriptGenerator.generateModuleDescription(context, chunk, filesToCompile, totalRemovedFiles != 0)
+        val moduleFile =
+            KotlinBuilderModuleScriptGenerator.generateModuleDescription(context, chunk, filesToCompile, totalRemovedFiles != 0)
         if (moduleFile == null) {
             KotlinBuilder.LOG.debug("Not compiling, because no files affected: " + filesToCompile.keySet().joinToString { it.presentableName })
             // No Kotlin sources found
@@ -781,8 +799,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         try {
             val compilerRunner = JpsKotlinCompilerRunner()
             compilerRunner.runK2JvmCompiler(commonArguments, k2JvmArguments, compilerSettings, environment, moduleFile)
-        }
+        } finally {
-        finally {
             if (System.getProperty("kotlin.jps.delete.module.file.after.build") != "false") {
                 moduleFile.delete()
             }
@@ -802,7 +819,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
             }
             val kind = kind(severity)
             if (kind != null) {
-                context.processMessage(CompilerMessage(
+                context.processMessage(
+                    CompilerMessage(
                         CompilerRunnerConstants.KOTLIN_COMPILER_NAME,
                         kind,
                         prefix + message,
@@ -810,9 +828,9 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
                         -1, -1, -1,
                         location?.line?.toLong() ?: -1,
                         location?.column?.toLong() ?: -1
-                ))
+                    )
-            }
+                )
-            else {
+            } else {
                 val path = if (location != null) "${location.path}:${location.line}:${location.column}: " else ""
                 KotlinBuilder.LOG.debug(path + message)
             }
@@ -830,7 +848,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
                 ERROR, EXCEPTION -> BuildMessage.Kind.ERROR
                 WARNING, STRONG_WARNING -> BuildMessage.Kind.WARNING
                 LOGGING -> null
-                else -> throw IllegalArgumentException("Unsupported severity: " + severity)
+                else -> throw IllegalArgumentException("Unsupported severity: $severity")
             }
         }
     }
@@ -926,6 +944,7 @@ private fun getDependenciesRecursively(module: JpsModule, kind: JpsJavaClasspath
 
 // TODO: investigate thread safety
 private val ALL_COMPILED_FILES_KEY = Key.create<MutableSet<File>>("_all_kotlin_compiled_files_")
+
 private fun getAllCompiledFilesContainer(context: CompileContext): MutableSet<File> {
     var allCompiledFiles = ALL_COMPILED_FILES_KEY.get(context)
     if (allCompiledFiles == null) {
@@ -937,10 +956,11 @@ private fun getAllCompiledFilesContainer(context: CompileContext): MutableSet<Fi
 
 // TODO: investigate thread safety
 private val PROCESSED_TARGETS_WITH_REMOVED_FILES = Key.create<MutableSet<ModuleBuildTarget>>("_processed_targets_with_removed_files_")
+
 private fun getProcessedTargetsWithRemovedFilesContainer(context: CompileContext): MutableSet<ModuleBuildTarget> {
     var set = PROCESSED_TARGETS_WITH_REMOVED_FILES.get(context)
     if (set == null) {
-        set = HashSet<ModuleBuildTarget>()
+        set = HashSet()
         PROCESSED_TARGETS_WITH_REMOVED_FILES.set(context, set)
     }
     return set

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilderModuleScriptGenerator.kt

@@ -62,10 +62,10 @@ object KotlinBuilderModuleScriptGenerator {
         val getProductionModuleMethod: Method
 
         try {
-            getTestModulePropertiesMethod = JpsJavaExtensionService::class.java.getDeclaredMethod("getTestModuleProperties", JpsModule::class.java)
+            getTestModulePropertiesMethod =
+                    JpsJavaExtensionService::class.java.getDeclaredMethod("getTestModuleProperties", JpsModule::class.java)
             getProductionModuleMethod = klass.getDeclaredMethod("getProductionModule")
-        }
+        } catch (e: NoSuchMethodException) {
-        catch (e: NoSuchMethodException) {
             return@run alwaysNull()
         }
 
@@ -100,7 +100,8 @@ object KotlinBuilderModuleScriptGenerator {
                 if (IncrementalCompilation.isEnabled())
                     sourceFiles.get(target)
                 else
-                        KotlinSourceFileCollector.getAllKotlinSourceFiles(target))
+                    KotlinSourceFileCollector.getAllKotlinSourceFiles(target)
+            )
 
             if (moduleSources.size > 0 || hasRemovedFiles) {
                 noSources = false
@@ -124,7 +125,8 @@ object KotlinBuilderModuleScriptGenerator {
                 (targetType as JavaModuleBuildTargetType).isTests,
                 // this excludes the output directories from the class path, to be removed for true incremental compilation
                 outputDirs,
-                    friendDirs)
+                friendDirs
+            )
         }
 
         if (noSources) return null
@@ -144,14 +146,12 @@ object KotlinBuilderModuleScriptGenerator {
         val dir = System.getProperty("kotlin.jps.dir.for.module.files")?.let { File(it) }?.takeIf { it.isDirectory }
         return try {
             File.createTempFile("kjps", readableSuffix + ".script.xml", dir)
-        }
+        } catch (e: IOException) {
-        catch (e: IOException) {
             // sometimes files cannot be created, because file name is too long (Windows, Mac OS)
             // see https://bugs.openjdk.java.net/browse/JDK-8148023
             try {
                 File.createTempFile("kjps", ".script.xml", dir)
-            }
+            } catch (e: IOException) {
-            catch (e: IOException) {
                 val message = buildString {
                     append("Could not create module file when building chunk $chunk")
                     if (dir != null) {

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinSourceFileCollector.java

@@ -42,8 +42,7 @@ public class KotlinSourceFileCollector {
     // For incremental compilation
     @NotNull
     public static MultiMap<ModuleBuildTarget, File> getDirtySourceFiles(DirtyFilesHolder<JavaSourceRootDescriptor, ModuleBuildTarget> dirtyFilesHolder)
-            throws IOException
+            throws IOException {
-    {
         final MultiMap<ModuleBuildTarget, File> result = new MultiMap<ModuleBuildTarget, File>();
 
         dirtyFilesHolder.processDirtyFiles(new FileProcessor<JavaSourceRootDescriptor, ModuleBuildTarget>() {
@@ -84,7 +83,8 @@ public class KotlinSourceFileCollector {
 
     @NotNull
     public static List<File> getAllKotlinSourceFiles(@NotNull ModuleBuildTarget target) {
-        final List<File> moduleExcludes = ContainerUtil.map(target.getModule().getExcludeRootsList().getUrls(), new Function<String, File>() {
+        final List<File> moduleExcludes =
+                ContainerUtil.map(target.getModule().getExcludeRootsList().getUrls(), new Function<String, File>() {
                     @Override
                     public File fun(String url) {
                         return JpsPathUtil.urlToFile(url);
@@ -92,7 +92,8 @@ public class KotlinSourceFileCollector {
                 });
 
         final JpsCompilerExcludes compilerExcludes =
-                JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(target.getModule().getProject()).getCompilerExcludes();
+                JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(target.getModule().getProject())
+                        .getCompilerExcludes();
 
         final List<File> result = ContainerUtil.newArrayList();
         for (JpsModuleSourceRoot sourceRoot : getRelevantSourceRoots(target)) {
@@ -135,5 +136,6 @@ public class KotlinSourceFileCollector {
         return FileUtilRt.extensionEquals(file.getName(), "kt");
     }
 
-    private KotlinSourceFileCollector() {}
+    private KotlinSourceFileCollector() {
+    }
 }

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/MarkerFile.kt

@@ -57,4 +57,5 @@ abstract class MarkerFile(private val fileName: String, private val paths: Build
 }
 
 class HasKotlinMarker(dataManager: BuildDataManager) : MarkerFile(HAS_KOTLIN_MARKER_FILE_NAME, dataManager.dataPaths)
-class RebuildAfterCacheVersionChangeMarker(dataManager: BuildDataManager) : MarkerFile(REBUILD_AFTER_CACHE_VERSION_CHANGE_MARKER, dataManager.dataPaths)
+class RebuildAfterCacheVersionChangeMarker(dataManager: BuildDataManager) :
+    MarkerFile(REBUILD_AFTER_CACHE_VERSION_CHANGE_MARKER, dataManager.dataPaths)

jps/jps-plugin/src/org/jetbrains/kotlin/jps/build/TeamcityStatisticsLogger.kt

@@ -47,8 +47,7 @@ class TeamcityStatisticsLogger {
             val escChar = escapedChar(c)
             if (escChar == 0.toChar()) {
                 escaped.append(c)
-            }
+            } else {
-            else {
                 escaped.append('|').append(escChar)
             }
         }

jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt

@@ -21,7 +21,7 @@ import com.intellij.openapi.util.io.FileUtil
 class PathFunctionPair(
     val path: String,
     val function: String
-): Comparable<PathFunctionPair> {
+) : Comparable<PathFunctionPair> {
     override fun compareTo(other: PathFunctionPair): Int {
         val pathComp = FileUtil.comparePaths(path, other.path)
 

jps/jps-plugin/src/org/jetbrains/kotlin/jps/model/BaseJpsCompilerSettingsSerializer.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.config.SettingConstants
 abstract class BaseJpsCompilerSettingsSerializer<T : Any>(
     componentName: String,
     private val settingsFactory: () -> T
-): JpsProjectExtensionSerializer(SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE, componentName) {
+) : JpsProjectExtensionSerializer(SettingConstants.KOTLIN_COMPILER_SETTINGS_FILE, componentName) {
     protected abstract fun onLoad(project: JpsProject, settings: T)
 
     override fun loadExtension(project: JpsProject, componentTag: Element) {