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

This breaks the circular dependency between them
2017-06-02 17:18:49 +03:00
parent 1273ac9647
commit f6c263b54d
6 changed files with 108 additions and 97 deletions
@@ -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,
-                      kotlinFiles: List<KtFile> = sourceFiles,
-                      arguments: Array<String>? = null): Boolean {
-        return JavacWrapperRegistrar.registerJavac(this, javaFiles, kotlinFiles, arguments)
+    fun registerJavac(
+            javaFiles: List<File> = allJavaFiles,
+            kotlinFiles: List<KtFile> = sourceFiles,
+            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)
-
-    fun findJarFile(path: String) = applicationEnvironment.jarFileSystem.findFileByPath(path)
+    internal fun findLocalFile(path: String) = applicationEnvironment.localFileSystem.findFileByPath(path)

    private fun findLocalFile(root: JvmContentRoot): VirtualFile? {
        val path = root.file
@@ -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,
-               errorWriter: PrintWriter,
-               warningWriter: PrintWriter,
-               infoWriter: PrintWriter) : Log(context, errorWriter, warningWriter, infoWriter) {
+class JavacLogger(
+        context: Context,
+        errorWriter: PrintWriter,
+        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 val severity: CompilerMessageSeverity) : Writer() {
-
+private class MessageCollectorAdapter(
+        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()
-
-}
+}
@@ -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
+    }
+}
@@ -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>
@@ -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>,
-                   kotlinFiles: Collection<KtFile>,
-                   arguments: Array<String>?,
-                   private val environment: KotlinCoreEnvironment) : Closeable {
+class JavacWrapper(
+        javaFiles: Collection<File>,
+        kotlinFiles: Collection<KtFile>,
+        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,
-                                 "Compiling $javaFilesNumber Java source files" +
-                                 " to [${fileManager.getLocation(StandardLocation.CLASS_OUTPUT)?.firstOrNull()?.path}]")
+        context.get(Log.outKey)?.println("Compiling $javaFilesNumber Java source files" +
+                                         " 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))
        }
@@ -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
-    }
-
-}