Minor cleanup in Gradle plugin.

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

@@ -36,24 +36,23 @@ import org.gradle.api.initialization.dsl.ScriptHandler
 import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
 import javax.inject.Inject
 import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
-import org.gradle.api.tasks.Copy
 import org.gradle.api.file.SourceDirectorySet
 import kotlin.properties.Delegates
 import org.gradle.api.tasks.Delete
-import org.codehaus.groovy.runtime.MethodClosure
 import groovy.lang.Closure
-import org.gradle.api.artifacts.ProjectDependency
 
 val DEFAULT_ANNOTATIONS = "org.jebrains.kotlin.gradle.defaultAnnotations"
 
 
-abstract class KotlinSourceSetProcessor<T : AbstractCompile>(val project: ProjectInternal,
-                                                             val javaBasePlugin: JavaBasePlugin,
-                                                             val sourceSet: SourceSet,
-                                                             val pluginName: String,
-                                                             val compileTaskNameSuffix: String,
-                                                             val taskDescription: String,
-                                                             val compilerClass: Class<T>) {
+abstract class KotlinSourceSetProcessor<T : AbstractCompile>(
+        val project: ProjectInternal,
+        val javaBasePlugin: JavaBasePlugin,
+        val sourceSet: SourceSet,
+        val pluginName: String,
+        val compileTaskNameSuffix: String,
+        val taskDescription: String,
+        val compilerClass: Class<T>
+) {
     abstract protected fun doTargetSpecificProcessing()
     val logger = Logging.getLogger(this.javaClass)
 
@@ -116,13 +115,14 @@ class Kotlin2JvmSourceSetProcessor(
         project: ProjectInternal,
         javaBasePlugin: JavaBasePlugin,
         sourceSet: SourceSet,
-        val scriptHandler: ScriptHandler)
-: KotlinSourceSetProcessor<KotlinCompile>(
+        val scriptHandler: ScriptHandler
+) : KotlinSourceSetProcessor<KotlinCompile>(
         project, javaBasePlugin, sourceSet,
         pluginName = "kotlin",
         compileTaskNameSuffix = "kotlin",
         taskDescription = "Compiles the $sourceSet.kotlin.",
-        compilerClass = javaClass()) {
+        compilerClass = javaClass()
+) {
 
     override fun doTargetSpecificProcessing() {
         // store kotlin classes in separate directory. They will serve as class-path to java compiler
@@ -138,7 +138,6 @@ class Kotlin2JvmSourceSetProcessor(
     }
 }
 
-
 class Kotlin2JsSourceSetProcessor(
         project: ProjectInternal,
         javaBasePlugin: JavaBasePlugin,
@@ -149,18 +148,16 @@ class Kotlin2JsSourceSetProcessor(
         pluginName = "kotlin2js",
         taskDescription = "Compiles the kotlin sources in $sourceSet to JavaScript.",
         compileTaskNameSuffix = "kotlin2Js",
-        compilerClass = javaClass<Kotlin2JsCompile>()) {
+        compilerClass = javaClass<Kotlin2JsCompile>()
+) {
+
     val copyKotlinJsTaskName = sourceSet.getTaskName("copy", "kotlinJs")
     val clean = project.getTasks().findByName("clean")
     val build = project.getTasks().findByName("build")
 
     val defaultKotlinDestinationDir = File(project.getBuildDir(), "kotlin2js/${sourceSetName}")
     private fun kotlinTaskDestinationDir(): File? = kotlinTask.kotlinDestinationDir
-    private fun kotlinJsDestinationDir(): File? = if (kotlinTask.outputFile() == null) {
-        null
-    } else {
-        File(kotlinTask.outputFile()).directory
-    }
+    private fun kotlinJsDestinationDir(): File? = kotlinTask.outputFile()?.let { File(it).directory }
 
     private fun copyKotlinJsTaskOutput(): String? = if (kotlinJsDestinationDir() == null) {
         null
@@ -233,11 +230,9 @@ abstract class AbstractKotlinPlugin [Inject] (val scriptHandler: ScriptHandler)
     open protected fun configureSourceSetDefaults(project: ProjectInternal,
                                                   javaBasePlugin: JavaBasePlugin,
                                                   javaPluginConvention: JavaPluginConvention) {
-        javaPluginConvention.getSourceSets()?.all(object : Action<SourceSet> {
-            override fun execute(sourceSet: SourceSet?) {
-                if (sourceSet != null) {
-                    buildSourceSetProcessor(project, javaBasePlugin, sourceSet).run()
-                }
+        javaPluginConvention.getSourceSets()?.all(Action<SourceSet> { sourceSet ->
+            if (sourceSet != null) {
+                buildSourceSetProcessor(project, javaBasePlugin, sourceSet).run()
             }
         })
     }
@@ -253,11 +248,7 @@ abstract class AbstractKotlinPlugin [Inject] (val scriptHandler: ScriptHandler)
             kdoc.setSource(mainSourceSet.getConvention().getExtensionsAsDynamicObject().getProperty("kotlin"))
         }
 
-        project.getTasks().withType(javaClass<KDoc>(), object : Action<KDoc> {
-            override fun execute(task: KDoc?) {
-                task!!.destinationDir = File(javaPluginConvention.getDocsDir(), "kdoc")
-            }
-        })
+        project.getTasks().withType(javaClass<KDoc>()) { it!!.destinationDir = File(javaPluginConvention.getDocsDir(), "kdoc") }
     }
 
     public val KDOC_TASK_NAME: String = "kdoc"
@@ -265,7 +256,7 @@ abstract class AbstractKotlinPlugin [Inject] (val scriptHandler: ScriptHandler)
 
 
 open class KotlinPlugin [Inject] (scriptHandler: ScriptHandler) : AbstractKotlinPlugin(scriptHandler) {
-    override fun buildSourceSetProcessor(project: ProjectInternal, javaBasePlugin: JavaBasePlugin, sourceSet: SourceSet): KotlinSourceSetProcessor<KotlinCompile> =
+    override fun buildSourceSetProcessor(project: ProjectInternal, javaBasePlugin: JavaBasePlugin, sourceSet: SourceSet) =
             Kotlin2JvmSourceSetProcessor(project, javaBasePlugin, sourceSet, scriptHandler)
 }
 
@@ -308,7 +299,7 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler) : Plu
 
         (ext as ExtensionAware).getExtensions().add("kotlinOptions", K2JVMCompilerArguments())
 
-        project afterEvaluate { (project: Project?): Unit ->
+        project afterEvaluate { project ->
             if (project != null) {
                 val testVariants = ext.getTestVariants()!!
                 processVariants(testVariants, project, ext)
@@ -344,7 +335,7 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler) : Plu
                 val buildTypeSourceSetName = AndroidGradleWrapper.getVariantName(variant)
 
                 logger.debug("Variant build type is [$buildTypeSourceSetName]")
-                val buildTypeSourceSet: AndroidSourceSet? = sourceSets.findByName(buildTypeSourceSetName)
+                val buildTypeSourceSet = sourceSets.findByName(buildTypeSourceSetName)
 
                 val javaTask = variant.getJavaCompile()!!
                 val variantName = variant.getName()
@@ -444,7 +435,7 @@ open class GradleUtils(val scriptHandler: ScriptHandler, val project: ProjectInt
         val deps = coordinates map { dependencyHandler.create(it) }
         val configuration = configurationsContainer.detachedConfiguration(*deps.copyToArray())
 
-        return configuration.getResolvedConfiguration().getFiles({true})
+        return configuration.getResolvedConfiguration().getFiles { true }
     }
 
     public fun kotlinPluginVersion(): String = project.getProperties()["kotlin.gradle.plugin.version"] as String

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

@@ -10,7 +10,6 @@ import java.util.HashSet
 import org.jetbrains.kotlin.doc.KDocCompiler
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.file.SourceDirectorySet
-import java.util.ArrayList
 import org.apache.commons.io.FilenameUtils
 import org.jetbrains.jet.cli.jvm.K2JVMCompiler
 import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments
@@ -26,21 +25,7 @@ import org.gradle.api.Project
 import org.jetbrains.jet.config.Services
 import org.jetbrains.jet.cli.js.K2JSCompiler
 import org.jetbrains.jet.cli.common.arguments.K2JSCompilerArguments
-import org.jetbrains.k2js.config.MetaInfServices
-import org.jetbrains.k2js.config.ClassPathLibraryDefintionsConfig
-import org.jetbrains.jet.cli.common.CLIConfigurationKeys
-import org.jetbrains.jet.config.CompilerConfiguration
-import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil
-import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment
-import com.intellij.openapi.Disposable
-import com.intellij.openapi.util.Disposer
-import org.jetbrains.k2js.config.EcmaVersion
-import org.gradle.api.tasks.Copy
-import org.gradle.api.Action
-import org.gradle.api.internal.project.ProjectInternal
-import groovy.lang.Closure
 import org.codehaus.groovy.runtime.MethodClosure
-import org.gradle.api.DefaultTask
 import org.jetbrains.jet.cli.common.arguments.CommonCompilerArguments
 import org.jetbrains.jet.cli.common.CLICompiler
 import com.intellij.ide.highlighter.JavaFileType
@@ -169,7 +154,8 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
         args.noParamAssertions = kotlinOptions.noParamAssertions
     }
 
-    private fun getJavaSourceRoots(): Set<File> = getSource()
+    private fun getJavaSourceRoots(): Set<File> = 
+            getSource()
             .filter { isJava(it) }
             .map { findSrcDirRoot(it) }
             .filterNotNull()
@@ -177,6 +163,7 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
 
     override fun afterCompileHook(args: K2JVMCompilerArguments) {
         getLogger().debug("Copying resulting files to classes")
+
         // Copy kotlin classes to all classes directory
         val outputDirFile = File(args.destination!!)
         if (outputDirFile.exists()) {
@@ -195,7 +182,7 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
     }
 
     public fun addLibraryFiles(vararg fs: String) {
-        kotlinOptions.libraryFiles = (kotlinOptions.libraryFiles + fs).copyToArray()
+        kotlinOptions.libraryFiles = (kotlinOptions.libraryFiles + (fs as Array<String>)).copyToArray()
     }
 
     public fun addLibraryFiles(vararg fs: File) {
@@ -212,6 +199,7 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
     }
 
     override fun populateTargetSpecificArgs(args: K2JSCompilerArguments) {
+        args.noStdlib = true
         args.outputFile = outputFile()
         args.outputPrefix = kotlinOptions.outputPrefix
         args.outputPostfix = kotlinOptions.outputPostfix
@@ -220,7 +208,7 @@ public open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArgumen
         args.sourceMap = kotlinOptions.sourceMap
 
         if (args.outputFile == null) {
-            throw GradleException("${getName()}.kotlinOptions.outputFile must be set to a string.")
+            throw GradleException("${getName()}.kotlinOptions.outputFile should be specified.")
         }
 
         val outputDir = File(args.outputFile).directory