Implement full support for JVM type signatures

buildSrc/src/main/kotlin/DownloadJavadocListFiles.kt

@@ -0,0 +1,51 @@
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import kotlin.io.path.createDirectories
+import kotlin.io.path.deleteIfExists
+import org.gradle.api.DefaultTask
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+abstract class DownloadJavadocListFiles : DefaultTask() {
+
+    @get:Input
+    abstract val dependencies: ListProperty<MinimalExternalModuleDependency>
+
+    @get:OutputDirectory
+    abstract val output: DirectoryProperty
+
+    @TaskAction
+    fun run() {
+        val client = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.ALWAYS).build()
+
+        val outDir = output.get().asFile.toPath()
+        val base = "https://static.javadoc.io"
+        dependencies.get().forEach { m ->
+            val types = listOf("element", "package")
+            var response: HttpResponse<*>? = null
+            for (type in types) {
+                val filePath = "${m.module.group}/${m.module.name}/${m.versionConstraint}/$type-list"
+                val url = "$base/$filePath"
+                val outFile = outDir.resolve(filePath)
+                outFile.parent.createDirectories()
+
+                val request = HttpRequest.newBuilder().GET().uri(URI.create(url)).build()
+                response = client.send(request, HttpResponse.BodyHandlers.ofFile(outFile))
+                if (response.statusCode() == 200) {
+                    break
+                }
+
+                outFile.deleteIfExists()
+            }
+            if (response == null || response.statusCode() != 200) {
+                throw Exception("Failed: $response")
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/HypoJavaExtension.kt

@@ -1,7 +1,9 @@
+import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.artifacts.MinimalExternalModuleDependency
 import org.gradle.api.artifacts.ProjectDependency
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.ListProperty
+import org.gradle.kotlin.dsl.domainObjectContainer
 import org.gradle.kotlin.dsl.listProperty
 
 open class HypoJavaExtension(objects: ObjectFactory) {
@@ -10,4 +12,6 @@ open class HypoJavaExtension(objects: ObjectFactory) {
 
     val javadocLibs: ListProperty<MinimalExternalModuleDependency> = objects.listProperty()
     val javadocProjects: ListProperty<ProjectDependency> = objects.listProperty()
+
+    val patchJavadocList: NamedDomainObjectContainer<HypoPatchSpec> = objects.domainObjectContainer(HypoPatchSpec::class)
 }

buildSrc/src/main/kotlin/HypoPatchSpec.kt

@@ -0,0 +1,8 @@
+import org.gradle.api.Named
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.provider.Property
+
+interface HypoPatchSpec : Named {
+
+    val library: Property<MinimalExternalModuleDependency>
+}

buildSrc/src/main/kotlin/PatchJavadocList.kt

@@ -0,0 +1,63 @@
+import javax.inject.Inject
+import kotlin.io.path.bufferedReader
+import kotlin.io.path.bufferedWriter
+import kotlin.io.path.deleteIfExists
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.readText
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputDirectory
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+abstract class PatchJavadocList : DefaultTask() {
+
+    @get:InputDirectory
+    abstract val input: DirectoryProperty
+
+    @get:Input
+    abstract val patches: ListProperty<HypoPatchSpec>
+
+    @get:OutputDirectory
+    abstract val output: DirectoryProperty
+
+    @get:Inject
+    abstract val fs: FileSystemOperations
+
+    @TaskAction
+    fun run() {
+        fs.sync {
+            from(input)
+            into(output)
+        }
+
+        val outputDir = output.get().asFile.toPath()
+        patches.get().forEach { patch ->
+            val lib = patch.library.get()
+
+            val packageListFile = outputDir.resolve("${lib.module.group}/${lib.module.name}/${lib.versionConstraint}/package-list")
+            val elementListFile = packageListFile.resolveSibling("element-list")
+
+            if (elementListFile.isRegularFile()) {
+                val originalText = elementListFile.readText()
+                elementListFile.bufferedWriter().use { writer ->
+                    writer.appendLine("module:${patch.name}")
+                    writer.append(originalText)
+                }
+            } else {
+                elementListFile.bufferedWriter().use { writer ->
+                    writer.appendLine("module:${patch.name}")
+
+                    packageListFile.bufferedReader().use { reader ->
+                        reader.copyTo(writer)
+                    }
+                }
+            }
+
+            packageListFile.deleteIfExists()
+        }
+    }
+}

buildSrc/src/main/kotlin/hypo-java.gradle.kts

@@ -1,3 +1,5 @@
+import kotlin.io.path.absolutePathString
+
 plugins {
     `java-library`
 }
@@ -12,7 +14,11 @@ java {
 }
 
 tasks.withType<JavaCompile>().configureEach {
-    options.release = 11
+    options.release = 21
+}
+
+hypoJava.patchJavadocList.register("org.jetbrains.annotations") {
+    library.set(lib("annotations"))
 }
 
 afterEvaluate {
@@ -33,7 +39,27 @@ afterEvaluate {
         }
     }
 
+    // javadoc doesn't like that static.javadoc.io redirects, so we'll manually copy the
+    // {element,package}-list for it so it doesn't complain
+    val javadocElementList by tasks.registering(DownloadJavadocListFiles::class) {
+        dependencies.set(hypoJava.javadocLibs)
+        output.set(layout.buildDirectory.dir("javadocElementLists"))
+    }
+
+    val elementLists = layout.buildDirectory.dir("javadocElementListsPatched")
+    val javadocElementListPatch by tasks.registering(PatchJavadocList::class) {
+        input.set(javadocElementList.flatMap { it.output })
+        patches.set(hypoJava.patchJavadocList)
+        output.set(elementLists)
+    }
+
     tasks.javadoc {
+        dependsOn(javadocElementListPatch)
+
+        javadocTool = javaToolchains.javadocToolFor {
+            languageVersion = JavaLanguageVersion.of(21)
+        }
+
         for (projDep in hypoJava.jdkVersionProjects.get()) {
             val proj = project(projDep.path)
 
@@ -42,22 +68,22 @@ afterEvaluate {
             classpath += sources
         }
 
-        val base = "https://javadoc.io/doc"
+        val packageListDir = elementLists.get().asFile.toPath()
         hypoJava.javadocLibs.get().forEach { m ->
-            val url = "$base/${m.module.group}/${m.module.name}/${m.versionConstraint}"
-            opt.links(url)
+            val base = "https://static.javadoc.io"
+            val artifact = "${m.module.group}/${m.module.name}/${m.versionConstraint}"
+            val packageDir = packageListDir.resolve(artifact)
+            val url = "$base/$artifact"
+
+            opt.linksOffline(url, packageDir.absolutePathString())
         }
+
         hypoJava.javadocProjects.get().forEach { p ->
             val javadocTask = project(p.path).tasks.javadoc
             dependsOn(javadocTask)
 
             val url = "$base/${p.group}/${p.name}/${p.version}"
             opt.linksOffline(url, javadocTask.get().destinationDir!!.absolutePath)
         }
-
-        doLast {
-            // a lot of tools still require a package-list file instead of element-list
-            destinationDir!!.resolve("element-list").copyTo(destinationDir!!.resolve("package-list"))
-        }
     }
 }

buildSrc/src/main/kotlin/hypo-module.gradle.kts

@@ -10,7 +10,7 @@ plugins {
 val hypoModule = extensions.create("hypoModule", HypoModuleExtension::class)
 
 tasks.withType<JavaCompile>().configureEach {
-    options.compilerArgs = listOf("-Xlint:all,-serial,-fallthrough", "-Werror")
+    options.compilerArgs = listOf("-Xlint:all,-serial,-fallthrough,-options", "-Werror")
     options.errorprone {
         disable("NonApiType", "LabelledBreakTarget")
     }

buildSrc/src/main/kotlin/hypo-test.gradle.kts

@@ -1,12 +1,17 @@
+import kotlin.math.max
+
 plugins {
     `java-library`
 }
 
 dependencies {
     testImplementation(lib("junit-api"))
     testRuntimeOnly(lib("junit-runtime"))
+    testRuntimeOnly(lib("junit-launcher"))
 }
 
 tasks.test {
     useJUnitPlatform()
+
+    maxParallelForks = max(Runtime.getRuntime().availableProcessors() / 2, 1)
 }

gradle.properties

@@ -1,4 +1,4 @@
 group = dev.denwav.hypo
-version = 2.4.1
+version = 3.0.0
 
 org.gradle.parallel=true

gradle/libs.versions.toml

@@ -1,19 +1,21 @@
 [versions]
-junit = "5.10.0"
-errorprone = "2.21.0"
-asm = "9.5"
-slf4j = "2.0.7"
-log4j = "2.20.0"
+junit = "5.11.3"
+junit-platform = "1.11.3"
+errorprone = "2.36.0"
+asm = "9.7.1"
+slf4j = "2.0.16"
+log4j = "2.24.3"
 
 [plugins]
 nexusPublish = "io.github.gradle-nexus.publish-plugin:2.0.0"
 
 [libraries]
 # Deps
-annotations = "org.jetbrains:annotations:24.0.1"
+annotations = "org.jetbrains:annotations:26.0.1"
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 slf4j-log4j2-impl = { module = "org.apache.logging.log4j:log4j-slf4j2-impl", version.ref = "log4j" }
 log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j" }
+log4j-requirement = "biz.aQute.bnd:biz.aQute.bnd.annotation:7.1.0"
 
 asm-core = { module = "org.ow2.asm:asm", version.ref = "asm" }
 asm-tree = { module = "org.ow2.asm:asm-tree", version.ref = "asm" }
@@ -22,19 +24,24 @@ asm-commons = { module = "org.ow2.asm:asm-commons", version.ref = "asm" }
 
 lorenz = "org.cadixdev:lorenz:0.5.8"
 bombe = "org.cadixdev:bombe:0.4.4"
-jgrapht = "org.jgrapht:jgrapht-core:1.4.0"
+jgrapht = "org.jgrapht:jgrapht-core:1.5.2"
 lorenzTiny = "org.quiltmc:lorenz-tiny:3.0.0"
 
+staxUtils = "net.java.dev.stax-utils:stax-utils:20070216"
+
 # Testing
 junit-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
 junit-runtime = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
+junit-launcher = { module = "org.junit.platform:junit-platform-launcher", version.ref = "junit-platform" }
+
+guava = "com.google.guava:guava:33.4.7-jre"
 
 # Linting
 errorprone-core = { module = "com.google.errorprone:error_prone_core", version.ref = "errorprone" }
 errorprone-annotations = { module = "com.google.errorprone:error_prone_annotations", version.ref = "errorprone" }
 
 # Gradle
-gradle-errorprone = "net.ltgt.errorprone:net.ltgt.errorprone.gradle.plugin:3.1.0"
+gradle-errorprone = "net.ltgt.errorprone:net.ltgt.errorprone.gradle.plugin:4.1.0"
 gradle-licenser = "org.cadixdev.licenser:org.cadixdev.licenser.gradle.plugin:0.6.1"
 
 [bundles]

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME