Rewrite :shared:buildSrc to Java to avoid dependency on kotlin stdlib (KTI-118)

Composite build hangs on some version combination after start using 1.4.255-SNAPSHOT in
Kotlin build. This is probably caused by kotlin-stdlib substitution in buildSrc build.

(cherry picked from commit 89c57b281e57cb576aa7739c22fbc2c44a704110)

shared/buildSrc/build.gradle

@@ -15,23 +15,14 @@
  */
 buildscript {
     ext.rootBuildDirectory = "$rootDir/../.."
-    apply from: "$rootBuildDirectory/gradle/loadRootProperties.gradle"
-    apply from: "$rootBuildDirectory/gradle/kotlinGradlePlugin.gradle"
-
 }
 
-
+apply plugin: 'java'
-apply plugin: 'kotlin'
 
 repositories {
-    maven {
-        url buildKotlinCompilerRepo
-    }
     mavenCentral()
 }
 
 dependencies {
     compile gradleApi()
-    compile localGroovy()
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
 }

shared/buildSrc/src/main/java/org/jetbrains/kotlin/VersionGenerator.java

@@ -0,0 +1,107 @@
+package org.jetbrains.kotlin;
+
+import groovy.lang.Closure;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.Task;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.OutputFile;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.PrintWriter;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class VersionGenerator extends DefaultTask {
+    @OutputDirectory
+    public File getVersionSourceDirectory() {
+        return getProject().file("build/generated");
+    }
+
+    @OutputFile
+    public File getVersionFile() {
+        return getProject().file(getVersionSourceDirectory().getPath() + "/org/jetbrains/kotlin/konan/CompilerVersionGenerated.kt");
+    }
+
+    @Input
+    public String getKonanVersion() {
+        return getProject().getProperties().get("konanVersion").toString();
+    }
+
+
+    // TeamCity passes all configuration parameters into a build script as project properties.
+    // Thus we can use them here instead of environment variables.
+    @Optional
+    @Input
+    public String getBuildNumber() {
+        Object property = getProject().findProperty("build.number");
+        if (property == null) return null;
+
+        return property.toString();
+    }
+
+    @Input
+    public String getMeta() {
+        Object konanMetaVersionProperty = getProject().getProperties().get("konanMetaVersion");
+        if (konanMetaVersionProperty == null) {
+            return "MetaVersion.DEV";
+        }
+
+        return "MetaVersion." + konanMetaVersionProperty.toString().toUpperCase();
+    }
+
+    private final static Pattern versionPattern = Pattern.compile(
+            "^(\\d+)\\.(\\d+)(?:\\.(\\d+))?(?:-M(\\p{Digit}))?(?:-(\\p{Alpha}\\p{Alnum}*))?(?:-(\\d+))?$"
+    );
+
+    @SuppressWarnings("NullableProblems")
+    @Override
+    public Task configure(@SuppressWarnings("NullableProblems") Closure closure) {
+        Task result = super.configure(closure);
+
+        doFirst(task -> {
+            Matcher matcher = versionPattern.matcher(getKonanVersion());
+            if (!matcher.matches()) {
+                throw new IllegalArgumentException("Cannot parse Kotlin/Native version: $konanVersion");
+            }
+
+            int major = Integer.parseInt(matcher.group(1));
+            int minor = Integer.parseInt(matcher.group(2));
+
+            String maintenanceStr = matcher.group(3);
+            int maintenance = maintenanceStr != null ? Integer.parseInt(maintenanceStr) : 0;
+
+            String milestoneStr = matcher.group(4);
+            int milestone = milestoneStr != null ? Integer.parseInt(milestoneStr) : -1;
+
+            String buildNumber = getBuildNumber();
+            getProject().getLogger().info("BUILD_NUMBER: " + getBuildNumber());
+            int build = -1;
+            if (buildNumber != null) {
+                String[] buildNumberSplit = buildNumber.split("-");
+                build = Integer.parseInt(buildNumberSplit[buildNumberSplit.length - 1]); // //7-dev-buildcount
+            }
+
+
+            try (PrintWriter printWriter = new PrintWriter(getVersionFile())) {
+                printWriter.println(
+                        "package org.jetbrains.kotlin.konan\n" +
+                        "\n" +
+                        "internal val currentCompilerVersion: CompilerVersion =\n" +
+                        "    CompilerVersionImpl(\n" +
+                                getMeta() + ", " + major + ", " + minor + ",\n" +
+                                maintenance + ", " + milestone + ", "+ build + ")\n" +
+                        "\n" +
+                        "val CompilerVersion.Companion.CURRENT: CompilerVersion\n" +
+                        "    get() = currentCompilerVersion"
+                );
+            } catch (FileNotFoundException e) {
+                throw new IllegalStateException(e);
+            }
+        });
+
+        return result;
+    }
+}

shared/buildSrc/src/main/kotlin/org/jetbrains/kotlin/VersionGenerator.kt

@@ -1,70 +0,0 @@
-/*
- * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
- * that can be found in the LICENSE file.
- */
-
-package org.jetbrains.kotlin
-
-import groovy.lang.Closure
-import org.gradle.api.DefaultTask
-import org.gradle.api.Task
-import org.gradle.api.tasks.*
-import java.io.File
-
-
-open class VersionGenerator: DefaultTask() {
-    @OutputDirectory
-    val versionSourceDirectory = project.file("build/generated")
-    @OutputFile
-    val versionFile:File = project.file("${versionSourceDirectory.path}/org/jetbrains/kotlin/konan/CompilerVersionGenerated.kt")
-
-    val konanVersion: String
-        @Input get() = project.properties["konanVersion"].toString()
-
-    val buildNumber: String?
-        // TeamCity passes all configuration parameters into a build script as project properties.
-        // Thus we can use them here instead of environment variables.
-        @Optional @Input get() = project.findProperty("build.number")?.toString()
-
-    val meta: String
-        @Input get() = project.properties["konanMetaVersion"]?.let {
-            "MetaVersion.${it.toString().toUpperCase()}"
-        } ?: "MetaVersion.DEV"
-
-
-    private val versionPattern = "(\\d+)\\.(\\d+)(?:\\.(\\d+))?(?:-M(\\p{Digit}))?(?:-(\\p{Alpha}\\p{Alnum}*))?(?:-(\\d+))?".toRegex()
-
-    override fun configure(closure: Closure<*>): Task {
-        val result = super.configure(closure)
-        doFirst {
-            val content = buildString {
-                operator fun String.unaryPlus() = this@buildString.append(this)
-                val (majorStr, minorStr, maintenanceStr, milestoneStr) =
-                        versionPattern.matchEntire(konanVersion)?.destructured
-                                ?: throw IllegalArgumentException("Cannot parse Kotlin/Native version: $konanVersion")
-                val major = majorStr.toInt()
-                val minor = minorStr.toInt()
-                val maintenance = maintenanceStr.toIntOrNull() ?: 0
-                val milestone = milestoneStr.toIntOrNull() ?: -1
-                project.logger.info("BUILD_NUMBER: $buildNumber")
-                val build = buildNumber?.let {
-                    it.split("-").last().toInt() //7-dev-buildcount
-                }?: -1
-
-                + """
-                   |package org.jetbrains.kotlin.konan
-                   |
-                   |internal val currentCompilerVersion: CompilerVersion =
-                   |    CompilerVersionImpl($meta, $major, $minor, $maintenance, $milestone, $build)
-                   |
-                   |val CompilerVersion.Companion.CURRENT: CompilerVersion
-                   |    get() = currentCompilerVersion
-                """.trimMargin()
-            }
-            versionFile.printWriter().use {
-                it.println(content)
-            }
-        }
-        return result
-    }
-}