Make assemble configuration cache compatible

Author: marcphilipp

buildSrc/src/main/kotlin/java-library-conventions.gradle.kts

@@ -157,8 +157,8 @@ val compileModule by tasks.registering(JavaCompile::class) {
 			"-Werror", // Terminates compilation when warnings occur.
 			"--module-version", "${project.version}",
 	))
-	options.compilerArgumentProviders.add(ModulePathArgumentProvider(project, modularProjects))
-	options.compilerArgumentProviders.addAll(modularProjects.map { PatchModuleArgumentProvider(project, it) })
+	options.compilerArgumentProviders.add(objects.newInstance(ModulePathArgumentProvider::class, project, modularProjects))
+	options.compilerArgumentProviders.addAll(modularProjects.map { objects.newInstance(PatchModuleArgumentProvider::class, project, it) })
 	modularity.inferModulePath.set(false)
 }
 

buildSrc/src/main/kotlin/org/junit/gradle/java/ModulePathArgumentProvider.kt

@@ -3,25 +3,35 @@ package org.junit.gradle.java
 import org.gradle.api.Named
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 import org.gradle.kotlin.dsl.get
 import org.gradle.process.CommandLineArgumentProvider
+import javax.inject.Inject
 
-class ModulePathArgumentProvider(project: Project, modularProjects: List<Project>) : CommandLineArgumentProvider,
-    Named {
+abstract class ModulePathArgumentProvider @Inject constructor(project: Project, modularProjects: List<Project>) :
+    CommandLineArgumentProvider, Named {
 
     @get:CompileClasspath
-    val modulePath: Provider<Configuration> = project.configurations.named("compileClasspath")
+    abstract val modulePath: ConfigurableFileCollection
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    val moduleSourceDirs: FileCollection = project.files(modularProjects.map { "${it.projectDir}/src/module" })
+    abstract val moduleSourceDirs: ConfigurableFileCollection
+
+    init {
+        modulePath.from(project.configurations.named("compileClasspath"))
+        modularProjects.forEach {
+            moduleSourceDirs.from(project.files("${it.projectDir}/src/module"))
+        }
+    }
 
     override fun asArguments() = listOf(
         "--module-path",
-        modulePath.get().asPath,
+        modulePath.asPath,
         "--module-source-path",
         moduleSourceDirs.asPath
     )

buildSrc/src/main/kotlin/org/junit/gradle/java/PatchModuleArgumentProvider.kt

@@ -3,36 +3,45 @@ package org.junit.gradle.java
 import javaModuleName
 import org.gradle.api.Named
 import org.gradle.api.Project
+import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
+import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.the
 import org.gradle.process.CommandLineArgumentProvider
+import javax.inject.Inject
 
-class PatchModuleArgumentProvider(compiledProject: Project, patchModuleProject: Project) : CommandLineArgumentProvider,
-	Named {
+abstract class PatchModuleArgumentProvider @Inject constructor(compiledProject: Project, patchModuleProject: Project) :
+    CommandLineArgumentProvider, Named {
 
-	@get:Input
-	val module: String = patchModuleProject.javaModuleName
+    @get:Input
+    abstract val module: Property<String>
 
-	@get:InputFiles
-	@get:PathSensitive(PathSensitivity.RELATIVE)
-	val patch: Provider<FileCollection> = compiledProject.provider {
-		if (patchModuleProject == compiledProject)
-			compiledProject.files(compiledProject.the<SourceSetContainer>().matching { it.name.startsWith("main") }.map { it.output })
-		else
-			patchModuleProject.files(patchModuleProject.the<SourceSetContainer>()["main"].java.srcDirs)
-	}
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val patch: ConfigurableFileCollection
 
-	override fun asArguments(): List<String> {
-		val path = patch.get().filter { it.exists() }.asPath
-		if (path.isEmpty()) {
-			return emptyList()
-		}
-		return listOf("--patch-module", "$module=$path")
-	}
+    init {
+        module.convention(patchModuleProject.javaModuleName)
+        patch.from(compiledProject.provider {
+            if (patchModuleProject == compiledProject)
+                compiledProject.files(compiledProject.the<SourceSetContainer>().matching { it.name.startsWith("main") }
+                    .map { it.output })
+            else
+                patchModuleProject.files(patchModuleProject.the<SourceSetContainer>()["main"].java.srcDirs)
+        })
+    }
 
-	@Internal
-	override fun getName() = "patch-module($module)"
+    override fun asArguments(): List<String> {
+        val path = patch.filter { it.exists() }.asPath
+        if (path.isEmpty()) {
+            return emptyList()
+        }
+        return listOf("--patch-module", "${module.get()}=$path")
+    }
+
+    @Internal
+    override fun getName() = "patch-module(${module.get()})"
 }