Android Projects error on R.java about kotlin-language-server HOT 15 CLOSED

diff --git a/src/main/kotlin/org/javacs/kt/classpath/gradleDependencyResolver.kt b/src/main/kotlin/org/javacs/kt/classpath/gradleDependencyResolver.kt
index cc21d2d..f3aca10 100644
--- a/src/main/kotlin/org/javacs/kt/classpath/gradleDependencyResolver.kt
+++ b/src/main/kotlin/org/javacs/kt/classpath/gradleDependencyResolver.kt
@@ -9,13 +9,7 @@ import java.io.File
 import java.nio.file.FileSystems
 import java.nio.file.Files
 import java.nio.file.Path
-import java.nio.file.Paths
-import java.util.regex.Pattern
-import org.gradle.tooling.*
-import org.gradle.tooling.model.*
-import org.gradle.tooling.model.eclipse.*
-import org.gradle.tooling.model.idea.*
-import org.gradle.kotlin.dsl.tooling.models.*
+import org.gradle.tooling.GradleConnector
 
 fun readBuildGradle(buildFile: Path): Set<Path> {
     val projectDirectory = buildFile.getParent()
@@ -26,10 +20,6 @@ fun readBuildGradle(buildFile: Path): Set<Path> {
     // The first successful dependency resolver is used
     // (evaluating them from top to bottom)
     var dependencies = firstNonNull<Set<Path>>(
-        { tryResolving("dependencies using Gradle task") { readDependenciesViaTask(projectDirectory) } },
-        { tryResolving("dependencies using Eclipse project model") { readDependenciesViaEclipseProject(connection) } },
-        { tryResolving("dependencies using Kotlin DSL model") { readDependenciesViaKotlinDSL(connection) } },
-        { tryResolving("dependencies using IDEA model") { readDependenciesViaIdeaProject(connection) } },
         { tryResolving("dependencies using Gradle dependencies CLI") { readDependenciesViaGradleCLI(projectDirectory) } }
     ).orEmpty()
 
@@ -42,20 +32,17 @@ fun readBuildGradle(buildFile: Path): Set<Path> {
 }
 
 private fun createTemporaryGradleFile(): File {
-    val temp = File.createTempFile("tempGradle", ".config")
     val config = File.createTempFile("classpath", ".gradle")
 
+    LOG.info("Creating temporary gradle file ${config.absolutePath}")
+
     config.bufferedWriter().use { configWriter ->
         ClassLoader.getSystemResourceAsStream("classpathFinder.gradle").bufferedReader().use { configReader ->
             configReader.copyTo(configWriter)
         }
     }
 
-    temp.bufferedWriter().use {
-        it.write("rootProject { apply from: '${config.absolutePath.replace("\\", "\\\\")}'} ")
-    }
-
-    return temp
+    return config
 }
 
 private fun getGradleCommand(workspace: Path): Path {
@@ -67,101 +54,27 @@ private fun getGradleCommand(workspace: Path): Path {
     }
 }
 
-val jarArtifactOutputLine by lazy { Pattern.compile("^.+?\\.jar$") }
-
-private fun readDependenciesViaTask(directory: Path): Set<Path>? {
-    val gradle = getGradleCommand(directory)
-    val config = createTemporaryGradleFile()
-
-    val gradleCommand = "$gradle -I ${config.absolutePath} classpath"
-    val classpathCommand = Runtime.getRuntime().exec(gradleCommand, null, directory.toFile())
-    val stdout = classpathCommand.inputStream
-    val dependencies = mutableSetOf<Path>()
-
-    stdout.bufferedReader().use { reader ->
-        reader.lines().forEach {
-            val line = it.toString().trim()
-            if (!line.startsWith("Download") && jarArtifactOutputLine.matcher(line).matches()) {
-                dependencies.add(Paths.get(line))
-            }
-        }
-    }
-
-    classpathCommand.waitFor()
-
-    if (dependencies.size > 0) {
-        return dependencies
-    } else {
-        return null
-    }
-}
-
-private fun readDependenciesViaEclipseProject(connection: ProjectConnection): Set<Path> {
-    val dependencies = mutableSetOf<Path>()
-    val project: EclipseProject = connection.getModel(EclipseProject::class.java)
-
-    for (dependency in project.classpath) {
-        dependencies.add(dependency.file.toPath())
-    }
-
-    return dependencies
-}
-
-private fun readDependenciesViaIdeaProject(connection: ProjectConnection): Set<Path> {
-    val dependencies = mutableSetOf<Path>()
-    val project: IdeaProject = connection.getModel(IdeaProject::class.java)
-
-    for (child in project.children) {
-        for (dependency in child.dependencies) {
-            if (dependency is ExternalDependency) {
-                dependencies.add(dependency.file.toPath())
-            }
-        }
-    }
-
-    return dependencies
-}
-
-private fun readDependenciesViaKotlinDSL(connection: ProjectConnection): Set<Path> {
-    val project: KotlinBuildScriptModel = connection.getModel(KotlinBuildScriptModel::class.java)
-    return project.classPath.map { it.toPath() }.toSet()
-}
-
 private fun readDependenciesViaGradleCLI(projectDirectory: Path): Set<Path>? {
     LOG.fine("Attempting dependency resolution through CLI...")
+    val config = createTemporaryGradleFile()
     val gradle = getGradleCommand(projectDirectory)
-    val classpathCommand = "$gradle dependencies --configuration=compileClasspath --console=plain"
-    val testClasspathCommand = "$gradle dependencies --configuration=testCompileClasspath --console=plain"
-    val dependencies = findGradleCLIDependencies(classpathCommand, projectDirectory)
-    val testDependencies = findGradleCLIDependencies(testClasspathCommand, projectDirectory)
-
-    return dependencies?.union(testDependencies.orEmpty()).orEmpty()
+    val cmd = "$gradle -I ${config.absolutePath} kotlinLSPDeps --console=plain"
+    LOG.fine("  -- executing $cmd")
+    val dependencies = findGradleCLIDependencies(cmd, projectDirectory)
+    return dependencies
 }
 
 private fun findGradleCLIDependencies(command: String, projectDirectory: Path): Set<Path>? {
-    return parseGradleCLIDependencies(execAndReadStdout(command, projectDirectory))
+    val result = execAndReadStdout(command, projectDirectory)
+    LOG.fine(result)
+    return parseGradleCLIDependencies(result)
 }
 
-private val artifactPattern by lazy { "[\\S]+:[\\S]+:[\\S]+( -> )*([\\d.]+)*".toRegex() }
-private val jarMatcher by lazy { FileSystems.getDefault().getPathMatcher("glob:**.jar") }
+private val artifactPattern by lazy { "kotlin-lsp-gradle (.+)\n".toRegex() }
 
 private fun parseGradleCLIDependencies(output: String): Set<Path>? {
     val artifacts = artifactPattern.findAll(output)
-        .map { findGradleArtifact(parseArtifact(it.value, it.groups[2]?.value)) }
+        .mapNotNull { FileSystems.getDefault().getPath(it.groups[1]?.value) }
         .filterNotNull()
     return artifacts.toSet()
 }
-
-private fun findGradleArtifact(artifact: Artifact): Path? {
-    val jarPath = gradleCaches
-            ?.resolve(artifact.group)
-            ?.resolve(artifact.artifact)
-            ?.resolve(artifact.version)
-            ?.let { dependencyFolder ->
-                Files.walk(dependencyFolder)
-                        .filter { jarMatcher.matches(it) }
-                        .findFirst()
-            }
-            ?.orElse(null)
-    return jarPath
-}
diff --git a/src/main/resources/classpathFinder.gradle b/src/main/resources/classpathFinder.gradle
index 2bf3fde..76d760b 100644
--- a/src/main/resources/classpathFinder.gradle
+++ b/src/main/resources/classpathFinder.gradle
@@ -1,83 +1,66 @@
-boolean isResolvable(Configuration conf) {
-	// isCanBeResolved was added in Gradle 3.3. Previously, all configurations were resolvable
-	if (Configuration.class.declaredMethods.any { it.name == 'isCanBeResolved' }) {
-		return conf.canBeResolved
-	}
-	return true
-}
+allprojects { project ->
 
-File getBuildCacheForDependency(File dependency) {
-	String name = dependency.getName()
-	String home = System.getProperty("user.home")
-	String gradleCache = home + File.separator + '.gradle' + File.separator + 'caches' + File.separator
-	if (file(gradleCache).exists()) {
-		String include = 'transforms*' + File.separator + '**' + File.separator + name + File.separator + '**' + File.separator + 'classes.jar'
-		return fileTree(dir: gradleCache, include: include).files.find { it.isFile() }
-	} else {
-		return zipTree(dependency).files.find { it.isFile() && it.name.endsWith('jar') }
-	}
-}
+  task kotlinLSPDeps {
+    task -> doLast {
+      System.out.println ""
+      System.out.println "gradle-version " + gradleVersion
+      System.out.println "kotlin-lsp-project " + project.name
+
+      if(project.hasProperty('android')) {
+
+        def rootDir = project.rootDir
 
-task classpath {
-	doLast {
-		HashSet<String> classpathFiles = new HashSet<String>()
-		for (proj in allprojects) {
-			for (conf in proj.configurations) {
-				if (isResolvable(conf)) {
-					for (dependency in conf) {
-						classpathFiles += dependency
-					}
-				}
-			}
+        def level = "21"
+        if(project.android.defaultConfig.targetSdkVersion != null) {
+          level = project.android.defaultConfig.targetSdkVersion.getApiLevel()
+          System.out.println "kotlin-lsp-target android-" + level
+        }
 
-			def rjava = proj.getBuildDir().absolutePath + File.separator + "intermediates" + File.separator + "classes" + File.separator + "debug"
-			def rFiles = new File(rjava)
-			if (rFiles.exists()) {
-				classpathFiles += rFiles
-			}
+        def localProperties = new File(rootDir, "local.properties")
 
-			if (proj.hasProperty("android")) {
-				classpathFiles += proj.android.getBootClasspath()
-				if (proj.android.hasProperty("applicationVariants")) {
-					proj.android.applicationVariants.all { v ->
-						if (v.hasProperty("javaCompile")) {
-							classpathFiles += v.javaCompile.classpath
-						}
-						if (v.hasProperty("compileConfiguration")) {
-							v.compileConfiguration.each { dependency ->
-								classpathFiles += dependency
-							}
-						}
-						if (v.hasProperty("runtimeConfiguration")) {
-							v.runtimeConfiguration.each { dependency ->
-								classpathFiles += dependency
-							}
-						}
-						if (v.hasProperty("getApkLibraries")) {
-							println v.getApkLibraries()
-							classpathFiles += v.getApkLibraries()
-						}
-						if (v.hasProperty("getCompileLibraries")) {
-							classpathFiles += v.getCompileLibraries()
-						}
-					}
-				}
+        if (localProperties.exists()) {
+          Properties properties = new Properties()
+          localProperties.withInputStream { instr -> properties.load(instr) }
+          def sdkDir = properties.getProperty('sdk.dir')
+          def androidJarPath = sdkDir + "/platforms/android-" + level + "/android.jar"
+          System.out.println "kotlin-lsp-gradle " + androidJarPath
+        }
 
-				if (proj.android.hasProperty("libraryVariants")) {
-					proj.android.libraryVariants.all { v ->
-						classpathFiles += v.javaCompile.classpath.files
-					}
-				}
-			}
+        if(project.android.hasProperty('applicationVariants')) {
+          project.android.applicationVariants.all { variant ->
+            variant.getCompileClasspath().each {
+              System.out.println "kotlin-lsp-gradle " + it
+            }
+          }
+        }
 
-			HashSet<String> computedPaths = new HashSet<String>()
-			for (dependency in classpathFiles) {
-				if (dependency.name.endsWith("jar")) {
-					println dependency
-				} else if (dependency != null) {
-					println getBuildCacheForDependency(dependency)
-				}
-			}
-		}
-	}
+        def buildClasses = project.getBuildDir().absolutePath + File.separator + "intermediates" + File.separator + "classes" + File.separator + "debug"
+        System.out.println "kotlin-lsp-gradle " + buildClasses
+
+      } else {
+        // Print the list of all dependencies jar files.
+        project.configurations.findAll {
+          it.metaClass.respondsTo(it, "isCanBeResolved") ? it.isCanBeResolved() : false
+        }.each {
+          it.resolve().each {
+            if(it.inspect().endsWith("jar")) {
+              System.out.println "kotlin-lsp-gradle " + it
+            } else if(it.inspect().endsWith("aar")) {
+              // If the dependency is an AAR file we try to determine the location
+              // of the classes.jar file in the exploded aar folder.
+              def splitted = it.inspect().split("/")
+              def namespace = splitted[-5]
+              def name = splitted[-4]
+              def version = splitted[-3]
+              def explodedPath = "$project.buildDir/intermediates/exploded-aar" +
+                                 "/$namespace/$name/$version/jars/classes.jar"
+              System.out.println "kotlin-lsp-gradle " + explodedPath
+            }
+          }
+        }
+      }
+    }
+  }
 }
+
+