Working Java to Kotlin converter - fixes #24

Author: fwcd

build.gradle

@@ -59,6 +59,7 @@ dependencies {
 	kotlinJVMLib tc("$kotlinTeamCity/lib/kotlin-plugin.jar")
 
 	implementation fileTree(dir: "lib", include: ["*.jar"])
+	implementation fileTree(dir: "lib-kotlin", include: ["*.jar"])
 	testImplementation "org.hamcrest:hamcrest-all:1.3"
 	testImplementation "junit:junit:4.10"
 	testImplementation "org.openjdk.jmh:jmh-core:1.20"

lib/kotlin-converter.jar

@@ -1,15 +1,17 @@
 package org.javacs.kt
 
+import com.intellij.codeInsight.NullableNotNullManager
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.PsiFileFactory
+import com.intellij.mock.MockProject
 import org.jetbrains.kotlin.cli.common.script.CliScriptDefinitionProvider
 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.cli.jvm.config.JvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -35,6 +37,7 @@ import java.nio.file.Paths
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
 import org.javacs.kt.util.KotlinLSException
+import org.javacs.kt.util.KotlinNullableNotNullManager
 
 /**
  * Incrementally compiles files and expressions.
@@ -43,7 +46,7 @@ import org.javacs.kt.util.KotlinLSException
 class Compiler(classPath: Set<Path>) {
     private val config = CompilerConfiguration().apply {
         put(CommonConfigurationKeys.MODULE_NAME, JvmAbi.DEFAULT_MODULE_NAME)
-        addAll(JVMConfigurationKeys.CONTENT_ROOTS, classPath.map { JvmClasspathRoot(it.toFile())})
+        addJvmClasspathRoots(classPath.map { it.toFile() })
     }
     val environment: KotlinCoreEnvironment
 
@@ -54,6 +57,10 @@ class Compiler(classPath: Set<Path>) {
             configuration = config,
             configFiles = EnvironmentConfigFiles.JVM_CONFIG_FILES
         )
+        val project = environment.project
+        if (project is MockProject) {
+            project.registerService(NullableNotNullManager::class.java, KotlinNullableNotNullManager(project))
+        }
     }
 
     private val parser = KtPsiFactory(environment.project)

src/main/kotlin/org/javacs/kt/Compiler.kt

@@ -1,5 +1,6 @@
 package org.javacs.kt
 
+import com.intellij.openapi.project.Project
 import org.eclipse.lsp4j.*
 import org.eclipse.lsp4j.services.WorkspaceService
 import org.eclipse.lsp4j.services.LanguageClient
@@ -37,7 +38,7 @@ class KotlinWorkspaceService(
                 val range = gson.fromJson(args[1] as JsonElement, Range::class.java)
 
                 val selectedJavaCode = extractRange(sp.content(filePath), range)
-                val kotlinCode = convertJavaToKotlin(cp.compiler.environment, selectedJavaCode)
+                val kotlinCode = convertJavaToKotlin(selectedJavaCode, cp.compiler)
 
                 languageClient?.applyEdit(ApplyWorkspaceEditParams(WorkspaceEdit(listOf(TextDocumentEdit(
                     VersionedTextDocumentIdentifier().apply { uri = fileUri },

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

@@ -1,10 +1,17 @@
 package org.javacs.kt.j2k
 
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.j2k.JavaToKotlinTranslator
 import org.javacs.kt.LOG
+import org.javacs.kt.Compiler
+import org.javacs.kt.util.nonNull
 
-fun convertJavaToKotlin(environment: KotlinCoreEnvironment, javaCode: String): String {
-	LOG.info("Converting to Kotlin: $javaCode")
-	return JavaToKotlinTranslator.generateKotlinCode(javaCode, environment.project)
+fun convertJavaToKotlin(javaCode: String, compiler: Compiler): String {
+	val project = compiler.environment.project
+	LOG.info("Converting to Kotlin: $javaCode with project ${project}")
+
+	return JavaToKotlinTranslator.generateKotlinCode(
+		nonNull(javaCode, "No Java code has been provided to the J2K-converter"),
+		nonNull(project, "No project is present in the KotlinCoreEnvironment")
+	)
 }

src/main/kotlin/org/javacs/kt/j2k/javaToKotlinConverter.kt

@@ -0,0 +1,7 @@
+package org.javacs.kt.util
+
+public class KotlinLSException: RuntimeException {
+	constructor(msg: String) : super(msg) {}
+
+	constructor(msg: String, cause: Throwable) : super(msg, cause) {}
+}

src/main/kotlin/org/javacs/kt/util/KotlinLSException.kt

@@ -0,0 +1,30 @@
+/*
+ * Source: https://github.com/JetBrains/kotlin-netbeans/blob/master/src/main/java/org/jetbrains/kotlin/model/KotlinNullableNotNullManager.kt
+ * Licensed under http://www.apache.org/licenses/LICENSE-2.0
+ */
+package org.javacs.kt.util
+
+import com.intellij.openapi.project.Project
+import com.intellij.codeInsight.NullableNotNullManager
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiModifierListOwner
+
+class KotlinNullableNotNullManager(project: Project): NullableNotNullManager(project) {
+	init {
+		setNotNulls("NotNull")
+		setNullables("Nullable")
+	}
+
+	override fun hasHardcodedContracts(element: PsiElement) = false
+
+	override fun isNotNull(owner: PsiModifierListOwner, checkBases: Boolean): Boolean {
+		val notNullAnnotations = notNulls.toSet()
+		return owner.modifierList?.annotations?.any { annotation ->
+			annotation.qualifiedName in notNullAnnotations
+		} ?: false
+	}
+
+	override fun isNullable(owner: PsiModifierListOwner, checkBases: Boolean) = !isNotNull(owner, checkBases)
+
+	override fun getPredefinedNotNulls() = emptyList<String>()
+}

src/main/kotlin/org/javacs/kt/util/KotlinNullableNotNullManager.kt

@@ -64,12 +64,6 @@ fun <T> emptyResult(message: String): List<T> = noResult(message, emptyList())
 
 fun <T> nullResult(message: String): T? = noResult(message, null)
 
-public class KotlinLSException: RuntimeException {
-	constructor(msg: String) : super(msg) {}
-
-	constructor(msg: String, cause: Throwable) : super(msg, cause) {}
-}
-
 fun <T> firstNonNull(vararg optionals: () -> T?): T? {
     for (optional in optionals) {
         val result = optional()
@@ -80,6 +74,11 @@ fun <T> firstNonNull(vararg optionals: () -> T?): T? {
     return null
 }
 
+fun <T> nonNull(item: T?, errorMsgIfNull: String): T =
+    if (item == null) {
+        throw NullPointerException(errorMsgIfNull)
+    } else item
+
 fun <T> tryResolving(what: String, resolver: () -> T?): T? {
     try {
         val resolved = resolver()