Fix toolchain jdk override was not working for all modules.

Now it also considers the case when separate tasks toolchain
are configured or module only has java toolchain.

^KT-46972 Fixed

buildSrc/src/main/kotlin/JvmToolchain.kt

@@ -1,5 +1,6 @@
 @file:JvmName("JvmToolchain")
 import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.jvm.toolchain.*
@@ -24,24 +25,31 @@ enum class JdkMajorVersion(
     JDK_16(16, mandatory = false);
 
     fun isMandatory(): Boolean = mandatory
+
+    companion object {
+        fun fromMajorVersion(majorVersion: Int) = values().first { it.majorVersion == majorVersion }
+    }
 }
 
 fun Project.configureJvmDefaultToolchain() {
     configureJvmToolchain(JdkMajorVersion.JDK_1_8)
 }
 
+fun Project.shouldOverrideObsoleteJdk(
+    jdkVersion: JdkMajorVersion
+): Boolean = kotlinBuildProperties.isObsoleteJdkOverrideEnabled &&
+        jdkVersion.overrideMajorVersion != null
+
 fun Project.configureJvmToolchain(
     jdkVersion: JdkMajorVersion
 ) {
     plugins.withId("org.jetbrains.kotlin.jvm") {
         val kotlinExtension = extensions.getByType<KotlinTopLevelExtension>()
 
-        if (project.kotlinBuildProperties.isObsoleteJdkOverrideEnabled &&
+        if (shouldOverrideObsoleteJdk(jdkVersion)) {
-            jdkVersion.overrideMajorVersion != null
-        ) {
             kotlinExtension.jvmToolchain {
                 (this as JavaToolchainSpec).languageVersion
-                    .set(JavaLanguageVersion.of(jdkVersion.overrideMajorVersion))
+                    .set(JavaLanguageVersion.of(jdkVersion.overrideMajorVersion!!))
             }
             updateJvmTarget(jdkVersion.targetName)
         } else {
@@ -66,6 +74,66 @@ fun Project.configureJvmToolchain(
     }
 }
 
+fun Project.configureJavaOnlyToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    plugins.withId("java-library") {
+        val javaExtension = extensions.getByType<JavaPluginExtension>()
+        if (shouldOverrideObsoleteJdk(jdkVersion)) {
+            javaExtension.toolchain.languageVersion.set(
+                JavaLanguageVersion.of(jdkVersion.overrideMajorVersion!!)
+            )
+            tasks.withType<JavaCompile>().configureEach {
+                targetCompatibility = jdkVersion.targetName
+                sourceCompatibility = jdkVersion.targetName
+            }
+        } else {
+            javaExtension.toolchain.languageVersion.set(
+                JavaLanguageVersion.of(jdkVersion.majorVersion)
+            )
+        }
+    }
+}
+
+fun KotlinCompile.configureTaskToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
+        kotlinJavaToolchain.toolchain.use(
+            project.getToolchainLauncherFor(
+                JdkMajorVersion.fromMajorVersion(
+                    jdkVersion.overrideMajorVersion!!
+                )
+            )
+        )
+        kotlinOptions {
+            jvmTarget = jdkVersion.targetName
+        }
+    } else {
+        kotlinJavaToolchain.toolchain.use(
+            project.getToolchainLauncherFor(jdkVersion)
+        )
+    }
+}
+
+fun JavaCompile.configureTaskToolchain(
+    jdkVersion: JdkMajorVersion
+) {
+    if (project.shouldOverrideObsoleteJdk(jdkVersion)) {
+        javaCompiler.set(
+            project.getToolchainCompilerFor(
+                JdkMajorVersion.fromMajorVersion(
+                    jdkVersion.overrideMajorVersion!!
+                )
+            )
+        )
+        targetCompatibility = jdkVersion.targetName
+        sourceCompatibility = jdkVersion.targetName
+    } else {
+        javaCompiler.set(project.getToolchainCompilerFor(jdkVersion))
+    }
+}
+
 fun Project.updateJvmTarget(
     jvmTarget: String
 ) {

compiler/compiler.version/build.gradle.kts

@@ -7,11 +7,7 @@ plugins {
 
 // This module does not apply Kotlin plugin, so we are setting toolchain via
 // java extension
-java {
+configureJavaOnlyToolchain(JdkMajorVersion.JDK_1_6)
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(6))
-    }
-}
 
 val kotlinVersion: String by rootProject.extra
 

core/descriptors.runtime/build.gradle.kts

@@ -1,4 +1,4 @@
-import org.jetbrains.kotlin.gradle.tasks.UsesKotlinJavaToolchain
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
     kotlin("jvm")
@@ -8,15 +8,15 @@ plugins {
 // Only compilation tasks should use JDK 1.6
 project.disableDeprecatedJvmTargetWarning()
 tasks
-    .matching { it.name == "compileKotlin" && it is UsesKotlinJavaToolchain }
+    .matching { it.name == "compileKotlin" && it is KotlinCompile }
     .configureEach {
-        (this as UsesKotlinJavaToolchain).kotlinJavaToolchain.toolchain.use(project.getToolchainLauncherFor(JdkMajorVersion.JDK_1_6))
+        (this as KotlinCompile).configureTaskToolchain(JdkMajorVersion.JDK_1_6)
     }
 
 tasks
     .matching { it.name == "compileJava" && it is JavaCompile }
     .configureEach {
-        (this as JavaCompile).javaCompiler.set(project.getToolchainCompilerFor(JdkMajorVersion.JDK_1_6))
+        (this as JavaCompile).configureTaskToolchain(JdkMajorVersion.JDK_1_6)
     }
 
 dependencies {

libraries/reflect/build.gradle.kts

@@ -20,11 +20,7 @@ plugins {
     java
 }
 
-java {
+configureJavaOnlyToolchain(JdkMajorVersion.JDK_1_6)
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(6))
-    }
-}
 
 publish()