Remove dependency of module 'frontend.java' on 'javac-wrapper'

This breaks the circular dependency between them

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

@@ -25,7 +25,9 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.builtins.JvmBuiltInsPackageFragmentProvider
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.container.ComponentProvider
+import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.context.ContextForNewModule
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContext
@@ -41,6 +43,9 @@ import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerFo
 import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
 import org.jetbrains.kotlin.frontend.java.di.initialize
 import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder
+import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory
+import org.jetbrains.kotlin.javac.components.StubJavaResolverCache
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass
@@ -144,7 +149,15 @@ object TopDownAnalyzerFacadeForJVM {
                 }
                 else null
 
-        val useJavac = configuration.getBoolean(JVMConfigurationKeys.USE_JAVAC)
+        fun StorageComponentContainer.useJavac() {
+            useImpl<JavacBasedClassFinder>()
+            useImpl<StubJavaResolverCache>()
+            useImpl<JavacBasedSourceElementFactory>()
+        }
+
+        val configureJavaClassFinder =
+                if (configuration.getBoolean(JVMConfigurationKeys.USE_JAVAC)) StorageComponentContainer::useJavac
+                else null
 
         val dependencyModule = if (separateModules) {
             val dependenciesContext = ContextForNewModule(
@@ -157,7 +170,7 @@ object TopDownAnalyzerFacadeForJVM {
 
             val dependenciesContainer = createContainerForTopDownAnalyzerForJvm(
                     dependenciesContext, trace, DeclarationProviderFactory.EMPTY, dependencyScope, lookupTracker,
-                    packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, languageVersionSettings, useJavac
+                    packagePartProvider(dependencyScope), moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder
             )
 
             StorageComponentContainerContributor.getInstances(project).forEach { it.onContainerComposed(dependenciesContainer, null) }
@@ -184,7 +197,7 @@ object TopDownAnalyzerFacadeForJVM {
         // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport
         val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker,
-                partProvider, moduleClassResolver, jvmTarget, languageVersionSettings, useJavac
+                partProvider, moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder
         ).apply {
             initJvmBuiltInsForTopDownAnalysis()
             (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get<DeserializationConfiguration>()

compiler/frontend.java/frontend.java.iml

@@ -11,6 +11,5 @@
     <orderEntry type="library" scope="PROVIDED" name="intellij-core" level="project" />
     <orderEntry type="module" module-name="descriptor.loader.java" exported="" />
     <orderEntry type="module" module-name="util" />
-    <orderEntry type="module" module-name="javac-wrapper" />
   </component>
 </module>

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -28,9 +28,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.frontend.di.configureModule
 import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder
+import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder
-import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory
-import org.jetbrains.kotlin.javac.components.StubJavaResolverCache
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.components.*
@@ -50,8 +48,7 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 private fun StorageComponentContainer.configureJavaTopDownAnalysis(
         moduleContentScope: GlobalSearchScope,
         project: Project,
-        lookupTracker: LookupTracker,
+        lookupTracker: LookupTracker
-        useJavac: Boolean
 ) {
     useInstance(moduleContentScope)
     useInstance(lookupTracker)
@@ -63,16 +60,6 @@ private fun StorageComponentContainer.configureJavaTopDownAnalysis(
 
     useInstance(VirtualFileFinderFactory.getInstance(project).create(moduleContentScope))
 
-    if (useJavac) {
-        useImpl<JavacBasedClassFinder>()
-        useImpl<StubJavaResolverCache>()
-        useImpl<JavacBasedSourceElementFactory>()
-    } else {
-        useImpl<JavaClassFinderImpl>()
-        useImpl<LazyResolveBasedCache>()
-        useImpl<JavaSourceElementFactoryImpl>()
-    }
-
     useImpl<JavaPropertyInitializerEvaluatorImpl>()
     useImpl<AnnotationResolverImpl>()
     useImpl<SignaturePropagatorImpl>()
@@ -97,10 +84,19 @@ fun createContainerForLazyResolveWithJava(
         jvmTarget: JvmTarget,
         languageVersionSettings: LanguageVersionSettings,
         useBuiltInsProvider: Boolean,
-        useJavac: Boolean = false
+        configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
     configureModule(moduleContext, JvmPlatform, jvmTarget, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, useJavac)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker)
+
+    if (configureJavaClassFinder != null) {
+        configureJavaClassFinder()
+    }
+    else {
+        useImpl<JavaClassFinderImpl>()
+        useImpl<LazyResolveBasedCache>()
+        useImpl<JavaSourceElementFactoryImpl>()
+    }
 
     useInstance(packagePartProvider)
     useInstance(moduleClassResolver)
@@ -115,10 +111,7 @@ fun createContainerForLazyResolveWithJava(
 
     targetEnvironment.configure(this)
 }.apply {
-    if (useJavac)
+    get<AbstractJavaClassFinder>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
-        get<JavacBasedClassFinder>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
-    else
-        get<JavaClassFinderImpl>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
 }
 
 
@@ -132,11 +125,11 @@ fun createContainerForTopDownAnalyzerForJvm(
         moduleClassResolver: ModuleClassResolver,
         jvmTarget: JvmTarget,
         languageVersionSettings: LanguageVersionSettings,
-        useJavac: Boolean = false
+        configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null
 ): ComponentProvider = createContainerForLazyResolveWithJava(
         moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver,
         CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, languageVersionSettings,
-        useBuiltInsProvider = true, useJavac = useJavac
+        useBuiltInsProvider = true, configureJavaClassFinder = configureJavaClassFinder
 )