[Injection] Make component containers composition more granular and flexible

Previously, containers set-up was performed by calls to static functions
like 'createContainerForLazyResolve', which would set-up whole container
from scratch.

This has several issues:
- complicates code re-use and encourages copy-paste of one and the same
set-up logic
- complicates composition of multiplatform containers (because each
set-up method relies on the fact that it should take an empty
container and compose it completely)

The idea of this commit is to split set-up methods into smaller ones,
with finer areas of responsibility, which allows to re-use them
in various scenarios (and, in particularly motivating composition
of multiplatform container)

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

@@ -24,9 +24,10 @@ import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.*
 import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.contracts.ContractDeserializerImpl
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.frontend.di.configureIncrementalCompilation
 import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder
@@ -44,7 +45,6 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformCompilerServices
 import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.types.SubstitutingScopeProviderImpl
 
@@ -66,21 +66,46 @@ fun createContainerForLazyResolveWithJava(
 ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatformCompilerServices) {
     configureModule(moduleContext, jvmPlatform, JvmPlatformCompilerServices, bindingTrace, languageVersionSettings)
 
+    configureIncrementalCompilation(lookupTracker, expectActualTracker)
+    configureStandardResolveComponents()
+
     useInstance(moduleContentScope)
-    useInstance(lookupTracker)
-    useInstance(expectActualTracker)
-    useImpl<ResolveSession>()
-    useImpl<LazyTopDownAnalyzer>()
+    useInstance(packagePartProvider)
+    useInstance(declarationProviderFactory)
+
+    useInstance(VirtualFileFinderFactory.getInstance(moduleContext.project).create(moduleContentScope))
+
+    configureJavaSpecificComponents(
+        moduleContext, moduleClassResolver, languageVersionSettings, configureJavaClassFinder,
+        javaClassTracker, useBuiltInsProvider
+    )
+
+    targetEnvironment.configure(this)
+
+}.apply {
+    initializeJavaSpecificComponents(bindingTrace)
+}
+
+fun StorageComponentContainer.initializeJavaSpecificComponents(bindingTrace: BindingTrace) {
+    get<AbstractJavaClassFinder>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
+}
+
+fun StorageComponentContainer.configureJavaSpecificComponents(
+    moduleContext: ModuleContext,
+    moduleClassResolver: ModuleClassResolver,
+    languageVersionSettings: LanguageVersionSettings,
+    configureJavaClassFinder: (StorageComponentContainer.() -> Unit)?,
+    javaClassTracker: JavaClassesTracker?,
+    useBuiltInsProvider: Boolean
+) {
     useImpl<JavaDescriptorResolver>()
     useImpl<DeserializationComponentsForJava>()
-    useInstance(VirtualFileFinderFactory.getInstance(moduleContext.project).create(moduleContentScope))
     useInstance(JavaPropertyInitializerEvaluatorImpl)
-    useImpl<AnnotationResolverImpl>()
     useImpl<SignaturePropagatorImpl>()
     useImpl<TraceBasedErrorReporter>()
     useInstance(InternalFlexibleTypeTransformer)
-    useImpl<CompilerDeserializationConfiguration>()
     useInstance(JavaDeprecationSettings)
+    useInstance(moduleClassResolver)
 
     if (configureJavaClassFinder != null) {
         configureJavaClassFinder()
@@ -90,10 +115,6 @@ fun createContainerForLazyResolveWithJava(
         useImpl<JavaSourceElementFactoryImpl>()
     }
 
-    useInstance(packagePartProvider)
-    useInstance(moduleClassResolver)
-    useInstance(declarationProviderFactory)
-
     useInstance(languageVersionSettings.getFlag(JvmAnalysisFlags.jsr305))
 
     if (useBuiltInsProvider) {
@@ -106,16 +127,10 @@ fun createContainerForLazyResolveWithJava(
         JavaResolverSettings.create(isReleaseCoroutines = languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines))
     )
 
-    targetEnvironment.configure(this)
-
-    useImpl<ContractDeserializerImpl>()
     useImpl<FilesByFacadeFqNameIndexer>()
     useImpl<SubstitutingScopeProviderImpl>()
-}.apply {
-    get<AbstractJavaClassFinder>().initialize(bindingTrace, get<KotlinCodeAnalyzer>())
 }
 
-
 fun ComponentProvider.initJvmBuiltInsForTopDownAnalysis() {
     get<JvmBuiltIns>().initialize(get<ModuleDescriptor>(), get<LanguageVersionSettings>())
 }