Use eclipse gradle plugin to get classpath with sources

Author: aiguofer

shared/build.gradle.kts

@@ -29,8 +29,9 @@ dependencies {
     // dependencies are constrained to versions defined
     // in /gradle/platform/build.gradle.kts
     implementation(platform("dev.fwcd.kotlin-language-server:platform"))
-
     implementation(kotlin("stdlib"))
+    implementation("org.simpleframework:simple-xml:2.7.1")
+    
     testImplementation("org.hamcrest:hamcrest-all")
     testImplementation("junit:junit")
 }

shared/src/main/kotlin/org/javacs/kt/classpath/GradleClassPathResolver.kt

@@ -9,17 +9,43 @@ import java.io.File
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
+import org.simpleframework.xml.Attribute
+import org.simpleframework.xml.ElementList
+import org.simpleframework.xml.Root
+import org.simpleframework.xml.Serializer
+import org.simpleframework.xml.core.Persister
+import kotlin.io.path.notExists
+import kotlin.io.path.readText
+
+
+@Root(strict = false)
+class XmlClasspathEntry {
+    @field:Attribute(name = "kind", required = true)
+    lateinit var kind: String
+
+    @field:Attribute(name = "path", required = false)
+    var path: String? = null
+
+    @field:Attribute(name = "sourcepath", required = false)
+    var sourcepath: String? = null
+}
+
+@Root(strict = false, name = "classpath")
+class XmlClasspath {
+    @field:ElementList(required = false, entry = "classpathentry", inline = true)
+    lateinit var entries: List<XmlClasspathEntry>
+}
 
 internal class GradleClassPathResolver(private val path: Path, private val includeKotlinDSL: Boolean): ClassPathResolver {
     override val resolverType: String = "Gradle"
     private val projectDirectory: Path get() = path.getParent()
     override val classpath: Set<ClassPathEntry> get() {
-        val scripts = listOf("projectClassPathFinder.gradle")
-        val tasks = listOf("kotlinLSPProjectDeps")
+        val scripts = listOf("projectEclipseClassPathFinder.gradle")
+        val tasks = listOf("eclipseClasspath")
+
+        executeGradleScript(projectDirectory, scripts, tasks)
 
-        return readDependenciesViaGradleCLI(projectDirectory, scripts, tasks)
-            .apply { if (isNotEmpty()) LOG.info("Successfully resolved dependencies for '${projectDirectory.fileName}' using Gradle") }
-            .map { ClassPathEntry(it, null) }.toSet()
+        return parseDotClasspath(projectDirectory)
     }
     override val buildScriptClasspath: Set<Path> get() {
         return if (includeKotlinDSL) {
@@ -70,25 +96,33 @@ private fun getGradleCommand(workspace: Path): Path {
     }
 }
 
-private fun readDependenciesViaGradleCLI(projectDirectory: Path, gradleScripts: List<String>, gradleTasks: List<String>): Set<Path> {
+private fun executeGradleScript(projectDirectory: Path, gradleScripts: List<String>, gradleTasks: List<String>): Pair<String, String> {
     LOG.info("Resolving dependencies for '{}' through Gradle's CLI using tasks {}...", projectDirectory.fileName, gradleTasks)
 
     val tmpScripts = gradleScripts.map { gradleScriptToTempFile(it, deleteOnExit = false).toPath().toAbsolutePath() }
     val gradle = getGradleCommand(projectDirectory)
 
     val command = listOf(gradle.toString()) + tmpScripts.flatMap { listOf("-I", it.toString()) } + gradleTasks + listOf("--console=plain")
-    val dependencies = findGradleCLIDependencies(command, projectDirectory)
+    LOG.debug("Running command: $command")
+    val ret = execAndReadStdoutAndStderr(command, projectDirectory)
+    tmpScripts.forEach(Files::delete)
+    return ret
+}
+
+private fun readDependenciesViaGradleCLI(projectDirectory: Path, gradleScripts: List<String>, gradleTasks: List<String>): Set<Path> {
+    val (result, errors) = executeGradleScript(projectDirectory, gradleScripts, gradleTasks)
+
+    val dependencies = findGradleCLIDependencies(result, errors)
         ?.also { LOG.debug("Classpath for task {}", it) }
         .orEmpty()
         .filter { it.toString().lowercase().endsWith(".jar") || Files.isDirectory(it) } // Some Gradle plugins seem to cause this to output POMs, therefore filter JARs
         .toSet()
 
-    tmpScripts.forEach(Files::delete)
+
     return dependencies
 }
 
-private fun findGradleCLIDependencies(command: List<String>, projectDirectory: Path): Set<Path>? {
-    val (result, errors) = execAndReadStdoutAndStderr(command, projectDirectory)
+private fun findGradleCLIDependencies(result: String, errors: String): Set<Path>? {
     if ("FAILURE: Build failed" in errors) {
         LOG.warn("Gradle task failed: {}", errors)
     } else {
@@ -111,3 +145,27 @@ private fun parseGradleCLIDependencies(output: String): Set<Path>? {
         .filterNotNull()
     return artifacts.toSet()
 }
+
+private fun parseDotClasspath(projectDirectory: Path) : Set<ClassPathEntry> {
+    val dotClasspath = projectDirectory.resolve(".classpath")
+    if (dotClasspath.notExists()){
+        return emptySet()
+    }
+    val xmlToParse = dotClasspath.readText()
+    val serializer: Serializer = Persister()
+    val classpath = serializer.read(XmlClasspath::class.java, xmlToParse)
+    val ret =
+        classpath
+        .entries
+        .map {
+            ClassPathEntry(Path.of(it.path ?: ""), Path.of(it.sourcepath ?: ""))
+        }
+        .toSet()
+
+    if (ret.isNotEmpty()) {
+        LOG.info("Using classpath from .classpath")
+    }
+    dotClasspath.toFile().delete()
+    return ret
+
+}

shared/src/main/resources/projectEclipseClassPathFinder.gradle

@@ -0,0 +1,3 @@
+allprojects { 
+    apply plugin: "eclipse" 
+}