use bootstrap.kotlin.default.version bootstrap for buildSrc

buildSrc/build.gradle.kts

@@ -1,10 +1,11 @@
 extra["versions.native-platform"] = "0.14"
 
 buildscript {
+
     val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-    val buildSrcKotlinVersion: String by extra(findProperty("buildSrc.kotlin.version")?.toString() ?: embeddedKotlinVersion)
-    val buildSrcKotlinRepo: String? by extra(findProperty("buildSrc.kotlin.repo") as String?)
+    extra["defaultSnapshotVersion"] = kotlinBuildProperties.defaultSnapshotVersion
+    kotlinBootstrapFrom(BootstrapOption.BintrayBootstrap(kotlinBuildProperties.kotlinBootstrapVersion!!, cacheRedirectorEnabled))
 
     repositories {
         if (cacheRedirectorEnabled) {
@@ -15,21 +16,21 @@ buildscript {
             maven("https://kotlin.bintray.com/kotlin-dependencies")
         }
 
-        buildSrcKotlinRepo?.let {
+        project.bootstrapKotlinRepo?.let {
             maven(url = it)
         }
     }
 
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$buildSrcKotlinVersion")
-        classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:$buildSrcKotlinVersion")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.15")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${project.bootstrapKotlinVersion}")
+        classpath("org.jetbrains.kotlin:kotlin-sam-with-receiver:${project.bootstrapKotlinVersion}")
     }
 }
 
 val cacheRedirectorEnabled = findProperty("cacheRedirectorEnabled")?.toString()?.toBoolean() == true
 
-logger.info("buildSrcKotlinVersion: " + extra["buildSrcKotlinVersion"])
+logger.info("buildSrcKotlinVersion: " + extra["bootstrapKotlinVersion"])
 logger.info("buildSrc kotlin compiler version: " + org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION)
 logger.info("buildSrc stdlib version: " + KotlinVersion.CURRENT)
 
@@ -83,14 +84,14 @@ repositories {
     maven("https://kotlin.bintray.com/kotlin-dependencies")
     gradlePluginPortal()
 
-    extra["buildSrcKotlinRepo"]?.let {
+    extra["bootstrapKotlinRepo"]?.let {
         maven(url = it)
     }
 }
 
 dependencies {
     implementation(kotlin("stdlib", embeddedKotlinVersion))
-    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
+    implementation("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.15")
 
     implementation("net.rubygrapefruit:native-platform:${property("versions.native-platform")}")
     implementation("net.rubygrapefruit:native-platform-windows-amd64:${property("versions.native-platform")}")

buildSrc/prepare-deps/build.gradle.kts

@@ -9,6 +9,9 @@ import java.text.SimpleDateFormat
 import java.util.*
 import javax.xml.stream.XMLOutputFactory
 
+import org.jetbrains.kotlin.gradle.tasks.internal.CleanableStore
+import org.jetbrains.kotlin.gradle.tasks.CleanDataTask
+
 plugins {
     base
 }
@@ -105,7 +108,7 @@ val nodeJSPlugin by configurations.creating
 val intellijRuntimeAnnotations = "intellij-runtime-annotations"
 
 val dependenciesDir = (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File)
-    ?: rootProject.rootDir.parentFile.resolve("dependencies")
+    ?: rootProject.gradle.gradleUserHomeDir.resolve("kotlin-build-dependencies")
 
 val customDepsRepoDir = dependenciesDir.resolve("repo")
 
@@ -142,14 +145,29 @@ dependencies {
     }
 }
 
-val makeIntellijCore = buildIvyRepositoryTask(intellijCore, customDepsOrg, customDepsRepoDir)
+
+val cleanupIntellijCore = tasks.register<CleanDataTask>("cleanupIntellijCore") {
+    cleanableStoreProvider = provider { CleanableStore[repoDir.resolve("intellij-core").absolutePath] }
+}
+
+val cleanupIntellijAnnotation = tasks.register<CleanDataTask>("cleanupIntellijAnnotation") {
+    cleanableStoreProvider = provider { CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath] }
+}
+
+val cleanupDependencies = tasks.register("cleanupDependencies") {
+    dependsOn(cleanupIntellijCore)
+    dependsOn(cleanupIntellijAnnotation)
+}
+
+val makeIntellijCore = buildIvyRepositoryTaskAndRegisterCleanupTask(intellijCore, customDepsOrg, customDepsRepoDir)
 
 val makeIntellijAnnotations by tasks.registering(Copy::class) {
     dependsOn(makeIntellijCore)
 
-    from(repoDir.resolve("intellij-core/$intellijVersion/artifacts/annotations.jar"))
+    val intellijCoreRepo = CleanableStore[repoDir.resolve("intellij-core").absolutePath][intellijVersion].use()
+    from(intellijCoreRepo.resolve("artifacts/annotations.jar"))
 
-    val targetDir = File(repoDir, "$intellijRuntimeAnnotations/$intellijVersion")
+    val targetDir = CleanableStore[repoDir.resolve(intellijRuntimeAnnotations).absolutePath][intellijVersion].use()
     into(targetDir)
 
     val ivyFile = File(targetDir, "$intellijRuntimeAnnotations.ivy.xml")
@@ -181,20 +199,20 @@ val mergeSources by tasks.creating(Jar::class.java) {
 val sourcesFile = mergeSources.outputs.files.singleFile
 
 val makeIde = if (androidStudioBuild != null) {
-    buildIvyRepositoryTask(
+    buildIvyRepositoryTaskAndRegisterCleanupTask(
         androidStudio,
         customDepsOrg,
         customDepsRepoDir,
         if (androidStudioOs == "mac")
-            ::skipContentsDirectory 
-        else 
+            ::skipContentsDirectory
+        else
             ::skipToplevelDirectory
     )
 } else {
     val task = if (installIntellijUltimate) {
-        buildIvyRepositoryTask(intellijUltimate, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+        buildIvyRepositoryTaskAndRegisterCleanupTask(intellijUltimate, customDepsOrg, customDepsRepoDir, null, sourcesFile)
     } else {
-        buildIvyRepositoryTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
+        buildIvyRepositoryTaskAndRegisterCleanupTask(intellij, customDepsOrg, customDepsRepoDir, null, sourcesFile)
     }
 
     task.configure {
@@ -204,8 +222,7 @@ val makeIde = if (androidStudioBuild != null) {
     task
 }
 
-val buildJpsStandalone = buildIvyRepositoryTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
-val buildNodeJsPlugin = buildIvyRepositoryTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
+val buildJpsStandalone = buildIvyRepositoryTaskAndRegisterCleanupTask(jpsStandalone, customDepsOrg, customDepsRepoDir, null, sourcesFile)
 
 tasks.named("build") {
     dependsOn(
@@ -215,11 +232,16 @@ tasks.named("build") {
         makeIntellijAnnotations
     )
 
-    if (installIntellijUltimate) {
-        dependsOn(buildNodeJsPlugin)
-    }
 }
 
+if (installIntellijUltimate) {
+    val buildNodeJsPlugin =
+        buildIvyRepositoryTaskAndRegisterCleanupTask(nodeJSPlugin, customDepsOrg, customDepsRepoDir, ::skipToplevelDirectory, sourcesFile)
+    tasks.named("build") { dependsOn(buildNodeJsPlugin) }
+}
+
+tasks.named("build") { dependsOn(cleanupDependencies) }
+
 // Task to delete legacy repo locations
 tasks.register<Delete>("cleanLegacy") {
     delete("$projectDir/android-dx")
@@ -227,93 +249,114 @@ tasks.register<Delete>("cleanLegacy") {
 }
 
 tasks.named<Delete>("clean") {
+    //TODO specify repos to clean? Use CleanDataTask
     delete(customDepsRepoDir)
 }
 
-fun buildIvyRepositoryTask(
+fun buildIvyRepositoryTaskAndRegisterCleanupTask(
     configuration: Configuration,
     organization: String,
     repoDirectory: File,
     pathRemap: ((String) -> String)? = null,
     sources: File? = null
-) = tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
+): TaskProvider<Task> {
+    fun ResolvedArtifact.storeDirectory(): CleanableStore =
+        CleanableStore[repoDirectory.resolve("$organization/${moduleVersion.id.name}").absolutePath]
 
     fun ResolvedArtifact.moduleDirectory(): File =
-        File(repoDirectory, "$organization/${moduleVersion.id.name}/${moduleVersion.id.version}")
+        storeDirectory()[moduleVersion.id.version].use()
 
-    dependsOn(configuration)
-    inputs.files(configuration)
+    val buildIvyRepositoryTask = tasks.register("buildIvyRepositoryFor${configuration.name.capitalize()}") {
+        dependsOn(configuration)
+        inputs.files(configuration)
 
-    if (verifyDependencyOutput) {
-        outputs.dir(provider {
-            configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory()
-        })
-    } else {
-        outputs.upToDateWhen {
-            configuration.resolvedConfiguration.resolvedArtifacts.single()
-                .moduleDirectory()
-                .exists()
-        }
-    }
-
-    doFirst {
-        configuration.resolvedConfiguration.resolvedArtifacts.single().run {
-            val moduleDirectory = moduleDirectory()
-            val artifactsDirectory = File(moduleDirectory(), "artifacts")
-
-            logger.info("Unpacking ${file.name} into ${artifactsDirectory.absolutePath}")
-            copy {
-                val fileTree = when (extension) {
-                    "tar.gz" -> tarTree(file)
-                    "zip" -> zipTree(file)
-                    else -> error("Unsupported artifact extension: $extension")
+        if (verifyDependencyOutput) {
+            outputs.dir(
+                provider {
+                    configuration.resolvedConfiguration.resolvedArtifacts.single().moduleDirectory()
                 }
-
-                from(fileTree.matching {
-                    exclude("**/plugins/Kotlin/**")
-                })
-
-                into(artifactsDirectory)
-
-                if (pathRemap != null) {
-                    eachFile {
-                        path = pathRemap(path)
-                    }
-                }
-
-                includeEmptyDirs = false
-            }
-
-            writeIvyXml(
-                organization,
-                moduleVersion.id.name,
-                moduleVersion.id.version,
-                moduleVersion.id.name,
-                File(artifactsDirectory, "lib"),
-                File(artifactsDirectory, "lib"),
-                File(moduleDirectory, "ivy"),
-                *listOfNotNull(sources).toTypedArray()
             )
+        } else {
+            outputs.upToDateWhen {
+                configuration.resolvedConfiguration.resolvedArtifacts.single()
+                    .moduleDirectory()
+                    .exists()
+            }
+        }
 
-            val pluginsDirectory = File(artifactsDirectory, "plugins")
-            if (pluginsDirectory.exists()) {
-                file(File(artifactsDirectory, "plugins"))
-                    .listFiles { file: File -> file.isDirectory }
-                    .forEach {
-                        writeIvyXml(
-                            organization,
-                            it.name,
-                            moduleVersion.id.version,
-                            it.name,
-                            File(it, "lib"),
-                            File(it, "lib"),
-                            File(moduleDirectory, "ivy"),
-                            *listOfNotNull(sources).toTypedArray()
-                        )
+        doFirst {
+            configuration.resolvedConfiguration.resolvedArtifacts.single().run {
+                val moduleDirectory = moduleDirectory()
+                val artifactsDirectory = File(moduleDirectory(), "artifacts")
+
+                logger.info("Unpacking ${file.name} into ${artifactsDirectory.absolutePath}")
+                copy {
+                    val fileTree = when (extension) {
+                        "tar.gz" -> tarTree(file)
+                        "zip" -> zipTree(file)
+                        else -> error("Unsupported artifact extension: $extension")
                     }
+
+                    from(
+                        fileTree.matching {
+                            exclude("**/plugins/Kotlin/**")
+                        }
+                    )
+
+                    into(artifactsDirectory)
+
+                    if (pathRemap != null) {
+                        eachFile {
+                            path = pathRemap(path)
+                        }
+                    }
+
+                    includeEmptyDirs = false
+                }
+
+                writeIvyXml(
+                    organization,
+                    moduleVersion.id.name,
+                    moduleVersion.id.version,
+                    moduleVersion.id.name,
+                    File(artifactsDirectory, "lib"),
+                    File(artifactsDirectory, "lib"),
+                    File(moduleDirectory, "ivy"),
+                    *listOfNotNull(sources).toTypedArray()
+                )
+
+                val pluginsDirectory = File(artifactsDirectory, "plugins")
+                if (pluginsDirectory.exists()) {
+                    file(File(artifactsDirectory, "plugins"))
+                        .listFiles { file: File -> file.isDirectory }
+                        .forEach {
+                            writeIvyXml(
+                                organization,
+                                it.name,
+                                moduleVersion.id.version,
+                                it.name,
+                                File(it, "lib"),
+                                File(it, "lib"),
+                                File(moduleDirectory, "ivy"),
+                                *listOfNotNull(sources).toTypedArray()
+                            )
+                        }
+                }
             }
         }
     }
+
+    val cleanupIvyRepositoryTask = tasks.register<CleanDataTask>("cleanupIvyRepositoryFor${configuration.name.capitalize()}") {
+        cleanableStoreProvider = provider {
+            configuration.resolvedConfiguration.resolvedArtifacts.single().storeDirectory()
+        }
+    }
+
+    cleanupDependencies {
+        dependsOn(cleanupIvyRepositoryTask)
+    }
+
+    return buildIvyRepositoryTask
 }
 
 fun writeIvyXml(

buildSrc/settings.gradle

@@ -20,7 +20,7 @@ buildscript {
         }
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.12")
+        classpath("org.jetbrains.kotlin:kotlin-build-gradle-plugin:0.0.15")
     }
 }
 

buildSrc/src/main/kotlin/Bootstrap.kt

@@ -1,114 +0,0 @@
-@file:Suppress("unused") // usages in build scripts are not tracked properly
-
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import java.net.URI
-
-
-var Project.bootstrapKotlinVersion: String
-    get() = this.property("bootstrapKotlinVersion") as String
-    private set(value) {
-        this.extra["bootstrapKotlinVersion"] = value
-    }
-
-var Project.bootstrapKotlinRepo: String?
-    get() = this.property("bootstrapKotlinRepo") as String?
-    private set(value) {
-        this.extra["bootstrapKotlinRepo"] = value
-    }
-
-val Project.internalKotlinRepo: String?
-    get() = "https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:$bootstrapKotlinVersion," +
-            "branch:default:any/artifacts/content/internal/repo"
-
-fun Project.kotlinBootstrapFrom(defaultSource: BootstrapOption) {
-    val customVersion = project.findProperty("bootstrap.kotlin.version") as String?
-    val customRepo = project.findProperty("bootstrap.kotlin.repo") as String?
-    val teamCityVersion = project.findProperty("bootstrap.teamcity.kotlin.version") as String?
-    val teamCityBuild = project.findProperty("bootstrap.teamcity.build.number") as String?
-    val teamCityProject = project.findProperty("bootstrap.teamcity.project") as String?
-
-    val bootstrapSource = when {
-        project.hasProperty("bootstrap.local") -> BootstrapOption.Local(
-            project.findProperty("bootstrap.local.version") as String?,
-            project.findProperty("bootstrap.local.path") as String?
-        )
-        teamCityVersion != null -> BootstrapOption.TeamCity(
-            teamCityVersion,
-            teamCityBuild,
-            projectExtId = teamCityProject,
-            onlySuccessBootstrap = false
-        )
-        customVersion != null -> BootstrapOption.Custom(kotlinVersion = customVersion, repo = customRepo)
-        else -> defaultSource
-    }
-
-    bootstrapSource.applyToProject(project)
-    project.logger.lifecycle("Using kotlin bootstrap version $bootstrapKotlinVersion from repo $bootstrapKotlinRepo")
-}
-
-sealed class BootstrapOption {
-    abstract fun applyToProject(project: Project)
-
-    /** Manual repository and version specification.
-     *
-     *  If [repo] is not specified the default buildscript and project repositories are used
-     */
-    open class Custom(val kotlinVersion: String, val repo: String?, val cacheRedirector: Boolean = false) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            project.bootstrapKotlinVersion = kotlinVersion
-            project.bootstrapKotlinRepo = if (cacheRedirector)
-                repo?.let { URI(it) }?.let { "https://cache-redirector.jetbrains.com/${it.host}/${it.path}" }
-            else
-                repo
-        }
-    }
-
-    /** Get bootstrap from kotlin-dev bintray repo */
-    class BintrayDev(kotlinVersion: String, cacheRedirector: Boolean = false) :
-        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-dev", cacheRedirector)
-
-    /** Get bootstrap from kotlin-bootstrap bintray repo, where bootstraps are published */
-    class BintrayBootstrap(kotlinVersion: String, cacheRedirector: Boolean = false) :
-        Custom(kotlinVersion, "https://dl.bintray.com/kotlin/kotlin-bootstrap", cacheRedirector)
-
-    /** Get bootstrap from teamcity maven artifacts of the specified build configuration
-     *
-     * [kotlinVersion] the version of maven artifacts
-     * [buildNumber] build number of a teamcity build, by default the same as [kotlinVersion],
-     * [projectExtId] extId of a teamcity build configuration, by default "Kotlin_dev_Compiler",
-     * [onlySuccessBootstrap] allow artifacts only from success builds of the default branch tagged with 'bootstrap' tag
-     */
-    class TeamCity(
-        val kotlinVersion: String,
-        val buildNumber: String? = null,
-        val projectExtId: String? = null,
-        val onlySuccessBootstrap: Boolean = true,
-        val teamcityUrl: String = "https://teamcity.jetbrains.com"
-    ) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            val query = if (onlySuccessBootstrap) "status:SUCCESS,tag:bootstrap,pinned:true" else "branch:default:any"
-            project.bootstrapKotlinRepo = "$teamcityUrl/guestAuth/app/rest/builds/buildType:(id:${projectExtId
-                ?: "Kotlin_dev_Compiler"}),number:${buildNumber ?: kotlinVersion},$query/artifacts/content/maven/"
-            project.bootstrapKotlinVersion = kotlinVersion
-        }
-    }
-
-    /**
-     * Use previously published local artifacts from the build/repo maven repository
-     *
-     * [kotlinVersion] version of artifacts, by default the snapshot version of project is used
-     * [localPath] the path to local repository, if specified it is resolved with respect or project dir
-     */
-    class Local(val kotlinVersion: String? = null, val localPath: String? = null) : BootstrapOption() {
-        override fun applyToProject(project: Project) {
-            val repoPath = if (localPath != null)
-                project.projectDir.resolve(localPath).canonicalFile
-            else
-                project.buildDir.resolve("repo")
-
-            project.bootstrapKotlinRepo = repoPath.toURI().toString()
-            project.bootstrapKotlinVersion = kotlinVersion ?: project.property("defaultSnapshotVersion") as String
-        }
-    }
-}

buildSrc/src/main/kotlin/dependencies.kt

@@ -2,14 +2,12 @@
 
 // usages in build scripts are not tracked properly
 
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
-import org.gradle.api.tasks.AbstractCopyTask
 import org.gradle.kotlin.dsl.extra
 import org.gradle.kotlin.dsl.project
 import java.io.File

buildSrc/src/main/kotlin/localDependencies.kt

@@ -28,7 +28,8 @@ import org.gradle.kotlin.dsl.*
 import java.io.File
 
 private fun Project.kotlinBuildLocalDependenciesDir(): File =
-    (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File) ?: project.rootDir.absoluteFile.resolve("dependencies")
+    (findProperty("kotlin.build.dependencies.dir") as String?)?.let(::File)
+        ?: rootProject.gradle.gradleUserHomeDir.resolve("kotlin-build-dependencies")
 
 private fun Project.kotlinBuildLocalRepoDir(): File = kotlinBuildLocalDependenciesDir().resolve("repo")