Convert usages of existing generated injectors to dynamic injectors

Rewrite RuntimeModuleData to use hand-written code as we do not pack container module into runtime
This change introduces some overhead (up to 10% for the tests I ran) in some scenarios in IDE, that should be addressed later

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt

@@ -16,18 +16,18 @@
 
 package org.jetbrains.kotlin.analyzer
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.psi.JetExpression
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.resolve.BindingContext
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.resolve.BindingTrace
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo
 
 public fun JetExpression.computeTypeInfoInContext(
@@ -37,8 +37,8 @@ public fun JetExpression.computeTypeInfoInContext(
         expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
         module: ModuleDescriptor = scope.getModule()
 ): JetTypeInfo {
-    val injectorForMacros = InjectorForMacros(getProject(), module)
-    return injectorForMacros.getExpressionTypingServices()!!.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
+    val expressionTypingServices = createContainerForMacros(getProject(), module).expressionTypingServices
+    return expressionTypingServices.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
 }
 
 public fun JetExpression.analyzeInContext(

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

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2010-2015 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.frontend.di
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.container.*
+import org.jetbrains.kotlin.context.LazyResolveToken
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.CallResolver
+import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+import org.jetbrains.kotlin.types.expressions.*
+
+public fun StorageComponentContainer.configureModule(
+        moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider
+) {
+    useInstance(moduleContext)
+    useInstance(moduleContext.module)
+    useInstance(moduleContext.project)
+    useInstance(moduleContext.storageManager)
+    useInstance(moduleContext.builtIns)
+    useInstance(moduleContext.platformToKotlinClassMap)
+    useInstance(additionalCheckerProvider)
+    useInstance(additionalCheckerProvider.symbolUsageValidator)
+}
+
+public fun StorageComponentContainer.configureModule(
+        moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider, trace: BindingTrace
+) {
+    configureModule(moduleContext, additionalCheckerProvider)
+    useInstance(trace)
+}
+
+public fun createContainerForBodyResolve(
+        moduleContext: ModuleContext, bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter
+): StorageComponentContainer = createContainer("BodyResolve") {
+    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+
+    useInstance(statementFilter)
+    useImpl<BodyResolver>()
+}
+
+public fun createContainerForLazyBodyResolve(
+        moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
+        bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider,
+        dynamicTypesSettings: DynamicTypesSettings
+): StorageComponentContainer = createContainer("LazyBodyResolve") {
+    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+
+    useInstance(kotlinCodeAnalyzer)
+    useInstance(kotlinCodeAnalyzer.getScopeProvider())
+    useInstance(dynamicTypesSettings)
+    useImpl<LazyTopDownAnalyzerForTopLevel>()
+}
+
+public fun createContainerForLazyLocalClassifierAnalyzer(
+        moduleContext: ModuleContext,
+        bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider,
+        dynamicTypesSettings: DynamicTypesSettings,
+        localClassDescriptorHolder: LocalClassDescriptorHolder
+): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") {
+    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+
+    useInstance(dynamicTypesSettings)
+    useInstance(localClassDescriptorHolder)
+
+    useImpl<LazyTopDownAnalyzer>()
+
+    useInstance(NoTopLevelDescriptorProvider)
+    useInstance(NoFileScopeProvider)
+
+    useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
+    useImpl<LocalLazyDeclarationResolver>()
+}
+
+private fun createContainerForLazyResolve(
+        moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+): StorageComponentContainer = createContainer("LazyResolve") {
+    configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
+
+    useInstance(dynamicTypesSettings)
+    useInstance(declarationProviderFactory)
+
+    useImpl<LazyResolveToken>()
+    useImpl<ResolveSession>()
+}
+
+public fun createLazyResolveSession(
+        moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+): ResolveSession = createContainerForLazyResolve(
+        moduleContext, declarationProviderFactory, bindingTrace, additionalCheckerProvider, dynamicTypesSettings
+).get<ResolveSession>()
+
+public fun createContainerForMacros(project: Project, module: ModuleDescriptor): ContainerForMacros {
+    val componentContainer = createContainer("Macros") {
+        configureModule(ModuleContext(module, project), AdditionalCheckerProvider.DefaultProvider)
+        useImpl<ExpressionTypingServices>()
+    }
+    return ContainerForMacros(componentContainer)
+}
+
+public class ContainerForMacros(container: StorageComponentContainer) {
+    val callResolver: CallResolver by container
+    val typeResolver: TypeResolver by container
+    val expressionTypingComponents: ExpressionTypingComponents by container
+    val expressionTypingServices: ExpressionTypingServices by container
+}

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.frontend.di.createContainerForLazyLocalClassifierAnalyzer
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.debugText.getDebugText
@@ -64,7 +64,7 @@ public class LocalClassifierAnalyzer(
     ) {
         val module = DescriptorUtils.getContainingModule(containingDeclaration)
         val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module)
-        val injector = InjectorForLazyLocalClassifierAnalyzer(
+        val container = createContainerForLazyLocalClassifierAnalyzer(
                 moduleContext,
                 context.trace,
                 additionalCheckerProvider,
@@ -83,7 +83,7 @@ public class LocalClassifierAnalyzer(
                 )
         )
 
-        injector.getLazyTopDownAnalyzer().analyzeDeclarations(
+        container.get<LazyTopDownAnalyzer>().analyzeDeclarations(
                 TopDownAnalysisMode.LocalDeclarations,
                 listOf(classOrObject),
                 context.dataFlowInfo