chore: fix configuration cache issues

Author: sureshg

plugins/project/src/main/kotlin/common/ProjectExtns.kt

@@ -621,25 +621,23 @@ fun Project.appRunCmd(binary: Path, args: List<String>): String {
 
 /** Returns the JDK install path provided by the [JavaToolchainService] */
 val Project.javaToolchainPath
-  get(): Path {
+  get(): Provider<Path> {
     val defToolchain = extensions.findByType(JavaPluginExtension::class)?.toolchain
     val javaToolchainSvc = extensions.findByType(JavaToolchainService::class)
-    // val jvm: JavaVersion? = org.gradle.internal.jvm.Jvm.current().javaVersion
 
     val jLauncher =
         when (defToolchain != null) {
           true -> javaToolchainSvc?.launcherFor(defToolchain)
-          else -> javaToolchainSvc?.launcherFor { configureJvmToolchain(project) }
-        }?.orNull
-
-    return jLauncher?.metadata?.installationPath?.asFile?.toPath()
-        ?: error("Requested JDK version ($javaVersion) is not available.")
+          else -> javaToolchainSvc?.launcherFor { languageVersion = toolchainVersion }
+        }
+    return jLauncher?.map { it.metadata?.installationPath?.asFile?.toPath() }
+        ?: error("Unable to find the JDK toolchain installation path")
   }
 
 /** Return incubator modules of the tool chain JDK */
 val Project.incubatorModules
   get(): String {
-    val javaCmd = project.javaToolchainPath.resolve("bin").resolve("java")
+    val javaCmd = project.javaToolchainPath.get().resolve("bin").resolve("java")
     val bos = ByteArrayOutputStream()
     val execResult =
         providers.exec {

plugins/project/src/main/kotlin/dev.suresh.plugin.kotlin.jvm.gradle.kts

@@ -157,10 +157,10 @@ tasks {
       description = "Print Java Platform Module dependencies of the application."
       group = LifecycleBasePlugin.BUILD_GROUP
 
-      val shadowJar = named<ShadowJar>("shadowJar")
-      doLast {
-        val jarFile = shadowJar.get().archiveFile.get().asFile
+      val shadowJarFile = tasks.named<ShadowJar>("shadowJar").flatMap { it.archiveFile }
+      val release = project.javaRelease.get()
 
+      doLast {
         val jdeps =
             ToolProvider.findFirst("jdeps").orElseGet { error("jdeps tool is missing in the JDK!") }
         val out = StringWriter()
@@ -172,26 +172,29 @@ tasks {
             "-R",
             "--print-module-deps",
             "--ignore-missing-deps",
-            "--multi-release=${javaRelease.get()}",
-            jarFile.absolutePath,
+            "--multi-release=$release",
+            shadowJarFile.get().asFile.absolutePath,
         )
 
         val modules = out.toString()
         logger.quiet(
             """
-            |Application modules for OpenJDK-${javaRelease.get()} are,
-            |${modules.split(",").mapIndexed { i, module -> " ${(i + 1).toString()
-                      .padStart(2)}) $module" }.joinToString(System.lineSeparator())}
+            |Application modules for OpenJDK-$release are,
+            |${modules.split(",")
+                      .mapIndexed { i, module -> " ${(i + 1).toString()
+                      .padStart(2)}) $module" }
+                      .joinToString(System.lineSeparator())}
             """
                 .trimMargin()
         )
       }
-      dependsOn(shadowJar)
+      dependsOn("shadowJar")
     }
 
     val jdepExtn = extensions.create<JdeprscanExtension>("jdeprscan")
     register<Jdeprscan>("jdeprscan", jdepExtn).configure {
       jarFile = named<ShadowJar>("shadowJar").flatMap { it.archiveFile }
+      javaHome = project.javaToolchainPath
     }
   }
 

plugins/project/src/main/kotlin/plugins/DepReportsPlugin.kt

@@ -22,6 +22,7 @@ class DepReportsPlugin : Plugin<Project> {
   override fun apply(target: Project) =
       with(target) {
         pluginManager.withPlugin("java-base") {
+          val projectLayout = project.layout
           val listResolvedArtifacts by
               tasks.registering(ListResolvedArtifacts::class) {
                 // Get the runtime-resolved artifacts
@@ -35,16 +36,17 @@ class DepReportsPlugin : Plugin<Project> {
                 artifactFiles =
                     resolvedArtifacts.map {
                       it.map { resolvedArtifactResult ->
-                        layout.projectDirectory.file(resolvedArtifactResult.file.absolutePath)
+                        projectLayout.projectDirectory.file(
+                            resolvedArtifactResult.file.absolutePath
+                        )
                       }
                     }
-                outputFile.convention(layout.buildDirectory.file("resolved-artifacts.txt"))
+                outputFile.convention(projectLayout.buildDirectory.file("resolved-artifacts.txt"))
               }
         }
       }
 }
 
-@CacheableTask
 abstract class ListResolvedArtifacts : DefaultTask() {
 
   @get:Input abstract val artifactIds: ListProperty<ComponentArtifactIdentifier>

plugins/project/src/main/kotlin/tasks/Jdeprscan.kt

@@ -2,6 +2,7 @@ package tasks
 
 import common.*
 import java.io.*
+import java.nio.file.Path
 import javax.inject.*
 import org.gradle.api.*
 import org.gradle.api.file.*
@@ -30,6 +31,8 @@ constructor(
   @get:[Input Optional]
   val classPath = objects.listProperty<File>()
 
+  @get:Input abstract val javaHome: Property<Path>
+
   @get:Internal internal val projectName = project.name
 
   init {
@@ -62,8 +65,8 @@ constructor(
       add(jarFile.get().asFile.absolutePath)
     }
 
-    // java bin directory
-    val jdeprscan = project.javaToolchainPath.resolve("bin").resolve("jdeprscan")
+    // jdeprscan binary path
+    val jdeprscan = javaHome.get().resolve("bin").resolve("jdeprscan")
     val bos = ByteArrayOutputStream()
     val execResult =
         execOps.exec {