Merge branch 'main' into GH-321

Author: themkat

.github/workflows/build.yml

@@ -1,18 +1,19 @@
 name: Build
-on: [push]
+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/CompiledFile.kt

@@ -2,15 +2,14 @@ package org.javacs.kt
 
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiIdentifier
 import org.javacs.kt.compiler.CompilationKind
 import org.javacs.kt.position.changedRegion
 import org.javacs.kt.position.position
 import org.javacs.kt.util.findParent
 import org.javacs.kt.util.nullResult
 import org.javacs.kt.util.toPath
-import org.jetbrains.kotlin.container.ComponentProvider
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
@@ -23,7 +22,7 @@ class CompiledFile(
     val content: String,
     val parse: KtFile,
     val compile: BindingContext,
-    val container: ComponentProvider,
+    val module: ModuleDescriptor,
     val sourcePath: Collection<KtFile>,
     val classPath: CompilerClassPath,
     val isScript: Boolean = false,
@@ -33,7 +32,7 @@ class CompiledFile(
      * Find the type of the expression at `cursor`
      */
     fun typeAtPoint(cursor: Int): KotlinType? {
-        var cursorExpr = parseAtPoint(cursor, asReference = true)?.findParent<KtExpression>() ?: return nullResult("Couldn't find expression at ${describePosition(cursor)}")
+        val cursorExpr = parseAtPoint(cursor, asReference = true)?.findParent<KtExpression>() ?: return nullResult("Couldn't find expression at ${describePosition(cursor)}")
         val surroundingExpr = expandForType(cursor, cursorExpr)
         val scope = scopeAtPoint(cursor) ?: return nullResult("Couldn't find scope at ${describePosition(cursor)}")
         return typeOfExpression(surroundingExpr, scope)
@@ -53,16 +52,33 @@ class CompiledFile(
         else return surroundingExpr
     }
 
+    /**
+     * Looks for a reference expression at the given cursor.
+     * This is currently used by many features in the language server.
+     * Unfortunately, it fails to find declarations for JDK symbols.
+     * [referenceExpressionAtPoint] provides an alternative implementation that can find JDK symbols.
+     * It cannot, however, replace this method at the moment.
+     * TODO: Investigate why this method doesn't find JDK symbols.
+     */
     fun referenceAtPoint(cursor: Int): Pair<KtExpression, DeclarationDescriptor>? {
         val element = parseAtPoint(cursor, asReference = true)
-        var cursorExpr = element?.findParent<KtExpression>() ?: return nullResult("Couldn't find expression at ${describePosition(cursor)} (only found $element)")
+        val cursorExpr = element?.findParent<KtExpression>() ?: return nullResult("Couldn't find expression at ${describePosition(cursor)} (only found $element)")
         val surroundingExpr = expandForReference(cursor, cursorExpr)
         val scope = scopeAtPoint(cursor) ?: return nullResult("Couldn't find scope at ${describePosition(cursor)}")
         val context = bindingContextOf(surroundingExpr, scope)
         LOG.info("Hovering {}", surroundingExpr)
         return referenceFromContext(cursor, context)
     }
 
+    /**
+     * Looks for a reference expression at the given cursor.
+     * This method is similar to [referenceAtPoint], but the latter fails to find declarations for JDK symbols.
+     * This method should not be used for anything other than finding definitions (at least for now).
+     */
+    fun referenceExpressionAtPoint(cursor: Int): Pair<KtExpression, DeclarationDescriptor>? {
+        return referenceFromContext(cursor, compile)
+    }
+
     private fun referenceFromContext(cursor: Int, context: BindingContext): Pair<KtExpression, DeclarationDescriptor>? {
         val targets = context.getSliceContents(BindingContext.REFERENCE_TARGET)
         return targets.asSequence()
@@ -203,9 +219,3 @@ class CompiledFile(
         return "$file ${start.line}:${start.character + 1}-${end.line + 1}:${end.character + 1}"
     }
 }
-
-private fun fileName(file: KtFile): String {
-    val parts = file.name.split('/')
-
-    return parts.last()
-}

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
 
 /**
@@ -18,8 +20,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 +71,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 +142,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
 
     override fun close() {
         compiler.close()
+        outputDirectory.delete()
     }
 }
 

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

@@ -31,8 +31,8 @@ public data class IndexingConfiguration(
 public data class ExternalSourcesConfiguration(
     /** Whether kls-URIs should be sent to the client to describe classes in JARs. */
     var useKlsScheme: Boolean = false,
-    /** Whether external classes classes should be automatically converted to Kotlin. */
-    var autoConvertToKotlin: Boolean = true
+    /** Whether external classes should be automatically converted to Kotlin. */
+    var autoConvertToKotlin: Boolean = false
 )
 
 public data class Configuration(

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

@@ -7,15 +7,13 @@ import org.eclipse.lsp4j.services.LanguageClient
 import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.services.LanguageServer
 import org.javacs.kt.command.ALL_COMMANDS
-import org.javacs.kt.externalsources.JarClassContentProvider
-import org.javacs.kt.externalsources.ClassPathSourceJarProvider
+import org.javacs.kt.externalsources.*
 import org.javacs.kt.util.AsyncExecutor
 import org.javacs.kt.util.TemporaryDirectory
 import org.javacs.kt.util.parseURI
 import org.javacs.kt.progress.Progress
 import org.javacs.kt.progress.LanguageClientProgress
 import org.javacs.kt.semantictokens.semanticTokensLegend
-import java.net.URI
 import java.io.Closeable
 import java.nio.file.Paths
 import java.util.concurrent.CompletableFuture
@@ -26,13 +24,13 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     val classPath = CompilerClassPath(config.compiler)
 
     private val tempDirectory = TemporaryDirectory()
-    private val uriContentProvider = URIContentProvider(JarClassContentProvider(config.externalSources, classPath, tempDirectory, ClassPathSourceJarProvider(classPath)))
+    private val uriContentProvider = URIContentProvider(ClassContentProvider(config.externalSources, classPath, tempDirectory, CompositeSourceArchiveProvider(JdkSourceArchiveProvider(classPath), ClassPathSourceArchiveProvider(classPath))))
     val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing)
     val sourceFiles = SourceFiles(sourcePath, uriContentProvider)
 
-    private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider)
+    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
 
@@ -110,7 +108,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)
@@ -124,6 +122,7 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
                 sourcePath.refresh()
             }
         }
+        progress?.close()
 
         textDocuments.lintAll()
 

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

@@ -1,21 +1,21 @@
 package org.javacs.kt
 
 import org.eclipse.lsp4j.*
-import org.javacs.kt.externalsources.JarClassContentProvider
-import org.javacs.kt.externalsources.toKlsURI
 import org.javacs.kt.util.AsyncExecutor
-import org.javacs.kt.util.noResult
 import org.javacs.kt.util.parseURI
-import java.net.URI
-import java.net.URISyntaxException
 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

@@ -8,7 +8,6 @@ import org.javacs.kt.codeaction.codeActions
 import org.javacs.kt.completion.*
 import org.javacs.kt.definition.goToDefinition
 import org.javacs.kt.diagnostic.convertDiagnostic
-import org.javacs.kt.externalsources.JarClassContentProvider
 import org.javacs.kt.formatting.formatKotlinCode
 import org.javacs.kt.hover.hoverAt
 import org.javacs.kt.position.offset
@@ -26,13 +25,11 @@ import org.javacs.kt.util.TemporaryDirectory
 import org.javacs.kt.util.parseURI
 import org.javacs.kt.util.describeURI
 import org.javacs.kt.util.describeURIs
-import org.javacs.kt.command.JAVA_TO_KOTLIN_COMMAND
 import org.javacs.kt.rename.renameSymbol
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import java.net.URI
 import java.io.Closeable
 import java.nio.file.Path
-import java.nio.file.Paths
 import java.time.Duration
 import java.util.concurrent.CompletableFuture
 
@@ -41,7 +38,8 @@ class KotlinTextDocumentService(
     private val sp: SourcePath,
     private val config: Configuration,
     private val tempDirectory: TemporaryDirectory,
-    private val uriContentProvider: URIContentProvider
+    private val uriContentProvider: URIContentProvider,
+    private val cp: CompilerClassPath
 ) : TextDocumentService, Closeable {
     private lateinit var client: LanguageClient
     private val async = AsyncExecutor()
@@ -93,7 +91,7 @@ class KotlinTextDocumentService(
 
     override fun codeAction(params: CodeActionParams): CompletableFuture<List<Either<Command, CodeAction>>> = async.compute {
         val (file, _) = recover(params.textDocument.uri, params.range.start, Recompile.NEVER)
-        codeActions(file, params.range, params.context)
+        codeActions(file, sp.index, params.range, params.context)
     }
 
     override fun hover(position: HoverParams): CompletableFuture<Hover?> = async.compute {
@@ -118,7 +116,7 @@ class KotlinTextDocumentService(
             LOG.info("Go-to-definition at {}", describePosition(position))
 
             val (file, cursor) = recover(position, Recompile.NEVER)
-            goToDefinition(file, cursor, uriContentProvider.jarClassContentProvider, tempDirectory, config.externalSources)
+            goToDefinition(file, cursor, uriContentProvider.classContentProvider, tempDirectory, config.externalSources, cp)
                 ?.let(::listOf)
                 ?.let { Either.forLeft<List<Location>, List<LocationLink>>(it) }
                 ?: noResult("Couldn't find definition at ${describePosition(position)}", Either.forLeft(emptyList()))
@@ -179,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 {
@@ -263,6 +264,7 @@ class KotlinTextDocumentService(
     fun lintAll() {
         debounceLint.submitImmediately {
             sp.compileAllFiles()
+            sp.saveAllFiles()
             sp.refreshDependencyIndexes()
         }
     }