Merge pull request #334 from daplf/setup-jdt-ls-extension

fwcd · web-flow · commit 4aa8456d1c84 · 2022-04-23T19:25:46.000+02:00
Setup JDT LS extension to provide Java + Kotlin interoperability
diff --git a/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt b/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt
@@ -5,7 +5,9 @@ import org.javacs.kt.classpath.defaultClassPathResolver
 import org.javacs.kt.compiler.Compiler
 import org.javacs.kt.util.AsyncExecutor
 import java.io.Closeable
+import java.io.File
 import java.nio.file.FileSystems
+import java.nio.file.Files
 import java.nio.file.Path
 
 /**
@@ -17,9 +19,10 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
     private val javaSourcePath = mutableSetOf<Path>()
     private val buildScriptClassPath = mutableSetOf<Path>()
     val classPath = mutableSetOf<ClassPathEntry>()
+    val outputDirectory: File = Files.createTempDirectory("klsBuildOutput").toFile()
     val javaHome: String? = System.getProperty("java.home", null)
 
-    var compiler = Compiler(javaSourcePath, classPath.map { it.compiledJar }.toSet(), buildScriptClassPath)
+    var compiler = Compiler(javaSourcePath, classPath.map { it.compiledJar }.toSet(), buildScriptClassPath, outputDirectory)
         private set
 
     private val async = AsyncExecutor()
@@ -67,7 +70,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
         if (refreshCompiler) {
             LOG.info("Reinstantiating compiler")
             compiler.close()
-            compiler = Compiler(javaSourcePath, classPath.map { it.compiledJar }.toSet(), buildScriptClassPath)
+            compiler = Compiler(javaSourcePath, classPath.map { it.compiledJar }.toSet(), buildScriptClassPath, outputDirectory)
             updateCompilerConfiguration()
         }
 
@@ -138,6 +141,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
 
     override fun close() {
         compiler.close()
+        outputDirectory.delete()
     }
 }
 
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt b/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt
@@ -30,7 +30,7 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
 
     private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider, classPath)
     private val workspaces = KotlinWorkspaceService(sourceFiles, sourcePath, classPath, textDocuments, config)
-    private val protocolExtensions = KotlinProtocolExtensionService(uriContentProvider)
+    private val protocolExtensions = KotlinProtocolExtensionService(uriContentProvider, classPath)
 
     private lateinit var client: LanguageClient
 
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinProtocolExtensionService.kt b/server/src/main/kotlin/org/javacs/kt/KotlinProtocolExtensionService.kt
@@ -6,11 +6,16 @@ import org.javacs.kt.util.parseURI
 import java.util.concurrent.CompletableFuture
 
 class KotlinProtocolExtensionService(
-    private val uriContentProvider: URIContentProvider
+    private val uriContentProvider: URIContentProvider,
+    private val cp: CompilerClassPath
 ) : KotlinProtocolExtensions {
     private val async = AsyncExecutor()
 
     override fun jarClassContents(textDocument: TextDocumentIdentifier): CompletableFuture<String?> = async.compute {
         uriContentProvider.contentOf(parseURI(textDocument.uri))
     }
+
+    override fun buildOutputLocation(): CompletableFuture<String?> = async.compute {
+        cp.outputDirectory.absolutePath
+    }
 }
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinProtocolExtensions.kt b/server/src/main/kotlin/org/javacs/kt/KotlinProtocolExtensions.kt
@@ -9,4 +9,7 @@ import java.util.concurrent.CompletableFuture
 interface KotlinProtocolExtensions {
     @JsonRequest
     fun jarClassContents(textDocument: TextDocumentIdentifier): CompletableFuture<String?>
+
+    @JsonRequest
+    fun buildOutputLocation(): CompletableFuture<String?>
 }
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinTextDocumentService.kt b/server/src/main/kotlin/org/javacs/kt/KotlinTextDocumentService.kt
@@ -177,6 +177,9 @@ class KotlinTextDocumentService(
         // Lint after saving to prevent inconsistent diagnostics
         val uri = parseURI(params.textDocument.uri)
         lintNow(uri)
+        debounceLint.schedule {
+            sp.save(uri)
+        }
     }
 
     override fun signatureHelp(position: SignatureHelpParams): CompletableFuture<SignatureHelp?> = async.compute {
@@ -261,6 +264,7 @@ class KotlinTextDocumentService(
     fun lintAll() {
         debounceLint.submitImmediately {
             sp.compileAllFiles()
+            sp.saveAllFiles()
             sp.refreshDependencyIndexes()
         }
     }
diff --git a/server/src/main/kotlin/org/javacs/kt/Main.kt b/server/src/main/kotlin/org/javacs/kt/Main.kt
@@ -4,8 +4,6 @@ import com.beust.jcommander.JCommander
 import com.beust.jcommander.Parameter
 import java.util.concurrent.Executors
 import org.eclipse.lsp4j.launch.LSPLauncher
-import org.eclipse.lsp4j.ConfigurationParams
-import org.eclipse.lsp4j.ConfigurationItem
 import org.javacs.kt.util.ExitingInputStream
 import org.javacs.kt.util.tcpStartServer
 import org.javacs.kt.util.tcpConnectToClient
@@ -43,7 +41,7 @@ fun main(argv: Array<String>) {
 
     val server = KotlinLanguageServer()
     val threads = Executors.newSingleThreadExecutor { Thread(it, "client") }
-    val launcher = LSPLauncher.createServerLauncher(server, ExitingInputStream(inStream), outStream, threads, { it })
+    val launcher = LSPLauncher.createServerLauncher(server, ExitingInputStream(inStream), outStream, threads) { it }
 
     server.connect(launcher.remoteProxy)
     launcher.startListening()
diff --git a/server/src/main/kotlin/org/javacs/kt/SourcePath.kt b/server/src/main/kotlin/org/javacs/kt/SourcePath.kt
@@ -48,7 +48,8 @@ class SourcePath(
         var compiledContext: BindingContext? = null,
         var module: ModuleDescriptor? = null,
         val language: Language? = null,
-        val isTemporary: Boolean = false // A temporary source file will not be returned by .all()
+        val isTemporary: Boolean = false, // A temporary source file will not be returned by .all()
+        var lastSavedFile: KtFile? = null,
     ) {
         val extension: String? = uri.fileExtension ?: "kt" // TODO: Use language?.associatedFileType?.defaultExtension again
         val isScript: Boolean = extension == "kts"
@@ -160,7 +161,10 @@ class SourcePath(
         }
 
     fun delete(uri: URI) {
-        files[uri]?.let { refreshWorkspaceIndexes(listOf(it), listOf()) }
+        files[uri]?.let {
+            refreshWorkspaceIndexes(listOf(it), listOf())
+            cp.compiler.removeGeneratedCode(listOfNotNull(it.lastSavedFile))
+        }
 
         files.remove(uri)
     }
@@ -248,10 +252,41 @@ class SourcePath(
         // TODO: Investigate the possibility of compiling all files at once, instead of iterating here
         // At the moment, compiling all files at once sometimes leads to an internal error from the TopDownAnalyzer
         files.keys.forEach {
-            compileFiles(listOf(it))
+            // If one of the files fails to compile, we compile the others anyway
+            try {
+                compileFiles(listOf(it))
+            } catch (ex: Exception) {
+                LOG.printStackTrace(ex)
+            }
+        }
+    }
+
+    /**
+     * Saves a file. This generates code for the file and deletes previously generated code for this file.
+     */
+    fun save(uri: URI) {
+        files[uri]?.let {
+            if (!it.isScript) {
+                // If the code generation fails for some reason, we generate code for the other files anyway
+                try {
+                    cp.compiler.removeGeneratedCode(listOfNotNull(it.lastSavedFile))
+                    it.module?.let { module ->
+                        it.compiledContext?.let { context ->
+                            cp.compiler.generateCode(module, context, listOfNotNull(it.compiledFile))
+                            it.lastSavedFile = it.compiledFile
+                        }
+                    }
+                } catch (ex: Exception) {
+                    LOG.printStackTrace(ex)
+                }
+            }
         }
     }
 
+    fun saveAllFiles() {
+        files.keys.forEach { save(it) }
+    }
+
     fun refreshDependencyIndexes() {
         compileAllFiles()
 
diff --git a/server/src/main/kotlin/org/javacs/kt/compiler/Compiler.kt b/server/src/main/kotlin/org/javacs/kt/compiler/Compiler.kt
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration as KotlinCompilerConfiguration
 import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.container.get
@@ -22,6 +23,8 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
 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.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.scripting.compiler.plugin.ScriptingCompilerConfigurationComponentRegistrar
 import org.jetbrains.kotlin.scripting.compiler.plugin.definitions.CliScriptDefinitionProvider
@@ -32,6 +35,9 @@ import org.jetbrains.kotlin.scripting.definitions.KotlinScriptDefinition // Lega
 import org.jetbrains.kotlin.scripting.definitions.findScriptDefinition
 import org.jetbrains.kotlin.scripting.definitions.getEnvironment
 import org.jetbrains.kotlin.scripting.resolve.KotlinScriptDefinitionFromAnnotatedTemplate
+import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+import org.jetbrains.kotlin.util.KotlinFrontEndException
 import java.io.Closeable
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -51,19 +57,19 @@ import org.javacs.kt.LOG
 import org.javacs.kt.CompilerConfiguration
 import org.javacs.kt.util.KotlinLSException
 import org.javacs.kt.util.LoggingMessageCollector
+import org.jetbrains.kotlin.cli.common.output.writeAllTo
+import org.jetbrains.kotlin.codegen.ClassBuilderFactories
+import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.container.getService
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.cli.jvm.compiler.CliBindingTrace
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.config.*
-import org.jetbrains.kotlin.container.getService
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.resolve.calls.components.InferenceSession
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
-import org.jetbrains.kotlin.util.KotlinFrontEndException
+import java.io.File
 
 private val GRADLE_DSL_DEPENDENCY_PATTERN = Regex("^gradle-(?:kotlin-dsl|core).*\\.jar$")
 
@@ -429,7 +435,7 @@ enum class CompilationKind {
  * Incrementally compiles files and expressions.
  * The basic strategy for compiling one file at-a-time is outlined in OneFilePerformance.
  */
-class Compiler(javaSourcePath: Set<Path>, classPath: Set<Path>, buildScriptClassPath: Set<Path> = emptySet()) : Closeable {
+class Compiler(javaSourcePath: Set<Path>, classPath: Set<Path>, buildScriptClassPath: Set<Path> = emptySet(), private val outputDirectory: File) : Closeable {
     private var closed = false
     private val localFileSystem: VirtualFileSystem
 
@@ -539,6 +545,34 @@ class Compiler(javaSourcePath: Set<Path>, classPath: Set<Path>, buildScriptClass
         }
     }
 
+    fun removeGeneratedCode(files: Collection<KtFile>) {
+        files.forEach { file ->
+            file.declarations.forEach { declaration ->
+                outputDirectory.resolve(
+                    file.packageFqName.asString().replace(".", File.separator) + File.separator + declaration.name + ".class"
+                ).delete()
+            }
+        }
+    }
+
+    fun generateCode(module: ModuleDescriptor, bindingContext: BindingContext, files: Collection<KtFile>) {
+        outputDirectory.let {
+            compileLock.withLock {
+                val compileEnv = compileEnvironmentFor(CompilationKind.DEFAULT)
+                val state = GenerationState.Builder(
+                    project = compileEnv.environment.project,
+                    builderFactory = ClassBuilderFactories.BINARIES,
+                    module = module,
+                    bindingContext = bindingContext,
+                    files = files.toList(),
+                    configuration = compileEnv.environment.configuration
+                ).build()
+                KotlinCodegenFacade.compileCorrectFiles(state)
+                state.factory.writeAllTo(it)
+            }
+        }
+    }
+
     override fun close() {
         if (!closed) {
             defaultCompileEnvironment.close()
diff --git a/server/src/test/kotlin/org/javacs/kt/CompiledFileTest.kt b/server/src/test/kotlin/org/javacs/kt/CompiledFileTest.kt
@@ -2,21 +2,30 @@ package org.javacs.kt
 
 import org.hamcrest.Matchers.equalTo
 import org.javacs.kt.compiler.Compiler
+import org.junit.AfterClass
 import org.junit.Assert.assertThat
 import org.junit.Test
 import org.junit.BeforeClass
+import java.io.File
 import java.nio.file.Files
 
 class CompiledFileTest {
     val compiledFile = compileFile()
 
     companion object {
-        @JvmStatic @BeforeClass fun setupLogger() {
+        lateinit var outputDirectory: File
+
+        @JvmStatic @BeforeClass fun setup() {
             LOG.connectStdioBackend()
+            outputDirectory = Files.createTempDirectory("klsBuildOutput").toFile()
+        }
+
+        @JvmStatic @AfterClass fun tearDown() {
+            outputDirectory.delete()
         }
     }
 
-    fun compileFile(): CompiledFile = Compiler(setOf(), setOf()).use { compiler ->
+    fun compileFile(): CompiledFile = Compiler(setOf(), setOf(), outputDirectory = outputDirectory).use { compiler ->
         val file = testResourcesRoot().resolve("compiledFile/CompiledFileExample.kt")
         val content = Files.readAllLines(file).joinToString("\n")
         val parse = compiler.createKtFile(content, file)
diff --git a/server/src/test/kotlin/org/javacs/kt/CompilerTest.kt b/server/src/test/kotlin/org/javacs/kt/CompilerTest.kt
@@ -10,11 +10,12 @@ import org.javacs.kt.compiler.Compiler
 import org.junit.Assert.assertThat
 import org.junit.Test
 import org.junit.After
+import org.junit.AfterClass
 import org.junit.BeforeClass
+import java.io.File
 import java.nio.file.Files
 
 class CompilerTest {
-    val compiler = Compiler(setOf(), setOf())
     val myTestResources = testResourcesRoot().resolve("compiler")
     val file = myTestResources.resolve("FileToEdit.kt")
     val editedText = """
@@ -23,8 +24,18 @@ private class FileToEdit {
 }"""
 
     companion object {
-        @JvmStatic @BeforeClass fun setupLogger() {
+        lateinit var outputDirectory: File
+        lateinit var compiler: Compiler
+
+        @JvmStatic @BeforeClass fun setup() {
             LOG.connectStdioBackend()
+            outputDirectory = Files.createTempDirectory("klsBuildOutput").toFile()
+            compiler = Compiler(setOf(), setOf(), outputDirectory = outputDirectory)
+        }
+
+        @JvmStatic @AfterClass
+        fun tearDown() {
+            outputDirectory.delete()
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,7 @@ import java.util.concurrent.CompletableFuture`
`9`	`9`	`interface KotlinProtocolExtensions {`
`10`	`10`	`@JsonRequest`
`11`	`11`	`fun jarClassContents(textDocument: TextDocumentIdentifier): CompletableFuture<String?>`
	`12`	`+`
	`13`	`+ @JsonRequest`
	`14`	`+ fun buildOutputLocation(): CompletableFuture<String?>`
`12`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -177,6 +177,9 @@ class KotlinTextDocumentService(`
`177`	`177`	`// Lint after saving to prevent inconsistent diagnostics`
`178`	`178`	`val uri = parseURI(params.textDocument.uri)`
`179`	`179`	`lintNow(uri)`
	`180`	`+ debounceLint.schedule {`
	`181`	`+ sp.save(uri)`
	`182`	`+ }`
`180`	`183`	`}`
`181`	`184`
`182`	`185`	`override fun signatureHelp(position: SignatureHelpParams): CompletableFuture<SignatureHelp?> = async.compute {`
`@@ -261,6 +264,7 @@ class KotlinTextDocumentService(`
`261`	`264`	`fun lintAll() {`
`262`	`265`	`debounceLint.submitImmediately {`
`263`	`266`	`sp.compileAllFiles()`
	`267`	`+ sp.saveAllFiles()`
`264`	`268`	`sp.refreshDependencyIndexes()`
`265`	`269`	`}`
`266`	`270`	`}`