Revert "KT-38250 The minimal supported Gradle version is 5.3 now"

This reverts commit 61f213c8

build.gradle.kts

@@ -779,15 +779,15 @@ fun CopySpec.setExecutablePermissions() {
 
 val zipCompiler by task<Zip> {
     dependsOn(dist)
-    destinationDirectory.set(file(distDir))
+    destinationDir = file(distDir)
-    archiveFileName.set("kotlin-compiler-$kotlinVersion.zip")
+    archiveName = "kotlin-compiler-$kotlinVersion.zip"
 
     from(distKotlinHomeDir)
     into("kotlinc")
     setExecutablePermissions()
 
     doLast {
-        logger.lifecycle("Compiler artifacts packed to ${archiveFile.get().asFile.absolutePath}")
+        logger.lifecycle("Compiler artifacts packed to $archivePath")
     }
 }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts

@@ -52,7 +52,7 @@ val shortenTempRootName = System.getProperty("os.name")!!.contains("Windows")
 projectTest("test", shortenTempRootName = shortenTempRootName) {}
 
 projectTest("testAdvanceGradleVersion", shortenTempRootName = shortenTempRootName) {
-    val gradleVersionForTests = "6.3"
+    val gradleVersionForTests = "5.3-rc-2"
     systemProperty("kotlin.gradle.version.for.tests", gradleVersionForTests)
 }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt

@@ -12,6 +12,9 @@ import kotlin.test.assertTrue
 open class KotlinAndroid33GradleIT : KotlinAndroid32GradleIT() {
     override val androidGradlePluginVersion: AGPVersion
         get() = AGPVersion.v3_3_2
+
+    override val defaultGradleVersion: GradleVersionRequired
+        get() = GradleVersionRequired.AtLeast("5.0")
 }
 
 open class KotlinAndroid36GradleIT : KotlinAndroid33GradleIT() {
@@ -407,6 +410,46 @@ open class KotlinAndroid32GradleIT : KotlinAndroid3GradleIT() {
     }
 }
 
+class KotlinAndroid30GradleIT : KotlinAndroid3GradleIT() {
+    override val androidGradlePluginVersion: AGPVersion
+        get() = AGPVersion.v3_0_0
+
+    override val defaultGradleVersion: GradleVersionRequired
+        get() = GradleVersionRequired.Until("4.10.2")
+
+    @Test
+    fun testOmittedStdlibVersion() = Project("AndroidProject").run {
+        setupWorkingDir()
+
+        gradleBuildScript("Lib").modify {
+            it.checkedReplace("kotlin-stdlib:\$kotlin_version", "kotlin-stdlib") + "\n" + """
+            apply plugin: 'maven'
+            group 'com.example'
+            version '1.0'
+            android {
+                defaultPublishConfig 'flavor1Debug'
+            }
+            uploadArchives {
+                repositories {
+                    mavenDeployer {
+                        repository(url: "file://${'$'}buildDir/repo")
+                    }
+                }
+            }
+            """.trimIndent()
+        }
+
+        build(":Lib:assembleFlavor1Debug", ":Lib:uploadArchives") {
+            assertSuccessful()
+            assertTasksExecuted(":Lib:compileFlavor1DebugKotlin", ":Lib:uploadArchives")
+            val pomLines = File(projectDir, "Lib/build/repo/com/example/Lib/1.0/Lib-1.0.pom").readLines()
+            val stdlibVersionLineNumber = pomLines.indexOfFirst { "<artifactId>kotlin-stdlib</artifactId>" in it } + 1
+            val versionLine = pomLines[stdlibVersionLineNumber]
+            assertTrue { "<version>${defaultBuildOptions().kotlinVersion}</version>" in versionLine }
+        }
+    }
+}
+
 abstract class KotlinAndroid3GradleIT : AbstractKotlinAndroidGradleTests() {
     @Test
     fun testApplyWithFeaturePlugin() {
@@ -681,6 +724,29 @@ fun getSomething() = 10
         val project = Project("AndroidExtensionsSpecificFeatures")
         val options = defaultBuildOptions().copy(incremental = false)
 
+        if (this is KotlinAndroid30GradleIT) {
+            project.setupWorkingDir()
+            project.gradleBuildScript("app").modify {
+                """
+                def projectEvaluated = false
+
+                configurations.all { configuration ->
+                    incoming.beforeResolve {
+                        if (!projectEvaluated) {
+                            throw new RuntimeException("${'$'}configuration resolved during project configuration phase.")
+                        }
+                    }
+                }
+
+                $it
+
+                afterEvaluate {
+                    projectEvaluated = true
+                }
+                """.trimIndent()
+            }
+        }
+
         project.build("assemble", options = options) {
             assertFailed()
             assertContains("Unresolved reference: textView")

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt

@@ -168,9 +168,17 @@ abstract class BaseGradleIT {
             assert(version != runnerGradleVersion) { "Not stopping Gradle daemon v$version as it matches the runner version" }
             println("Stopping gradle daemon v$version")
 
+            val envVariables = if (GradleVersion.version(version) < GradleVersion.version("5.0")) {
+                // Gradle versions below 5.0 do not support running on JDK11, and some of the tests
+                // set JAVA_HOME to JDK11. This makes sure we are using JDK8 when stopping those daemons.
+                environmentVariables + mapOf("JAVA_HOME" to System.getenv()["JDK_18"]!!)
+            } else {
+                environmentVariables
+            }
+
             val wrapperDir = gradleWrappers[version] ?: error("Was asked to stop unknown daemon $version")
             val cmd = createGradleCommand(wrapperDir, arrayListOf("-stop"))
-            val result = runProcess(cmd, wrapperDir, environmentVariables)
+            val result = runProcess(cmd, wrapperDir, envVariables)
             assert(result.isSuccessful) { "Could not stop daemon: $result" }
             DaemonRegistry.unregister(version)
         }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationAvoidanceIT.kt

@@ -10,7 +10,7 @@ import org.junit.Test
 class ConfigurationAvoidanceIT : BaseGradleIT() {
 
     @Test
-    fun testUnrelatedTaskNotConfigured() = with(Project("simpleProject")) {
+    fun testUnrelatedTaskNotConfigured() = with(Project("simpleProject", GradleVersionRequired.AtLeast("4.10.2"))) {
         setupWorkingDir()
 
         val expensivelyConfiguredTaskName = "expensivelyConfiguredTask"

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ExecutionStrategyIT.kt

@@ -89,6 +89,8 @@ abstract class ExecutionStrategyIT : BaseGradleIT() {
     }
 
     private fun CompiledProject.checkCompileDaemon() {
+        val isGradleAtLeast50 = project.testGradleVersionAtLeast("5.0")
+
         val m = "Kotlin compile daemon JVM options: \\[(.*?)\\]".toRegex().find(output)
             ?: error("Could not find Kotlin compile daemon JVM options in Gradle's output")
         val kotlinDaemonJvmArgs = m.groupValues[1].split(",").mapTo(LinkedHashSet()) { it.trim() }
@@ -100,8 +102,11 @@ abstract class ExecutionStrategyIT : BaseGradleIT() {
             )
         }
 
-        // 256m is the default value for Gradle 5.0+
+        if (isGradleAtLeast50) {
-        assertDaemonArgsContain("-XX:MaxMetaspaceSize=256m")
+            // 256m is the default value for Gradle 5.0+
+            assertDaemonArgsContain("-XX:MaxMetaspaceSize=256m")
+        }
+
         assertDaemonArgsContain("-ea")
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/GradleVersionRequired.kt

@@ -17,12 +17,11 @@
 package org.jetbrains.kotlin.gradle
 
 import org.gradle.util.GradleVersion
-import org.jetbrains.kotlin.gradle.GradleVersionRequired.Companion.OLDEST_SUPPORTED
 import org.junit.Assume
 
 sealed class GradleVersionRequired(val minVersion: String, val maxVersion: String?) {
     companion object {
-        const val OLDEST_SUPPORTED = "5.3"
+        const val OLDEST_SUPPORTED = "4.9"
 
         val FOR_MPP_SUPPORT = AtLeast("6.0")
     }
@@ -35,13 +34,13 @@ sealed class GradleVersionRequired(val minVersion: String, val maxVersion: Strin
 
     class Until(maxVersion: String) : GradleVersionRequired(OLDEST_SUPPORTED, maxVersion)
 
-    object None : GradleVersionRequired(OLDEST_SUPPORTED, null)
+    object None : GradleVersionRequired(GradleVersionRequired.OLDEST_SUPPORTED, null)
 }
 
 
 fun BaseGradleIT.Project.chooseWrapperVersionOrFinishTest(): String {
     val gradleVersionForTests = System.getProperty("kotlin.gradle.version.for.tests")?.toGradleVersion()
-    val minVersion = max(gradleVersionRequirement.minVersion.toGradleVersion(), OLDEST_SUPPORTED.toGradleVersion())
+    val minVersion = gradleVersionRequirement.minVersion.toGradleVersion()
     val maxVersion = gradleVersionRequirement.maxVersion?.toGradleVersion()
 
     if (gradleVersionForTests == null) {
@@ -53,6 +52,4 @@ fun BaseGradleIT.Project.chooseWrapperVersionOrFinishTest(): String {
     return gradleVersionForTests.version
 }
 
-private fun <T : Comparable<T>> max(a: T, b: T): T = if (a < b) b else a
-
 private fun String.toGradleVersion() = GradleVersion.version(this)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt

@@ -20,6 +20,9 @@ open class Kapt3Android33IT : Kapt3AndroidIT() {
     override val androidGradlePluginVersion: AGPVersion
         get() = AGPVersion.v3_3_2
 
+    override val defaultGradleVersion: GradleVersionRequired
+        get() = GradleVersionRequired.AtLeast("5.2")
+
     @Test
     fun testAndroidxNavigationSafeArgs() = with(Project("androidx-navigation-safe-args", directoryPrefix = "kapt2")) {
         // KT-30735
@@ -69,19 +72,22 @@ open class Kapt3Android33IT : Kapt3AndroidIT() {
     }
 }
 
-class Kapt3Android34IT : Kapt3AndroidIT() {
+class Kapt3Android31IT : Kapt3AndroidIT() {
     override val androidGradlePluginVersion: AGPVersion
-        get() = AGPVersion.v3_4_1
+        get() = AGPVersion.v3_1_0
 
     // there is a weird validation exception in testICWithAnonymousClasses with 5.0 todo: fix it
     override val defaultGradleVersion: GradleVersionRequired
-        get() = GradleVersionRequired.Until("5.4.1")
+        get() = GradleVersionRequired.Until("4.10.2")
 }
 
 open class Kapt3AndroidIT : Kapt3BaseIT() {
     protected open val androidGradlePluginVersion: AGPVersion
         get() = AGPVersion.v3_0_0
 
+    override val defaultGradleVersion: GradleVersionRequired
+        get() = GradleVersionRequired.Until("4.10.2")
+
     override fun defaultBuildOptions() =
         super.defaultBuildOptions().copy(
             androidHome = KotlinTestUtils.findAndroidSdk(),

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3IT.kt

@@ -69,7 +69,7 @@ class Kapt3WorkersIT : Kapt3IT() {
         Assume.assumeTrue("JDK 10 isn't available", javaHome.isDirectory)
         val options = defaultBuildOptions().copy(javaHome = javaHome)
 
-        val project = Project("simple", directoryPrefix = "kapt2")
+        val project = Project("simple", directoryPrefix = "kapt2", gradleVersionRequirement = GradleVersionRequired.AtLeast("4.7"))
         project.build("build", options = options) {
             assertSuccessful()
             assertKaptSuccessful()
@@ -84,7 +84,7 @@ class Kapt3WorkersIT : Kapt3IT() {
         Assume.assumeTrue("JDK 11 isn't available", javaHome.isDirectory)
         val options = defaultBuildOptions().copy(javaHome = javaHome)
 
-        val project = Project("simple", directoryPrefix = "kapt2")
+        val project = Project("simple", directoryPrefix = "kapt2", gradleVersionRequirement = GradleVersionRequired.AtLeast("5.0"))
         project.build("build", options = options) {
             assertSuccessful()
             assertKaptSuccessful()
@@ -649,7 +649,7 @@ open class Kapt3IT : Kapt3BaseIT() {
         Assume.assumeTrue("JDK 11 isn't available", javaHome.isDirectory)
         val options = defaultBuildOptions().copy(javaHome = javaHome)
 
-        val project = Project("simple", directoryPrefix = "kapt2").also {
+        val project = Project("simple", directoryPrefix = "kapt2", gradleVersionRequirement = GradleVersionRequired.AtLeast("5.0")).also {
             it.setupWorkingDir()
             it.gradleBuildScript().appendText("\nsourceCompatibility = '8'")
         }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt

@@ -37,7 +37,7 @@ class Kotlin2JsIrGradlePluginIT : AbstractKotlin2JsGradlePluginIT(true) {
 
     @Test
     fun testCleanOutputWithEmptySources() {
-        with(Project("kotlin-js-nodejs-project")) {
+        with(Project("kotlin-js-nodejs-project", GradleVersionRequired.AtLeast("5.3"))) {
             setupWorkingDir()
             gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
             gradleSettingsScript().modify(::transformBuildScriptWithPluginsDsl)
@@ -512,7 +512,7 @@ abstract class AbstractKotlin2JsGradlePluginIT(private val irBackend: Boolean) :
     }
 
     @Test
-    fun testNewKotlinJsPlugin() = with(Project("kotlin-js-plugin-project")) {
+    fun testNewKotlinJsPlugin() = with(Project("kotlin-js-plugin-project", GradleVersionRequired.AtLeast("5.3"))) {
         assumeFalse(irBackend) // TODO: Support IR version of kotlinx.html
         setupWorkingDir()
         gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
@@ -558,7 +558,7 @@ abstract class AbstractKotlin2JsGradlePluginIT(private val irBackend: Boolean) :
     }
 
     @Test
-    fun testYarnSetup() = with(Project("yarn-setup")) {
+    fun testYarnSetup() = with(Project("yarn-setup", GradleVersionRequired.AtLeast("5.3"))) {
         setupWorkingDir()
         gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
         gradleSettingsScript().modify(::transformBuildScriptWithPluginsDsl)
@@ -589,7 +589,7 @@ abstract class AbstractKotlin2JsGradlePluginIT(private val irBackend: Boolean) :
     }
 
     @Test
-    fun testNpmDependencies() = with(Project("npm-dependencies")) {
+    fun testNpmDependencies() = with(Project("npm-dependencies", GradleVersionRequired.AtLeast("5.3"))) {
         setupWorkingDir()
         gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
 
@@ -603,7 +603,7 @@ abstract class AbstractKotlin2JsGradlePluginIT(private val irBackend: Boolean) :
     }
 
     @Test
-    fun testBrowserDistribution() = with(Project("kotlin-js-browser-project")) {
+    fun testBrowserDistribution() = with(Project("kotlin-js-browser-project", GradleVersionRequired.AtLeast("5.3"))) {
         setupWorkingDir()
         gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
         gradleSettingsScript().modify(::transformBuildScriptWithPluginsDsl)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt

@@ -588,12 +588,14 @@ class KotlinGradleIT : BaseGradleIT() {
 
     @Test
     fun testNoUnnamedInputsOutputs() {
+        // Use a new Gradle version to enable the usage of the input/output builders, which are new API:
+        val gradleVersionRequirement = GradleVersionRequired.AtLeast("4.4")
 
         val projects = listOf(
-            Project("simpleProject"),
+            Project("simpleProject", gradleVersionRequirement),
-            Project("kotlin2JsProject"),
+            Project("kotlin2JsProject", gradleVersionRequirement),
-            Project("multiplatformProject"),
+            Project("multiplatformProject", gradleVersionRequirement),
-            Project("simple", directoryPrefix = "kapt2")
+            Project("simple", gradleVersionRequirement, "kapt2")
         )
 
         projects.forEach {
@@ -892,7 +894,7 @@ class KotlinGradleIT : BaseGradleIT() {
     }
 
     @Test
-    fun testNewModelInOldJvmPlugin() = with(Project("new-model-in-old-plugin")) {
+    fun testNewModelInOldJvmPlugin() = with(Project("new-model-in-old-plugin", GradleVersionRequired.AtLeast("5.0"))) {
         setupWorkingDir()
         gradleBuildScript().modify(::transformBuildScriptWithPluginsDsl)
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/NewMultiplatformIT.kt

@@ -452,7 +452,7 @@ class NewMultiplatformIT : BaseGradleIT() {
         }
 
     @Test
-    fun testResourceProcessing() = with(Project("sample-lib", gradleVersion, "new-mpp-lib-and-app")) {
+    fun testResourceProcessing() = with(Project("sample-lib", directoryPrefix = "new-mpp-lib-and-app")) {
         val targetsWithResources = listOf("jvm6", "nodeJs", "wasm32", nativeHostTargetName)
         val processResourcesTasks =
             targetsWithResources.map { ":${it}ProcessResources" }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SubpluginsIT.kt

@@ -149,14 +149,25 @@ class SubpluginsIT : BaseGradleIT() {
         var isFailed = false
         project.build("build", options = options) {
             val classesDir = kotlinClassesDir("app", "main")
-            assertSuccessful()
+            if (project.testGradleVersionAtLeast("5.0")) {
-            assertFileExists("${classesDir}World.class")
+                assertSuccessful()
-            assertFileExists("${classesDir}Alice.class")
+                assertFileExists("${classesDir}World.class")
-            assertFileExists("${classesDir}Bob.class")
+                assertFileExists("${classesDir}Alice.class")
+                assertFileExists("${classesDir}Bob.class")
 
-            if (withIC) {
+                if (withIC) {
-                // compile iterations are not logged when IC is disabled
+                    // compile iterations are not logged when IC is disabled
-                assertCompiledKotlinSources(project.relativize(bobGreet, aliceGreet, worldGreet, greetScriptTemplateKt))
+                    assertCompiledKotlinSources(project.relativize(bobGreet, aliceGreet, worldGreet, greetScriptTemplateKt))
+                }
+            } else {
+                val usedGradleVersion =
+                    GradleVersion.version(
+                        System.getProperty("kotlin.gradle.version.for.tests")
+                            ?: project.gradleVersionRequirement.minVersion
+                    )
+                assertEquals(true, usedGradleVersion.version.substringBefore('.').toIntOrNull()?.let { it < 5 }, "Expected gradle version < 5, got ${usedGradleVersion.version}")
+                assertContains("kotlin scripting plugin: incompatible Gradle version")
+                isFailed = true
             }
         }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/VariantAwareDependenciesIT.kt

@@ -279,7 +279,7 @@ class VariantAwareDependenciesIT : BaseGradleIT() {
     // Starting with Gradle 5.0, plain Maven dependencies are represented as two variants, and resolving them to the API one leads
     // to transitive dependencies left out of the resolution results. We need to ensure that our attributes schema does not lead to the API
         // variants chosen over the runtime ones when resolving a configuration with no required Usage:
-        with(Project("simpleProject")) {
+        with(Project("simpleProject", GradleVersionRequired.AtLeast("5.0-milestone-1"))) {
             setupWorkingDir()
             gradleBuildScript().appendText("\ndependencies { compile 'org.jetbrains.kotlin:kotlin-compiler-embeddable' }")
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/AGPVersion.kt

@@ -22,7 +22,6 @@ class AGPVersion private constructor(private val versionNumber: VersionNumber) {
         val v3_1_0 = fromString("3.1.0")
         val v3_2_0 = fromString("3.2.0")
         val v3_3_2 = fromString("3.3.2")
-        val v3_4_1 = fromString("3.4.1")
         val v3_6_0 = fromString("3.6.0")
         val v4_0_ALPHA_8 = fromString("4.0.0-alpha08")
     }

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

@@ -242,7 +242,7 @@ internal open class GradleCompilerRunner(protected val task: Task) {
                 ?: return null
             val sourceSet = javaConvention.sourceSets.findByName(sourceSetName) ?: return null
             val jarTask = project.tasks.findByName(sourceSet.jarTaskName) as? Jar
-            return jarTask?.archiveFile?.get()?.asFile
+            return jarTask?.archivePath
         }
 
         @Synchronized

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

@@ -7,10 +7,11 @@ package org.jetbrains.kotlin.gradle.internal.tasks
 
 import org.gradle.api.Task
 import org.gradle.api.file.FileCollection
+import org.jetbrains.kotlin.gradle.utils.outputsCompatible
 
 internal interface TaskWithLocalState : Task {
     fun localStateDirectories(): FileCollection
 }
 
 internal fun TaskWithLocalState.allOutputFiles(): FileCollection =
-    outputs.files + localStateDirectories()
+    outputsCompatible.files + localStateDirectories()

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

@@ -11,6 +11,7 @@ import com.android.build.gradle.api.BaseVariant
 import com.android.builder.model.SourceProvider
 import org.gradle.api.*
 import org.gradle.api.artifacts.ExternalDependency
+import org.gradle.api.artifacts.MutableVersionConstraint
 import org.gradle.api.artifacts.maven.Conf2ScopeMappingContainer
 import org.gradle.api.artifacts.maven.MavenResolver
 import org.gradle.api.attributes.Usage
@@ -223,7 +224,7 @@ internal class Kotlin2JvmSourceSetProcessor(
                 .flatMap { it.getSubpluginKotlinTasks(project, kotlinTaskInstance) }
                 .forEach { plugin -> kotlinCompilation.allKotlinSourceSets.forEach { sourceSet -> plugin.source(sourceSet.kotlin) } }
 
-            javaTask?.let { configureJavaTask(kotlinTaskInstance, it) }
+            javaTask?.let { configureJavaTask(kotlinTaskInstance, it, logger) }
 
             if (project.pluginManager.hasPlugin("java-library") && sourceSetName == SourceSet.MAIN_SOURCE_SET_NAME) {
                 registerKotlinOutputForJavaLibrary(kotlinTaskInstance.destinationDir, kotlinTaskInstance)
@@ -530,7 +531,7 @@ internal abstract class AbstractKotlinPlugin(
                 project.registerTask<InspectClassesForMultiModuleIC>("inspectClassesForKotlinIC") {
                     it.sourceSetName = SourceSet.MAIN_SOURCE_SET_NAME
                     it.archivePath.set(project.provider { jarTask.archivePathCompatible.canonicalPath })
-                    it.archiveName.set(project.provider { jarTask.archiveFileName.get() })
+                    it.archiveName.set(project.provider { jarTask.archiveNameCompatible })
                     it.dependsOn(classesTask)
                 }
             jarTask.dependsOn(inspectTask)
@@ -639,11 +640,21 @@ internal abstract class AbstractKotlinPlugin(
 
 internal fun configureDefaultVersionsResolutionStrategy(project: Project, kotlinPluginVersion: String) {
     project.configurations.all { configuration ->
+        fun MutableVersionConstraint.chooseVersion(version: String) {
+            if (isGradleVersionAtLeast(5, 0)) {
+                // In Gradle 5.0, the semantics of 'prefer' has changed to be much less imperative, and now it's 'require' that we need:
+                val requireMethod = javaClass.getMethod("require", String::class.java)
+                requireMethod(this, version)
+            } else {
+                prefer(version)
+            }
+        }
+
         // Use the API introduced in Gradle 4.4 to modify the dependencies directly before they are resolved:
         configuration.withDependencies { dependencySet ->
             dependencySet.filterIsInstance<ExternalDependency>()
                 .filter { it.group == "org.jetbrains.kotlin" && it.version.isNullOrEmpty() }
-                .forEach { it.version { constraint -> constraint.require(kotlinPluginVersion) } }
+                .forEach { it.version { constraint -> constraint.chooseVersion(kotlinPluginVersion) } }
         }
     }
 }
@@ -1079,11 +1090,11 @@ abstract class AbstractAndroidProjectHandler(private val kotlinConfigurationTool
     }
 }
 
-internal fun configureJavaTask(kotlinTask: KotlinCompile, javaTask: AbstractCompile) {
+internal fun configureJavaTask(kotlinTask: KotlinCompile, javaTask: AbstractCompile, logger: Logger) {
     kotlinTask.javaOutputDir = javaTask.destinationDir
 
     // Make Gradle check if the javaTask is up-to-date based on the Kotlin classes
-    javaTask.inputs.run {
+    javaTask.inputsCompatible.run {
         dir(kotlinTask.destinationDir)
             .withNormalizer(CompileClasspathNormalizer::class.java)
             .withPropertyName("${kotlinTask.name}OutputClasses")
@@ -1139,7 +1150,7 @@ internal fun Task.registerSubpluginOptionsAsInputs(subpluginId: String, subplugi
                 }.run { /* exhaustive when */ }
 
                 else -> {
-                    inputs.property("$subpluginId." + option.key + indexSuffix, Callable { option.value })
+                    inputsCompatible.propertyCompatible("$subpluginId." + option.key + indexSuffix, Callable { option.value })
                 }
             }
         }

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

@@ -8,11 +8,16 @@ package org.jetbrains.kotlin.gradle.plugin.mpp
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ConfigurablePublishArtifact
 import org.gradle.api.artifacts.Dependency
+import org.gradle.api.attributes.Usage.JAVA_API
+import org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.sources.KotlinDependencyScope
+import org.jetbrains.kotlin.gradle.plugin.sources.sourceSetDependencyConfigurationByScope
 import org.jetbrains.kotlin.gradle.targets.metadata.KotlinMetadataTargetConfigurator
 import org.jetbrains.kotlin.gradle.targets.metadata.isCompatibilityMetadataVariantEnabled
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import javax.inject.Inject
 
 internal const val COMMON_MAIN_ELEMENTS_CONFIGURATION_NAME = "commonMainMetadataElements"

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

@@ -351,8 +351,8 @@ internal fun sourcesJarTask(
     (project.tasks.findByName(taskName) as? Jar)?.let { return it }
 
     val result = project.tasks.create(taskName, Jar::class.java) { sourcesJar ->
-        sourcesJar.archiveAppendix.set(artifactNameAppendix)
+        sourcesJar.setArchiveAppendixCompatible { artifactNameAppendix }
-        sourcesJar.archiveClassifier.set("sources")
+        sourcesJar.setArchiveClassifierCompatible { "sources" }
     }
 
     project.whenEvaluated {

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

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType.jvm
 import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.usageByName
 import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 
 object KotlinUsages {
     const val KOTLIN_API = "kotlin-api"
@@ -40,14 +41,15 @@ object KotlinUsages {
 
     internal fun producerApiUsage(target: KotlinTarget) = target.project.usageByName(
         when (target.platformType) {
-            in jvmPlatformTypes -> "java-api-jars"
+            in jvmPlatformTypes ->
+                if (isGradleVersionAtLeast(5, 3)) "java-api-jars" else JAVA_API
             else -> KOTLIN_API
         }
     )
 
     internal fun producerRuntimeUsage(target: KotlinTarget) = target.project.usageByName(
         when (target.platformType) {
-            in jvmPlatformTypes -> "java-runtime-jars"
+            in jvmPlatformTypes -> JAVA_RUNTIME_JARS
             else -> KOTLIN_RUNTIME
         }
     )
@@ -59,13 +61,13 @@ object KotlinUsages {
             when {
                 consumerValue?.name == KOTLIN_API && producerValue?.name.let { it == JAVA_API || it == "java-api-jars" } ->
                     compatible()
-                consumerValue?.name in values && producerValue?.name.let { it == JAVA_RUNTIME || it == "java-runtime-jars" } ->
+                consumerValue?.name in values && producerValue?.name.let { it == JAVA_RUNTIME || it == JAVA_RUNTIME_JARS } ->
                     compatible()
             }
         }
     }
 
-    private val javaUsagesForKotlinMetadataConsumers = listOf("java-api-jars", JAVA_API, "java-runtime-jars", JAVA_RUNTIME)
+    private val javaUsagesForKotlinMetadataConsumers = listOf("java-api-jars", JAVA_API, JAVA_RUNTIME_JARS, JAVA_RUNTIME)
 
     private class KotlinMetadataCompatibility : AttributeCompatibilityRule<Usage> {
         override fun execute(details: CompatibilityCheckDetails<Usage>) = with(details) {
@@ -105,7 +107,7 @@ object KotlinUsages {
             }
 
             val javaApiUsages = setOf(JAVA_API, "java-api-jars")
-            val javaRuntimeUsages = setOf("java-runtime-jars", JAVA_RUNTIME)
+            val javaRuntimeUsages = setOf(JAVA_RUNTIME_JARS, JAVA_RUNTIME)
 
             if (javaApiUsages.any { it in candidateNames } &&
                 javaRuntimeUsages.any { it in candidateNames } &&

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

@@ -16,6 +16,7 @@ import org.gradle.api.artifacts.result.ResolvedVariantResult
 import org.gradle.api.attributes.Usage
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.usageByName
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import java.io.File
 
 internal class ResolvedMppVariantsProvider private constructor(private val project: Project) {
@@ -104,7 +105,7 @@ internal class ResolvedMppVariantsProvider private constructor(private val proje
 
         configuration.incoming.resolutionResult.allComponents { component ->
             val moduleId = ModuleIds.fromComponent(project, component)
-            val variants = component.variants
+            val variants = component.variantsCompatible
 
             val isMpp = variants.any { variant -> variant.attributes.keySet().any { it.name == KotlinPlatformType.attribute.name } }
             if (isMpp) {
@@ -206,4 +207,12 @@ internal class ResolvedMppVariantsProvider private constructor(private val proje
         val resolvedMetadataArtifactByConfiguration: MutableMap<Configuration, File?> = HashMap()
         val chosenPlatformModuleByConfiguration: MutableMap<Configuration, ModuleEntry?> = HashMap()
     }
-}
+}
+
+private val ResolvedComponentResult.variantsCompatible: List<ResolvedVariantResult>
+    get() = if (isGradleVersionAtLeast(5, 2)) {
+        variants
+    } else {
+        @Suppress("DEPRECATION")
+        listOf(variant)
+    }

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

@@ -26,7 +26,10 @@ import org.jetbrains.kotlin.gradle.plugin.sources.getSourceSetHierarchy
 import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.locateTask
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
+import org.jetbrains.kotlin.gradle.utils.archivePathCompatible
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import java.io.File
+import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.gradle.utils.*
 import java.util.*
 import java.util.concurrent.Callable

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

@@ -10,15 +10,15 @@ import org.gradle.api.DomainObjectSet
 import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ConfigurablePublishArtifact
+import org.gradle.api.artifacts.Configuration
 import org.gradle.api.artifacts.PublishArtifact
 import org.gradle.api.attributes.Attribute
 import org.gradle.api.attributes.AttributeContainer
-import org.gradle.api.attributes.Usage
+import org.gradle.api.attributes.Usage.JAVA_API
 import org.gradle.api.attributes.Usage.JAVA_RUNTIME_JARS
 import org.gradle.api.component.ComponentWithCoordinates
 import org.gradle.api.component.ComponentWithVariants
 import org.gradle.api.component.SoftwareComponent
-import org.gradle.api.component.SoftwareComponentFactory
 import org.gradle.api.internal.component.SoftwareComponentInternal
 import org.gradle.api.internal.component.UsageContext
 import org.gradle.api.internal.project.ProjectInternal
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 
 internal const val PRIMARY_SINGLE_COMPONENT_NAME = "kotlin"
@@ -79,16 +80,32 @@ abstract class AbstractKotlinTarget(
     }
 
     override val components: Set<SoftwareComponent> by lazy {
-        buildAdhocComponentsFromKotlinVariants(kotlinComponents)
+        val kotlinVariants = kotlinComponents
+        if (isGradleVersionAtLeast(5, 3)) {
+            buildAdhocComponentsFromKotlinVariants(kotlinVariants)
+        } else {
+            kotlinVariants.also { project.components.addAll(it) }
+        }
     }
 
+    // This API is introduced in Gradle 5.3. TODO when we build against Gradle 5.3+, rewrite this function
     private fun buildAdhocComponentsFromKotlinVariants(kotlinVariants: Set<KotlinTargetComponent>): Set<SoftwareComponent> {
-        val softwareComponentFactoryClass = SoftwareComponentFactory::class.java
+        val softwareComponentFactoryClass = Class.forName("org.gradle.api.component.SoftwareComponentFactory")
         // TODO replace internal API access with injection (not possible until we have this class on the compile classpath)
         val softwareComponentFactory = (project as ProjectInternal).services.get(softwareComponentFactoryClass)
 
+        val adhocMethod = softwareComponentFactoryClass.getMethod("adhoc", String::class.java)
+        val adhocSoftwareComponentClass = Class.forName("org.gradle.api.component.AdhocComponentWithVariants")
+        val addVariantsFromConfigurationMethod = adhocSoftwareComponentClass.getMethod(
+            "addVariantsFromConfiguration", Configuration::class.java, org.gradle.api.Action::class.java
+        )
+        val configurationVariantDetailsClass = Class.forName("org.gradle.api.component.ConfigurationVariantDetails")
+        val mapToMavenScopeMethod = configurationVariantDetailsClass.getMethod(
+            "mapToMavenScope", String::class.java
+        )
+
         return kotlinVariants.map { kotlinVariant ->
-            val adhocVariant = softwareComponentFactory.adhoc(kotlinVariant.name)
+            val adhocVariant = adhocMethod(softwareComponentFactory, kotlinVariant.name)
 
             project.whenEvaluated {
                 (kotlinVariant as SoftwareComponentInternal).usages.filterIsInstance<KotlinUsageContext>().forEach { kotlinUsageContext ->
@@ -110,14 +127,16 @@ abstract class AbstractKotlinTarget(
                             }
                         }
 
-                    adhocVariant.addVariantsFromConfiguration(configuration) { configurationVariantDetails ->
+                    val chooseMavenScopeAction = Action<Any> { configurationVariantDetails ->
                         val mavenScope = when (kotlinUsageContext.usage.name) {
                             "java-api-jars" -> "compile"
-                            "java-runtime-jars" -> "runtime"
+                            JAVA_RUNTIME_JARS -> "runtime"
                             else -> error("unexpected usage value '${kotlinUsageContext.usage.name}'")
                         }
-                        configurationVariantDetails.mapToMavenScope(mavenScope)
+                        mapToMavenScopeMethod(configurationVariantDetails, mavenScope)
                     }
+
+                    addVariantsFromConfigurationMethod(adhocVariant, configuration, chooseMavenScopeAction)
                 }
             }
 
@@ -220,7 +239,12 @@ abstract class AbstractKotlinTarget(
 internal fun KotlinTarget.disambiguateName(simpleName: String) =
     lowerCamelCaseName(targetName, simpleName)
 
-internal fun javaApiUsageForMavenScoping() = "java-api-jars"
+internal fun javaApiUsageForMavenScoping() =
+    if (isGradleVersionAtLeast(5, 3)) {
+        "java-api-jars"
+    } else {
+        JAVA_API
+    }
 
 abstract class KotlinOnlyTarget<T : KotlinCompilation<*>>(
     project: Project,

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

@@ -9,6 +9,8 @@ import groovy.lang.Closure
 import org.gradle.api.InvalidUserCodeException
 import org.gradle.api.Project
 import org.gradle.api.file.SourceDirectorySet
+import org.gradle.api.internal.file.DefaultSourceDirectorySet
+import org.gradle.api.internal.file.FileResolver
 import org.gradle.util.ConfigureUtil
 import org.jetbrains.kotlin.build.DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
@@ -26,7 +28,8 @@ const val METADATA_CONFIGURATION_NAME_SUFFIX = "DependenciesMetadata"
 
 class DefaultKotlinSourceSet(
     private val project: Project,
-    val displayName: String
+    val displayName: String,
+    fileResolver: FileResolver
 ) : KotlinSourceSet {
 
     override val apiConfigurationName: String
@@ -53,7 +56,7 @@ class DefaultKotlinSourceSet(
     override val runtimeOnlyMetadataConfigurationName: String
         get() = lowerCamelCaseName(runtimeOnlyConfigurationName, METADATA_CONFIGURATION_NAME_SUFFIX)
 
-    override val kotlin: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name Kotlin source").apply {
+    override val kotlin: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name Kotlin source", fileResolver).apply {
         filter.include("**/*.java")
         filter.include("**/*.kt")
         filter.include("**/*.kts")
@@ -61,7 +64,7 @@ class DefaultKotlinSourceSet(
 
     override val languageSettings: LanguageSettingsBuilder = DefaultLanguageSettingsBuilder()
 
-    override val resources: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name resources")
+    override val resources: SourceDirectorySet = createDefaultSourceDirectorySet(project, "$name resources", fileResolver)
 
     override fun kotlin(configureClosure: Closure<Any?>): SourceDirectorySet =
         kotlin.apply { ConfigureUtil.configure(configureClosure, this) }
@@ -223,8 +226,28 @@ internal fun KotlinSourceSet.disambiguateName(simpleName: String): String {
     return lowerCamelCaseName(*nameParts.toTypedArray())
 }
 
-private fun createDefaultSourceDirectorySet(project: Project, name: String?): SourceDirectorySet =
+private fun createDefaultSourceDirectorySet(project: Project, name: String?, resolver: FileResolver?): SourceDirectorySet {
-    project.objects.sourceDirectorySet(name, name)
+    if (isGradleVersionAtLeast(5, 0)) {
+        val objects = project.objects
+        val sourceDirectorySetMethod = objects.javaClass.methods.single { it.name == "sourceDirectorySet" && it.parameterCount == 2 }
+        return sourceDirectorySetMethod(objects, name, name) as SourceDirectorySet
+    }
+
+    val klass = DefaultSourceDirectorySet::class.java
+    val defaultConstructor = klass.constructorOrNull(String::class.java, FileResolver::class.java)
+
+    return if (defaultConstructor != null && defaultConstructor.getAnnotation(java.lang.Deprecated::class.java) == null) {
+        // TODO: drop when gradle < 2.12 are obsolete
+        defaultConstructor.newInstance(name, resolver)
+    } else {
+        val directoryFileTreeFactoryClass = Class.forName("org.gradle.api.internal.file.collections.DirectoryFileTreeFactory")
+        val alternativeConstructor = klass.getConstructor(String::class.java, FileResolver::class.java, directoryFileTreeFactoryClass)
+
+        val defaultFileTreeFactoryClass = Class.forName("org.gradle.api.internal.file.collections.DefaultDirectoryFileTreeFactory")
+        val defaultFileTreeFactory = defaultFileTreeFactoryClass.getConstructor().newInstance()
+        alternativeConstructor.newInstance(name, resolver, defaultFileTreeFactory)
+    }
+}
 
 internal fun KotlinSourceSet.getSourceSetHierarchy(): Set<KotlinSourceSet> {
     val result = mutableSetOf<KotlinSourceSet>()

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

@@ -88,6 +88,6 @@ internal class DefaultKotlinSourceSetFactory(
     }
 
     override fun doCreateSourceSet(name: String): DefaultKotlinSourceSet {
-        return DefaultKotlinSourceSet(project, name)
+        return DefaultKotlinSourceSet(project, name, fileResolver)
     }
 }

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

@@ -22,11 +22,15 @@ 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.KotlinCompile
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.scripting.compiler.plugin.impl.reporter
 import org.jetbrains.kotlin.scripting.definitions.ScriptDefinitionsFromClasspathDiscoverySource
 import java.io.File
 import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration
 
+private const val MIN_SUPPORTED_GRADLE_MAJOR_VERSION = 5
+private const val MIN_SUPPORTED_GRADLE_MINOR_VERSION = 0
+
 private const val SCRIPTING_LOG_PREFIX = "kotlin scripting plugin:"
 
 class ScriptingGradleSubplugin : Plugin<Project> {
@@ -66,7 +70,10 @@ class ScriptingGradleSubplugin : Plugin<Project> {
                                 discoveryClasspathConfiguration.allDependencies.isEmpty() -> {
                                     // skip further checks - user did not configured any discovery sources
                                 }
-                                else -> configureScriptsExtensions(project, javaPluginConvention, task.sourceSetName)
+                                !isGradleVersionAtLeast(MIN_SUPPORTED_GRADLE_MAJOR_VERSION, MIN_SUPPORTED_GRADLE_MINOR_VERSION) ->
+                                    project.logger.warn("$SCRIPTING_LOG_PREFIX incompatible Gradle version. Please use the plugin with Gradle version $MIN_SUPPORTED_GRADLE_MAJOR_VERSION.$MIN_SUPPORTED_GRADLE_MINOR_VERSION or newer.")
+                                else ->
+                                    configureScriptsExtensions(project, javaPluginConvention, task.sourceSetName)
                             }
                         } catch (e: IllegalStateException) {
                             project.logger.warn("$SCRIPTING_LOG_PREFIX applied in the non-supported environment (error received: ${e.message})")
@@ -139,14 +146,16 @@ private fun configureDiscoveryTransformation(
     project.configurations.maybeCreate(discoveryResultsConfigurationName).apply {
         isCanBeConsumed = false
     }
-    project.dependencies.apply {
+    if (isGradleVersionAtLeast(MIN_SUPPORTED_GRADLE_MAJOR_VERSION, MIN_SUPPORTED_GRADLE_MINOR_VERSION)) {
-        add(
+        project.dependencies.apply {
-            discoveryResultsConfigurationName,
+            add(
-            project.withRegisteredDiscoverScriptExtensionsTransform {
+                discoveryResultsConfigurationName,
-                discoveryConfiguration.discoverScriptExtensionsFiles()
+                project.withRegisteredDiscoverScriptExtensionsTransform {
-            }
+                    discoveryConfiguration.discoverScriptExtensionsFiles()
-        )
+                }
-    }
+            )
+        }
+    } // otherwise the warning should already be reported in the ScriptingGradleSubplugin.apply
 }
 
 internal class DiscoverScriptExtensionsTransform : ArtifactTransform() {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt

@@ -13,6 +13,7 @@ import org.gradle.api.Project
 import org.gradle.api.attributes.Usage.JAVA_RUNTIME_JARS
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.utils.dashSeparatedName
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
 
 open class KotlinAndroidTarget(

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTargetConfigurator.kt

@@ -55,7 +55,8 @@ open class KotlinJsIrTargetConfigurator(kotlinPluginVersion: String) :
 
     override fun createArchiveTasks(target: KotlinJsIrTarget): Zip {
         return super.createArchiveTasks(target).apply {
-            archiveExtension.set(KLIB_TYPE)
+            // not archiveExtension because it is since Gradle 5.1 only
+            extension = KLIB_TYPE
         }
     }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/nodejs/NodeJsSetupTask.kt

@@ -1,12 +1,15 @@
 package org.jetbrains.kotlin.gradle.targets.js.nodejs
 
 import org.gradle.api.DefaultTask
+import org.gradle.api.artifacts.repositories.IvyPatternRepositoryLayout
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
 import org.jetbrains.kotlin.gradle.logging.kotlinInfo
 import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
+import org.jetbrains.kotlin.gradle.utils.patternLayoutCompatible
 import org.jetbrains.kotlin.statistics.metrics.NumericalMetrics
 import java.io.File
 import java.net.URI
@@ -37,12 +40,15 @@ open class NodeJsSetupTask : DefaultTask() {
             repo.name = "Node Distributions at ${settings.nodeDownloadBaseUrl}"
             repo.url = URI(settings.nodeDownloadBaseUrl)
 
-            repo.patternLayout {
+            repo.patternLayoutCompatible {
-                it.artifact("v[revision]/[artifact](-v[revision]-[classifier]).[ext]")
+                artifact("v[revision]/[artifact](-v[revision]-[classifier]).[ext]")
-                it.ivy("v[revision]/ivy.xml")
+                ivy("v[revision]/ivy.xml")
             }
             repo.metadataSources { it.artifact() }
-            repo.content { it.includeModule("org.nodejs", "node") }
+
+            if (isGradleVersionAtLeast(5, 1)) {
+                repo.content { it.includeModule("org.nodejs", "node") }
+            }
         }
 
         val dep = this.project.dependencies.create(ivyDependency)

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinJvmTarget.kt

@@ -113,7 +113,7 @@ open class KotlinJvmTarget @Inject constructor(
         val targetJar = project.tasks.getByName(artifactsTaskName) as Jar
         val javaJar = project.tasks.getByName(javaPluginConvention.sourceSets.getByName("main").jarTaskName) as Jar
         (javaJar.source as? ConfigurableFileCollection)?.setFrom(targetJar.source)
-        javaJar.conventionMapping("archiveName") { targetJar.archiveFileName.get() }
+        javaJar.conventionMapping("archiveName") { targetJar.archiveName }
         javaJar.dependsOn(targetJar)
         javaJar.enabled = false
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/jvm/KotlinWithJavaTarget.kt

@@ -46,7 +46,7 @@ open class KotlinWithJavaTarget<KotlinOptionsType : KotlinCommonOptions>(
     internal val defaultArtifactClassesListFile: File
         get() {
             val jarTask = project.tasks.getByName(artifactsTaskName) as Jar
-            return File(File(project.buildDir, KOTLIN_BUILD_DIR_NAME), "${sanitizeFileName(jarTask.archiveFileName.get())}-classes.txt")
+            return File(File(project.buildDir, KOTLIN_BUILD_DIR_NAME), "${sanitizeFileName(jarTask.archiveName)}-classes.txt")
         }
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt

@@ -29,6 +29,8 @@ import org.jetbrains.kotlin.gradle.tasks.locateTask
 import org.jetbrains.kotlin.gradle.tasks.registerTask
 import org.jetbrains.kotlin.gradle.utils.addExtendsFromRelation
 import org.jetbrains.kotlin.gradle.utils.lowerCamelCaseName
+import org.jetbrains.kotlin.gradle.utils.setArchiveAppendixCompatible
+import org.jetbrains.kotlin.gradle.utils.setArchiveClassifierCompatible
 import org.jetbrains.kotlin.statistics.metrics.BooleanMetrics
 import java.util.concurrent.Callable
 
@@ -136,7 +138,7 @@ class KotlinMetadataTargetConfigurator(kotlinPluginVersion: String) :
         if (target.project.isKotlinGranularMetadataEnabled) {
             target.project.locateTask<Jar>(target.artifactsTaskName)!!.configure {
                 if (!target.project.isCompatibilityMetadataVariantEnabled) {
-                    it.archiveClassifier.set("commonMain")
+                    it.setArchiveClassifierCompatible { "commonMain" }
                 }
                 it.onlyIf { target.project.isCompatibilityMetadataVariantEnabled }
             }
@@ -149,10 +151,10 @@ class KotlinMetadataTargetConfigurator(kotlinPluginVersion: String) :
                 allMetadataJar.description = "Assembles a jar archive containing the metadata for all Kotlin source sets."
                 allMetadataJar.group = BasePlugin.BUILD_GROUP
 
-                allMetadataJar.archiveAppendix.set(target.name.toLowerCase())
+                allMetadataJar.setArchiveAppendixCompatible { target.name.toLowerCase() }
 
                 if (target.project.isCompatibilityMetadataVariantEnabled) {
-                    allMetadataJar.archiveClassifier.set("all")
+                    allMetadataJar.setArchiveClassifierCompatible { "all" }
                 }
             }
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeTarget.kt

@@ -25,6 +25,8 @@ import org.jetbrains.kotlin.gradle.targets.native.KotlinNativeHostTestRun
 import org.jetbrains.kotlin.gradle.targets.native.KotlinNativeSimulatorTestRun
 import org.jetbrains.kotlin.gradle.targets.native.NativeBinaryTestRunSource
 import org.jetbrains.kotlin.gradle.tasks.locateOrRegisterTask
+import org.jetbrains.kotlin.gradle.utils.setArchiveAppendixCompatible
+import org.jetbrains.kotlin.gradle.utils.setArchiveClassifierCompatible
 import org.jetbrains.kotlin.konan.target.HostManager
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import javax.inject.Inject
@@ -60,8 +62,8 @@ open class KotlinNativeTarget @Inject constructor(
 
             if (hostSpecificSourceSets.isNotEmpty()) {
                 val hostSpecificMetadataJar = project.locateOrRegisterTask<Jar>(hostSpecificMetadataJarTaskName) {
-                    it.archiveAppendix.set(project.provider { disambiguationClassifier.orEmpty().toLowerCase() })
+                    it.setArchiveAppendixCompatible { disambiguationClassifier.orEmpty().toLowerCase() }
-                    it.archiveClassifier.set("metadata")
+                    it.setArchiveClassifierCompatible { "metadata" }
                 }
                 project.artifacts.add(Dependency.ARCHIVES_CONFIGURATION, hostSpecificMetadataJar)
 

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

@@ -82,8 +82,8 @@ class NativeCompilerDownloader(
     private fun setupRepo(repoUrl: String): ArtifactRepository {
         return project.repositories.ivy { repo ->
             repo.setUrl(repoUrl)
-            repo.patternLayout {
+            repo.patternLayoutCompatible {
-                it.artifact("[artifact]-[revision].[ext]")
+                artifact("[artifact]-[revision].[ext]")
             }
             repo.metadataSources {
                 it.artifact()

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

@@ -17,12 +17,14 @@
 package org.jetbrains.kotlin.gradle.tasks
 
 import org.gradle.api.Task
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.utils.outputsCompatible
 
 internal fun isBuildCacheEnabledForKotlin(): Boolean =
     System.getProperty(KOTLIN_CACHING_ENABLED_PROPERTY)?.toBoolean() ?: true
 
 internal fun <T : Task> T.cacheOnlyIfEnabledForKotlin() {
-    outputs.cacheIf { isBuildCacheEnabledForKotlin() }
+    outputsCompatible.cacheIf { isBuildCacheEnabledForKotlin() }
 }
 
 private const val KOTLIN_CACHING_ENABLED_PROPERTY = "kotlin.caching.enabled"

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

@@ -9,8 +9,11 @@ import org.gradle.api.DefaultTask
 import org.gradle.api.file.FileCollection
 import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.tasks.*
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
+import org.gradle.jvm.tasks.Jar
 import org.jetbrains.kotlin.gradle.dsl.KotlinSingleJavaTargetExtension
 import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+import org.jetbrains.kotlin.gradle.utils.archivePathCompatible
 import org.jetbrains.kotlin.gradle.utils.newProperty
 import java.io.File
 

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

@@ -15,6 +15,7 @@ import org.gradle.process.internal.ExecHandleFactory
 import org.jetbrains.kotlin.gradle.internal.testing.KotlinTestRunnerListener
 import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessagesTestExecutor
 import org.jetbrains.kotlin.gradle.utils.injected
+import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import javax.inject.Inject
 
 abstract class KotlinTest : AbstractTestTask() {
@@ -38,7 +39,7 @@ abstract class KotlinTest : AbstractTestTask() {
 
     @Suppress("DEPRECATION")
     val excludePatterns: Set<String>
-        @Input get() = excludes + filterExt.excludePatterns
+        @Input get() = excludes + if (isGradleVersionAtLeast(5, 0)) filterExt.excludePatterns else emptySet()
 
     @get:Inject
     open val fileResolver: FileResolver

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

@@ -442,9 +442,17 @@ open class KotlinCompile : AbstractKotlinCompile<K2JVMCompilerArguments>(), Kotl
     private fun disableMultiModuleIC(): Boolean {
         if (!isIncrementalCompilationEnabled() || javaOutputDir == null) return false
 
+        fun forEachTask(fn: (Task) -> Unit) {
+            if (isGradleVersionAtLeast(4, 10)) {
+                project.tasks.configureEach(fn)
+            } else {
+                project.tasks.forEach(fn)
+            }
+        }
+
         var illegalTaskOrNull: AbstractCompile? = null
 
-        project.tasks.configureEach {
+        forEachTask {
             if (it is AbstractCompile &&
                 it !is JavaCompile &&
                 it !is AbstractKotlinCompile<*> &&

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

@@ -68,7 +68,7 @@ internal inline fun <reified T : Task> Project.locateTask(name: String): TaskPro
  * with [name], type [T] and initialization script [body]
  */
 internal inline fun <reified T : Task> Project.locateOrRegisterTask(name: String, noinline body: (T) -> (Unit)): TaskProvider<T> {
-    return project.locateTask(name) ?: project.registerTask(name, T::class.java, body = body)
+    return project.locateTask(name) ?: registerTask(project, name, T::class.java, body)
 }
 
 internal open class KotlinTasksProvider(val targetName: String) {
@@ -80,7 +80,7 @@ internal open class KotlinTasksProvider(val targetName: String) {
     ): TaskProvider<out KotlinCompile> {
         val properties = PropertiesProvider(project)
         val taskClass = taskOrWorkersTask<KotlinCompile, KotlinCompileWithWorkers>(properties)
-        val result = project.registerTask(name, taskClass) {
+        val result = registerTask(project, name, taskClass) {
             configureAction(it)
         }
         configure(result, project, properties, compilation)

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

@@ -16,16 +16,17 @@
 
 package org.jetbrains.kotlin.gradle.utils
 
+import org.gradle.api.Action
 import org.gradle.api.GradleException
 import org.gradle.api.Task
+import org.gradle.api.artifacts.repositories.IvyArtifactRepository
+import org.gradle.api.artifacts.repositories.IvyPatternRepositoryLayout
 import org.gradle.api.tasks.TaskInputs
 import org.gradle.api.tasks.TaskOutputs
 import org.gradle.api.tasks.bundling.AbstractArchiveTask
 import org.gradle.util.GradleVersion
 import java.io.File
 
-const val minSupportedGradleVersion = "5.4"
-
 internal val Task.inputsCompatible: TaskInputs get() = inputs
 
 internal val Task.outputsCompatible: TaskOutputs get() = outputs
@@ -52,7 +53,7 @@ internal fun TaskInputs.dirCompatible(dirPath: Any) {
 
 internal fun checkGradleCompatibility(
     withComponent: String = "the Kotlin Gradle plugin",
-    minSupportedVersion: GradleVersion = GradleVersion.version(minSupportedGradleVersion)
+    minSupportedVersion: GradleVersion = GradleVersion.version("4.9")
 ) {
     val currentVersion = GradleVersion.current()
     if (currentVersion < minSupportedVersion) {
@@ -63,5 +64,49 @@ internal fun checkGradleCompatibility(
     }
 }
 
+internal fun AbstractArchiveTask.setArchiveAppendixCompatible(appendixProvider: () -> String) {
+    if (isGradleVersionAtLeast(5, 2)) {
+        archiveAppendix.set(project.provider { appendixProvider() })
+    } else {
+        @Suppress("DEPRECATION")
+        appendix = appendixProvider()
+    }
+}
+
 internal val AbstractArchiveTask.archivePathCompatible: File
-    get() = archiveFile.get().asFile
+    get() =
+        if (isGradleVersionAtLeast(5, 1)) {
+            archiveFile.get().asFile
+        } else {
+            @Suppress("DEPRECATION")
+            archivePath
+        }
+
+internal val AbstractArchiveTask.archiveNameCompatible: String
+    get() =
+        if (isGradleVersionAtLeast(5, 1)) {
+            archiveFileName.get()
+        } else {
+            @Suppress("DEPRECATION")
+            archiveName
+        }
+
+internal fun AbstractArchiveTask.setArchiveClassifierCompatible(classifierProvider: () -> String) {
+    if (isGradleVersionAtLeast(5, 2)) {
+        archiveClassifier.set(project.provider { classifierProvider() })
+    } else {
+        @Suppress("DEPRECATION")
+        classifier = classifierProvider()
+    }
+}
+
+internal fun IvyArtifactRepository.patternLayoutCompatible(config: IvyPatternRepositoryLayout.() -> Unit) {
+    if (isGradleVersionAtLeast(5, 0)) {
+        patternLayout(config)
+    } else {
+        // The "layout" method is planned to be removed in Gradle 6.0. Access it using reflection.
+        javaClass
+            .getMethod("layout", String::class.java, Action::class.java)
+            .invoke(this, "pattern", Action<IvyPatternRepositoryLayout> { it.config() })
+    }
+}

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

@@ -41,7 +41,13 @@ internal fun <T> Project.optionalProvider(initialize: () -> T?): ReadOnlyPropert
 // Before 5.0 fileProperty is created via ProjectLayout
 // https://docs.gradle.org/current/javadoc/org/gradle/api/model/ObjectFactory.html#fileProperty--
 internal fun Project.newFileProperty(initialize: (() -> File)? = null): RegularFileProperty {
-    val regularFileProperty = project.objects.fileProperty()
+    val regularFileProperty = if (isGradleVersionAtLeast(5, 0)) {
+        project.objects.fileProperty()
+    } else {
+        val projectLayoutClass = Class.forName("org.gradle.api.file.ProjectLayout")
+        val filePropertyMethod = projectLayoutClass.getMethod("fileProperty")
+        filePropertyMethod(project.layout) as RegularFileProperty
+    }
 
     return regularFileProperty.apply {
         if (initialize != null) {