Deduplicate code in container creation for JVM analysis

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/CliReplAnalyzerEngine.kt

@@ -20,12 +20,14 @@ import com.intellij.psi.search.ProjectScope
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.repl.di.createContainerForReplWithJava
+import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
@@ -54,12 +56,14 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
 
         scriptDeclarationFactory = ScriptMutableDeclarationProviderFactory()
 
-        val container = createContainerForReplWithJava(
+        val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
                 trace,
                 scriptDeclarationFactory,
                 ProjectScope.getAllScope(environment.project),
-                JvmPackagePartProvider(environment)
+                LookupTracker.DO_NOTHING,
+                JvmPackagePartProvider(environment),
+                LanguageVersionSettingsImpl.DEFAULT
         )
 
         this.resolveSession = container.get<ResolveSession>()

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt

@@ -1,57 +0,0 @@
-/*
- * Copyright 2010-2016 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.repl.di
-
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
-import org.jetbrains.kotlin.container.ComponentProvider
-import org.jetbrains.kotlin.container.useImpl
-import org.jetbrains.kotlin.container.useInstance
-import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
-import org.jetbrains.kotlin.frontend.di.configureModule
-import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis
-import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis
-import org.jetbrains.kotlin.frontend.java.di.javaAnalysisInit
-import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.CompilerEnvironment
-import org.jetbrains.kotlin.resolve.createContainer
-import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-
-fun createContainerForReplWithJava(
-        moduleContext: ModuleContext,
-        bindingTrace: BindingTrace,
-        declarationProviderFactory: DeclarationProviderFactory,
-        moduleContentScope: GlobalSearchScope,
-        packagePartProvider: PackagePartProvider
-): ComponentProvider = createContainer("ReplWithJava", JvmPlatform) {
-    useInstance(packagePartProvider)
-    configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, LanguageVersionSettingsImpl.DEFAULT)
-
-    useInstance(declarationProviderFactory)
-
-    CompilerEnvironment.configure(this)
-
-    useImpl<SingleModuleClassResolver>()
-}.apply {
-    javaAnalysisInit()
-    initJvmBuiltInsForTopDownAnalysis()
-}

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

@@ -30,7 +30,6 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer
 import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
 import org.jetbrains.kotlin.load.java.components.*
-import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
@@ -83,25 +82,25 @@ fun createContainerForLazyResolveWithJava(
         bindingTrace: BindingTrace,
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
-        moduleClassResolver: ModuleClassResolver,
-        targetEnvironment: TargetEnvironment = CompilerEnvironment,
+        registerModuleClassResolver: StorageComponentContainer.() -> Unit,
+        targetEnvironment: TargetEnvironment,
+        lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
-        languageVersionSettings: LanguageVersionSettings
-): ComponentProvider = createContainer("LazyResolveWithJava", JvmPlatform) {
-    //TODO: idea specific code
-    useInstance(packagePartProvider)
-
+        languageVersionSettings: LanguageVersionSettings,
+        useLazyResolve: Boolean
+): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) {
     configureModule(moduleContext, JvmPlatform, bindingTrace)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageVersionSettings)
 
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, languageVersionSettings)
-
-    useInstance(moduleClassResolver)
-
+    useInstance(packagePartProvider)
+    registerModuleClassResolver()
     useInstance(declarationProviderFactory)
 
     targetEnvironment.configure(this)
 
-    useImpl<LazyResolveToken>()
+    if (useLazyResolve) {
+        useImpl<LazyResolveToken>()
+    }
 }.apply {
     javaAnalysisInit()
 }
@@ -115,20 +114,11 @@ fun createContainerForTopDownAnalyzerForJvm(
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
         languageVersionSettings: LanguageVersionSettings
-): ComponentProvider = createContainer("TopDownAnalyzerForJvm", JvmPlatform) {
-    useInstance(packagePartProvider)
-
-    configureModule(moduleContext, JvmPlatform, bindingTrace)
-    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker, languageVersionSettings)
-
-    useInstance(declarationProviderFactory)
-
-    CompilerEnvironment.configure(this)
-
-    useImpl<SingleModuleClassResolver>()
-}.apply {
-    javaAnalysisInit()
-    initJvmBuiltInsForTopDownAnalysis()
+): ComponentProvider = createContainerForLazyResolveWithJava(
+        moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, { useImpl<SingleModuleClassResolver>() },
+        CompilerEnvironment, lookupTracker, packagePartProvider, languageVersionSettings, useLazyResolve = false
+).apply {
+    initJvmBuiltInsForTopDownAnalysis(moduleContext.module, languageVersionSettings)
 }
 
 fun StorageComponentContainer.javaAnalysisInit() {
@@ -138,7 +128,6 @@ fun StorageComponentContainer.javaAnalysisInit() {
 
 // 'initBuiltIns' body cannot be merged with 'javaAnalysisInit' because the latter is used in IDE,
 // where built-ins instances are shared between modules and manual initialization is necessary (to avoid multiple initialization)
-fun StorageComponentContainer.initJvmBuiltInsForTopDownAnalysis() {
-    get<JvmBuiltIns>().initialize(get<ModuleDescriptor>(),
-                                  get<LanguageVersionSettings>().supportsFeature(LanguageFeature.AdditionalBuiltInsMembers))
+fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis(module: ModuleDescriptor, languageVersionSettings: LanguageVersionSettings) {
+    get<JvmBuiltIns>().initialize(module, languageVersionSettings.supportsFeature(LanguageFeature.AdditionalBuiltInsMembers))
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -21,11 +21,13 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
+import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
@@ -83,10 +85,12 @@ object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
                 trace,
                 declarationProviderFactory,
                 moduleContentScope,
-                moduleClassResolver,
+                { useInstance(moduleClassResolver) },
                 targetEnvironment,
+                LookupTracker.DO_NOTHING,
                 packagePartProvider,
-                LanguageVersionSettingsImpl.DEFAULT // TODO: see KT-12410
+                LanguageVersionSettingsImpl.DEFAULT, // TODO: see KT-12410
+                useLazyResolve = true
         )
         val resolveSession = container.get<ResolveSession>()
         val javaDescriptorResolver = container.get<JavaDescriptorResolver>()

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/ModuleClassResolver.kt

@@ -16,11 +16,9 @@
 
 package org.jetbrains.kotlin.load.java.lazy
 
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import kotlin.properties.Delegates
 import javax.inject.Inject
 
 interface ModuleClassResolver {
@@ -28,12 +26,10 @@ interface ModuleClassResolver {
 }
 
 class SingleModuleClassResolver() : ModuleClassResolver {
-    override fun resolveClass(javaClass: JavaClass): ClassDescriptor? {
-        return resolver!!.resolveClass(javaClass)
-    }
+    override fun resolveClass(javaClass: JavaClass): ClassDescriptor? = resolver.resolveClass(javaClass)
 
     // component dependency cycle
-    var resolver: JavaDescriptorResolver? = null
+    lateinit var resolver: JavaDescriptorResolver
         @Inject set
 }