Some more cleanup around source JAR URIs

Author: fwcd

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

@@ -17,7 +17,7 @@ class URIContentProvider(
 ) {
     fun contentOf(uri: URI): String = when (uri.scheme) {
         "file" -> Paths.get(uri).toFile().readText()
-        "kls" -> uri.toKlsURI()?.let { jarClassContentProvider.contentOf(it, it.source).second }
+        "kls" -> uri.toKlsURI()?.let { jarClassContentProvider.contentOf(it).second }
             ?: throw KotlinLSException("Could not find ${uri}")
         else -> throw KotlinLSException("Unrecognized scheme ${uri.scheme}")
     }

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

@@ -48,7 +48,7 @@ fun goToDefinition(
             val sourceURI = getSourceURI(rawClassURI, compilerClassPath)
             val actualClassURI = sourceURI ?: rawClassURI
             parseURI(actualClassURI).toKlsURI()?.let { klsURI ->
-                val (klsSourceURI, content) = jarClassContentProvider.contentOf(klsURI, sourceURI != null)
+                val (klsSourceURI, content) = jarClassContentProvider.contentOf(klsURI)
 
                 if (config.useKlsScheme) {
                     // Defer decompilation until a jarClassContents request is sent

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

@@ -33,19 +33,17 @@ class JarClassContentProvider(
      * contents.
      * If the file is inside a source JAR, the source code is returned as is.
      */
-    public fun contentOf(uri: KlsURI, source: Boolean): Pair<KlsURI, String> {
+    public fun contentOf(uri: KlsURI): Pair<KlsURI, String> {
         val key = uri.toString()
         val (contents, extension) = cachedContents[key] ?: run {
                 LOG.info("Finding contents of {}", describeURI(uri.fileUri))
-                tryReadContentOf(uri, source)
-                    ?: tryReadContentOf(uri.withFileExtension("class"), source)
-                    ?: tryReadContentOf(uri.withFileExtension("java"), source)
-                    ?: tryReadContentOf(uri.withFileExtension("kt"), source)
+                tryReadContentOf(uri)
+                    ?: tryReadContentOf(uri.withFileExtension("class"))
+                    ?: tryReadContentOf(uri.withFileExtension("java"))
+                    ?: tryReadContentOf(uri.withFileExtension("kt"))
                     ?: throw KotlinLSException("Could not find $uri")
-            }.also {
-                cachedContents[key] = Pair(it.first, it.second)
-            }
-        val sourceURI = uri.withFileExtension(extension).withSource(source)
+            }.also { cachedContents[key] = it }
+        val sourceURI = uri.withFileExtension(extension)
         return Pair(sourceURI, contents)
     }
 
@@ -55,17 +53,16 @@ class JarClassContentProvider(
         javaCode
     }
 
-    private fun tryReadContentOf(uri: KlsURI, source: Boolean): Pair<String, String>? = try {
-        val actualUri = uri.withoutQuery()
-        when (actualUri.fileExtension) {
-            "class" -> Pair(actualUri.extractToTemporaryFile(tempDir)
+    private fun tryReadContentOf(uri: KlsURI): Pair<String, String>? = try {
+        when (uri.fileExtension) {
+            "class" -> Pair(uri.extractToTemporaryFile(tempDir)
                 .let(decompiler::decompileClass)
                 .let { Files.newInputStream(it) }
                 .bufferedReader()
                 .use(BufferedReader::readText)
                 .let(this::convertToKotlinIfNeeded), if (config.autoConvertToKotlin) "kt" else "java")
-            "java" -> if (source) Pair(actualUri.readContents(), "java") else Pair(convertToKotlinIfNeeded(actualUri.readContents()), "kt")
-            else -> Pair(actualUri.readContents(), "kt") // e.g. for Kotlin source files
+            "java" -> if (uri.source) Pair(uri.readContents(), "java") else Pair(convertToKotlinIfNeeded(uri.readContents()), "kt")
+            else -> Pair(uri.readContents(), "kt") // e.g. for Kotlin source files
         }
     } catch (e: FileNotFoundException) { null }
 }

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

@@ -28,10 +28,7 @@ fun URI.toKlsURI(): KlsURI? = when (scheme) {
  * which case the file will directly be used without invoking the decompiler.
  */
 data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
-
-    /**
-     * Possible KLS URI query parameters
-     */
+    /** Possible KLS URI query parameters. */
     enum class QueryParam(val parameterName: String) {
         SOURCE("source");
 
@@ -44,8 +41,6 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
         }
     }
 
-    constructor(uri: URI) : this(parseKlsURIFileURI(uri), parseKlsURIQuery(uri))
-
     val fileName: String
         get() = fileUri.toString().substringAfterLast("/")
     val fileExtension: String?
@@ -59,10 +54,12 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
     val isCompiled: Boolean
         get() = fileExtension == "class"
 
+    constructor(uri: URI) : this(parseKlsURIFileURI(uri), parseKlsURIQuery(uri))
+
     fun withFileExtension(newExtension: String): KlsURI {
-        val (parentURI, fileName) = uri.toString().partitionAroundLast("/")
-        val newURI = "$parentURI${fileName.split(".").first()}.$newExtension"
-        return KlsURI(URI(newURI), query)
+        val (parentUri, fileName) = fileUri.toString().partitionAroundLast("/")
+        val newUri = URI("$parentUri${fileName.split(".").first()}.$newExtension")
+        return KlsURI(newUri, query)
     }
 
     fun withSource(source: Boolean): KlsURI {
@@ -72,9 +69,7 @@ data class KlsURI(val fileUri: URI, val query: Map<QueryParam, Any>) {
         return KlsURI(fileUri, newQuery)
     }
 
-    fun withoutQuery(): KlsURI {
-        return KlsURI(fileUri, mapOf())
-    }
+    fun withoutQuery(): KlsURI = KlsURI(fileUri, mapOf())
 
     fun toFileURI(): URI = URI(uri.schemeSpecificPart)