Reformat kotlin-gradle-plugin according to code style

generators/tests/org/jetbrains/kotlin/generators/arguments/GenerateGradleOptions.kt

@@ -194,7 +194,9 @@ private fun Printer.generateImpl(
             generatePropertyDeclaration(property, modifiers = "override")
             withIndent {
                 println("get() = $backingField ?: ${property.gradleDefaultValue}")
-                println("set(value) { $backingField = value }")
+                println("set(value) {")
+                withIndent { println("$backingField = value") }
+                println("}")
             }
         }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCompilationResults.kt

@@ -14,8 +14,12 @@ import java.rmi.server.UnicastRemoteObject
 
 internal class GradleCompilationResults(
     project: Project
-): CompilationResults,
+) : CompilationResults,
-   UnicastRemoteObject(SOCKET_ANY_FREE_PORT, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) {
+    UnicastRemoteObject(
+        SOCKET_ANY_FREE_PORT,
+        LoopbackNetworkInterface.clientLoopbackSocketFactory,
+        LoopbackNetworkInterface.serverLoopbackSocketFactory
+    ) {
 
     private val log = project.logger
     private val projectRootFile = project.rootProject.projectDir

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleIncrementalCompilerServicesFacadeImpl.kt

@@ -39,7 +39,8 @@ internal open class GradleCompilerServicesFacadeImpl(
                     category = category,
                     severity = severity,
                     message = message,
-                        attachment = attachment)
+                    attachment = attachment
+                )
             }
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerRunner.kt

@@ -148,12 +148,14 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
         environment: GradleCompilerEnvironment
     ): ExitCode {
         if (compilerArgs.version) {
-            project.logger.lifecycle("Kotlin version " + loadCompilerVersion(environment.compilerClasspath) +
+            project.logger.lifecycle(
-                    " (JRE " + System.getProperty("java.runtime.version") + ")")
+                "Kotlin version " + loadCompilerVersion(environment.compilerClasspath) +
+                        " (JRE " + System.getProperty("java.runtime.version") + ")"
+            )
             compilerArgs.version = false
         }
         val argsArray = ArgumentUtils.convertArgumentsToStringList(compilerArgs).toTypedArray()
-        with (project.logger) {
+        with(project.logger) {
             kotlinDebug { "Kotlin compiler class: $compilerClassName" }
             kotlinDebug { "Kotlin compiler classpath: ${environment.compilerFullClasspath.map { it.canonicalPath }.joinToString()}" }
             kotlinDebug { "Kotlin compiler args: ${argsArray.joinToString(" ")}" }
@@ -165,8 +167,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
 
             if (daemonExitCode != null) {
                 return daemonExitCode
-            }
+            } else {
-            else {
                 log.warn("Could not connect to kotlin daemon. Using fallback strategy.")
             }
         }
@@ -174,8 +175,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
         val isGradleDaemonUsed = System.getProperty("org.gradle.daemon")?.let(String::toBoolean)
         return if (executionStrategy == IN_PROCESS_EXECUTION_STRATEGY || isGradleDaemonUsed == false) {
             compileInProcess(argsArray, compilerClassName, environment)
-        }
+        } else {
-        else {
             compileOutOfProcess(argsArray, compilerClassName, environment)
         }
     }
@@ -183,12 +183,15 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
     private val kotlinCompilerExecutionStrategy: String
         get() = System.getProperty(KOTLIN_COMPILER_EXECUTION_STRATEGY_PROPERTY) ?: DAEMON_EXECUTION_STRATEGY
 
-    override fun compileWithDaemon(compilerClassName: String, compilerArgs: CommonCompilerArguments, environment: GradleCompilerEnvironment): ExitCode? {
+    override fun compileWithDaemon(
+        compilerClassName: String,
+        compilerArgs: CommonCompilerArguments,
+        environment: GradleCompilerEnvironment
+    ): ExitCode? {
         val connection =
             try {
                 getDaemonConnection(environment)
-                }
+            } catch (e: Throwable) {
-                catch (e: Throwable) {
                 log.warn("Caught an exception trying to connect to Kotlin Daemon")
                 e.printStackTrace()
                 null
@@ -196,8 +199,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
         if (connection == null) {
             if (environment is GradleIncrementalCompilerEnvironment) {
                 log.warn("Could not perform incremental compilation: $COULD_NOT_CONNECT_TO_DAEMON_MESSAGE")
-            }
+            } else {
-            else {
                 log.warn(COULD_NOT_CONNECT_TO_DAEMON_MESSAGE)
             }
             return null
@@ -217,8 +219,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
                 nonIncrementalCompilationWithDaemon(daemon, sessionId, targetPlatform, environment)
             }
             exitCodeFromProcessExitCode(res.get())
-        }
+        } catch (e: Throwable) {
-        catch (e: Throwable) {
             log.warn("Compilation with Kotlin compile daemon was not successful")
             e.printStackTrace()
             null
@@ -228,8 +229,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
         // TODO: implement a proper logic to avoid remote calls in such cases
         try {
             daemon.clearJarCache()
-        }
+        } catch (e: RemoteException) {
-        catch (e: RemoteException) {
             log.warn("Unable to clear jar cache after compilation, maybe daemon is already down: $e")
         }
         logFinish(DAEMON_EXECUTION_STRATEGY)
@@ -248,7 +248,8 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
             targetPlatform = targetPlatform,
             reportCategories = reportCategories(verbose),
             reportSeverity = reportSeverity(verbose),
-                requestedCompilationResults = emptyArray())
+            requestedCompilationResults = emptyArray()
+        )
         val servicesFacade = GradleCompilerServicesFacadeImpl(project, environment.messageCollector)
         val argsArray = ArgumentUtils.convertArgumentsToStringList(environment.compilerArgs).toTypedArray()
         return daemon.compile(sessionId, argsArray, compilationOptions, servicesFacade, compilationResults = null)
@@ -288,16 +289,14 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
     private fun reportCategories(verbose: Boolean): Array<Int> =
         if (!verbose) {
             arrayOf(ReportCategory.COMPILER_MESSAGE.code)
-            }
+        } else {
-            else {
             ReportCategory.values().map { it.code }.toTypedArray()
         }
 
     private fun reportSeverity(verbose: Boolean): Int =
         if (!verbose) {
             ReportSeverity.INFO.code
-            }
+        } else {
-            else {
             ReportSeverity.DEBUG.code
         }
 
@@ -419,8 +418,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
                 val projectName = project.rootProject.name.normalizeForFlagFile()
                 clientIsAliveFlagFile = newTmpFile(prefix = "kotlin-compiler-in-$projectName-", suffix = ".alive")
                 log.kotlinDebug { CREATED_CLIENT_FILE_PREFIX + clientIsAliveFlagFile!!.canonicalPath }
-            }
+            } else {
-            else {
                 log.kotlinDebug { EXISTING_CLIENT_FILE_PREFIX + clientIsAliveFlagFile!!.canonicalPath }
             }
 
@@ -444,8 +442,7 @@ internal class GradleCompilerRunner(private val project: Project) : KotlinCompil
                 val sessionFilesDir = sessionsDir(project).apply { mkdirs() }
                 sessionFlagFile = newTmpFile(prefix = "kotlin-compiler-", suffix = ".salive", directory = sessionFilesDir)
                 log.kotlinDebug { CREATED_SESSION_FILE_PREFIX + sessionFlagFile!!.relativeToRoot(project) }
-            }
+            } else {
-            else {
                 log.kotlinDebug { EXISTING_SESSION_FILE_PREFIX + sessionFlagFile!!.relativeToRoot(project) }
             }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/KotlinNativeToolRunner.kt

@@ -28,9 +28,9 @@ import org.jetbrains.kotlin.konan.util.DependencyDirectories
 /** Copied from Kotlin/Native repository. */
 
 internal enum class KotlinNativeProjectProperty(val propertyName: String) {
-    KONAN_HOME_OVERRIDE            ("org.jetbrains.kotlin.native.home"),
+    KONAN_HOME_OVERRIDE("org.jetbrains.kotlin.native.home"),
-    KONAN_JVM_ARGS                 ("org.jetbrains.kotlin.native.jvmArgs"),
+    KONAN_JVM_ARGS("org.jetbrains.kotlin.native.jvmArgs"),
-    KONAN_VERSION                  ("org.jetbrains.kotlin.native.version"),
+    KONAN_VERSION("org.jetbrains.kotlin.native.version"),
     KONAN_USE_ENVIRONMENT_VARIABLES("org.jetbrains.kotlin.native.useEnvironmentVariables")
 }
 
@@ -56,7 +56,7 @@ internal val Project.konanVersion: KonanVersion
         KonanVersion.fromString(it.toString())
     } ?: NativeCompilerDownloader.DEFAULT_KONAN_VERSION
 
-internal interface KonanToolRunner: Named {
+internal interface KonanToolRunner : Named {
     val mainClass: String
     val classpath: FileCollection
     val jvmArgs: List<String>
@@ -72,7 +72,7 @@ internal abstract class KonanCliRunner(
     val fullName: String,
     val project: Project,
     private val additionalJvmArgs: List<String>
-): KonanToolRunner {
+) : KonanToolRunner {
     override val mainClass = "org.jetbrains.kotlin.cli.utilities.MainKt"
 
     override fun getName() = toolName
@@ -121,9 +121,11 @@ internal abstract class KonanCliRunner(
     override fun run(args: List<String>) {
         project.logger.info("Run tool: $toolName with args: ${args.joinToString(separator = " ")}")
         if (classpath.isEmpty) {
-            throw IllegalStateException("Classpath of the tool is empty: $toolName\n" +
+            throw IllegalStateException(
+                "Classpath of the tool is empty: $toolName\n" +
                         "Probably the '${KotlinNativeProjectProperty.KONAN_HOME_OVERRIDE}' project property contains an incorrect path.\n" +
-                                        "Please change it to the compiler root directory and rerun the build.")
+                        "Please change it to the compiler root directory and rerun the build."
+            )
         }
 
         project.javaexec { spec ->
@@ -145,15 +147,16 @@ internal abstract class KonanCliRunner(
     }
 }
 
-internal class KonanInteropRunner(project: Project, additionalJvmArgs: List<String> = emptyList())
+internal class KonanInteropRunner(project: Project, additionalJvmArgs: List<String> = emptyList()) :
-    : KonanCliRunner("cinterop", "Kotlin/Native cinterop tool", project, additionalJvmArgs)
+    KonanCliRunner("cinterop", "Kotlin/Native cinterop tool", project, additionalJvmArgs) {
-{
     init {
         if (HostManager.host == KonanTarget.MINGW_X64) {
             //TODO: Oh-ho-ho fix it in more convinient way.
-            environment.put("PATH", DependencyDirectories.defaultDependenciesRoot.absolutePath +
+            environment.put(
+                "PATH", DependencyDirectories.defaultDependenciesRoot.absolutePath +
                         "\\msys2-mingw-w64-x86_64-gcc-7.3.0-clang-llvm-lld-6.0.1" +
-                            "\\bin;${environment.get("PATH")}")
+                        "\\bin;${environment.get("PATH")}"
+            )
         }
     }
 }
@@ -162,8 +165,7 @@ internal class KonanCompilerRunner(
     project: Project,
     additionalJvmArgs: List<String> = emptyList(),
     val useArgFile: Boolean = true
-) : KonanCliRunner("konanc", "Kotlin/Native compiler", project, additionalJvmArgs)
+) : KonanCliRunner("konanc", "Kotlin/Native compiler", project, additionalJvmArgs) {
-{
     override fun transformArgs(args: List<String>): List<String> {
         if (!useArgFile) {
             return args
@@ -182,5 +184,5 @@ internal class KonanCompilerRunner(
     }
 }
 
-internal class KonanKlibRunner(project: Project, additionalJvmArgs: List<String> = emptyList())
+internal class KonanKlibRunner(project: Project, additionalJvmArgs: List<String> = emptyList()) :
-    : KonanCliRunner("klib", "Klib management tool", project, additionalJvmArgs)
+    KonanCliRunner("klib", "Klib management tool", project, additionalJvmArgs)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/utils.kt

@@ -54,16 +54,15 @@ internal fun loadCompilerVersion(compilerClasspath: List<File>): String {
                     val bytes = jar.getInputStream(jar.getEntry(versionClassFileName)).use { it.readBytes() }
                     checkVersion(bytes)
                 }
-            }
+            } else if (cpFile.isDirectory) {
-            else if (cpFile.isDirectory) {
                 File(cpFile, versionClassFileName).takeIf { it.isFile }?.let {
                     checkVersion(it.readBytes())
                 }
             }
             if (result != null) break
         }
+    } catch (e: Throwable) {
     }
-    catch (e: Throwable) {}
 
     return result ?: "<unknown>"
 }
@@ -73,7 +72,7 @@ internal fun runToolInSeparateProcess(
     logger: KotlinLogger, messageCollector: MessageCollector
 ): ExitCode {
     val javaBin = System.getProperty("java.home") + File.separator + "bin" + File.separator + "java"
-    val classpathString = classpath.map {it.absolutePath}.joinToString(separator = File.pathSeparator)
+    val classpathString = classpath.map { it.absolutePath }.joinToString(separator = File.pathSeparator)
     val builder = ProcessBuilder(javaBin, "-cp", classpathString, compilerClassName, *argsArray)
     val process = launchProcessWithFallback(builder, DaemonReportingTargets(messageCollector = messageCollector))
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinCompile.kt

@@ -18,10 +18,7 @@ package org.jetbrains.kotlin.gradle.dsl
 
 import groovy.lang.Closure
 import org.gradle.api.Task
-import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.Internal
-import org.jetbrains.kotlin.cli.common.arguments.CommonToolArguments
-import org.jetbrains.kotlin.compilerRunner.ArgumentUtils
 
 interface KotlinCompile<T : KotlinCommonOptions> : Task {
     @get:Internal

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinJsDceOptionsBase.kt

@@ -7,27 +7,37 @@ internal abstract class KotlinJsDceOptionsBase : org.jetbrains.kotlin.gradle.dsl
     private var allWarningsAsErrorsField: kotlin.Boolean? = null
     override var allWarningsAsErrors: kotlin.Boolean
         get() = allWarningsAsErrorsField ?: false
-        set(value) { allWarningsAsErrorsField = value }
+        set(value) {
+            allWarningsAsErrorsField = value
+        }
 
     private var suppressWarningsField: kotlin.Boolean? = null
     override var suppressWarnings: kotlin.Boolean
         get() = suppressWarningsField ?: false
-        set(value) { suppressWarningsField = value }
+        set(value) {
+            suppressWarningsField = value
+        }
 
     private var verboseField: kotlin.Boolean? = null
     override var verbose: kotlin.Boolean
         get() = verboseField ?: false
-        set(value) { verboseField = value }
+        set(value) {
+            verboseField = value
+        }
 
     private var devModeField: kotlin.Boolean? = null
     override var devMode: kotlin.Boolean
         get() = devModeField ?: false
-        set(value) { devModeField = value }
+        set(value) {
+            devModeField = value
+        }
 
     private var outputDirectoryField: kotlin.String?? = null
     override var outputDirectory: kotlin.String?
         get() = outputDirectoryField ?: null
-        set(value) { outputDirectoryField = value }
+        set(value) {
+            outputDirectoryField = value
+        }
 
     internal open fun updateArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments) {
         allWarningsAsErrorsField?.let { args.allWarningsAsErrors = it }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinJsOptionsBase.kt

@@ -7,82 +7,114 @@ internal abstract class KotlinJsOptionsBase : org.jetbrains.kotlin.gradle.dsl.Ko
     private var allWarningsAsErrorsField: kotlin.Boolean? = null
     override var allWarningsAsErrors: kotlin.Boolean
         get() = allWarningsAsErrorsField ?: false
-        set(value) { allWarningsAsErrorsField = value }
+        set(value) {
+            allWarningsAsErrorsField = value
+        }
 
     private var suppressWarningsField: kotlin.Boolean? = null
     override var suppressWarnings: kotlin.Boolean
         get() = suppressWarningsField ?: false
-        set(value) { suppressWarningsField = value }
+        set(value) {
+            suppressWarningsField = value
+        }
 
     private var verboseField: kotlin.Boolean? = null
     override var verbose: kotlin.Boolean
         get() = verboseField ?: false
-        set(value) { verboseField = value }
+        set(value) {
+            verboseField = value
+        }
 
     private var apiVersionField: kotlin.String?? = null
     override var apiVersion: kotlin.String?
         get() = apiVersionField ?: null
-        set(value) { apiVersionField = value }
+        set(value) {
+            apiVersionField = value
+        }
 
     private var languageVersionField: kotlin.String?? = null
     override var languageVersion: kotlin.String?
         get() = languageVersionField ?: null
-        set(value) { languageVersionField = value }
+        set(value) {
+            languageVersionField = value
+        }
 
     private var friendModulesDisabledField: kotlin.Boolean? = null
     override var friendModulesDisabled: kotlin.Boolean
         get() = friendModulesDisabledField ?: false
-        set(value) { friendModulesDisabledField = value }
+        set(value) {
+            friendModulesDisabledField = value
+        }
 
     private var mainField: kotlin.String? = null
     override var main: kotlin.String
         get() = mainField ?: "call"
-        set(value) { mainField = value }
+        set(value) {
+            mainField = value
+        }
 
     private var metaInfoField: kotlin.Boolean? = null
     override var metaInfo: kotlin.Boolean
         get() = metaInfoField ?: true
-        set(value) { metaInfoField = value }
+        set(value) {
+            metaInfoField = value
+        }
 
     private var moduleKindField: kotlin.String? = null
     override var moduleKind: kotlin.String
         get() = moduleKindField ?: "plain"
-        set(value) { moduleKindField = value }
+        set(value) {
+            moduleKindField = value
+        }
 
     private var noStdlibField: kotlin.Boolean? = null
     override var noStdlib: kotlin.Boolean
         get() = noStdlibField ?: true
-        set(value) { noStdlibField = value }
+        set(value) {
+            noStdlibField = value
+        }
 
     private var outputFileField: kotlin.String?? = null
     override var outputFile: kotlin.String?
         get() = outputFileField ?: null
-        set(value) { outputFileField = value }
+        set(value) {
+            outputFileField = value
+        }
 
     private var sourceMapField: kotlin.Boolean? = null
     override var sourceMap: kotlin.Boolean
         get() = sourceMapField ?: false
-        set(value) { sourceMapField = value }
+        set(value) {
+            sourceMapField = value
+        }
 
     private var sourceMapEmbedSourcesField: kotlin.String?? = null
     override var sourceMapEmbedSources: kotlin.String?
         get() = sourceMapEmbedSourcesField ?: null
-        set(value) { sourceMapEmbedSourcesField = value }
+        set(value) {
+            sourceMapEmbedSourcesField = value
+        }
 
     private var sourceMapPrefixField: kotlin.String?? = null
     override var sourceMapPrefix: kotlin.String?
         get() = sourceMapPrefixField ?: null
-        set(value) { sourceMapPrefixField = value }
+        set(value) {
+            sourceMapPrefixField = value
+        }
 
     private var targetField: kotlin.String? = null
     override var target: kotlin.String
         get() = targetField ?: "v5"
-        set(value) { targetField = value }
+        set(value) {
+            targetField = value
+        }
 
     private var typedArraysField: kotlin.Boolean? = null
     override var typedArrays: kotlin.Boolean
         get() = typedArraysField ?: true
-        set(value) { typedArraysField = value }
+        set(value) {
+            typedArraysField = value
+        }
 
     internal open fun updateArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments) {
         allWarningsAsErrorsField?.let { args.allWarningsAsErrors = it }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinJvmOptionsBase.kt

@@ -7,62 +7,86 @@ internal abstract class KotlinJvmOptionsBase : org.jetbrains.kotlin.gradle.dsl.K
     private var allWarningsAsErrorsField: kotlin.Boolean? = null
     override var allWarningsAsErrors: kotlin.Boolean
         get() = allWarningsAsErrorsField ?: false
-        set(value) { allWarningsAsErrorsField = value }
+        set(value) {
+            allWarningsAsErrorsField = value
+        }
 
     private var suppressWarningsField: kotlin.Boolean? = null
     override var suppressWarnings: kotlin.Boolean
         get() = suppressWarningsField ?: false
-        set(value) { suppressWarningsField = value }
+        set(value) {
+            suppressWarningsField = value
+        }
 
     private var verboseField: kotlin.Boolean? = null
     override var verbose: kotlin.Boolean
         get() = verboseField ?: false
-        set(value) { verboseField = value }
+        set(value) {
+            verboseField = value
+        }
 
     private var apiVersionField: kotlin.String?? = null
     override var apiVersion: kotlin.String?
         get() = apiVersionField ?: null
-        set(value) { apiVersionField = value }
+        set(value) {
+            apiVersionField = value
+        }
 
     private var languageVersionField: kotlin.String?? = null
     override var languageVersion: kotlin.String?
         get() = languageVersionField ?: null
-        set(value) { languageVersionField = value }
+        set(value) {
+            languageVersionField = value
+        }
 
     private var includeRuntimeField: kotlin.Boolean? = null
     override var includeRuntime: kotlin.Boolean
         get() = includeRuntimeField ?: false
-        set(value) { includeRuntimeField = value }
+        set(value) {
+            includeRuntimeField = value
+        }
 
     private var javaParametersField: kotlin.Boolean? = null
     override var javaParameters: kotlin.Boolean
         get() = javaParametersField ?: false
-        set(value) { javaParametersField = value }
+        set(value) {
+            javaParametersField = value
+        }
 
     private var jdkHomeField: kotlin.String?? = null
     override var jdkHome: kotlin.String?
         get() = jdkHomeField ?: null
-        set(value) { jdkHomeField = value }
+        set(value) {
+            jdkHomeField = value
+        }
 
     private var jvmTargetField: kotlin.String? = null
     override var jvmTarget: kotlin.String
         get() = jvmTargetField ?: "1.6"
-        set(value) { jvmTargetField = value }
+        set(value) {
+            jvmTargetField = value
+        }
 
     private var noJdkField: kotlin.Boolean? = null
     override var noJdk: kotlin.Boolean
         get() = noJdkField ?: false
-        set(value) { noJdkField = value }
+        set(value) {
+            noJdkField = value
+        }
 
     private var noReflectField: kotlin.Boolean? = null
     override var noReflect: kotlin.Boolean
         get() = noReflectField ?: true
-        set(value) { noReflectField = value }
+        set(value) {
+            noReflectField = value
+        }
 
     private var noStdlibField: kotlin.Boolean? = null
     override var noStdlib: kotlin.Boolean
         get() = noStdlibField ?: true
-        set(value) { noStdlibField = value }
+        set(value) {
+            noStdlibField = value
+        }
 
     internal open fun updateArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments) {
         allWarningsAsErrorsField?.let { args.allWarningsAsErrors = it }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformCommonOptionsBase.kt

@@ -7,27 +7,37 @@ internal abstract class KotlinMultiplatformCommonOptionsBase : org.jetbrains.kot
     private var allWarningsAsErrorsField: kotlin.Boolean? = null
     override var allWarningsAsErrors: kotlin.Boolean
         get() = allWarningsAsErrorsField ?: false
-        set(value) { allWarningsAsErrorsField = value }
+        set(value) {
+            allWarningsAsErrorsField = value
+        }
 
     private var suppressWarningsField: kotlin.Boolean? = null
     override var suppressWarnings: kotlin.Boolean
         get() = suppressWarningsField ?: false
-        set(value) { suppressWarningsField = value }
+        set(value) {
+            suppressWarningsField = value
+        }
 
     private var verboseField: kotlin.Boolean? = null
     override var verbose: kotlin.Boolean
         get() = verboseField ?: false
-        set(value) { verboseField = value }
+        set(value) {
+            verboseField = value
+        }
 
     private var apiVersionField: kotlin.String?? = null
     override var apiVersion: kotlin.String?
         get() = apiVersionField ?: null
-        set(value) { apiVersionField = value }
+        set(value) {
+            apiVersionField = value
+        }
 
     private var languageVersionField: kotlin.String?? = null
     override var languageVersion: kotlin.String?
         get() = languageVersionField ?: null
-        set(value) { languageVersionField = value }
+        set(value) {
+            languageVersionField = value
+        }
 
     internal open fun updateArguments(args: org.jetbrains.kotlin.cli.common.arguments.K2MetadataCompilerArguments) {
         allWarningsAsErrorsField?.let { args.allWarningsAsErrors = it }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformExtension.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.gradle.dsl
 
-import org.gradle.api.InvalidUserCodeException
 import org.gradle.api.NamedDomainObjectCollection
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.KotlinTargetPreset

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinProjectExtension.kt

@@ -41,7 +41,9 @@ open class KotlinProjectExtension {
     var sourceSets: NamedDomainObjectContainer<out KotlinSourceSet>
         @Suppress("UNCHECKED_CAST")
         get() = DslObject(this).extensions.getByName("sourceSets") as NamedDomainObjectContainer<out KotlinSourceSet>
-        internal set(value) { DslObject(this).extensions.add("sourceSets", value) }
+        internal set(value) {
+            DslObject(this).extensions.add("sourceSets", value)
+        }
 }
 
 open class KotlinSingleJavaTargetExtension : KotlinProjectExtension() {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/AndroidSubplugin.kt

@@ -38,7 +38,8 @@ import javax.inject.Inject
 import javax.xml.parsers.DocumentBuilderFactory
 
 // Use apply plugin: 'kotlin-android-extensions' to enable Android Extensions in an Android project.
-class AndroidExtensionsSubpluginIndicator @Inject internal constructor(private val registry: ToolingModelBuilderRegistry) : Plugin<Project> {
+class AndroidExtensionsSubpluginIndicator @Inject internal constructor(private val registry: ToolingModelBuilderRegistry) :
+    Plugin<Project> {
     override fun apply(project: Project) {
         val extension = project.extensions.create("androidExtensions", AndroidExtensionsExtension::class.java)
 
@@ -69,8 +70,11 @@ class AndroidExtensionsSubpluginIndicator @Inject internal constructor(private v
 
             if (name != requiredConfigurationName) return@all
 
-            configuration.dependencies.add(project.dependencies.create(
+            configuration.dependencies.add(
-                    "org.jetbrains.kotlin:kotlin-android-extensions-runtime:$kotlinPluginVersion"))
+                project.dependencies.create(
+                    "org.jetbrains.kotlin:kotlin-android-extensions-runtime:$kotlinPluginVersion"
+                )
+            )
         }
     }
 }
@@ -107,8 +111,10 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         val androidExtensionsExtension = project.extensions.getByType(AndroidExtensionsExtension::class.java)
 
         if (androidExtensionsExtension.isExperimental) {
-            return applyExperimental(kotlinCompile, androidExtension, androidExtensionsExtension,
+            return applyExperimental(
-                    project, variantData, androidProjectHandler)
+                kotlinCompile, androidExtension, androidExtensionsExtension,
+                project, variantData, androidProjectHandler
+            )
         }
 
         val sourceSets = androidExtension.sourceSets
@@ -120,7 +126,8 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         val manifestFile = mainSourceSet.manifest.srcFile
         val applicationPackage = getApplicationPackageFromManifest(manifestFile) ?: run {
             project.logger.warn(
-                    "Application package name is not present in the manifest file (${manifestFile.absolutePath})")
+                "Application package name is not present in the manifest file (${manifestFile.absolutePath})"
+            )
             ""
         }
         pluginOptions += SubpluginOption("package", applicationPackage)
@@ -128,11 +135,13 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         fun addVariant(sourceSet: AndroidSourceSet) {
             val optionValue = sourceSet.name + ';' +
                     sourceSet.res.srcDirs.joinToString(";") { it.absolutePath }
-            pluginOptions += CompositeSubpluginOption("variant", optionValue, listOf(
+            pluginOptions += CompositeSubpluginOption(
+                "variant", optionValue, listOf(
                     SubpluginOption("sourceSetName", sourceSet.name),
                     //use the INTERNAL option kind since the resources are tracked as sources (see below)
                     FilesSubpluginOption("resDirs", sourceSet.res.srcDirs.toList())
-            ))
+                )
+            )
             kotlinCompile.source(project.files(getLayoutDirectories(sourceSet.res.srcDirs)))
         }
 
@@ -172,8 +181,10 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
                                          AndroidExtensionsFeature.parseFeatures(androidExtensionsExtension.features).joinToString(",") { it.featureName })
 
         pluginOptions += SubpluginOption("experimental", "true")
-        pluginOptions += SubpluginOption("defaultCacheImplementation",
+        pluginOptions += SubpluginOption(
-                androidExtensionsExtension.defaultCacheImplementation.optionName)
+            "defaultCacheImplementation",
+            androidExtensionsExtension.defaultCacheImplementation.optionName
+        )
 
         val mainSourceSet = androidExtension.sourceSets.getByName("main")
         pluginOptions += SubpluginOption("package", getApplicationPackage(project, mainSourceSet))
@@ -184,10 +195,13 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
                 append(';')
                 resDirectories.joinTo(this, separator = ";") { it.canonicalPath }
             }
-            pluginOptions += CompositeSubpluginOption("variant", optionValue, listOf(
+            pluginOptions += CompositeSubpluginOption(
+                "variant", optionValue, listOf(
                     SubpluginOption("variantName", name),
                     // use INTERNAL option kind since the resources are tracked as sources (see below)
-                    FilesSubpluginOption("resDirs", resDirectories)))
+                    FilesSubpluginOption("resDirs", resDirectories)
+                )
+            )
 
             kotlinCompile.source(project.files(getLayoutDirectories(resDirectories)))
         }
@@ -227,13 +241,15 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
     }
 
     // Android25ProjectHandler.KaptVariant actually contains BaseVariant, not BaseVariantData
-    private fun getVariantComponentNames(flavorData: Any?): VariantComponentNames? = when(flavorData) {
+    private fun getVariantComponentNames(flavorData: Any?): VariantComponentNames? = when (flavorData) {
         is KaptVariantData<*> -> getVariantComponentNames(flavorData.variantData)
         is TestVariantData -> getVariantComponentNames(flavorData.testedVariantData)
         is TestVariant -> getVariantComponentNames(flavorData.testedVariant)
         is BaseVariant -> VariantComponentNames(flavorData.name, flavorData.flavorName, flavorData.buildType.name)
-        is BaseVariantData<*> -> VariantComponentNames(flavorData.name, flavorData.variantConfiguration.flavorName,
+        is BaseVariantData<*> -> VariantComponentNames(
-                flavorData.variantConfiguration.buildType.name)
+            flavorData.name, flavorData.variantConfiguration.flavorName,
+            flavorData.variantConfiguration.buildType.name
+        )
         else -> null
     }
 
@@ -254,8 +270,10 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
         val applicationPackage = getApplicationPackageFromManifest(manifestFile)
 
         if (applicationPackage == null) {
-            project.logger.warn("Application package name is not present in the manifest file " +
+            project.logger.warn(
-                    "(${manifestFile.absolutePath})")
+                "Application package name is not present in the manifest file " +
+                        "(${manifestFile.absolutePath})"
+            )
 
             return ""
         } else {
@@ -266,8 +284,7 @@ class AndroidSubplugin : KotlinGradleSubplugin<KotlinCompile> {
     private fun getApplicationPackageFromManifest(manifestFile: File): String? {
         try {
             return manifestFile.parseXml().documentElement.getAttribute("package")
-        }
+        } catch (e: Exception) {
-        catch (e: Exception) {
             return null
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/CompilerArgumentsGradleInput.kt

@@ -19,7 +19,6 @@ package org.jetbrains.kotlin.gradle.internal
 import org.jetbrains.kotlin.cli.common.arguments.*
 import kotlin.reflect.KProperty
 import kotlin.reflect.KProperty1
-import kotlin.reflect.full.memberProperties
 
 internal object CompilerArgumentsGradleInput {
     fun <T : CommonToolArguments> createInputsMap(args: T): Map<String, String> {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/Kapt3KotlinGradleSubplugin.kt

@@ -24,10 +24,10 @@ import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.getKa
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.getKaptGeneratedSourcesDir
 import org.jetbrains.kotlin.gradle.internal.Kapt3KotlinGradleSubplugin.Companion.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.model.builder.KaptModelBuilder
-import org.jetbrains.kotlin.gradle.tasks.isWorkerAPISupported
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.isWorkerAPISupported
 import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -76,7 +76,8 @@ abstract class KaptVariantData<T>(val variantData: T) {
     abstract fun registerGeneratedJavaSource(
         project: Project,
         kaptTask: KaptTask,
-            javaTask: AbstractCompile)
+        javaTask: AbstractCompile
+    )
 
     open val annotationProcessorOptionProviders: List<*>
         get() = emptyList<Any>()
@@ -201,8 +202,7 @@ class Kapt3KotlinGradleSubplugin : KotlinGradleSubplugin<KotlinCompile> {
             }
 
             kaptVariantData.name
-        }
+        } else {
-        else {
             if (kotlinCompilation == null) error("In non-Android projects, Kotlin compilation should not be null")
 
             handleSourceSet(kotlinCompilation.compilationName)
@@ -410,7 +410,8 @@ class Kapt3KotlinGradleSubplugin : KotlinGradleSubplugin<KotlinCompile> {
     private fun Kapt3SubpluginContext.createKaptGenerateStubsTask(): KaptGenerateStubsTask {
         val kaptTask = project.tasks.create(
             getKaptTaskName("kaptGenerateStubs"),
-                KaptGenerateStubsTask::class.java)
+            KaptGenerateStubsTask::class.java
+        )
 
         kaptTask.sourceSetName = sourceSetName
         kaptTask.kotlinCompileTask = kotlinCompile

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptGenerateStubsTask.kt

@@ -21,15 +21,15 @@ import org.gradle.api.file.FileCollection
 import org.gradle.api.tasks.*
 import org.gradle.api.tasks.incremental.IncrementalTaskInputs
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
+import org.jetbrains.kotlin.gradle.incremental.ChangedFiles
 import org.jetbrains.kotlin.gradle.plugin.kotlinDebug
 import org.jetbrains.kotlin.gradle.tasks.FilteringSourceRootsContainer
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.SourceRoots
-import org.jetbrains.kotlin.gradle.incremental.ChangedFiles
 import org.jetbrains.kotlin.gradle.utils.isParentOf
+import org.jetbrains.kotlin.gradle.utils.pathsAsStringRelativeTo
 import org.jetbrains.kotlin.incremental.classpathAsList
 import org.jetbrains.kotlin.incremental.destinationAsFile
-import org.jetbrains.kotlin.gradle.utils.pathsAsStringRelativeTo
 import java.io.File
 
 @CacheableTask
@@ -45,19 +45,24 @@ open class KaptGenerateStubsTask : KotlinCompile() {
     @get:Internal
     lateinit var generatedSourcesDir: File
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
+    @get:InputFiles
     val kaptClasspath: FileCollection
         get() = project.files(*kaptClasspathConfigurations.toTypedArray())
 
     @get:Internal
     internal lateinit var kaptClasspathConfigurations: List<Configuration>
 
-    @get:Classpath @get:InputFiles @Suppress("unused")
+    @get:Classpath
-    internal val kotlinTaskPluginClasspath get() = kotlinCompileTask.pluginClasspath
+    @get:InputFiles
+    @Suppress("unused")
+    internal val kotlinTaskPluginClasspath
+        get() = kotlinCompileTask.pluginClasspath
 
     override fun source(vararg sources: Any?): SourceTask? {
         return super.source(sourceRootsContainer.add(sources))
     }
+
     override fun setSource(sources: Any?) {
         super.setSource(sourceRootsContainer.set(sources))
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptTask.kt

@@ -5,10 +5,10 @@ import org.gradle.api.artifacts.Configuration
 import org.gradle.api.file.FileCollection
 import org.gradle.api.internal.ConventionTask
 import org.gradle.api.tasks.*
-import org.jetbrains.kotlin.gradle.tasks.*
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.cacheOnlyIfEnabledForKotlin
+import org.jetbrains.kotlin.gradle.tasks.isBuildCacheSupported
 import org.jetbrains.kotlin.gradle.utils.isJavaFile
-import org.jetbrains.kotlin.gradle.utils.isParentOf
-import org.jetbrains.kotlin.gradle.utils.toSortedPathsArray
 import java.io.File
 
 @CacheableTask
@@ -29,12 +29,15 @@ abstract class KaptTask : ConventionTask() {
     @get:Internal
     internal lateinit var stubsDir: File
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
+    @get:InputFiles
     val kaptClasspath: FileCollection
         get() = project.files(*kaptClasspathConfigurations.toTypedArray())
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
-    val compilerClasspath: List<File> get() = kotlinCompileTask.computedCompilerClasspath
+    @get:InputFiles
+    val compilerClasspath: List<File>
+        get() = kotlinCompileTask.computedCompilerClasspath
 
     @get:Internal
     internal lateinit var kaptClasspathConfigurations: List<Configuration>
@@ -51,14 +54,16 @@ abstract class KaptTask : ConventionTask() {
     @get:Nested
     internal val annotationProcessorOptionProviders: MutableList<Any> = mutableListOf()
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
+    @get:InputFiles
     val classpath: FileCollection
         get() = kotlinCompileTask.classpath
 
     @get:Internal
     var useBuildCache: Boolean = false
 
-    @get:InputFiles @get:PathSensitive(PathSensitivity.RELATIVE)
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
     val source: Collection<File>
         get() {
             val result = HashSet<File>()

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithKotlincTask.kt

@@ -30,7 +30,8 @@ open class KaptWithKotlincTask : KaptTask(), CompilerArgumentAwareWithInput<K2JV
     @get:Classpath
     @get:InputFiles
     @Suppress("unused")
-    internal val kotlinTaskPluginClasspaths get() = kotlinCompileTask.pluginClasspath
+    internal val kotlinTaskPluginClasspaths
+        get() = kotlinCompileTask.pluginClasspath
 
     @get:Classpath
     @get:InputFiles

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithoutKotlincTask.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.gradle.internal
 
-import org.gradle.api.tasks.*
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.TaskAction
 import org.gradle.workers.IsolationMode
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.gradle.internal.Kapt3KotlinGradleSubplugin.Companion.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/subpluginUtils.kt

@@ -16,9 +16,9 @@
 
 package org.jetbrains.kotlin.gradle.internal
 
-import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
 import org.jetbrains.kotlin.gradle.plugin.CompositeSubpluginOption
 import org.jetbrains.kotlin.gradle.plugin.FilesSubpluginOption
+import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
 import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import java.io.ByteArrayOutputStream
 import java.io.File

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinGradleBuildServices.kt

@@ -108,7 +108,8 @@ internal class KotlinGradleBuildServices private constructor(gradle: Gradle) : B
         log.lifecycle(FORCE_SYSTEM_GC_MESSAGE)
         val gcCountBefore = getGcCount()
         System.gc()
-        while (getGcCount() == gcCountBefore) {}
+        while (getGcCount() == gcCountBefore) {
+        }
 
         val rt = Runtime.getRuntime()
         return (rt.totalMemory() - rt.freeMemory()) / 1024

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinJsDcePlugin.kt

@@ -71,7 +71,7 @@ class KotlinJsDcePlugin : Plugin<Project> {
 
             val configuration = project.configurations.getByName(kotlinCompilation.compileDependencyConfigurationName)
 
-            with (dceTask) {
+            with(dceTask) {
                 classpath = configuration
                 destinationDir = dceTask.dceOptions.outputDirectory?.let { File(it) } ?: outputDir
                 source(kotlinTask.outputFile)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinMultiplatformPlugin.kt

@@ -76,8 +76,7 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
                     configurationsForCommonModuleDependency(project).forEach { configuration ->
                         configuration.dependencies.add(dep)
                     }
-                }
+                } else {
-                else {
                     throw GradleException("$project '${config.name}' dependency is not a project: $dep")
                 }
             }
@@ -104,7 +103,8 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
                 throw GradleException(
                     "Platform project $platformProject has an " +
                             "'$EXPECTED_BY_CONFIG_NAME'${if (implementConfigurationIsUsed) "/'$IMPLEMENT_CONFIG_NAME'" else ""} " +
-                        "dependency to non-common project $commonProject")
+                            "dependency to non-common project $commonProject"
+                )
             }
 
             // Since the two projects may add source sets in arbitrary order, and both may do that after the plugin is applied,
@@ -159,7 +159,8 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
         project.kotlinExtension.sourceSets
 
     protected open fun addCommonSourceSetToPlatformSourceSet(commonSourceSet: Named, platformProject: Project) {
-        platformProject.whenEvaluated { // At the point when the source set in the platform module is created, the task does not exist
+        platformProject.whenEvaluated {
+            // At the point when the source set in the platform module is created, the task does not exist
             val platformTask = platformProject.tasks
                 .withType(AbstractKotlinCompile::class.java)
                 .singleOrNull { it.sourceSetName == commonSourceSet.name } // TODO use strict check once this code is not run in K/N
@@ -203,8 +204,7 @@ open class KotlinPlatformImplementationPluginBase(platformName: String) : Kotlin
 internal fun <T> Project.whenEvaluated(fn: Project.() -> T) {
     if (state.executed) {
         fn()
-    }
+    } else {
-    else {
         afterEvaluate { it.fn() }
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt

@@ -7,7 +7,6 @@ import groovy.lang.Closure
 import org.gradle.api.*
 import org.gradle.api.artifacts.ExternalDependency
 import org.gradle.api.attributes.Usage
-import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.logging.Logger
@@ -18,7 +17,6 @@ import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.CompileClasspathNormalizer
 import org.gradle.api.tasks.Delete
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.SourceSetOutput
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.tasks.Jar
@@ -265,14 +263,16 @@ internal class Kotlin2JsSourceSetProcessor(
 
             val subpluginEnvironment: SubpluginEnvironment = SubpluginEnvironment.loadSubplugins(project, kotlinPluginVersion)
             val appliedPlugins = subpluginEnvironment.addSubpluginOptions(
-                    project, kotlinTask, null, null, null, kotlinCompilation)
+                project, kotlinTask, null, null, null, kotlinCompilation
+            )
 
             if (outputDir.isParentOf(project.rootDir))
                 throw InvalidUserDataException(
                     "The output directory '$outputDir' (defined by outputFile of $kotlinTask) contains or " +
                             "matches the project root directory '${project.rootDir}'.\n" +
                             "Gradle will not be able to build the project because of the root directory lock.\n" +
-                        "To fix this, consider using the default outputFile location instead of providing it explicitly.")
+                            "To fix this, consider using the default outputFile location instead of providing it explicitly."
+                )
 
             kotlinTask.destinationDir = outputDir
 
@@ -334,7 +334,11 @@ internal abstract class AbstractKotlinPlugin(
     val registry: ToolingModelBuilderRegistry
 ) : Plugin<Project> {
 
-    internal abstract fun buildSourceSetProcessor(project: Project, compilation: KotlinCompilation, kotlinPluginVersion: String): KotlinSourceSetProcessor<*>
+    internal abstract fun buildSourceSetProcessor(
+        project: Project,
+        compilation: KotlinCompilation,
+        kotlinPluginVersion: String
+    ): KotlinSourceSetProcessor<*>
 
     override fun apply(project: Project) {
         project.plugins.apply(JavaPlugin::class.java)
@@ -399,7 +403,8 @@ internal abstract class AbstractKotlinPlugin(
             val compilationsUnderConstruction = mutableMapOf<String, KotlinWithJavaCompilation>()
 
             javaSourceSets.all { javaSourceSet ->
-                val kotlinCompilation = compilationsUnderConstruction[javaSourceSet.name] ?: kotlinTarget.compilations.maybeCreate(javaSourceSet.name)
+                val kotlinCompilation =
+                    compilationsUnderConstruction[javaSourceSet.name] ?: kotlinTarget.compilations.maybeCreate(javaSourceSet.name)
                 kotlinCompilation.javaSourceSet = javaSourceSet
                 val kotlinSourceSet = project.kotlinExtension.sourceSets.maybeCreate(kotlinCompilation.name)
                 javaSourceSet.addConvention(kotlinSourceSetDslName, kotlinSourceSet)
@@ -668,8 +673,10 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
                 setUpDependencyResolution(variant, compilation)
             }
 
-            val androidPluginIds = listOf("android", "com.android.application", "android-library", "com.android.library",
+            val androidPluginIds = listOf(
-                    "com.android.test", "com.android.feature", "com.android.dynamic-feature", "com.android.instantapp")
+                "android", "com.android.application", "android-library", "com.android.library",
+                "com.android.test", "com.android.feature", "com.android.dynamic-feature", "com.android.instantapp"
+            )
             val plugin = androidPluginIds.asSequence()
                 .mapNotNull { project.plugins.findPlugin(it) as? BasePlugin }
                 .firstOrNull()
@@ -751,7 +758,8 @@ abstract class AbstractAndroidProjectHandler<V>(private val kotlinConfigurationT
         val javaTask = getJavaTask(variantData)
 
         val appliedPlugins = subpluginEnvironment.addSubpluginOptions(
-                project, kotlinTask, javaTask, wrapVariantDataForKapt(variantData), this, null)
+            project, kotlinTask, javaTask, wrapVariantDataForKapt(variantData), this, null
+        )
 
         appliedPlugins.flatMap { it.getSubpluginKotlinTasks(project, kotlinTask) }
             .forEach { configureSources(it, variantData, null) }
@@ -785,8 +793,7 @@ internal fun configureJavaTask(kotlinTask: KotlinCompile, javaTask: AbstractComp
             dir(kotlinTask.destinationDir)
                 .withNormalizer(CompileClasspathNormalizer::class.java)
                 .withPropertyName("${kotlinTask.name}OutputClasses")
-        }
+        } else {
-        else {
             dirCompatible(kotlinTask.destinationDir)
         }
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt

@@ -38,7 +38,7 @@ import kotlin.reflect.KClass
 
 abstract class KotlinBasePluginWrapper(
     protected val fileResolver: FileResolver
-): Plugin<Project> {
+) : Plugin<Project> {
     private val log = Logging.getLogger(this.javaClass)
     val kotlinPluginVersion = loadKotlinVersionFromResource(log)
 
@@ -92,7 +92,7 @@ abstract class KotlinBasePluginWrapper(
 open class KotlinPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     protected val registry: ToolingModelBuilderRegistry
-): KotlinBasePluginWrapper(fileResolver) {
+) : KotlinBasePluginWrapper(fileResolver) {
     override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
         KotlinPlugin(kotlinPluginVersion, registry)
 
@@ -103,7 +103,7 @@ open class KotlinPluginWrapper @Inject constructor(
 open class KotlinCommonPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     protected val registry: ToolingModelBuilderRegistry
-): KotlinBasePluginWrapper(fileResolver) {
+) : KotlinBasePluginWrapper(fileResolver) {
     override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
         KotlinCommonPlugin(kotlinPluginVersion, registry)
 
@@ -114,7 +114,7 @@ open class KotlinCommonPluginWrapper @Inject constructor(
 open class KotlinAndroidPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     protected val registry: ToolingModelBuilderRegistry
-): KotlinBasePluginWrapper(fileResolver) {
+) : KotlinBasePluginWrapper(fileResolver) {
     override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
         KotlinAndroidPlugin(kotlinPluginVersion)
 }
@@ -122,7 +122,7 @@ open class KotlinAndroidPluginWrapper @Inject constructor(
 open class Kotlin2JsPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     protected val registry: ToolingModelBuilderRegistry
-): KotlinBasePluginWrapper(fileResolver) {
+) : KotlinBasePluginWrapper(fileResolver) {
     override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
         Kotlin2JsPlugin(kotlinPluginVersion, registry)
 
@@ -134,7 +134,7 @@ open class KotlinMultiplatformPluginWrapper @Inject constructor(
     fileResolver: FileResolver,
     private val instantiator: Instantiator,
     private val featurePreviews: FeaturePreviews
-): KotlinBasePluginWrapper(fileResolver) {
+) : KotlinBasePluginWrapper(fileResolver) {
     override fun getPlugin(project: Project, kotlinGradleBuildServices: KotlinGradleBuildServices): Plugin<Project> =
         KotlinMultiplatformPlugin(
             fileResolver,
@@ -152,8 +152,8 @@ fun Plugin<*>.loadKotlinVersionFromResource(log: Logger): String {
     log.kotlinDebug("Loading version information")
     val props = Properties()
     val propFileName = "project.properties"
-    val inputStream = javaClass.classLoader!!.getResourceAsStream(propFileName) ?:
+    val inputStream = javaClass.classLoader!!.getResourceAsStream(propFileName)
-            throw FileNotFoundException("property file '$propFileName' not found in the classpath")
+        ?: throw FileNotFoundException("property file '$propFileName' not found in the classpath")
 
     props.load(inputStream)
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinProperties.kt

@@ -77,8 +77,7 @@ internal class PropertiesProvider(private val project: Project) {
     private fun property(propName: String): String? =
         if (project.hasProperty(propName)) {
             project.property(propName) as? String
-            }
+        } else {
-            else {
             localProperties.getProperty(propName)
         }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinTargetConfigurator.kt

@@ -121,7 +121,8 @@ abstract class AbstractKotlinTargetConfigurator<KotlinTargetType : KotlinTarget>
             ?: return // Otherwise, there is no runtime classpath
 
         target.project.tasks.create(lowerCamelCaseName(target.targetName, testTaskNameSuffix), Test::class.java).apply {
-            project.afterEvaluate { // use afterEvaluate to override the JavaPlugin defaults for Test tasks
+            project.afterEvaluate {
+                // use afterEvaluate to override the JavaPlugin defaults for Test tasks
                 conventionMapping.map("testClassesDirs") { testCompilation.output.classesDirs }
                 conventionMapping.map("classpath") { testCompilation.runtimeDependencyFiles }
                 description = "Runs the unit tests."
@@ -327,7 +328,7 @@ internal val KotlinCompilation.deprecatedCompileConfigurationName: String
 internal val KotlinCompilationToRunnableFiles.deprecatedRuntimeConfigurationName: String
     get() = disambiguateName("runtime")
 
-open class KotlinTargetConfigurator<KotlinCompilationType: KotlinCompilation>(
+open class KotlinTargetConfigurator<KotlinCompilationType : KotlinCompilation>(
     createDefaultSourceSets: Boolean,
     createTestCompilation: Boolean
 ) : AbstractKotlinTargetConfigurator<KotlinOnlyTarget<KotlinCompilationType>>(
@@ -428,7 +429,7 @@ open class KotlinNativeTargetConfigurator(
         return buildDir.resolve("bin/$targetSubDirectory${compilation.name}/$buildTypeSubDirectory/$kindSubDirectory")
     }
 
-    private fun Project. klibOutputDirectory(
+    private fun Project.klibOutputDirectory(
         compilation: KotlinNativeCompilation
     ): File {
         val targetSubDirectory = compilation.target.disambiguationClassifier?.let { "$it/" }.orEmpty()
@@ -653,7 +654,9 @@ open class KotlinNativeTargetConfigurator(
 
         val compileOnlyDependencies = target.compilations.mapNotNull {
             val dependencies = configurations.getByName(it.compileOnlyConfigurationName).allDependencies
-            if (dependencies.isNotEmpty()) {it to dependencies} else null
+            if (dependencies.isNotEmpty()) {
+                it to dependencies
+            } else null
         }
 
         fun Dependency.stringCoordinates(): String = buildString {
@@ -666,13 +669,15 @@ open class KotlinNativeTargetConfigurator(
             with(target.project.logger) {
                 warn("A compileOnly dependency is used in the Kotlin/Native target '${target.name}':")
                 compileOnlyDependencies.forEach {
-                    warn("""
+                    warn(
+                        """
                         Compilation: ${it.first.name}
 
                         Dependencies:
                         ${it.second.joinToString(separator = "\n") { it.stringCoordinates() }}
 
-                    """.trimIndent())
+                    """.trimIndent()
+                    )
                 }
                 warn("Such dependencies are not applicable for Kotlin/Native, consider changing the dependency type to 'implementation' or 'api'.")
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/LegacyAndroidAndroidProjectHandler.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.utils.checkedReflection
 import java.io.File
 
-internal class LegacyAndroidAndroidProjectHandler(kotlinConfigurationTools: KotlinConfigurationTools)
+internal class LegacyAndroidAndroidProjectHandler(kotlinConfigurationTools: KotlinConfigurationTools) :
-    : AbstractAndroidProjectHandler<BaseVariantData<out BaseVariantOutputData>>(kotlinConfigurationTools) {
+    AbstractAndroidProjectHandler<BaseVariantData<out BaseVariantOutputData>>(kotlinConfigurationTools) {
 
     override fun getSourceProviders(variantData: BaseVariantData<out BaseVariantOutputData>): Iterable<SourceProvider> =
         variantData.sourceProviders
@@ -93,15 +93,18 @@ internal class LegacyAndroidAndroidProjectHandler(kotlinConfigurationTools: Kotl
         if (AndroidGradleWrapper.isJackEnabled(variant)) {
             throw ProjectConfigurationException(
                 "Kotlin Gradle plugin does not support the deprecated Jack toolchain.\n" +
-                    "Disable Jack or revert to Kotlin Gradle plugin version 1.1.1.", null)
+                        "Disable Jack or revert to Kotlin Gradle plugin version 1.1.1.", null
+            )
         }
     }
 
     override fun getJavaTask(variantData: BaseVariantData<out BaseVariantOutputData>): AbstractCompile? =
         AndroidGradleWrapper.getJavaTask(variantData)
 
-    override fun addJavaSourceDirectoryToVariantModel(variantData: BaseVariantData<out BaseVariantOutputData>,
+    override fun addJavaSourceDirectoryToVariantModel(
-                                                      javaSourceDirectory: File) =
+        variantData: BaseVariantData<out BaseVariantOutputData>,
+        javaSourceDirectory: File
+    ) =
         variantData.addJavaSourceFoldersToModel(javaSourceDirectory)
 
     override fun getTestedVariantData(variantData: BaseVariantData<*>): BaseVariantData<*>? =
@@ -114,8 +117,8 @@ internal class LegacyAndroidAndroidProjectHandler(kotlinConfigurationTools: Kotl
     private val BaseVariantData<*>.sourceProviders: List<SourceProvider>
         get() = variantConfiguration.sortedSourceProviders
 
-    private inner class KaptLegacyVariantData(variantData: BaseVariantData<out BaseVariantOutputData>)
+    private inner class KaptLegacyVariantData(variantData: BaseVariantData<out BaseVariantOutputData>) :
-        : KaptVariantData<BaseVariantData<out BaseVariantOutputData>>(variantData) {
+        KaptVariantData<BaseVariantData<out BaseVariantOutputData>>(variantData) {
 
         override val name: String = variantData.name
         override val sourceProviders: Iterable<SourceProvider> = getSourceProviders(variantData)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/gradleUtils.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.gradle.plugin
 
 import org.gradle.api.Task
 import org.gradle.api.file.FileCollection
-import org.gradle.api.file.FileTree
 import org.gradle.api.internal.HasConvention
 import org.gradle.api.logging.Logger
 import org.gradle.api.plugins.ExtensionAware

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/DefaultCInteropSettings.kt

@@ -22,7 +22,7 @@ open class DefaultCInteropSettings @Inject constructor(
     override val compilation: KotlinNativeCompilation
 ) : CInteropSettings {
 
-    inner class DefaultIncludeDirectories: CInteropSettings.IncludeDirectories {
+    inner class DefaultIncludeDirectories : CInteropSettings.IncludeDirectories {
         var allHeadersDirs: FileCollection = project.files()
         var headerFilterDirs: FileCollection = project.files()
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinCompilationFactory.kt

@@ -10,7 +10,7 @@ import org.gradle.api.NamedDomainObjectFactory
 import org.gradle.api.Project
 import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 
-interface KotlinCompilationFactory<T: KotlinCompilation> : NamedDomainObjectFactory<T> {
+interface KotlinCompilationFactory<T : KotlinCompilation> : NamedDomainObjectFactory<T> {
     val itemClass: Class<T>
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt

@@ -98,7 +98,8 @@ private fun rewriteMppDependenciesToTargetModuleDependencies(
         }
     )
 
-    val resolvedCompileDependencies by lazy { // don't resolve if no project dependencies on MPP projects are found
+    val resolvedCompileDependencies by lazy {
+        // don't resolve if no project dependencies on MPP projects are found
         targetCompileDependenciesConfiguration.resolvedConfiguration.lenientConfiguration.allModuleDependencies.associateBy {
             Triple(it.moduleGroup, it.moduleName, it.moduleVersion)
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/NativeBinaryTypes.kt

@@ -11,7 +11,7 @@ object KotlinNativeUsage {
     const val FRAMEWORK = "kotlin-native-framework"
 }
 
-enum class NativeBuildType(val optimized: Boolean, val debuggable: Boolean): Named {
+enum class NativeBuildType(val optimized: Boolean, val debuggable: Boolean) : Named {
     RELEASE(true, false),
     DEBUG(false, true);
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinCompilationOutputs.kt

@@ -33,7 +33,7 @@ class DefaultKotlinCompilationOutput(
 
 class KotlinWithJavaCompilationOutput(
     internal val compilation: KotlinWithJavaCompilation
-): KotlinCompilationOutput, Callable<FileCollection> {
+) : KotlinCompilationOutput, Callable<FileCollection> {
 
     private val javaSourceSetOutput
         get() = compilation.javaSourceSet.output
@@ -43,7 +43,9 @@ class KotlinWithJavaCompilationOutput(
 
     override var resourcesDirProvider: Any
         get() = javaSourceSetOutput.resourcesDir
-        set(value) { javaSourceSetOutput.setResourcesDir(value) }
+        set(value) {
+            javaSourceSetOutput.setResourcesDir(value)
+        }
 
     override val classesDirs: ConfigurableFileCollection =
         if (isGradleVersionAtLeast(4, 0))

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinCompilations.kt

@@ -11,10 +11,8 @@ import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.attributes.AttributeContainer
 import org.gradle.api.file.FileCollection
-import org.gradle.api.file.FileTree
 import org.gradle.api.file.SourceDirectorySet
 import org.gradle.api.tasks.SourceSet
-import org.gradle.api.tasks.SourceSetOutput
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
@@ -26,7 +24,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import java.io.File
-import java.lang.IllegalArgumentException
 import java.util.*
 import java.util.concurrent.Callable
 
@@ -327,11 +324,13 @@ class KotlinNativeCompilation(
     }
 
     var entryPoint: String? = null
-    fun entryPoint(value: String) { entryPoint = value }
+    fun entryPoint(value: String) {
+        entryPoint = value
+    }
 
     // Interop DSL.
     val cinterops = project.container(DefaultCInteropSettings::class.java) { cinteropName ->
-        DefaultCInteropSettings(project, cinteropName,this)
+        DefaultCInteropSettings(project, cinteropName, this)
     }
 
     var linkerOpts = mutableListOf<String>()
@@ -350,8 +349,8 @@ class KotlinNativeCompilation(
     fun findLinkTask(kind: NativeOutputKind, buildType: NativeBuildType): KotlinNativeCompile? = binaryTasks[kind to buildType]
 
     fun getLinkTask(kind: NativeOutputKind, buildType: NativeBuildType): KotlinNativeCompile =
-        findLinkTask(kind, buildType) ?:
+        findLinkTask(kind, buildType)
-        throw IllegalArgumentException("Cannot find a link task for the binary kind '$kind' and the build type '$buildType'")
+            ?: throw IllegalArgumentException("Cannot find a link task for the binary kind '$kind' and the build type '$buildType'")
 
     fun findLinkTask(kind: String, buildType: String) =
         findLinkTask(NativeOutputKind.valueOf(kind.toUpperCase()), NativeBuildType.valueOf(buildType.toUpperCase()))

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinTargetPresets.kt

@@ -194,7 +194,7 @@ class KotlinAndroidTargetPreset(
 class KotlinJvmWithJavaTargetPreset(
     private val project: Project,
     private val kotlinPluginVersion: String
-): KotlinTargetPreset<KotlinWithJavaTarget> {
+) : KotlinTargetPreset<KotlinWithJavaTarget> {
 
     override fun getName(): String = PRESET_NAME
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinTargets.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
-abstract class AbstractKotlinTarget (
+abstract class AbstractKotlinTarget(
     final override val project: Project
 ) : KotlinTarget {
     private val attributeContainer = HierarchyAttributeContainer(parent = null)
@@ -156,7 +156,8 @@ open class KotlinWithJavaTarget(
         get() = JavaPlugin.JAR_TASK_NAME
 
     override val compilations: NamedDomainObjectContainer<KotlinWithJavaCompilation> =
-        project.container(KotlinWithJavaCompilation::class.java,
+        project.container(
+            KotlinWithJavaCompilation::class.java,
             KotlinWithJavaCompilationFactory(project, this)
         )
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinVariants.kt

@@ -34,18 +34,17 @@ open class KotlinVariant(
 open class KotlinVariantWithCoordinates(
     target: KotlinTarget
 ) : KotlinVariant(target),
-    ComponentWithCoordinates /* Gradle 4.7+ API, don't use with older versions */
+    ComponentWithCoordinates /* Gradle 4.7+ API, don't use with older versions */ {
-{
     override fun getCoordinates() = object : ModuleVersionIdentifier {
         private val project get() = target.project
 
-        private val moduleName: String get() =
+        private val moduleName: String
-            publicationDelegate?.artifactId ?:
+            get() =
-            "${project.name}-${target.name.toLowerCase()}"
+                publicationDelegate?.artifactId ?: "${project.name}-${target.name.toLowerCase()}"
 
-        private val moduleGroup: String get() =
+        private val moduleGroup: String
-            publicationDelegate?.groupId ?:
+            get() =
-            project.group.toString()
+                publicationDelegate?.groupId ?: project.group.toString()
 
         override fun getGroup() = moduleGroup
         override fun getName() = moduleName
@@ -58,13 +57,13 @@ open class KotlinVariantWithCoordinates(
     }
 }
 
-class KotlinVariantWithMetadataVariant(target: KotlinTarget, private val metadataTarget: KotlinTarget)
+class KotlinVariantWithMetadataVariant(target: KotlinTarget, private val metadataTarget: KotlinTarget) :
-    : KotlinVariantWithCoordinates(target), ComponentWithVariants {
+    KotlinVariantWithCoordinates(target), ComponentWithVariants {
     override fun getVariants() = setOf(metadataTarget.component)
 }
 
-class KotlinVariantWithMetadataDependency(target: KotlinTarget, private val metadataTarget: KotlinTarget)
+class KotlinVariantWithMetadataDependency(target: KotlinTarget, private val metadataTarget: KotlinTarget) :
-    : KotlinVariantWithCoordinates(target) {
+    KotlinVariantWithCoordinates(target) {
     override fun getUsages(): Set<UsageContext> = target.createUsageContexts().mapTo(mutableSetOf()) { usageContext ->
         UsageContextWithAdditionalDependencies(usageContext, setOf(metadataDependency()))
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/DefaultKotlinSourceSet.kt

@@ -63,7 +63,8 @@ class DefaultKotlinSourceSet(
 
     override val resources: SourceDirectorySet = createDefaultSourceDirectorySet(displayName + " resources", fileResolver)
 
-    override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet = kotlin.apply { ConfigureUtil.configure(configureClosure, this) }
+    override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet =
+        kotlin.apply { ConfigureUtil.configure(configureClosure, this) }
 
     override fun languageSettings(configureClosure: Closure<Any?>): LanguageSettingsBuilder = languageSettings.apply {
         ConfigureUtil.configure(configureClosure, this)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/DefaultLanguageSettingsBuilder.kt

@@ -33,7 +33,7 @@ internal class DefaultLanguageSettingsBuilder : LanguageSettingsBuilder {
     override var apiVersion: String?
         get() = apiVersionImpl?.versionString
         set(value) {
-            apiVersionImpl = value ?.let { versionString ->
+            apiVersionImpl = value?.let { versionString ->
                 parseApiVersionSettings(versionString) ?: throw InvalidUserDataException(
                     "Incorrect API version. Expected one of: ${apiVersionValues.joinToString { "'${it.versionString}'" }}"
                 )

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/sources/KotlinSourceSetFactory.kt

@@ -36,7 +36,7 @@ internal abstract class KotlinSourceSetFactory<T : KotlinSourceSet> internal con
         defineSourceSetConfigurations(project, sourceSet)
     }
 
-    private fun defineSourceSetConfigurations(project: Project, sourceSet: KotlinSourceSet) = with (project.configurations) {
+    private fun defineSourceSetConfigurations(project: Project, sourceSet: KotlinSourceSet) = with(project.configurations) {
         sourceSet.relatedConfigurationNames.forEach { configurationName ->
             maybeCreate(configurationName)
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/scripting/internal/ScriptingGradleSubplugin.kt

@@ -12,12 +12,12 @@ import org.gradle.api.artifacts.Configuration
 import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.*
 import org.gradle.api.tasks.compile.AbstractCompile
+import org.jetbrains.kotlin.gradle.internal.KaptGenerateStubsTask
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.scripting.ScriptingExtension
 import org.jetbrains.kotlin.gradle.tasks.GradleMessageCollector
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
-import org.jetbrains.kotlin.gradle.internal.KaptGenerateStubsTask
 import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptDefinitionsFromClasspathDiscoverySource
 import kotlin.properties.Delegates
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/CacheableTasks.kt

@@ -34,8 +34,7 @@ internal fun <T : Task> T.cacheOnlyIfEnabledForKotlin() {
     // The `cacheIf` method may be missing if the Gradle version is too low:
     try {
         outputsCompatible.cacheIf { isBuildCacheEnabledForKotlin() }
-    }
+    } catch (_: NoSuchMethodError) {
-    catch (_: NoSuchMethodError) {
     }
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/CompilerPluginOptions.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.gradle.tasks
 
 import org.jetbrains.kotlin.gradle.plugin.SubpluginOption
-import java.io.File
 
 class CompilerPluginOptions {
     private val mutableArguments = arrayListOf<String>()

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinJsDce.kt

@@ -75,8 +75,10 @@ open class KotlinJsDce : AbstractKotlinCompileTool<K2JSDceArguments>(), KotlinJs
 
         val log = GradleKotlinLogger(project.logger)
         val allArgs = argsArray + outputDirArgs + inputFiles
-        val exitCode = runToolInSeparateProcess(allArgs, K2JSDce::class.java.name, computedCompilerClasspath,
+        val exitCode = runToolInSeparateProcess(
-                log, createLoggingMessageCollector(log))
+            allArgs, K2JSDce::class.java.name, computedCompilerClasspath,
+            log, createLoggingMessageCollector(log)
+        )
         throwGradleExceptionIfError(exitCode)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinNativeTasks.kt

@@ -164,10 +164,13 @@ open class KotlinNativeCompile : AbstractCompile() {
         // Delegate for compilations's extra options.
         override var freeCompilerArgs: List<String>
             get() = compilation.extraOpts
-            set(value) { compilation.extraOpts = value.toMutableList() }
+            set(value) {
+                compilation.extraOpts = value.toMutableList()
+            }
     }
 
-    @Internal val kotlinOptions: KotlinCommonToolOptions = NativeCompilerOpts()
+    @Internal
+    val kotlinOptions: KotlinCommonToolOptions = NativeCompilerOpts()
 
     fun kotlinOptions(fn: KotlinCommonToolOptions.() -> Unit) {
         kotlinOptions.fn()
@@ -204,9 +207,10 @@ open class KotlinNativeCompile : AbstractCompile() {
     val compilerPluginOptions = CompilerPluginOptions()
 
     val compilerPluginCommandLine
-        @Input get()= compilerPluginOptions.arguments
+        @Input get() = compilerPluginOptions.arguments
 
-    @Optional @InputFiles
+    @Optional
+    @InputFiles
     var compilerPluginClasspath: FileCollection? = null
 
     val serializedCompilerArguments: List<String>
@@ -297,7 +301,7 @@ open class KotlinNativeCompile : AbstractCompile() {
     }
 }
 
-open class CInteropProcess: DefaultTask() {
+open class CInteropProcess : DefaultTask() {
 
     @Internal
     lateinit var settings: DefaultCInteropSettings

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/SourceRoots.kt

@@ -25,7 +25,8 @@ internal sealed class SourceRoots(val kotlinSourceFiles: List<File>) {
             fun create(taskSource: FileTree, sourceRoots: FilteringSourceRootsContainer, sourceFilesExtensions: List<String>): ForJvm {
                 val kotlinSourceFiles = (taskSource as Iterable<File>).filter { it.isKotlinFile(sourceFilesExtensions) }
                 val javaSourceRoots = findRootsForSources(
-                        sourceRoots.sourceRoots, taskSource.filter(File::isJavaFile))
+                    sourceRoots.sourceRoots, taskSource.filter(File::isJavaFile)
+                )
                 return ForJvm(kotlinSourceFiles, javaSourceRoots)
             }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/SyncOutputTask.kt

@@ -108,8 +108,7 @@ internal open class SyncOutputTask : DefaultTask() {
             logger.kotlinDebug { "Incremental copying files from $sourceDirs to $javaOutputDir" }
             inputs.outOfDate { processIncrementally(it) }
             inputs.removed { processIncrementally(it) }
-        }
+        } else {
-        else {
             logger.kotlinDebug { "Non-incremental copying files from $sourceDirs to $javaOutputDir" }
             processNonIncrementally()
         }
@@ -143,8 +142,7 @@ internal open class SyncOutputTask : DefaultTask() {
         if (input.isRemoved) {
             // file was removed in kotlin dir, remove from java as well
             remove(fileInJavaDir)
-        }
+        } else {
-        else {
             // copy modified or added file from kotlin to java
             copy(fileInKotlinDir, fileInJavaDir)
         }
@@ -203,8 +201,7 @@ private fun saveTimestamps(snapshotFile: File, timestamps: Map<File, Long>, file
     if (!snapshotFile.exists()) {
         snapshotFile.parentFile.mkdirs()
         snapshotFile.createNewFile()
-    }
+    } else {
-    else {
         snapshotFile.delete()
     }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -81,7 +81,8 @@ abstract class AbstractKotlinCompileTool<T : CommonToolArguments>() : AbstractCo
     @get:Input
     internal var useFallbackCompilerSearch: Boolean = false
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
+    @get:InputFiles
     internal val computedCompilerClasspath: List<File>
         get() = compilerClasspath?.takeIf { it.isNotEmpty() }
             ?: compilerJarFile?.let {
@@ -129,7 +130,8 @@ abstract class AbstractKotlinCompile<T : CommonCompilerArguments>() : AbstractKo
         }
 
     @get:Internal
-    internal val buildHistoryFile: File get() = File(taskBuildDirectory, "build-history.bin")
+    internal val buildHistoryFile: File
+        get() = File(taskBuildDirectory, "build-history.bin")
 
     @get:Input
     internal var useModuleDetection: Boolean = false
@@ -146,7 +148,8 @@ abstract class AbstractKotlinCompile<T : CommonCompilerArguments>() : AbstractKo
     @get:Internal
     internal val pluginOptions = CompilerPluginOptions()
 
-    @get:Classpath @get:InputFiles
+    @get:Classpath
+    @get:InputFiles
     protected val additionalClasspath = arrayListOf<File>()
 
     @get:Internal // classpath already participates in the checks
@@ -413,8 +416,7 @@ open class KotlinCompile : AbstractKotlinCompile<K2JVMCompilerArguments>(), Kotl
 
             disableMultiModuleICIfNeeded()
             processCompilerExitCode(exitCode)
-        }
+        } catch (e: Throwable) {
-        catch (e: Throwable) {
             cleanupOnError()
             throw e
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/jarSearchingUtil.kt

@@ -156,8 +156,7 @@ private fun findPotentialModuleJars(project: Project, moduleId: String): Iterabl
 
         if (compilerEmbeddable != null) {
             return compilerEmbeddable.moduleArtifacts.map { it.file }
-        }
+        } else {
-        else {
             allFiles.addAll(configuration.files)
         }
     }
@@ -179,11 +178,9 @@ private fun File.hasEntry(entryToFind: String): Boolean {
 
     try {
         return zip.getEntry(entryToFind) != null
-    }
+    } catch (e: Exception) {
-    catch (e: Exception) {
         return false
-    }
+    } finally {
-    finally {
         zip.close()
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/tasksUtils.kt

@@ -2,21 +2,18 @@ package org.jetbrains.kotlin.gradle.tasks
 
 import org.gradle.api.GradleException
 import org.gradle.api.Task
-import org.gradle.api.tasks.OutputDirectory
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.gradle.plugin.kotlinDebug
 import org.jetbrains.kotlin.gradle.utils.outputsCompatible
 import java.io.File
-import kotlin.reflect.KProperty1
-import kotlin.reflect.full.findAnnotation
-import kotlin.reflect.full.memberProperties
 
 fun throwGradleExceptionIfError(exitCode: ExitCode) {
     when (exitCode) {
         ExitCode.COMPILATION_ERROR -> throw GradleException("Compilation error. See log for more details")
         ExitCode.INTERNAL_ERROR -> throw GradleException("Internal compiler error. See log for more details")
         ExitCode.SCRIPT_EXECUTION_ERROR -> throw GradleException("Script execution error. See log for more details")
-        ExitCode.OK -> {}
+        ExitCode.OK -> {
+        }
         else -> throw IllegalStateException("Unexpected exit code: $exitCode")
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/NativeCompilerDownloader.kt

@@ -10,7 +10,8 @@ import org.gradle.api.artifacts.repositories.ArtifactRepository
 import org.gradle.api.artifacts.repositories.IvyPatternRepositoryLayout
 import org.gradle.api.file.FileTree
 import org.gradle.api.logging.Logger
-import org.jetbrains.kotlin.compilerRunner.*
+import org.jetbrains.kotlin.compilerRunner.KonanCompilerRunner
+import org.jetbrains.kotlin.compilerRunner.konanVersion
 import org.jetbrains.kotlin.konan.KonanVersion
 import org.jetbrains.kotlin.konan.KonanVersionImpl
 import org.jetbrains.kotlin.konan.MetaVersion

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/ParsedGradleVersion.kt

@@ -30,8 +30,7 @@ internal data class ParsedGradleVersion(val major: Int, val minor: Int) : Compar
         private fun String.parseIntOrNull(): Int? =
             try {
                 toInt()
-                }
+            } catch (e: NumberFormatException) {
-                catch (e: NumberFormatException) {
                 null
             }
 
@@ -42,7 +41,7 @@ internal data class ParsedGradleVersion(val major: Int, val minor: Int) : Compar
                 ?.groups
                 ?.drop(1)?.take(2)
                 // checking if two subexpression groups are found and length of each is >0 and <4
-                    ?.let { if (it.all { (it?.value?.length ?: 0).let { it > 0 && it < 4 }}) it else null }
+                ?.let { if (it.all { (it?.value?.length ?: 0).let { it > 0 && it < 4 } }) it else null }
 
             val versions = matches?.mapNotNull { it?.value?.parseIntOrNull() } ?: emptyList()
             if (versions.size == 2 && versions.all { it >= 0 }) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/utils/reflectionUtils.kt

@@ -33,14 +33,11 @@ internal fun Class<*>.getDeclaredFieldInHierarchy(name: String): Field? {
 internal inline fun <T> checkedReflection(block: () -> T, onReflectionException: (Exception) -> T): T {
     return try {
         block()
-    }
+    } catch (e: InvocationTargetException) {
-    catch (e: InvocationTargetException) {
         throw e.targetException
-    }
+    } catch (e: ReflectiveOperationException) {
-    catch (e: ReflectiveOperationException) {
         onReflectionException(e)
-    }
+    } catch (e: IllegalArgumentException) {
-    catch (e: IllegalArgumentException) {
         onReflectionException(e)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinJvmOptionsImplTest.kt

@@ -13,7 +13,8 @@ class KotlinJvmOptionsTest {
             "-Xallow-kotlin-package",
             "-Xmultifile-parts-inherit",
             "-Xdump-declarations-to", "declarationsPath",
-                "-script-templates", "a,b,c")
+            "-script-templates", "a,b,c"
+        )
 
         val arguments = K2JVMCompilerArguments()
         options.updateArguments(arguments)