Manage Java source path in CompilerClassPath

Author: fwcd

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

@@ -29,11 +29,8 @@ import org.jetbrains.kotlin.config.ApiVersion
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
-import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
-import org.jetbrains.kotlin.load.java.JavaClassesTracker
 import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -43,7 +40,6 @@ import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
 import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.extensions.ExtraImportsProviderExtension
-import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCompilerConfigurationComponentRegistrar
@@ -91,7 +87,7 @@ private val GRADLE_DSL_DEPENDENCY_PATTERN = Regex("^gradle-(?:kotlin-dsl|core).*
  * files and expressions.
  */
 private class CompilationEnvironment(
-    workspaceRoots: Set<Path>,
+    javaSourcePath: Set<Path>,
     classPath: Set<Path>
 ) : Closeable {
     private val disposable = Disposer.newDisposable()
@@ -118,10 +114,9 @@ private class CompilationEnvironment(
                 put(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, languageVersionSettings)
                 put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, LoggingMessageCollector)
                 add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, ScriptingCompilerConfigurationComponentRegistrar())
-                addJvmClasspathRoots(classPath.map { it.toFile() })
 
-                // HACK: Use the SourcePath instead
-                addJavaSourceRoots(workspaceRoots.flatMap { it.toFile().walk().filter { it.name.endsWith(".java") }.toList() })
+                addJvmClasspathRoots(classPath.map { it.toFile() })
+                addJavaSourceRoots(javaSourcePath.map { it.toFile() })
 
                 // Setup script templates (e.g. used by Gradle's Kotlin DSL)
                 val scriptDefinitions: MutableList<ScriptDefinition> = mutableListOf(ScriptDefinition.getDefault(defaultJvmScriptingHostConfiguration))
@@ -172,7 +167,7 @@ private class CompilationEnvironment(
         // TODO: Update VFS source files dynamically inside the environment using updateClasspath
         // and use VirtualFileManager.getInstance instead of using a custom SourcePath/SourceFile mechanism.
         // Documentation on the VFS is available here: https://www.jetbrains.org/intellij/sdk/docs/basics/architectural_overview/virtual_file.html
-        // Virtual files can be manipulated using input-/output-stream-readers. Note that each virtual file has an associated charset.
+        // Virtual files can be manipulated using input-/output-stream-writers. Note that each virtual file has an associated charset.
 
         // environment.addKotlinSourceRoots(workspaceRoots.map { it.toFile() })
 
@@ -318,18 +313,7 @@ class Compiler(workspaceRoots: Set<Path>, classPath: Set<Path>, buildScriptClass
         compileLock.withLock {
             val compileEnv = compileEnvironmentFor(kind)
             val (container, trace) = compileEnv.createContainer(sourcePath)
-            val module = container.get<ModuleDescriptor>()
-            val moduleContext = container.get<ModuleContext>()
-            val project = compileEnv.environment.project
-            val analysisHandlerExtensions = AnalysisHandlerExtension.getInstances(project)
-
-            analysisHandlerExtensions.forEach { it.doAnalysis(project, module, moduleContext, files, trace, container) }
-
             container.get<LazyTopDownAnalyzer>().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files)
-            container.get<JavaClassesTracker>().onCompletedAnalysis(module)
-
-            analysisHandlerExtensions.forEach { it.analysisCompleted(project, module, trace, files) }
-
             return Pair(trace.bindingContext, container)
         }
     }

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

@@ -2,51 +2,64 @@ package org.javacs.kt
 
 import org.javacs.kt.classpath.defaultClassPathResolver
 import java.io.Closeable
+import java.nio.file.Files
+import java.nio.file.FileSystems
 import java.nio.file.Path
+import java.util.stream.Collectors
 
 class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
     private val workspaceRoots = mutableSetOf<Path>()
+    private val javaSourcePath = mutableSetOf<Path>()
     private val classPath = mutableSetOf<Path>()
     private val buildScriptClassPath = mutableSetOf<Path>()
-    var compiler = Compiler(workspaceRoots, classPath, buildScriptClassPath)
+    var compiler = Compiler(javaSourcePath, classPath, buildScriptClassPath)
         private set
 
     init {
         compiler.updateConfiguration(config)
     }
 
-    private fun refresh(updateBuildScriptClassPath: Boolean = true) {
+    private fun refresh(
+        updateClassPath: Boolean = true,
+        updateBuildScriptClassPath: Boolean = true,
+        updateJavaSourcePath: Boolean = false
+    ): Boolean {
         // TODO: Fetch class path and build script class path concurrently (and asynchronously)
         val resolver = defaultClassPathResolver(workspaceRoots)
-        var refreshCompiler = false
+        var refreshCompiler = updateJavaSourcePath
 
-        val newClassPath = resolver.classpathOrEmpty
-        if (newClassPath != classPath) {
-            syncClassPath(classPath, newClassPath)
-            refreshCompiler = true
+        if (updateClassPath) {
+            val newClassPath = resolver.classpathOrEmpty
+            if (newClassPath != classPath) {
+                syncPath(classPath, newClassPath, "class path")
+                refreshCompiler = true
+            }
         }
 
         if (updateBuildScriptClassPath) {
+            LOG.info("Update build script path")
             val newBuildScriptClassPath = resolver.buildScriptClasspathOrEmpty
             if (newBuildScriptClassPath != buildScriptClassPath) {
-                syncClassPath(buildScriptClassPath, newBuildScriptClassPath)
+                syncPath(buildScriptClassPath, newBuildScriptClassPath, "class path")
                 refreshCompiler = true
             }
         }
 
         if (refreshCompiler) {
             compiler.close()
-            compiler = Compiler(workspaceRoots, classPath, buildScriptClassPath)
+            compiler = Compiler(javaSourcePath, classPath, buildScriptClassPath)
             updateCompilerConfiguration()
         }
+
+        return refreshCompiler
     }
 
-    private fun syncClassPath(dest: MutableSet<Path>, new: Set<Path>) {
+    private fun syncPath(dest: MutableSet<Path>, new: Set<Path>, name: String) {
         val added = new - dest
         val removed = dest - new
 
-        logAdded(added)
-        logRemoved(removed)
+        logAdded(added, name)
+        logRemoved(removed, name)
 
         dest.removeAll(removed)
         dest.addAll(added)
@@ -56,53 +69,78 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
         compiler.updateConfiguration(config)
     }
 
-    fun addWorkspaceRoot(root: Path) {
-        LOG.info("Searching for dependencies in workspace root {}", root)
+    fun addWorkspaceRoot(root: Path): Boolean {
+        LOG.info("Searching for dependencies and Java sources in workspace root {}", root)
 
         workspaceRoots.add(root)
+        javaSourcePath.addAll(findJavaSourceFiles(root))
 
-        refresh()
+        return refresh(updateJavaSourcePath = true)
     }
 
-    fun removeWorkspaceRoot(root: Path) {
-        LOG.info("Remove dependencies from workspace root {}", root)
+    fun removeWorkspaceRoot(root: Path): Boolean {
+        LOG.info("Removing dependencies and Java source path from workspace root {}", root)
 
         workspaceRoots.remove(root)
+        javaSourcePath.removeAll(findJavaSourceFiles(root))
 
-        refresh()
+        return refresh(updateJavaSourcePath = true)
     }
 
-    fun createdOnDisk(file: Path) {
-        changedOnDisk(file)
+    fun createdOnDisk(file: Path): Boolean {
+        if (isJavaSource(file)) {
+            javaSourcePath.add(file)
+        }
+        return changedOnDisk(file)
     }
 
-    fun deletedOnDisk(file: Path) {
-        changedOnDisk(file)
+    fun deletedOnDisk(file: Path): Boolean {
+        if (isJavaSource(file)) {
+            javaSourcePath.remove(file)
+        }
+        return changedOnDisk(file)
     }
 
-    fun changedOnDisk(file: Path) {
-        val name = file.fileName.toString()
-        if (name == "pom.xml" || name == "build.gradle" || name == "build.gradle.kts")
-            refresh(updateBuildScriptClassPath = false)
+    fun changedOnDisk(file: Path): Boolean {
+        val buildScript = isBuildScript(file)
+        val javaSource = isJavaSource(file)
+        if (buildScript || javaSource) {
+            return refresh(updateClassPath = buildScript, updateBuildScriptClassPath = false, updateJavaSourcePath = javaSource)
+        } else {
+            return false
+        }
     }
 
+    private fun isJavaSource(file: Path): Boolean = file.fileName.toString().endsWith(".java")
+
+    private fun isBuildScript(file: Path): Boolean = file.fileName.toString().let { it == "pom.xml" || it == "build.gradle" || it == "build.gradle.kts" }
+
     override fun close() {
         compiler.close()
     }
 }
 
-private fun logAdded(sources: Collection<Path>) {
+// TODO: Cut off branches that are excluded in the walker directly
+private fun findJavaSourceFiles(root: Path): Set<Path> {
+    val sourceMatcher = FileSystems.getDefault().getPathMatcher("glob:*.java")
+    val exclusions = SourceExclusions(root)
+    return Files.walk(root)
+        .filter { exclusions.isPathIncluded(it) && sourceMatcher.matches(it.fileName) }
+        .collect(Collectors.toSet())
+}
+
+private fun logAdded(sources: Collection<Path>, name: String) {
     when {
         sources.isEmpty() -> return
-        sources.size > 5 -> LOG.info("Adding {} files to class path", sources.size)
-        else -> LOG.info("Adding {} to class path", sources)
+        sources.size > 5 -> LOG.info("Adding {} files to {}", sources.size, name)
+        else -> LOG.info("Adding {} to {}", sources, name)
     }
 }
 
-private fun logRemoved(sources: Collection<Path>) {
+private fun logRemoved(sources: Collection<Path>, name: String) {
     when {
         sources.isEmpty() -> return
-        sources.size > 5 -> LOG.info("Removing {} files from class path", sources.size)
-        else -> LOG.info("Removing {} from class path", sources)
+        sources.size > 5 -> LOG.info("Removing {} files from {}", sources.size, name)
+        else -> LOG.info("Removing {} from {}", sources, name)
     }
 }

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

@@ -73,7 +73,10 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
             val root = Paths.get(parseURI(params.rootUri))
 
             sourceFiles.addWorkspaceRoot(root)
-            classPath.addWorkspaceRoot(root)
+            val refreshed = classPath.addWorkspaceRoot(root)
+            if (refreshed) {
+                sourcePath.refresh()
+            }
         }
 
         return completedFuture(InitializeResult(serverCapabilities))

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

@@ -66,15 +66,15 @@ class KotlinWorkspaceService(
             when (change.type) {
                 FileChangeType.Created -> {
                     sf.createdOnDisk(uri)
-                    path?.let(cp::createdOnDisk)
+                    path?.let(cp::createdOnDisk)?.let { if (it) sp.refresh() }
                 }
                 FileChangeType.Deleted -> {
                     sf.deletedOnDisk(uri)
-                    path?.let(cp::deletedOnDisk)
+                    path?.let(cp::deletedOnDisk)?.let { if (it) sp.refresh() }
                 }
                 FileChangeType.Changed -> {
                     sf.changedOnDisk(uri)
-                    path?.let(cp::changedOnDisk)
+                    path?.let(cp::changedOnDisk)?.let { if (it) sp.refresh() }
                 }
                 null -> {
                     // Nothing to do
@@ -147,15 +147,21 @@ class KotlinWorkspaceService(
             val root = Paths.get(parseURI(change.uri))
 
             sf.addWorkspaceRoot(root)
-            cp.addWorkspaceRoot(root)
+            val refreshed = cp.addWorkspaceRoot(root)
+            if (refreshed) {
+                sp.refresh()
+            }
         }
         for (change in params.event.removed) {
             LOG.info("Dropping workspace {} from source path", change.uri)
 
             val root = Paths.get(parseURI(change.uri))
 
             sf.removeWorkspaceRoot(root)
-            cp.removeWorkspaceRoot(root)
+            val refreshed = cp.removeWorkspaceRoot(root)
+            if (refreshed) {
+                sp.refresh()
+            }
         }
     }
 }

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

@@ -216,8 +216,9 @@ private fun patch(sourceText: String, change: TextDocumentContentChangeEvent): S
     }
 }
 
+// TODO: Cut off branches that are excluded in the walker directly
 private fun findSourceFiles(root: Path): Set<URI> {
-    val sourceMatcher = FileSystems.getDefault().getPathMatcher("glob:*.{kt,kts,java}")
+    val sourceMatcher = FileSystems.getDefault().getPathMatcher("glob:*.{kt,kts}")
     val exclusions = SourceExclusions(root)
     return Files.walk(root)
         .filter { exclusions.isPathIncluded(it) && sourceMatcher.matches(it.fileName) }