Migrate build to Gradle 9 (#935)

Author: jupblb

.github/workflows/ci.yaml

@@ -5,6 +5,41 @@ on:
       - main
   pull_request:
 jobs:
+  format:
+    runs-on: ubuntu-latest
+    name: Formatting
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v4
+        with:
+          gradle-version: 9.4.1
+
+      - run: gradle spotlessCheck --no-daemon
+
+  kotlin_plugin:
+    runs-on: ubuntu-latest
+    name: scip-kotlinc
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - uses: gradle/actions/setup-gradle@v4
+        with:
+          gradle-version: 9.4.1
+
+      - name: scip-kotlinc tests
+        run: gradle :scip-kotlinc:test --no-daemon
+
   docker_test:
     runs-on: ubuntu-latest
     name: Docker CLI tests

.github/workflows/nix.yaml

@@ -107,21 +107,6 @@ jobs:
       - run: du -h index.scip
         working-directory: examples/bazel-example
 
-  kotlin_plugin:
-    runs-on: ubuntu-latest
-    name: scip-kotlinc
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: DeterminateSystems/nix-installer-action@v22
-        with:
-          summarize: false
-
-      - uses: DeterminateSystems/magic-nix-cache-action@v13
-
-      - name: scip-kotlinc tests
-        run: gradle :scip-kotlinc:test --no-daemon
-
   snapshots:
     runs-on: ubuntu-latest
     name: Snapshots

CONTRIBUTING.md

@@ -58,8 +58,8 @@ These are the main components of the project.
 | `gradle :scip-snapshots:saveSnapshots --no-daemon`      | terminal | Regenerate Java and Kotlin snapshot goldens.                             |
 | `gradle :scip-java:installDist --no-daemon`             | terminal | Build a local `scip-java` distribution under `scip-java/build/install/`. |
 | `gradle :scip-java:run --args='--cwd DIRECTORY'`        | terminal | Run `scip-java` against a given Gradle/Maven build.                      |
-| `google-java-format --replace $(git ls-files '*.java')` | terminal | Format Java sources (from `nix develop`). Enforced by `nix flake check`. |
-| `ktfmt --kotlinlang-style $(git ls-files '*.kt')`       | terminal | Format Kotlin sources (from `nix develop`). Enforced by `nix flake check`. |
+| `gradle spotlessApply`                                  | terminal | Format Java and Kotlin sources with Spotless.                            |
+| `gradle spotlessCheck`                                  | terminal | Check Java and Kotlin formatting. Enforced by GitHub Actions.            |
 
 ## Import the project into IntelliJ
 

bin/docker-setup.sh

@@ -10,7 +10,7 @@ unzip -d /opt/maven maven.zip
 rm maven.zip
 mv /opt/maven/*/* /opt/maven
 
-curl -fLo gradle.zip https://services.gradle.org/distributions/gradle-8.14.4-bin.zip
+curl -fLo gradle.zip https://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 unzip -d /opt/gradle gradle.zip 
 rm gradle.zip
 mv /opt/gradle/*/* /opt/gradle

build-logic/build.gradle.kts

@@ -0,0 +1,16 @@
+import org.gradle.plugin.use.PluginDependency
+
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(plugin(libs.plugins.kotlin.jvm))
+    implementation(plugin(libs.plugins.shadow))
+    implementation(plugin(libs.plugins.vanniktech.maven.publish))
+}
+
+// Maps a version-catalog plugin alias to its plugin-marker dependency so the
+// external plugin can be applied by id from the precompiled convention plugins.
+fun plugin(dependency: Provider<PluginDependency>): Provider<String> =
+    dependency.map { "${it.pluginId}:${it.pluginId}.gradle.plugin:${it.version}" }

build-logic/settings.gradle.kts

@@ -0,0 +1,13 @@
+dependencyResolutionManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "build-logic"

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/JavacInternals.kt

@@ -0,0 +1,21 @@
+package com.sourcegraph.buildlogic
+
+import java.io.File
+import java.util.Properties
+
+/**
+ * Reads the JVM flags scip-javac needs to access internal javac APIs on Java 9+, keeping
+ * gradle/javac-internals.properties the single source of truth.
+ */
+object JavacInternals {
+    fun propertiesFile(rootDir: File): File = rootDir.resolve("gradle/javac-internals.properties")
+
+    fun jvmOptions(rootDir: File): List<String> {
+        val file = propertiesFile(rootDir)
+        val raw =
+            Properties()
+                .apply { file.inputStream().use { load(it) } }
+                .getProperty("javac.jvmOptions") ?: error("Missing javac.jvmOptions in $file")
+        return raw.split(',').map { it.trim() }.filter { it.isNotEmpty() }
+    }
+}

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

@@ -0,0 +1,66 @@
+package com.sourcegraph.buildlogic
+
+import java.io.File
+import org.gradle.api.Task
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.Directory
+import org.gradle.api.file.FileSystemLocation
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.compile.JavaCompile
+
+/**
+ * Wires this [JavaCompile] task to run the scip-javac compiler plugin: puts the shaded plugin jar
+ * [javacShadowJar] on the compile classpath and forks javac with the internal-API flags from
+ * gradle/javac-internals.properties, recording [targetroot] as an output directory.
+ *
+ * Callers still add the case-specific `-Xplugin:scip ...` arguments and annotation processors.
+ */
+fun JavaCompile.useScipJavac(
+    rootDir: File,
+    javacShadowJar: Configuration,
+    targetroot: Provider<Directory>,
+) {
+    classpath = classpath.plus(javacShadowJar)
+    outputs.dir(targetroot)
+    options.isFork = true
+    options.forkOptions.jvmArgs =
+        (options.forkOptions.jvmArgs ?: emptyList()) + JavacInternals.jvmOptions(rootDir)
+}
+
+/**
+ * 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",
+        )
+    }
+
+/**
+ * Registers a `doFirst` action that empties [dir] (deletes then recreates it) before the task runs.
+ *
+ * The action lives here, in compiled build logic, rather than in a `.gradle.kts` script: a lambda
+ * declared in a build script captures a hidden reference to the script object, which the
+ * configuration cache cannot serialize.
+ */
+fun Task.cleanDirectoryBeforeRunning(dir: Provider<Directory>) {
+    doFirst {
+        val file = dir.get().asFile
+        file.deleteRecursively()
+        file.mkdirs()
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.sourcegraph.buildlogic
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.file.Directory
+import org.gradle.api.provider.Provider
+
+/**
+ * Declares a resolvable [Configuration] consuming the [configuration] artifact published by the
+ * project at [producerPath]. The returned `FileCollection` resolves to that project's output and
+ * carries the task dependency that builds it, so consumers avoid `evaluationDependsOn` and reaching
+ * across project boundaries, keeping evaluation order and the configuration cache intact.
+ */
+fun Project.projectArtifact(
+    producerPath: String,
+    configuration: String,
+    name: String,
+): Configuration {
+    val bucket = configurations.dependencyScope("${name}Classpath")
+    dependencies.add(
+        bucket.name,
+        dependencies.project(mapOf("path" to producerPath, "configuration" to configuration)),
+    )
+    return configurations.resolvable(name) { extendsFrom(bucket.get()) }.get()
+}
+
+/**
+ * Resolvable view of another project's shaded jar (the `scip.shadow-producer` convention plugin).
+ */
+fun Project.shadowJarArtifact(producerPath: String, name: String): Configuration =
+    projectArtifact(producerPath, "shadowJarElements", name)
+
+/**
+ * Publishes [directory] (produced by [producedBy]) as a consumable artifact in a [name]
+ * configuration, so a sibling project can resolve it with [projectArtifact].
+ */
+fun Project.publishDirectoryArtifact(
+    name: String,
+    directory: Provider<Directory>,
+    producedBy: Any,
+) {
+    val elements = configurations.consumable(name).get()
+    artifacts.add(elements.name, directory) { builtBy(producedBy) }
+}