PlatformConfigurator: create container for each platform (it contains static services, mostly checkers) ahead of time

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

@@ -18,7 +18,10 @@ 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.*
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.getValue
+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
@@ -30,6 +33,7 @@ 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.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.createContainer
 import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
@@ -41,7 +45,7 @@ fun createContainerForReplWithJava(
         declarationProviderFactory: DeclarationProviderFactory,
         moduleContentScope: GlobalSearchScope,
         packagePartProvider: PackagePartProvider
-): ContainerForReplWithJava = createContainer("ReplWithJava") {
+): ContainerForReplWithJava = createContainer("ReplWithJava", JvmPlatform) {
     useInstance(packagePartProvider)
     configureModule(moduleContext, JvmPlatform, bindingTrace)
     configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING, LanguageVersionSettingsImpl.DEFAULT)

compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.container
 
 import kotlin.reflect.KProperty
 
-fun createContainer(id: String, parent: StorageComponentContainer? = null, init: StorageComponentContainer.() -> Unit): StorageComponentContainer {
+fun composeContainer(id: String, parent: StorageComponentContainer? = null, init: StorageComponentContainer.() -> Unit): StorageComponentContainer {
     val c = StorageComponentContainer(id, parent)
     c.init()
     c.compose()

compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.container.tests
 
 import org.jetbrains.kotlin.container.*
-import org.junit.Ignore
 import org.junit.Test
 import javax.inject.Inject
 import kotlin.test.*
@@ -33,13 +32,13 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_to_null_when_empty() {
-        val container = createContainer("test") { }
+        val container = composeContainer("test") { }
         assertNull(container.resolve<TestComponentInterface>())
     }
 
     @Test
     fun should_resolve_to_instance_when_registered() {
-        val container = createContainer("test") { useImpl<TestComponent>() }
+        val container = composeContainer("test") { useImpl<TestComponent>() }
 
         val descriptor = container.resolve<TestComponentInterface>()
         assertNotNull(descriptor)
@@ -52,7 +51,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_instance_dependency() {
-        val container = createContainer("test") {
+        val container = composeContainer("test") {
             useInstance(ManualTestComponent("name"))
             useImpl<TestClientComponent>()
         }
@@ -74,7 +73,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_type_dependency() {
-        val container = createContainer("test") {
+        val container = composeContainer("test") {
             useImpl<TestComponent>()
             useImpl<TestClientComponent>()
         }
@@ -94,7 +93,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_multiple_types() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestComponent>()
             useImpl<TestClientComponent>()
             useImpl<TestClientComponent2>()
@@ -107,7 +106,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_singleton_types_to_same_instances() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestComponent>()
             useImpl<TestClientComponent>()
         }.use {
@@ -122,7 +121,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_adhoc_types_to_same_instances() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestAdhocComponent1>()
             useImpl<TestAdhocComponent2>()
         }.use {
@@ -138,7 +137,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_iterable() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestComponent>()
             useImpl<TestClientComponent>()
             useImpl<TestClientComponent2>()
@@ -155,7 +154,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_resolve_java_iterable() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestComponent>()
             useImpl<TestClientComponent>()
             useImpl<TestClientComponent2>()
@@ -175,7 +174,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_distinguish_generic() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestGenericClient>()
             useImpl<TestStringComponent>()
             useImpl<TestIntComponent>()
@@ -192,7 +191,7 @@ class ComponentContainerTest {
     @Ignore("Need generic type substitution")
     @Test
     fun should_resolve_generic_adhoc() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestImplicitGenericClient>()
         }.use {
             val descriptor = it.resolve<TestImplicitGenericClient>()
@@ -205,7 +204,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_fail_with_invalid_cardinality() {
-        createContainer("test") {
+        composeContainer("test") {
             useImpl<TestComponent>()
             useInstance(TestComponent())
         }.use {
@@ -228,7 +227,7 @@ class ComponentContainerTest {
 
     @Test
     fun should_inject_properties_of_singletons() {
-        val withSetters = createContainer("test") {
+        val withSetters = composeContainer("test") {
             useImpl<WithSetters>()
         }.get<WithSetters>()
 
@@ -238,7 +237,7 @@ class ComponentContainerTest {
     @Test
     fun should_not_inject_properties_of_instances() {
         val withSetters = WithSetters()
-        createContainer("test") {
+        composeContainer("test") {
             useInstance(withSetters)
         }
 
@@ -260,7 +259,7 @@ class ComponentContainerTest {
                 @Inject set
         }
 
-        val a = createContainer("test") {
+        val a = composeContainer("test") {
             useImpl<A>()
         }.get<A>()
 
@@ -275,11 +274,11 @@ class ComponentContainerTest {
         class A
         class B(val a: A)
 
-        val ac = createContainer("a") {
+        val ac = composeContainer("a") {
             useImpl<A>()
         }
 
-        val bc = createContainer("b", ac) {
+        val bc = composeContainer("b", ac) {
             useImpl<B>()
         }
         val b = bc.get<B>()
@@ -296,14 +295,14 @@ class ComponentContainerTest {
         class A
         class B(val a: A)
 
-        val ac = createContainer("a") {
+        val ac = composeContainer("a") {
             useImpl<A>()
         }
 
-        val bc1 = createContainer("b1", ac) {
+        val bc1 = composeContainer("b1", ac) {
             useImpl<B>()
         }
-        val bc2 = createContainer("b2", ac) {
+        val bc2 = composeContainer("b2", ac) {
             useImpl<B>()
         }
         val a = ac.get<A>()

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

@@ -87,7 +87,7 @@ fun createContainerForLazyResolveWithJava(
         targetEnvironment: TargetEnvironment = CompilerEnvironment,
         packagePartProvider: PackagePartProvider,
         languageVersionSettings: LanguageVersionSettings
-): ComponentProvider = createContainer("LazyResolveWithJava") {
+): ComponentProvider = createContainer("LazyResolveWithJava", JvmPlatform) {
     //TODO: idea specific code
     useInstance(packagePartProvider)
 
@@ -115,7 +115,7 @@ fun createContainerForTopDownAnalyzerForJvm(
         lookupTracker: LookupTracker,
         packagePartProvider: PackagePartProvider,
         languageVersionSettings: LanguageVersionSettings
-): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
+): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm", JvmPlatform) {
     useInstance(packagePartProvider)
 
     configureModule(moduleContext, JvmPlatform, bindingTrace)

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

@@ -76,9 +76,7 @@ object JvmPlatformConfigurator : PlatformConfigurator(
         overloadFilter = JvmOverloadFilter
 ) {
 
-    override fun configure(container: StorageComponentContainer) {
-        super.configure(container)
-
+    override fun configureModuleComponents(container: StorageComponentContainer) {
         container.useImpl<ReflectionAPICallChecker>()
         container.useImpl<JavaSyntheticScopes>()
         container.useInstance(JavaSyntheticConstructorsProvider)

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

@@ -41,7 +41,7 @@ fun StorageComponentContainer.configureModule(
 
     useInstance(platform)
 
-    platform.platformConfigurator.configure(this)
+    platform.platformConfigurator.configureModuleComponents(this)
 
     for (extension in StorageComponentContainerContributor.getInstances(moduleContext.project)) {
         extension.addDeclarations(this, platform)
@@ -67,7 +67,7 @@ fun createContainerForBodyResolve(
         platform: TargetPlatform,
         statementFilter: StatementFilter,
         languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("BodyResolve") {
+): StorageComponentContainer = createContainer("BodyResolve", platform) {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(statementFilter)
@@ -86,7 +86,7 @@ fun createContainerForLazyBodyResolve(
         platform: TargetPlatform,
         bodyResolveCache: BodyResolveCache,
         languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("LazyBodyResolve") {
+): StorageComponentContainer = createContainer("LazyBodyResolve", platform) {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(LookupTracker.DO_NOTHING)
@@ -105,7 +105,7 @@ fun createContainerForLazyLocalClassifierAnalyzer(
         lookupTracker: LookupTracker,
         languageVersionSettings: LanguageVersionSettings,
         localClassDescriptorHolder: LocalClassDescriptorHolder
-): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") {
+): StorageComponentContainer = createContainer("LocalClassifierAnalyzer", platform) {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(localClassDescriptorHolder)
@@ -132,7 +132,7 @@ fun createContainerForLazyResolve(
         platform: TargetPlatform,
         targetEnvironment: TargetEnvironment,
         languageVersionSettings: LanguageVersionSettings
-): StorageComponentContainer = createContainer("LazyResolve") {
+): StorageComponentContainer = createContainer("LazyResolve", platform) {
     configureModule(moduleContext, platform, bindingTrace)
 
     useInstance(declarationProviderFactory)

compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.resolve
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.composeContainer
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleParameters
@@ -45,8 +46,7 @@ abstract class TargetPlatform(
         override val platformConfigurator =
                 object : PlatformConfigurator(DynamicTypesSettings(), listOf(), listOf(), listOf(), listOf(), listOf(),
                                               IdentifierChecker.DEFAULT, OverloadFilter.DEFAULT) {
-                    override fun configure(container: StorageComponentContainer) {
-                        super.configure(container)
+                    override fun configureModuleComponents(container: StorageComponentContainer) {
                         container.useInstance(SyntheticScopes.Empty)
                         container.useInstance(SyntheticConstructorsProvider.Empty)
                         container.useInstance(TypeSpecificityComparator.NONE)
@@ -89,17 +89,17 @@ abstract class PlatformConfigurator(
     private val typeCheckers: List<AdditionalTypeChecker> = DEFAULT_TYPE_CHECKERS + additionalTypeCheckers
     private val classifierUsageCheckers: List<ClassifierUsageChecker> = DEFAULT_CLASSIFIER_USAGE_CHECKERS + additionalClassifierUsageCheckers
 
-    open fun configure(container: StorageComponentContainer) {
-        with (container) {
-            useInstance(dynamicTypesSettings)
-            declarationCheckers.forEach { useInstance(it) }
-            callCheckers.forEach { useInstance(it) }
-            typeCheckers.forEach { useInstance(it) }
-            classifierUsageCheckers.forEach { useInstance(it) }
-            additionalAnnotationCheckers.forEach { useInstance(it) }
-            useInstance(identifierChecker)
-            useInstance(overloadFilter)
-        }
+    abstract fun configureModuleComponents(container: StorageComponentContainer)
+
+    val platformSpecificContainer = composeContainer(this.javaClass.simpleName) {
+        useInstance(dynamicTypesSettings)
+        declarationCheckers.forEach { useInstance(it) }
+        callCheckers.forEach { useInstance(it) }
+        typeCheckers.forEach { useInstance(it) }
+        classifierUsageCheckers.forEach { useInstance(it) }
+        additionalAnnotationCheckers.forEach { useInstance(it) }
+        useInstance(identifierChecker)
+        useInstance(overloadFilter)
     }
 }
 
@@ -110,3 +110,7 @@ fun TargetPlatform.createModule(
         builtIns: KotlinBuiltIns,
         capabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap()
 ) = ModuleDescriptorImpl(name, storageManager, defaultModuleParameters, builtIns, capabilities)
+
+
+fun createContainer(id: String, platform: TargetPlatform, init: StorageComponentContainer.() -> Unit)
+        = composeContainer(id, platform.platformConfigurator.platformSpecificContainer, init)

compiler/tests-common/org/jetbrains/kotlin/tests/di/injection.kt

@@ -19,6 +19,11 @@ package org.jetbrains.kotlin.tests.di
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.container.*
+import org.jetbrains.kotlin.config.LanguageVersion
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.getValue
+import org.jetbrains.kotlin.container.useImpl
+import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.frontend.di.configureModule
@@ -26,12 +31,13 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.resolve.DescriptorResolver
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver
 import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.resolve.createContainer
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.FakeCallResolver
 
 fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
-    return ContainerForTests(createContainer("Tests") {
+    return ContainerForTests(createContainer("Tests", JvmPlatform) {
         configureModule(ModuleContext(module, project), JvmPlatform)
         useInstance(LookupTracker.DO_NOTHING)
         useInstance(LanguageVersionSettingsImpl.DEFAULT)

js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.frontend.js.di
 
 import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.container.createContainer
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.container.useImpl
 import org.jetbrains.kotlin.container.useInstance
@@ -28,6 +27,7 @@ import org.jetbrains.kotlin.js.resolve.JsPlatform
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.CompilerEnvironment
 import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.createContainer
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProviderImpl
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -38,7 +38,7 @@ fun createTopDownAnalyzerForJs(
         declarationProviderFactory: DeclarationProviderFactory,
         languageVersionSettings: LanguageVersionSettings
 ): LazyTopDownAnalyzerForTopLevel {
-    val storageComponentContainer = createContainer("TopDownAnalyzerForJs") {
+    val storageComponentContainer = createContainer("TopDownAnalyzerForJs", JsPlatform) {
         configureModule(moduleContext, JsPlatform, bindingTrace)
 
         useInstance(declarationProviderFactory)

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatformConfigurator.kt

@@ -39,9 +39,7 @@ object JsPlatformConfigurator : PlatformConfigurator(
         identifierChecker = IdentifierChecker.DEFAULT,
         overloadFilter = OverloadFilter.DEFAULT
 ) {
-    override fun configure(container: StorageComponentContainer) {
-        super.configure(container)
-
+    override fun configureModuleComponents(container: StorageComponentContainer) {
         container.useImpl<JsCallChecker>()
         container.useInstance(SyntheticScopes.Empty)
         container.useInstance(SyntheticConstructorsProvider.Empty)