Factor out ClassPathSourceJarProvider

Author: fwcd

server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt

@@ -8,6 +8,7 @@ import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.services.LanguageServer
 import org.javacs.kt.commands.ALL_COMMANDS
 import org.javacs.kt.externalsources.JarClassContentProvider
+import org.javacs.kt.externalsources.ClassPathSourceJarProvider
 import org.javacs.kt.util.AsyncExecutor
 import org.javacs.kt.util.TemporaryDirectory
 import org.javacs.kt.util.parseURI
@@ -24,11 +25,11 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     val classPath = CompilerClassPath(config.compiler)
 
     private val tempDirectory = TemporaryDirectory()
-    private val uriContentProvider = URIContentProvider(JarClassContentProvider(config.externalSources, classPath, tempDirectory))
+    private val uriContentProvider = URIContentProvider(JarClassContentProvider(config.externalSources, classPath, tempDirectory, ClassPathSourceJarProvider(classPath)))
     val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing)
     val sourceFiles = SourceFiles(sourcePath, uriContentProvider)
 
-    private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, classPath, config, tempDirectory, uriContentProvider)
+    private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider)
     private val workspaces = KotlinWorkspaceService(sourceFiles, sourcePath, classPath, textDocuments, config)
     private val protocolExtensions = KotlinProtocolExtensionService(uriContentProvider)
 

server/src/main/kotlin/org/javacs/kt/KotlinTextDocumentService.kt

@@ -36,7 +36,6 @@ import java.util.concurrent.CompletableFuture
 class KotlinTextDocumentService(
     private val sf: SourceFiles,
     private val sp: SourcePath,
-    private val classPath: CompilerClassPath,
     private val config: Configuration,
     private val tempDirectory: TemporaryDirectory,
     private val uriContentProvider: URIContentProvider
@@ -125,7 +124,7 @@ class KotlinTextDocumentService(
             LOG.info("Go-to-definition at {}", describePosition(position))
 
             val (file, cursor) = recover(position, Recompile.NEVER)
-            goToDefinition(file, cursor, uriContentProvider.jarClassContentProvider, tempDirectory, config.externalSources, classPath.classPath)
+            goToDefinition(file, cursor, uriContentProvider.jarClassContentProvider, tempDirectory, config.externalSources)
                 ?.let(::listOf)
                 ?.let { Either.forLeft<List<Location>, List<LocationLink>>(it) }
                 ?: noResult("Couldn't find definition at ${describePosition(position)}", Either.forLeft(emptyList()))

server/src/main/kotlin/org/javacs/kt/definition/GoToDefinition.kt

@@ -28,8 +28,7 @@ fun goToDefinition(
     cursor: Int,
     jarClassContentProvider: JarClassContentProvider,
     tempDir: TemporaryDirectory,
-    config: ExternalSourcesConfiguration,
-    compilerClassPath: Set<ClassPathEntry>
+    config: ExternalSourcesConfiguration
 ): Location? {
     val (_, target) = file.referenceAtPoint(cursor) ?: return null
 
@@ -45,9 +44,7 @@ fun goToDefinition(
         val rawClassURI = destination.uri
 
         if (isInsideJar(rawClassURI)) {
-            val sourceURI = getSourceURI(rawClassURI, compilerClassPath)
-            val actualClassURI = sourceURI ?: rawClassURI
-            parseURI(actualClassURI).toKlsURI()?.let { klsURI ->
+            parseURI(rawClassURI).toKlsURI()?.let { klsURI ->
                 val (klsSourceURI, content) = jarClassContentProvider.contentOf(klsURI)
 
                 if (config.useKlsScheme) {
@@ -90,13 +87,4 @@ fun goToDefinition(
     return destination
 }
 
-private fun getSourceURI(rawClassURI: String, compilerClassPath: Set<ClassPathEntry>): String? {
-    val rawClassPath = parseURI(rawClassURI).path.toString()
-    val jarUri = rawClassPath.substring(0, rawClassPath.indexOf("!"))
-    val classPartUri = rawClassPath.substring(rawClassPath.indexOf("!"))
-    val sourceJar = compilerClassPath.find { it.compiledJar.toUri().path == jarUri }?.sourceJar
-
-    return if (sourceJar != null) sourceJar.toUri().toString() + classPartUri else null
-}
-
 private fun isInsideJar(uri: String) = uri.contains(".jar!")

server/src/main/kotlin/org/javacs/kt/externalsources/ClassPathSourceJarProvider.kt

@@ -0,0 +1,11 @@
+package org.javacs.kt.externalsources
+
+import org.javacs.kt.CompilerClassPath
+import java.nio.file.Path
+
+class ClassPathSourceJarProvider(
+    private val cp: CompilerClassPath
+) : SourceJarProvider {
+    override fun fetchSourceJar(compiledJar: Path): Path? =
+        cp.classPath.firstOrNull { it.compiledJar == compiledJar }?.sourceJar
+}

server/src/main/kotlin/org/javacs/kt/externalsources/JarClassContentProvider.kt

@@ -20,6 +20,7 @@ class JarClassContentProvider(
     private val config: ExternalSourcesConfiguration,
     private val cp: CompilerClassPath,
     private val tempDir: TemporaryDirectory,
+    private val sourceJarProvider: SourceJarProvider,
     private val decompiler: Decompiler = FernflowerDecompiler()
 ) {
     /** Maps recently used (source-)KLS-URIs to their source contents (e.g. decompiled code) and the file extension. */
@@ -34,17 +35,18 @@ class JarClassContentProvider(
      * If the file is inside a source JAR, the source code is returned as is.
      */
     public fun contentOf(uri: KlsURI): Pair<KlsURI, String> {
-        val key = uri.toString()
+        val resolvedUri = sourceJarProvider.fetchSourceJar(uri.jarPath)?.let(uri::withJarPath) ?: uri
+        val key = resolvedUri.toString()
         val (contents, extension) = cachedContents[key] ?: run {
                 LOG.info("Finding contents of {}", describeURI(uri.fileUri))
-                tryReadContentOf(uri)
-                    ?: tryReadContentOf(uri.withFileExtension("class"))
-                    ?: tryReadContentOf(uri.withFileExtension("java"))
-                    ?: tryReadContentOf(uri.withFileExtension("kt"))
+                tryReadContentOf(resolvedUri)
+                    ?: tryReadContentOf(resolvedUri.withFileExtension("class"))
+                    ?: tryReadContentOf(resolvedUri.withFileExtension("java"))
+                    ?: tryReadContentOf(resolvedUri.withFileExtension("kt"))
                     ?: throw KotlinLSException("Could not find $uri")
             }.also { cachedContents[key] = it }
-        val sourceURI = uri.withFileExtension(extension)
-        return Pair(sourceURI, contents)
+        val sourceUri = resolvedUri.withFileExtension(extension)
+        return Pair(sourceUri, contents)
     }
 
     private fun convertToKotlinIfNeeded(javaCode: String): String = if (config.autoConvertToKotlin) {

server/src/main/kotlin/org/javacs/kt/externalsources/KlsURI.kt

@@ -8,6 +8,7 @@ import java.net.JarURLConnection
 import java.io.BufferedReader
 import java.nio.file.Path
 import java.nio.file.Files
+import java.nio.file.Paths
 
 fun URI.toKlsURI(): KlsURI? = when (scheme) {
     "kls" -> KlsURI(URI("kls:$schemeSpecificPart"))
@@ -41,21 +42,32 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
         }
     }
 
+    private val queryString: String
+        get() = if (query.isEmpty()) "" else query.entries.fold("?") { accum, next -> "$accum${next.key}=${next.value}" }
+
     val fileName: String
         get() = fileUri.toString().substringAfterLast("/")
     val fileExtension: String?
         get() = fileName
             .split(".")
             .takeIf { it.size > 1 }
             ?.lastOrNull()
-    private val queryString get() = if (query.isEmpty()) "" else query.entries.fold("?") { accum, next -> "$accum${next.key}=${next.value}" }
-    private val uri: URI get() = URI(fileUri.toString() + queryString)
-    val source: Boolean get() = query[QueryParam.SOURCE] as? Boolean ?: false
+
+    val jarPath: Path
+        get() = Paths.get(fileUri.path.split("!")[0])
+    val innerPath: String?
+        get() = fileUri.path.split("!", limit = 2).get(1)
+
+    val source: Boolean
+        get() = query[QueryParam.SOURCE] as? Boolean ?: false
     val isCompiled: Boolean
         get() = fileExtension == "class"
 
     constructor(uri: URI) : this(parseKlsURIFileURI(uri), parseKlsURIQuery(uri))
 
+    fun withJarPath(newJarPath: Path): KlsURI =
+        KlsURI(URI(newJarPath.toUri().toString() + (innerPath?.let { "!$it" } ?: "")), query)
+
     fun withFileExtension(newExtension: String): KlsURI {
         val (parentUri, fileName) = fileUri.toString().partitionAroundLast("/")
         val newUri = URI("$parentUri${fileName.split(".").first()}.$newExtension")
@@ -69,11 +81,9 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
         return KlsURI(fileUri, newQuery)
     }
 
-    fun withoutQuery(): KlsURI = KlsURI(fileUri, mapOf())
-
-    fun toFileURI(): URI = URI(uri.schemeSpecificPart)
+    fun toURI(): URI = URI(fileUri.toString() + queryString)
 
-    private fun toJarURL(): URL = URL("jar:${uri.schemeSpecificPart}")
+    private fun toJarURL(): URL = URL("jar:${toURI().schemeSpecificPart}")
 
     private fun openJarURLConnection() = toJarURL().openConnection() as JarURLConnection
 
@@ -105,7 +115,7 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
         tmpFile
     }
 
-    override fun toString(): String = uri.toString()
+    override fun toString(): String = toURI().toString()
 }
 
 private fun parseKlsURIFileURI(uri: URI): URI = URI(uri.toString().split("?")[0])

server/src/main/kotlin/org/javacs/kt/externalsources/SourceJarProvider.kt

@@ -3,5 +3,5 @@ package org.javacs.kt.externalsources
 import java.nio.file.Path
 
 interface SourceJarProvider {
-    fun fetchSourceJar(compiledJar: Path): Path
+    fun fetchSourceJar(compiledJar: Path): Path?
 }