Remove dependency of module 'javac-wrapper' on 'cli' and 'cli-common'

This breaks the circular dependency between them

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

@@ -73,6 +73,7 @@ import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.JvmRuntimeVersionsConsistencyChecker
 import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.cli.jvm.index.*
+import org.jetbrains.kotlin.cli.jvm.javac.JavacWrapperRegistrar
 import org.jetbrains.kotlin.cli.jvm.modules.CliJavaModuleFinder
 import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
@@ -83,7 +84,6 @@ import org.jetbrains.kotlin.extensions.DeclarationAttributeAltererExtension
 import org.jetbrains.kotlin.extensions.PreprocessedVirtualFileFactoryExtension
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.javac.JavacWrapperRegistrar
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
 import org.jetbrains.kotlin.load.kotlin.MetadataFinderFactory
 import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityManager
@@ -243,10 +243,12 @@ class KotlinCoreEnvironment private constructor(
                 .flatMap { it.javaFiles }
                 .map { File(it.canonicalPath) }
 
-    fun registerJavac(javaFiles: List<File> = allJavaFiles,
+    fun registerJavac(
-                      kotlinFiles: List<KtFile> = sourceFiles,
+            javaFiles: List<File> = allJavaFiles,
-                      arguments: Array<String>? = null): Boolean {
+            kotlinFiles: List<KtFile> = sourceFiles,
-        return JavacWrapperRegistrar.registerJavac(this, javaFiles, kotlinFiles, arguments)
+            arguments: Array<String>? = null
+    ): Boolean {
+        return JavacWrapperRegistrar.registerJavac(projectEnvironment.project, configuration, javaFiles, kotlinFiles, arguments)
     }
 
     private val applicationEnvironment: CoreApplicationEnvironment
@@ -381,9 +383,7 @@ class KotlinCoreEnvironment private constructor(
         }
     }
 
-    fun findLocalFile(path: String) = applicationEnvironment.localFileSystem.findFileByPath(path)
+    internal fun findLocalFile(path: String) = applicationEnvironment.localFileSystem.findFileByPath(path)
-
-    fun findJarFile(path: String) = applicationEnvironment.jarFileSystem.findFileByPath(path)
 
     private fun findLocalFile(root: JvmContentRoot): VirtualFile? {
         val path = root.file

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.javac
+package org.jetbrains.kotlin.cli.jvm.javac
 
 import com.sun.tools.javac.util.Context
 import com.sun.tools.javac.util.Log
@@ -24,10 +24,12 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import java.io.PrintWriter
 import java.io.Writer
 
-class JavacLogger(context: Context,
+class JavacLogger(
-               errorWriter: PrintWriter,
+        context: Context,
-               warningWriter: PrintWriter,
+        errorWriter: PrintWriter,
-               infoWriter: PrintWriter) : Log(context, errorWriter, warningWriter, infoWriter) {
+        warningWriter: PrintWriter,
+        infoWriter: PrintWriter
+) : Log(context, errorWriter, warningWriter, infoWriter) {
     init {
         context.put(Log.outKey, infoWriter)
     }
@@ -44,12 +46,12 @@ class JavacLogger(context: Context,
             })
         }
     }
-
 }
 
-private class MessageCollectorAdapter(private val messageCollector: MessageCollector,
+private class MessageCollectorAdapter(
-                                      private val severity: CompilerMessageSeverity) : Writer() {
+        private val messageCollector: MessageCollector,
-
+        private val severity: CompilerMessageSeverity
+) : Writer() {
     override fun write(buffer: CharArray, offset: Int, length: Int) {
         if (length == 1 && buffer[0] == '\n') return
 
@@ -61,5 +63,4 @@ private class MessageCollectorAdapter(private val messageCollector: MessageColle
     }
 
     override fun close() = flush()
-
+}
-}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.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.config.jvmClasspathRoots
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.javac.JavacWrapper
+import org.jetbrains.kotlin.psi.KtFile
+import java.io.File
+
+object JavacWrapperRegistrar {
+
+    private const val JAVAC_CONTEXT_CLASS = "com.sun.tools.javac.util.Context"
+
+    fun registerJavac(
+            project: MockProject,
+            configuration: CompilerConfiguration,
+            javaFiles: List<File>,
+            kotlinFiles: List<KtFile>,
+            arguments: Array<String>?
+    ): Boolean {
+        val messageCollector = configuration.getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY)
+
+        try {
+            Class.forName(JAVAC_CONTEXT_CLASS)
+        }
+        catch (e: ClassNotFoundException) {
+            messageCollector.report(STRONG_WARNING, "'$JAVAC_CONTEXT_CLASS' class can't be found ('tools.jar' is not found)")
+            return false
+        }
+
+        val context = Context()
+        JavacLogger.preRegister(context, messageCollector)
+
+        val jvmClasspathRoots = configuration.jvmClasspathRoots
+        val outputDirectory = configuration.get(JVMConfigurationKeys.OUTPUT_DIRECTORY)
+
+        val javacWrapper = JavacWrapper(javaFiles, kotlinFiles, arguments, jvmClasspathRoots, outputDirectory, context)
+
+        project.registerService(JavacWrapper::class.java, javacWrapper)
+
+        return true
+    }
+}

compiler/javac-wrapper/javac-wrapper.iml

@@ -23,7 +23,5 @@
     <orderEntry type="library" name="javax.inject" level="project" />
     <orderEntry type="module" module-name="frontend" />
     <orderEntry type="module" module-name="frontend.java" />
-    <orderEntry type="module" module-name="cli-common" />
-    <orderEntry type="module" module-name="cli" />
   </component>
 </module>

compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt

@@ -18,7 +18,9 @@ package org.jetbrains.kotlin.javac
 
 import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.StandardFileSystems
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.openapi.vfs.VirtualFileManager
 import com.intellij.psi.CommonClassNames
 import com.intellij.psi.search.EverythingGlobalScope
 import com.intellij.psi.search.GlobalSearchScope
@@ -35,29 +37,24 @@ import com.sun.tools.javac.model.JavacElements
 import com.sun.tools.javac.model.JavacTypes
 import com.sun.tools.javac.tree.JCTree
 import com.sun.tools.javac.util.Context
-import com.sun.tools.javac.util.List as JavacList
+import com.sun.tools.javac.util.Log
 import com.sun.tools.javac.util.Names
 import com.sun.tools.javac.util.Options
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedClass
 import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedClassifierType
 import org.jetbrains.kotlin.javac.wrappers.symbols.SymbolBasedPackage
-import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.isSubpackageOf
-import org.jetbrains.kotlin.name.parentOrNull
-import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.javac.wrappers.trees.TreeBasedClass
 import org.jetbrains.kotlin.javac.wrappers.trees.TreeBasedPackage
 import org.jetbrains.kotlin.javac.wrappers.trees.TreePathResolverCache
 import org.jetbrains.kotlin.javac.wrappers.trees.computeClassId
+import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaClassifier
 import org.jetbrains.kotlin.load.java.structure.JavaPackage
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.isSubpackageOf
+import org.jetbrains.kotlin.name.parentOrNull
+import org.jetbrains.kotlin.psi.KtFile
 import java.io.Closeable
 import java.io.File
 import javax.lang.model.element.Element
@@ -65,11 +62,18 @@ import javax.lang.model.type.TypeMirror
 import javax.tools.JavaFileManager
 import javax.tools.JavaFileObject
 import javax.tools.StandardLocation
+import com.sun.tools.javac.util.List as JavacList
 
-class JavacWrapper(javaFiles: Collection<File>,
+class JavacWrapper(
-                   kotlinFiles: Collection<KtFile>,
+        javaFiles: Collection<File>,
-                   arguments: Array<String>?,
+        kotlinFiles: Collection<KtFile>,
-                   private val environment: KotlinCoreEnvironment) : Closeable {
+        arguments: Array<String>?,
+        jvmClasspathRoots: List<File>,
+        private val outputDirectory: File?,
+        private val context: Context
+) : Closeable {
+    private val localFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL)!!
+    private val jarFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL)!!
 
     companion object {
         fun getInstance(project: Project): JavacWrapper = ServiceManager.getService(project, JavacWrapper::class.java)
@@ -92,12 +96,7 @@ class JavacWrapper(javaFiles: Collection<File>,
         createCommonClassifierType(CommonClassNames.JAVA_LANG_ANNOTATION_ANNOTATION)
     }
 
-    private val messageCollector = environment.configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]
-
-    private val context = Context()
-
     init {
-        messageCollector?.let { JavacLogger.preRegister(context, it) }
         arguments?.toList()?.let { JavacOptionsMapper.map(Options.instance(context), it) }
     }
 
@@ -110,7 +109,7 @@ class JavacWrapper(javaFiles: Collection<File>,
     init {
         // use rt.jar instead of lib/ct.sym
         fileManager.setSymbolFileEnabled(false)
-        fileManager.setLocation(StandardLocation.CLASS_PATH, environment.configuration.jvmClasspathRoots)
+        fileManager.setLocation(StandardLocation.CLASS_PATH, jvmClasspathRoots)
     }
 
     private val names = Names.instance(context)
@@ -155,9 +154,8 @@ class JavacWrapper(javaFiles: Collection<File>,
         if (javaFilesNumber == 0) return true
 
         fileManager.setClassPathForCompilation(outDir)
-        messageCollector?.report(CompilerMessageSeverity.INFO,
+        context.get(Log.outKey)?.println("Compiling $javaFilesNumber Java source files" +
-                                 "Compiling $javaFilesNumber Java source files" +
+                                         " to [${fileManager.getLocation(StandardLocation.CLASS_OUTPUT)?.firstOrNull()?.path}]")
-                                 " to [${fileManager.getLocation(StandardLocation.CLASS_OUTPUT)?.firstOrNull()?.path}]")
         compile(fileObjects)
         errorCount() == 0
     }
@@ -251,10 +249,10 @@ class JavacWrapper(javaFiles: Collection<File>,
     fun toVirtualFile(javaFileObject: JavaFileObject): VirtualFile? =
             javaFileObject.toUri().let { uri ->
                 if (uri.scheme == "jar") {
-                    environment.findJarFile(uri.schemeSpecificPart.substring("file:".length))
+                    jarFileSystem.findFileByPath(uri.schemeSpecificPart.substring("file:".length))
                 }
                 else {
-                    environment.findLocalFile(uri.schemeSpecificPart)
+                    localFileSystem.findFileByPath(uri.schemeSpecificPart)
                 }
             }
 
@@ -283,7 +281,7 @@ class JavacWrapper(javaFiles: Collection<File>,
     }
 
     private fun JavacFileManager.setClassPathForCompilation(outDir: File?) = apply {
-        (outDir ?: environment.configuration[JVMConfigurationKeys.OUTPUT_DIRECTORY])?.let { outputDir ->
+        (outDir ?: outputDirectory)?.let { outputDir ->
             outputDir.mkdirs()
             fileManager.setLocation(StandardLocation.CLASS_OUTPUT, listOf(outputDir))
         }

compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapperRegistrar.kt

@@ -1,49 +0,0 @@
-/*
- * 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.javac
-
-import com.intellij.mock.MockProject
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
-import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.psi.KtFile
-import java.io.File
-
-object JavacWrapperRegistrar {
-
-    private const val JAVAC_CONTEXT_CLASS = "com.sun.tools.javac.util.Context"
-
-    fun registerJavac(environment: KotlinCoreEnvironment,
-                      javaFiles: List<File>,
-                      kotlinFiles: List<KtFile>,
-                      arguments: Array<String>?): Boolean {
-        try {
-            Class.forName(JAVAC_CONTEXT_CLASS)
-        } catch (e: ClassNotFoundException) {
-            environment.configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY]
-                    ?.report(CompilerMessageSeverity.STRONG_WARNING,
-                             "'$JAVAC_CONTEXT_CLASS' class can't be found ('tools.jar' is not found). ")
-            return false
-        }
-
-        (environment.project as MockProject).registerService(JavacWrapper::class.java,
-                                                             JavacWrapper(javaFiles, kotlinFiles, arguments, environment))
-
-        return true
-    }
-
-}