minor code style improvements

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

@@ -9,11 +9,9 @@ import org.jetbrains.kotlin.gradle.internal.KotlinSourceSetImpl
 import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.internal.HasConvention
 import org.jetbrains.kotlin.gradle.internal.KotlinSourceSet
-import org.gradle.api.specs.Spec
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KDoc
 import java.io.File
-import java.util.concurrent.Callable
 import org.gradle.api.Action
 import org.gradle.api.tasks.compile.AbstractCompile
 import org.gradle.api.logging.Logging
@@ -24,18 +22,15 @@ import org.gradle.api.internal.DefaultDomainObjectSet
 import com.android.build.gradle.api.BaseVariant
 import com.android.build.gradle.api.AndroidSourceSet
 import org.gradle.api.plugins.ExtensionAware
-import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments;
+import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments
 import java.util.ArrayList
 import com.android.build.gradle.BasePlugin
 import com.android.build.gradle.api.LibraryVariant
 import com.android.build.gradle.api.ApkVariant
-import com.android.builder.model.BuildType
 import com.android.build.gradle.api.TestVariant
 import org.gradle.api.plugins.JavaPlugin
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.artifacts.ConfigurationContainer
-import org.gradle.api.artifacts.Dependency
-import java.util.HashSet
 import org.gradle.api.UnknownDomainObjectException
 import org.gradle.api.initialization.dsl.ScriptHandler
 import org.jetbrains.kotlin.gradle.plugin.android.AndroidGradleWrapper
@@ -62,40 +57,35 @@ open class KotlinPlugin [Inject] (val scriptHandler: ScriptHandler): Plugin<Proj
     private fun configureSourceSetDefaults(project: ProjectInternal,
                                            javaBasePlugin: JavaBasePlugin,
                                            javaPluginConvention: JavaPluginConvention) {
-        javaPluginConvention.getSourceSets()?.all(object : Action<SourceSet> {
+        javaPluginConvention.getSourceSets()?.all(Action<SourceSet> { sourceSet ->
-            override fun execute(sourceSet: SourceSet?) {
+            if (sourceSet is HasConvention) {
-                if (sourceSet is HasConvention) {
+                val sourceSetName = sourceSet.getName()
-                    val sourceSetName = sourceSet.getName()
+                val kotlinSourceSet = KotlinSourceSetImpl( sourceSetName, project.getFileResolver())
-                    val kotlinSourceSet = KotlinSourceSetImpl( sourceSetName, project.getFileResolver())
+                sourceSet.getConvention().getPlugins().put("kotlin", kotlinSourceSet)
-                    sourceSet.getConvention().getPlugins().put("kotlin", kotlinSourceSet)
 
-                    val kotlinDirSet = kotlinSourceSet.getKotlin()
+                val kotlinDirSet = kotlinSourceSet.getKotlin()
-                    kotlinDirSet.srcDir(project.file("src/${sourceSetName}/kotlin"))
+                kotlinDirSet.srcDir(project.file("src/${sourceSetName}/kotlin"))
 
-                    sourceSet.getAllJava()?.source(kotlinDirSet)
+                sourceSet.getAllJava()?.source(kotlinDirSet)
-                    sourceSet.getAllSource()?.source(kotlinDirSet)
+                sourceSet.getAllSource()?.source(kotlinDirSet)
-                    sourceSet.getResources()?.getFilter()?.exclude(KSpec({ elem ->
+                sourceSet.getResources()?.getFilter()?.exclude({ kotlinDirSet.contains(it.getFile()) })
-                        kotlinDirSet.contains(elem.getFile())
-                    }))
 
-                    val kotlinTaskName = sourceSet.getCompileTaskName("kotlin")
+                val kotlinTaskName = sourceSet.getCompileTaskName("kotlin")
-                    val kotlinTask: KotlinCompile = project.getTasks().create(kotlinTaskName, javaClass<KotlinCompile>())
+                val kotlinTask: KotlinCompile = project.getTasks().create(kotlinTaskName, javaClass<KotlinCompile>())
 
-                    javaBasePlugin.configureForSourceSet(sourceSet, kotlinTask)
+                javaBasePlugin.configureForSourceSet(sourceSet, kotlinTask)
-                    // store kotlin classes in separate directory. They will serve as class-path to java compiler
+                // store kotlin classes in separate directory. They will serve as class-path to java compiler
-                    val kotlinOutputDir = File(project.getBuildDir(), "kotlin-classes/${sourceSetName}")
+                kotlinTask.kotlinDestinationDir = File(project.getBuildDir(), "kotlin-classes/${sourceSetName}")
-                    kotlinTask.kotlinDestinationDir = kotlinOutputDir;
 
-                    kotlinTask.setDescription("Compiles the $sourceSet.kotlin.")
+                kotlinTask.setDescription("Compiles the $sourceSet.kotlin.")
-                    kotlinTask.source(kotlinDirSet)
+                kotlinTask.source(kotlinDirSet)
 
-                    val javaTask = project.getTasks().findByName(sourceSet.getCompileJavaTaskName()) as AbstractCompile?
+                val javaTask = project.getTasks().findByName(sourceSet.getCompileJavaTaskName()) as AbstractCompile?
 
-                    if (javaTask != null) {
+                if (javaTask != null) {
-                        javaTask.dependsOn(kotlinTaskName)
+                    javaTask.dependsOn(kotlinTaskName)
-                        val javacClassPath = javaTask.getClasspath() + project.files(kotlinTask.kotlinDestinationDir);
+                    val javacClassPath = javaTask.getClasspath() + project.files(kotlinTask.kotlinDestinationDir)
-                        javaTask.setClasspath(javacClassPath)
+                    javaTask.setClasspath(javacClassPath)
-                    }
                 }
             }
         })
@@ -132,32 +122,30 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
         val project = p0 as ProjectInternal
         val ext = project.getExtensions().getByName("android") as BaseExtension
 
-        ext.getSourceSets().all(object : Action<AndroidSourceSet> {
+        ext.getSourceSets().all(Action<AndroidSourceSet> { sourceSet ->
-            override fun execute(sourceSet: AndroidSourceSet?) {
+            if (sourceSet is HasConvention) {
-                if (sourceSet is HasConvention) {
+                val sourceSetName = sourceSet.getName()
-                    val sourceSetName = sourceSet.getName()
+                val kotlinSourceSet = KotlinSourceSetImpl( sourceSetName, project.getFileResolver())
-                    val kotlinSourceSet = KotlinSourceSetImpl( sourceSetName, project.getFileResolver())
+                sourceSet.getConvention().getPlugins().put("kotlin", kotlinSourceSet)
-                    sourceSet.getConvention().getPlugins().put("kotlin", kotlinSourceSet)
+                val kotlinDirSet = kotlinSourceSet.getKotlin()
-                    val kotlinDirSet = kotlinSourceSet.getKotlin()
+                kotlinDirSet.srcDir(project.file("src/${sourceSetName}/kotlin"))
-                    kotlinDirSet.srcDir(project.file("src/${sourceSetName}/kotlin"))
 
 
-                    /*TODO: before 0.11 gradle android plugin there was:
+                /*TODO: before 0.11 gradle android plugin there was:
-                      sourceSet.getAllJava().source(kotlinDirSet)
+                  sourceSet.getAllJava().source(kotlinDirSet)
-                      sourceSet.getAllSource().source(kotlinDirSet)
+                  sourceSet.getAllSource().source(kotlinDirSet)
-                      AndroidGradleWrapper.getResourceFilter(sourceSet)?.exclude(KSpec({ elem ->
+                  AndroidGradleWrapper.getResourceFilter(sourceSet)?.exclude(KSpec({ elem ->
-                        kotlinDirSet.contains(elem.getFile())
+                    kotlinDirSet.contains(elem.getFile())
-                      }))
+                  }))
-                     but those methods were removed so commented as temporary hack*/
+                 but those methods were removed so commented as temporary hack*/
 
-                    project.getLogger().debug("Created kotlin sourceDirectorySet at ${kotlinDirSet.getSrcDirs()}")
+                project.getLogger().debug("Created kotlin sourceDirectorySet at ${kotlinDirSet.getSrcDirs()}")
-                }
             }
         })
 
         (ext as ExtensionAware).getExtensions().add("kotlinOptions", K2JVMCompilerArguments())
 
-        project.afterEvaluate( { (project: Project?): Unit ->
+        project afterEvaluate { (project: Project?): Unit ->
             if (project != null) {
                 val testVariants = ext.getTestVariants()!!
                 processVariants(testVariants, project, ext)
@@ -167,14 +155,14 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
                 }
 
                 if (ext is LibraryExtension) {
-                    val libVariants = ext.getLibraryVariants()!!;
+                    val libVariants = ext.getLibraryVariants()!!
                     processVariants(libVariants, project, ext)
                 }
             }
+        }
 
-        })
         val version = project.getProperties()["kotlin.gradle.plugin.version"] as String
-        project.getExtensions().add(DEFAULT_ANNOTATIONS, GradleUtils(scriptHandler!!).resolveDependencies("org.jetbrains.kotlin:kotlin-android-sdk-annotations:$version"));
+        project.getExtensions().add(DEFAULT_ANNOTATIONS, GradleUtils(scriptHandler!!).resolveDependencies("org.jetbrains.kotlin:kotlin-android-sdk-annotations:$version"))
     }
 
     private fun processVariants(variants: DefaultDomainObjectSet<out BaseVariant>, project: Project, androidExt: BaseExtension): Unit {
@@ -206,7 +194,7 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
 
                 // store kotlin classes in separate directory. They will serve as class-path to java compiler
                 val kotlinOutputDir = File(project.getBuildDir(), "tmp/kotlin-classes/${variantName}")
-                kotlinTask.kotlinDestinationDir = kotlinOutputDir;
+                kotlinTask.kotlinDestinationDir = kotlinOutputDir
                 kotlinTask.setDestinationDir(javaTask.getDestinationDir())
                 kotlinTask.setDescription("Compiles the ${variantName} kotlin.")
                 kotlinTask.setClasspath(javaTask.getClasspath())
@@ -230,11 +218,11 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
                 }
 
                 for (resourceFolder in AndroidGradleWrapper.getRClassFolder(variant)) {
-                    javaSourceList.add(Callable<File?>{ resourceFolder })
+                    javaSourceList add { resourceFolder }
                 }
-                javaSourceList.add(Callable<File?>{ variant.getGenerateBuildConfig()?.getSourceOutputDir() })
+                javaSourceList add { variant.getGenerateBuildConfig()?.getSourceOutputDir() }
-                javaSourceList.add(Callable<File?>{ variant.getAidlCompile().getSourceOutputDir() })
+                javaSourceList add { variant.getAidlCompile().getSourceOutputDir() }
-                javaSourceList.add(Callable<File?>{ variant.getRenderscriptCompile().getSourceOutputDir() })
+                javaSourceList add { variant.getRenderscriptCompile().getSourceOutputDir() }
 
                 if (variant is ApkVariant) {
                     for (flavourName in AndroidGradleWrapper.getProductFlavorsNames(variant)) {
@@ -253,7 +241,7 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
                     }
                 }
 
-                kotlinTask.doFirst({ task  ->
+                kotlinTask doFirst {
                     var plugin = project.getPlugins().findPlugin("android")
                     if (null == plugin) {
                         plugin = project.getPlugins().findPlugin("android-library")
@@ -262,11 +250,11 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
                     val javaSources = project.files(javaSourceList)
                     val androidRT = project.files(AndroidGradleWrapper.getRuntimeJars(basePlugin))
                     val fullClasspath = (javaTask.getClasspath() + (javaSources + androidRT)) - project.files(kotlinTask.kotlinDestinationDir)
-                    (task as AbstractCompile).setClasspath(fullClasspath)
+                    (it as AbstractCompile).setClasspath(fullClasspath)
-                })
+                }
 
                 javaTask.dependsOn(kotlinTaskName)
-                val javacClassPath = javaTask.getClasspath() + project.files(kotlinTask.kotlinDestinationDir);
+                val javacClassPath = javaTask.getClasspath() + project.files(kotlinTask.kotlinDestinationDir)
                 javaTask.setClasspath(javacClassPath)
             }
         }
@@ -285,21 +273,16 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler): Plug
 
 }
 
-open class KSpec<T: Any?>(val predicate: (T) -> Boolean): Spec<T> {
-    public override fun isSatisfiedBy(p0: T?): Boolean {
-        return p0 != null && predicate(p0)
-    }
-}
 
 open class GradleUtils(val scriptHandler: ScriptHandler) {
     public fun resolveDependencies(vararg coordinates: String): Collection<File> {
         val dependencyHandler : DependencyHandler = scriptHandler.getDependencies()
         val configurationsContainer : ConfigurationContainer = scriptHandler.getConfigurations()
 
-        val deps = coordinates.map { dependencyHandler.create(it) }
+        val deps = coordinates map { dependencyHandler.create(it) }
         val configuration = configurationsContainer.detachedConfiguration(*deps.copyToArray())
 
-        return configuration.getResolvedConfiguration().getFiles(KSpec({ dep -> true }))!!
+        return configuration.getResolvedConfiguration().getFiles({true})
     }
 }
 

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

@@ -13,7 +13,7 @@ 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;
+import org.jetbrains.jet.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.jet.cli.common.messages.MessageCollector
 import org.jetbrains.jet.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.jet.cli.common.messages.CompilerMessageLocation
@@ -33,7 +33,7 @@ public open class KotlinCompile(): AbstractCompile() {
     private val logger = Logging.getLogger(this.javaClass)
     override fun getLogger() = logger
 
-    public var kotlinOptions: K2JVMCompilerArguments = K2JVMCompilerArguments();
+    public var kotlinOptions: K2JVMCompilerArguments = K2JVMCompilerArguments()
 
     public var kotlinDestinationDir : File? = getDestinationDir()
 
@@ -103,7 +103,7 @@ public open class KotlinCompile(): AbstractCompile() {
         args.freeArgs = sources.map { it.getAbsolutePath() }
 
         if (StringUtils.isEmpty(kotlinOptions.classpath)) {
-            val existingClasspathEntries =  getClasspath().filter(KSpec<File?>({ it != null && it.exists() }))
+            val existingClasspathEntries = getClasspath().filter({ it != null && it.exists() })
             val effectiveClassPath = (javaSrcRoots + existingClasspathEntries).makeString(File.pathSeparator)
             args.classpath = effectiveClassPath
         }
@@ -148,7 +148,7 @@ public open class KDoc(): SourceTask() {
 
     public var kdocArgs: KDocArguments = KDocArguments()
 
-    public var destinationDir: File? = null;
+    public var destinationDir: File? = null
 
     {
         // by default, output dir is not defined in options
@@ -190,7 +190,7 @@ public open class KDoc(): SourceTask() {
         val compiler = KDocCompiler()
 
         val messageCollector = GradleMessageCollector(getLogger())
-        val exitCode = compiler.exec(messageCollector, Services.EMPTY, args);
+        val exitCode = compiler.exec(messageCollector, Services.EMPTY, args)
 
         when (exitCode) {
             ExitCode.COMPILATION_ERROR -> throw GradleException("Failed to generate kdoc. See log for more details")

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

@@ -17,11 +17,11 @@ abstract class KotlinBasePluginWrapper: Plugin<Project> {
     val log = Logging.getLogger(this.javaClass)
 
     public override fun apply(project: Project) {
-        val sourceBuildScript = findSourceBuildScript(project);
+        val sourceBuildScript = findSourceBuildScript(project)
         if (sourceBuildScript == null) {
             log.error("Failed to determine source cofiguration of kotlin plugin. Can not download core. Please verify that this or any parent project " +
-                      "contains 'kotlin-gradle-plugin' in buildscript's classpath configuration.");
+                      "contains 'kotlin-gradle-plugin' in buildscript's classpath configuration.")
-            return;
+            return
         }
         val dependencyHandler : DependencyHandler = sourceBuildScript.getDependencies()
         val configurationsContainer : ConfigurationContainer = sourceBuildScript.getConfigurations()
@@ -35,7 +35,7 @@ abstract class KotlinBasePluginWrapper: Plugin<Project> {
             throw FileNotFoundException("property file '" + propFileName + "' not found in the classpath")
         }
 
-        props.load(inputStream);
+        props.load(inputStream)
 
         val projectVersion = props["project.version"] as String
         log.debug("Found project version [$projectVersion]")
@@ -47,7 +47,7 @@ abstract class KotlinBasePluginWrapper: Plugin<Project> {
         val configuration = configurationsContainer.detachedConfiguration(dependency)
 
         log.debug("Resolving [" + kotlinPluginCoreCoordinates + "]")
-        val kotlinPluginDependencies : List<URL> = configuration.getResolvedConfiguration().getFiles(KSpec({ dep -> true }))!!.map({(f: File):URL -> f.toURI().toURL() })
+        val kotlinPluginDependencies : List<URL> = configuration.getResolvedConfiguration().getFiles({true})!!.map { it.toURI().toURL() }
         log.debug("Resolved files: [" + kotlinPluginDependencies.toString() + "]")
         log.debug("Load plugin in parent-last URL classloader")
         val kotlinPluginClassloader = ParentLastURLClassLoader(kotlinPluginDependencies, this.javaClass.getClassLoader())
@@ -60,7 +60,7 @@ abstract class KotlinBasePluginWrapper: Plugin<Project> {
 
         val applyMethod = cls.getMethod("apply", javaClass<Project>())
         log.debug("'apply' method found, invoking...")
-        applyMethod.invoke(pluginInstance, project);
+        applyMethod.invoke(pluginInstance, project)
         log.debug("'apply' method invoked successfully")
     }
 
@@ -72,7 +72,7 @@ abstract class KotlinBasePluginWrapper: Plugin<Project> {
         while (curProject != curProject.getParent()) {
             log.debug("Looking in project $project")
             val scriptHandler = curProject.getBuildscript()
-            val found = scriptHandler.getConfigurations().findByName("classpath")?.find { it.name.contains("kotlin-gradle-plugin") } != null;
+            val found = scriptHandler.getConfigurations().findByName("classpath")?.firstOrNull { it.name.contains("kotlin-gradle-plugin") } != null
             if (found) {
                 log.debug("Found! returning...")
                 return scriptHandler
@@ -95,9 +95,3 @@ open class KotlinAndriodPluginWrapper: KotlinBasePluginWrapper() {
         return "org.jetbrains.kotlin.gradle.plugin.KotlinAndroidPlugin"
     }
 }
-
-open class KSpec<T: Any?>(val predicate: (T) -> Boolean): Spec<T> {
-    public override fun isSatisfiedBy(p0: T?): Boolean {
-        return p0 != null && predicate(p0)
-    }
-}