Merge branch 'main' of github.com:fwcd/kotlin-language-server into setup-jdt-ls-extension

Author: daplf

.github/workflows/build.yml

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

.github/workflows/deploy.yml

@@ -8,11 +8,12 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Setup JDK
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
-          java-version: 11
+          distribution: 'temurin'
+          java-version: '11'
       - name: Build distribution
         run: ./gradlew :server:distZip :grammars:distZip
       - name: Create release

.gitignore

@@ -1,23 +1,29 @@
+# General
+.DS_Store
+hs_err_*
+
+# Java/Eclipse/IDEA
 .settings
 .classpath
 .project
 .factorypath
 .gradle
-
 .idea
 *.iml
-
-lib-kotlin
 bin
 build
 target
 out
+
+# Python
 __pycache__
-*.vsix
 
+# Node.js
 node_modules
-.vscode-test
-
-.DS_Store
 
-hs_err_*
+# VSCode
+.vscode-test
+.vscode/*
+!.vscode/launch.json
+!.vscode/tasks.json
+*.vsix

CHANGELOG.md

@@ -3,6 +3,12 @@ All notable changes to the language server will be documented in this file.
 
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
+## [1.3.0]
+- Bump to Kotlin 1.6
+- Support JDK 17
+- Add incremental indexing
+- Improve logged Gradle errors
+
 ## [1.2.0]
 - Support for renaming
 - Improved semantic highlighting for enum members

gradle.properties

@@ -1,5 +1,5 @@
-projectVersion=1.3.0
-kotlinVersion=1.5.20
-exposedVersion=0.32.1
+projectVersion=1.4.0
+kotlinVersion=1.6.10
+exposedVersion=0.37.3
 lsp4jVersion=0.12.0
 javaVersion=11

server/build.gradle

@@ -46,7 +46,7 @@ dependencies {
     implementation "org.jetbrains.exposed:exposed-dao:$exposedVersion"
     implementation "org.jetbrains.exposed:exposed-jdbc:$exposedVersion"
     implementation 'com.h2database:h2:1.4.200'
-    implementation 'com.github.fwcd.ktfmt:ktfmt:8ef3ee752a'
+    implementation 'com.github.fwcd.ktfmt:ktfmt:b5d31d1'
     implementation 'com.beust:jcommander:1.78'
 
     testImplementation 'org.hamcrest:hamcrest-all:1.3'
@@ -72,7 +72,7 @@ applicationDistribution.into('bin') {
 
 tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
     kotlinOptions {
-        jvmTarget = "1.8"
+        jvmTarget = "11"
     }
 }
 

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

@@ -20,6 +20,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
     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, outputDirectory)
         private set

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,8 +7,7 @@ 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
@@ -25,11 +24,11 @@ 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, classPath)