Merge branch 'main' of github.com:fwcd/kotlin-language-server into dependency-caching

Author: daplf

.github/workflows/build.yml

@@ -1,18 +1,19 @@
 name: Build
-on: [push, pull_request]
+on: [ push, pull_request ]
 
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        java: ['11', '17']
+        java: [ '11', '17' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup JDK
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
           java-version: ${{ matrix.java }}
+      - uses: gradle/gradle-build-action@v2
       - name: Build
         run: ./gradlew :server:build :shared:build

.github/workflows/deploy.yml

@@ -7,13 +7,15 @@ on:
 jobs:
   deploy:
     runs-on: ubuntu-latest
+    if: github.repository == 'fwcd/kotlin-language-server'
     steps:
       - uses: actions/checkout@v3
       - name: Setup JDK
-        uses: actions/setup-java@v2
+        uses: actions/setup-java@v3
         with:
           distribution: 'temurin'
           java-version: '11'
+      - uses: gradle/gradle-build-action@v2
       - name: Build distribution
         run: ./gradlew :server:distZip :grammars:distZip
       - name: Create release

README.md

@@ -1,4 +1,5 @@
 # Kotlin Language Server
+
 [![Release](https://img.shields.io/github/release/fwcd/kotlin-language-server)](https://github.com/fwcd/kotlin-language-server/releases)
 [![Build](https://github.com/fwcd/kotlin-language-server/actions/workflows/build.yml/badge.svg)](https://github.com/fwcd/kotlin-language-server/actions/workflows/build.yml)
 [![Downloads](https://img.shields.io/github/downloads/fwcd/kotlin-language-server/total)](https://github.com/fwcd/kotlin-language-server/releases)
@@ -11,6 +12,7 @@ A [language server](https://microsoft.github.io/language-server-protocol/) that
 Any editor conforming to LSP is supported, including [VSCode](https://github.com/fwcd/vscode-kotlin) and [Atom](https://github.com/fwcd/atom-ide-kotlin).
 
 ## Getting Started
+
 * See [BUILDING.md](BUILDING.md) for build instructions
 * See [Editor Integration](EDITORS.md) for editor-specific instructions
 * See [Roadmap](https://github.com/fwcd/kotlin-language-server/projects/1) for features, planned additions, bugfixes and changes
@@ -19,6 +21,7 @@ Any editor conforming to LSP is supported, including [VSCode](https://github.com
 * See [tree-sitter-kotlin](https://github.com/fwcd/tree-sitter-kotlin) for an experimental [Tree-Sitter](https://tree-sitter.github.io/tree-sitter/) grammar
 
 ## This repository needs your help!
+
 [The original author](https://github.com/georgewfraser) created this project while he was considering using Kotlin in his work. He ended up deciding not to and is not really using Kotlin these days though this is a pretty fully-functional language server that just needs someone to use it every day for a while and iron out the last few pesky bugs.
 
 There are two hard parts of implementing a language server:
@@ -27,7 +30,23 @@ There are two hard parts of implementing a language server:
 
 The project uses the internal APIs of the [Kotlin compiler](https://github.com/JetBrains/kotlin/tree/master/compiler).
 
-Dependencies are determined by the [findClassPath](server/src/main/kotlin/org/javacs/kt/classpath/findClassPath.kt) function, which invokes Maven or Gradle and tells it to output a list of dependencies. Currently, both Maven and Gradle projects are supported.
+### Figuring out the dependencies
+
+Dependencies are determined by the [DefaultClassPathResolver.kt](shared/src/main/kotlin/org/javacs/kt/classpath/DefaultClassPathResolver.kt), which invokes Maven or Gradle to get a list of classpath JARs. Alternatively, projects can also 'manually' provide a list of dependencies through a shell script, located either at `[project root]/kotlinLspClasspath.{sh,bat,cmd}` or `[config root]/KotlinLanguageServer/classpath.{sh,bat,cmd}`, which outputs a list of JARs.
+
+* Example of the `~/.config/KotlinLanguageServer/classpath.sh` on Linux:
+```bash
+#!/bin/bash
+echo /my/path/kotlin-compiler-1.4.10/lib/kotlin-stdlib.jar:/my/path/my-lib.jar
+```
+
+* Example of the `%HOMEPATH%\.config\KotlinLanguageServer\classpath.bat` on Windows:
+```cmd
+@echo off
+echo C:\my\path\kotlin-compiler-1.4.10\lib\kotlin-stdlib.jar;C:\my\path\my-lib.jar
+```
+
+### Incrementally re-compiling as the user types
 
 I get incremental compilation at the file-level by keeping the same `KotlinCoreEnvironment` alive between compilations in [Compiler.kt](server/src/main/kotlin/org/javacs/kt/compiler/Compiler.kt). There is a performance benchmark in [OneFilePerformance.kt](server/src/test/kotlin/org/javacs/kt/OneFilePerformance.kt) that verifies this works.
 

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

@@ -6,7 +6,9 @@ import org.javacs.kt.compiler.Compiler
 import org.javacs.kt.storage.Storage
 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
 
 /**
@@ -19,9 +21,10 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
     private val buildScriptClassPath = mutableSetOf<Path>()
     val classPath = mutableSetOf<ClassPathEntry>()
     var storage: Storage? = null
+    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()
@@ -69,7 +72,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()
         }
 
@@ -140,6 +143,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
 
     override fun close() {
         compiler.close()
+        outputDirectory.delete()
     }
 }
 

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
 
@@ -112,7 +112,7 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
 
         folders.forEachIndexed { i, folder ->
             LOG.info("Adding workspace folder {}", folder.name)
-            val progressPrefix = "[${i + 1}/${folders.size}] ${folder.name}"
+            val progressPrefix = "[${i + 1}/${folders.size}] ${folder.name ?: ""}"
             val progressPercent = (100 * i) / folders.size
 
             progress?.update("$progressPrefix: Updating source path", progressPercent)
@@ -126,6 +126,7 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
                 sourcePath.refresh()
             }
         }
+        progress?.close()
 
         textDocuments.lintAll()
 

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
+    }
 }

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?>
 }

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()
         }
     }

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()

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()