Enable configuration cache and consolidate generated-file tasks

Author: jupblb

build-logic/src/main/kotlin/com/sourcegraph/buildlogic/GeneratedFiles.kt

@@ -0,0 +1,26 @@
+package com.sourcegraph.buildlogic
+
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.TaskProvider
+
+/**
+ * Registers a task that writes [content] (plus a trailing newline) to
+ * build/generated/[relativePath], tracking the content for up-to-date checks.
+ */
+fun Project.registerGeneratedFile(
+    name: String,
+    relativePath: String,
+    content: String,
+): TaskProvider<Task> {
+    val output = layout.buildDirectory.file("generated/$relativePath")
+    return tasks.register(name) {
+        inputs.property("content", content)
+        outputs.file(output)
+        doLast {
+            val file = output.get().asFile
+            file.parentFile.mkdirs()
+            file.writeText("$content\n")
+        }
+    }
+}

build-logic/src/main/kotlin/com/sourcegraph/buildlogic/SharedArtifacts.kt

@@ -2,6 +2,8 @@ package com.sourcegraph.buildlogic
 
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.FileSystemLocation
+import org.gradle.api.provider.Provider
 
 /**
  * Declares a resolvable view of another project's shaded jar, published by its `shadowJarElements`
@@ -20,3 +22,26 @@ fun Project.shadowJarArtifact(producerPath: String, name: String): Configuration
     )
     return configurations.resolvable(name) { extendsFrom(bucket.get()) }.get()
 }
+
+/**
+ * Builds the `kotlinc` arguments that load the scip-kotlinc compiler plugin from [pluginClasspath]
+ * (the resolved shaded jar) and point it at [sourceroot]/[targetroot].
+ *
+ * The mapping lives here, in compiled build logic, rather than in a build script: a `.map {}`
+ * lambda declared in a `.gradle.kts` file captures a hidden reference to the script object, which
+ * the configuration cache cannot serialize.
+ */
+fun scipKotlincPluginArgs(
+    pluginClasspath: Provider<Set<FileSystemLocation>>,
+    sourceroot: String,
+    targetroot: String,
+): Provider<List<String>> =
+    pluginClasspath.map { locations ->
+        listOf(
+            "-Xplugin=${locations.single().asFile.absolutePath}",
+            "-P",
+            "plugin:scip-kotlinc:sourceroot=$sourceroot",
+            "-P",
+            "plugin:scip-kotlinc:targetroot=$targetroot",
+        )
+    }

gradle.properties

@@ -1,3 +1,5 @@
 org.gradle.jvmargs=-Xmx2g -Dfile.encoding=UTF-8
+org.gradle.configuration-cache=true
+org.gradle.parallel=true
 kotlin.code.style=official
 kotlin.stdlib.default.dependency=false

scip-java/build.gradle.kts

@@ -1,4 +1,5 @@
 import com.sourcegraph.buildlogic.JavacInternals
+import com.sourcegraph.buildlogic.registerGeneratedFile
 import com.sourcegraph.buildlogic.shadowJarArtifact
 
 plugins {
@@ -62,32 +63,18 @@ tasks.named<Jar>("jar") {
     }
 }
 
-val generateDistributionVersion = tasks.register("generateDistributionVersion") {
-    val output = layout.buildDirectory.file("generated/distribution/VERSION")
-    val version = project.version.toString()
-    inputs.property("version", version)
-    outputs.file(output)
-    doLast {
-        val file = output.get().asFile
-        file.parentFile.mkdirs()
-        file.writeText("version:=$version\n")
-    }
-}
+val generateDistributionVersion =
+    registerGeneratedFile("generateDistributionVersion", "distribution/VERSION", "version:=${project.version}")
 
 // Emit the javac --add-exports flags as a ready-to-use, space-separated string
 // so the Docker wrapper script can read them with a plain `cat`, keeping
 // gradle/javac-internals.properties the single source of truth.
-val generateJavacJvmOptions = tasks.register("generateJavacJvmOptions") {
-    val output = layout.buildDirectory.file("generated/distribution/javac-jvm-options")
-    val options = JavacInternals.jvmOptions(rootDir).joinToString(" ")
-    inputs.property("options", options)
-    outputs.file(output)
-    doLast {
-        val file = output.get().asFile
-        file.parentFile.mkdirs()
-        file.writeText("$options\n")
-    }
-}
+val generateJavacJvmOptions =
+    registerGeneratedFile(
+        "generateJavacJvmOptions",
+        "distribution/javac-jvm-options",
+        JavacInternals.jvmOptions(rootDir).joinToString(" "),
+    )
 
 distributions {
     named("main") {

scip-maven-plugin/build.gradle.kts

@@ -1,3 +1,5 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+
 plugins {
     id("scip.java-library")
     id("scip.maven-publish")
@@ -11,12 +13,14 @@ dependencies {
     compileOnly(libs.maven.plugin.annotations)
 }
 
+val mavenPluginVersion = project.version.toString()
+
 tasks.named<ProcessResources>("processResources") {
     exclude("META-INF/maven/plugin.template.xml")
     from("src/main/resources/META-INF/maven/plugin.template.xml") {
         into("META-INF/maven")
         rename { "plugin.xml" }
-        filter { line: String -> line.replace("@VERSION@", project.version.toString()) }
+        filter(mapOf("tokens" to mapOf("VERSION" to mavenPluginVersion)), ReplaceTokens::class.java)
     }
-    inputs.property("version", project.version.toString())
+    inputs.property("version", mavenPluginVersion)
 }

scip-snapshots/cases/kotlin/common/build.gradle.kts

@@ -1,4 +1,5 @@
 import com.sourcegraph.buildlogic.JavacInternals
+import com.sourcegraph.buildlogic.scipKotlincPluginArgs
 import com.sourcegraph.buildlogic.shadowJarArtifact
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
@@ -16,24 +17,19 @@ dependencies {
 
 val scipTargetroot = layout.buildDirectory.dir("scip-targetroot")
 
-val kotlincPluginArgs = kotlincShadowJar.elements.map { locations ->
-    val pluginPath = locations.single().asFile.absolutePath
-    listOf(
-        "-Xplugin=$pluginPath",
-        "-P",
-        "plugin:scip-kotlinc:sourceroot=${rootProject.rootDir.absolutePath}",
-        "-P",
-        "plugin:scip-kotlinc:targetroot=${scipTargetroot.get().asFile.absolutePath}",
-    )
-}
+val sourceroot = rootProject.rootDir.absolutePath
+val targetroot = scipTargetroot.get().asFile.absolutePath
 
 tasks.named<KotlinCompile>("compileKotlin") {
+    // Bind to a local so the doFirst action captures the provider, not the
+    // surrounding script object (which the configuration cache cannot serialize).
+    val targetrootDir = scipTargetroot
     inputs.files(kotlincShadowJar)
-    outputs.dir(scipTargetroot)
-    compilerOptions.freeCompilerArgs.addAll(kotlincPluginArgs)
+    outputs.dir(targetrootDir)
+    compilerOptions.freeCompilerArgs.addAll(scipKotlincPluginArgs(kotlincShadowJar.elements, sourceroot, targetroot))
     doFirst {
-        scipTargetroot.get().asFile.deleteRecursively()
-        scipTargetroot.get().asFile.mkdirs()
+        targetrootDir.get().asFile.deleteRecursively()
+        targetrootDir.get().asFile.mkdirs()
     }
 }