Basic resolve main-class command for use with run code lenses (and

more?)

Author: themkat

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

@@ -13,7 +13,8 @@ import java.nio.file.Path
  * and the compiler. Note that Kotlin sources are stored in SourcePath.
  */
 class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
-    private val workspaceRoots = mutableSetOf<Path>()
+    val workspaceRoots = mutableSetOf<Path>()
+
     private val javaSourcePath = mutableSetOf<Path>()
     private val buildScriptClassPath = mutableSetOf<Path>()
     val classPath = mutableSetOf<ClassPathEntry>()

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

@@ -8,11 +8,14 @@ import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.jsonrpc.messages.Either
 import org.javacs.kt.symbols.workspaceSymbols
 import org.javacs.kt.command.JAVA_TO_KOTLIN_COMMAND
+import org.javacs.kt.command.RESOLVE_MAIN
 import org.javacs.kt.j2k.convertJavaToKotlin
 import org.javacs.kt.KotlinTextDocumentService
 import org.javacs.kt.position.extractRange
 import org.javacs.kt.util.filePath
 import org.javacs.kt.util.parseURI
+import org.javacs.kt.util.AsyncExecutor
+import org.javacs.kt.resolve.resolveMain
 import java.net.URI
 import java.nio.file.Paths
 import java.util.concurrent.CompletableFuture
@@ -30,6 +33,8 @@ class KotlinWorkspaceService(
     private val gson = Gson()
     private var languageClient: LanguageClient? = null
 
+    private val async = AsyncExecutor()
+    
     override fun connect(client: LanguageClient): Unit {
         languageClient = client
     }
@@ -53,6 +58,26 @@ class KotlinWorkspaceService(
                     )
                 )))))
             }
+
+            RESOLVE_MAIN -> {
+                val fileUri = parseURI(gson.fromJson(args[0] as JsonElement, String::class.java))
+                val filePath = Paths.get(fileUri)
+
+                // we find the longest one in case both the root and submodule are included
+                val workspacePath = cp.workspaceRoots.filter {
+                    filePath.startsWith(it)
+                }.map {
+                    it.toString()
+                }.maxByOrNull(String::length) ?: ""
+                
+                val compiledFile = sp.currentVersion(fileUri)
+
+                return async.compute {
+                    resolveMain(compiledFile) + mapOf(
+                        "projectRoot" to workspacePath
+                    )
+                }
+            }
         }
 
         return CompletableFuture.completedFuture(null)

server/src/main/kotlin/org/javacs/kt/command/Commands.kt

@@ -1,6 +1,9 @@
 package org.javacs.kt.command
 
 const val JAVA_TO_KOTLIN_COMMAND = "convertJavaToKotlin"
+const val RESOLVE_MAIN = "resolveMain"
+
 val ALL_COMMANDS = listOf(
-	JAVA_TO_KOTLIN_COMMAND
+    JAVA_TO_KOTLIN_COMMAND,
+    RESOLVE_MAIN
 )

server/src/main/kotlin/org/javacs/kt/resolve/ResolveMain.kt

@@ -0,0 +1,36 @@
+package org.javacs.kt.resolve
+
+import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.javacs.kt.CompiledFile
+import org.javacs.kt.LOG
+import org.javacs.kt.position.range
+import org.javacs.kt.util.partitionAroundLast
+import com.intellij.openapi.util.TextRange
+
+
+fun resolveMain(file: CompiledFile): Map<String,Any> {
+    LOG.info("Resolving main function! yay")
+    
+    val parsedFile = file.parse.copy() as KtFile
+    val mainFunction = findTopLevelMainFunction(parsedFile)
+    if(null != mainFunction) {
+        // the KtFiles name is weird. Full path. This causes the class to have full path in name as well. Correcting to top level only
+        parsedFile.name = parsedFile.name.partitionAroundLast("/").second.substring(1)
+
+        return mapOf("mainClass" to JvmFileClassUtil.getFileClassInfoNoResolve(parsedFile).facadeClassFqName.asString(),
+                     "range" to range(file.content, mainFunction.second))
+    }
+    
+    return emptyMap()
+}
+
+// only one allowed (so invalid syntax files will not show any main methods)
+private fun findTopLevelMainFunction(file: KtFile): Pair<String?, TextRange>? = file.declarations.find {
+    // TODO: any validations on arguments
+    it is KtNamedFunction && "main" == it.name
+}?.let {
+    // TODO: any better things to return?
+    Pair(it.name, it.textRangeInParent)
+}

server/src/test/kotlin/org/javacs/kt/ResolveMainCommandTest.kt

@@ -0,0 +1,63 @@
+package org.javacs.kt
+
+import com.google.gson.Gson
+import org.eclipse.lsp4j.ExecuteCommandParams
+import org.eclipse.lsp4j.Position
+import org.eclipse.lsp4j.Range
+import org.junit.Test
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.javacs.kt.command.RESOLVE_MAIN
+
+class NoMainResolve : SingleFileTestFixture("resolvemain", "NoMain.kt") {
+    @Test
+    fun `Should not find any main class info`() {
+        val root = testResourcesRoot().resolve(workspaceRoot)
+        val executeCommandParams = ExecuteCommandParams(RESOLVE_MAIN, listOf(Gson().toJsonTree(root.resolve(file).toUri().toString(), )))
+        
+        val commandResult = languageServer.workspaceService.executeCommand(executeCommandParams).get()
+
+        assertNotNull(commandResult)
+        val mainInfo = commandResult as Map<String, String>
+        assertNull(mainInfo["mainClass"])
+        assertEquals(root.toString(), mainInfo["projectRoot"])
+    }
+}
+
+
+class SimpleMainResolve : SingleFileTestFixture("resolvemain", "Simple.kt") {
+    @Test
+    fun `Should resolve correct main class of simple file`() {
+        val root = testResourcesRoot().resolve(workspaceRoot)
+        val executeCommandParams = ExecuteCommandParams(RESOLVE_MAIN, listOf(Gson().toJsonTree(root.resolve(file).toUri().toString())))
+        
+        val commandResult = languageServer.workspaceService.executeCommand(executeCommandParams).get()
+
+        assertNotNull(commandResult)
+        val mainInfo = commandResult as Map<String, Any>
+        assertEquals("test.SimpleKt", mainInfo["mainClass"])
+        assertEquals(Range(Position(2, 0), Position(4, 1)), mainInfo["range"])
+        assertEquals(root.toString(), mainInfo["projectRoot"])
+    }
+}
+
+
+class JvmNameAnnotationMainResolve : SingleFileTestFixture("resolvemain", "JvmNameAnnotation.kt") {
+    @Test
+    fun `Should resolve correct main class of file annotated with JvmName`() {
+        val root = testResourcesRoot().resolve(workspaceRoot)
+        val executeCommandParams = ExecuteCommandParams(RESOLVE_MAIN, listOf(Gson().toJsonTree(root.resolve(file).toUri().toString())))
+        
+        val commandResult = languageServer.workspaceService.executeCommand(executeCommandParams).get()
+
+        assertNotNull(commandResult)
+        val mainInfo = commandResult as Map<String, Any>
+        assertEquals("com.mypackage.name.Potato", mainInfo["mainClass"])
+        assertEquals(Range(Position(5, 0), Position(7, 1)), mainInfo["range"])
+        assertEquals(root.toString(), mainInfo["projectRoot"])
+    }
+}
+
+
+// TODO: should we support inner companion object mains?

server/src/test/resources/resolvemain/JvmNameAnnotation.kt

@@ -0,0 +1,8 @@
+@JvmName("Potato")
+package com.mypackage.name
+
+val MY_CONSTANT = 1
+
+fun main(args: Array<String>) {
+	
+}

server/src/test/resources/resolvemain/NoMain.kt

@@ -0,0 +1,3 @@
+package no.main.found.hopefully
+
+fun multiplyByOne(num: Int) = num*1

server/src/test/resources/resolvemain/Simple.kt

@@ -0,0 +1,5 @@
+package test
+
+fun main() {
+	println("Hello!")
+}