javac-wrapper: refactoring, fixes and tests

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -242,7 +242,10 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                                       arguments: K2JVMCompilerArguments): Boolean {
         if (arguments.useJavac) {
             environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true)
-            return environment.registerJavac(compileJava = arguments.compileJava, arguments = arguments.javacArguments)
+            if (arguments.compileJava) {
+                environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true)
+            }
+            return environment.registerJavac(arguments = arguments.javacArguments)
         }
 
         return true

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -275,10 +275,11 @@ class KotlinCoreEnvironment private constructor(
     fun registerJavac(
             javaFiles: List<File> = allJavaFiles,
             kotlinFiles: List<KtFile> = sourceFiles,
-            compileJava: Boolean = false,
-            arguments: Array<String>? = null
+            arguments: Array<String>? = null,
+            bootClasspath: List<File>? = null,
+            sourcePath: List<File>? = null
     ): Boolean {
-        return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, compileJava, arguments)
+        return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments, bootClasspath, sourcePath, CliLightClassGenerationSupport(project))
     }
 
     private val applicationEnvironment: CoreApplicationEnvironment

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.kt

@@ -159,7 +159,7 @@ object KotlinToJVMBytecodeCompiler {
                 writeOutput(state.configuration, state.factory, null)
             }
 
-            if (projectConfiguration.getBoolean(JVMConfigurationKeys.USE_JAVAC)) {
+            if (projectConfiguration.getBoolean(JVMConfigurationKeys.COMPILE_JAVA)) {
                 val singleModule = chunk.singleOrNull()
                 if (singleModule != null) {
                     return JavacWrapper.getInstance(environment.project).use {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/JavacWrapperRegistrar.kt

@@ -20,6 +20,7 @@ import com.intellij.mock.MockProject
 import com.sun.tools.javac.util.Context
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_WARNING
+import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
@@ -36,8 +37,10 @@ object JavacWrapperRegistrar {
             configuration: CompilerConfiguration,
             javaFiles: List<File>,
             kotlinFiles: List<KtFile>,
-            compileJava: Boolean,
-            arguments: Array<String>?
+            arguments: Array<String>?,
+            bootClasspath: List<File>?,
+            sourcePath: List<File>?,
+            lightClassGenerationSupport: CliLightClassGenerationSupport
     ): Boolean {
         val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
 
@@ -54,8 +57,11 @@ object JavacWrapperRegistrar {
 
         val jvmClasspathRoots = configuration.jvmClasspathRoots
         val outputDirectory = configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)
+        val compileJava = configuration.getBoolean(JVMConfigurationKeys.COMPILE_JAVA)
+        val kotlinSupertypesResolver = KotlinSupertypeResolverImpl(lightClassGenerationSupport)
 
-        val javacWrapper = JavacWrapper(javaFiles, kotlinFiles, arguments, jvmClasspathRoots, compileJava, outputDirectory, context)
+        val javacWrapper = JavacWrapper(javaFiles, kotlinFiles, arguments, jvmClasspathRoots, bootClasspath, sourcePath,
+                                        kotlinSupertypesResolver, compileJava, outputDirectory, context)
 
         project.registerService(JavacWrapper::class.java, javacWrapper)
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/javac/KotlinSupertypeResolverImpl.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.javac
+
+import com.intellij.psi.PsiClass
+import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
+import org.jetbrains.kotlin.javac.KotlinSupertypeResolver
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.KtClassOrObject
+
+class KotlinSupertypeResolverImpl(private val lightClassGenerationSupport: CliLightClassGenerationSupport) : KotlinSupertypeResolver {
+
+    override fun resolveSupertypes(classOrObject: KtClassOrObject): List<ClassId> {
+        val lightClass = lightClassGenerationSupport.getLightClass(classOrObject) ?: return emptyList()
+
+        return lightClass.superTypes
+                .mapNotNull { it.resolve()?.computeClassId() }
+    }
+
+    private fun PsiClass.computeClassId(): ClassId? =
+            containingClass?.computeClassId()?.createNestedClassId(Name.identifier(name!!)) ?: qualifiedName?.let { ClassId.topLevel(FqName(it)) }
+
+}