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/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -36,6 +36,8 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.repl.di.ContainerForReplWithJava;
+import org.jetbrains.kotlin.cli.jvm.repl.di.DiPackage;
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories;
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler;
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade;
@@ -45,7 +47,6 @@ import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForReplWithJava;
 import org.jetbrains.kotlin.idea.JetLanguage;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.parsing.JetParserDefinition;
@@ -118,7 +119,7 @@ public class ReplInterpreter {
             }
         };
 
-        InjectorForReplWithJava injector = new InjectorForReplWithJava(
+        ContainerForReplWithJava container = DiPackage.createContainerForReplWithJava(
                 moduleContext,
                 trace,
                 scriptDeclarationFactory,
@@ -127,13 +128,13 @@ public class ReplInterpreter {
         );
 
         this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY);
-        this.topDownAnalyzer = injector.getLazyTopDownAnalyzerForTopLevel();
+        this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel();
-        this.resolveSession = injector.getResolveSession();
+        this.resolveSession = container.getResolveSession();
 
         moduleContext.initializeModuleContents(new CompositePackageFragmentProvider(
                 Arrays.asList(
-                        injector.getResolveSession().getPackageFragmentProvider(),
+                        container.getResolveSession().getPackageFragmentProvider(),
-                        injector.getJavaDescriptorResolver().getPackageFragmentProvider()
+                        container.getJavaDescriptorResolver().getPackageFragmentProvider()
                 )
         ));
 

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

@@ -0,0 +1,58 @@
+/*
+ * 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.cli.jvm.repl.di
+
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.container.*
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis
+import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+
+public fun createContainerForReplWithJava(
+        moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: ScopeProvider.AdditionalFileScopeProvider
+): ContainerForReplWithJava = createContainer("ReplWithJava") {
+    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
+
+
+    useInstance(additionalFileScopeProvider)
+    useInstance(declarationProviderFactory)
+
+    useImpl<ScopeProvider>()
+    useImpl<SingleModuleClassResolver>()
+}.let {
+    it.get<JavaClassFinderImpl>().initialize()
+    it.get<JavaClassFinderPostConstruct>().postCreate()
+    ContainerForReplWithJava(it)
+}
+
+public class ContainerForReplWithJava(container: StorageComponentContainer) {
+    val resolveSession: ResolveSession by container
+    val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container
+    val javaDescriptorResolver: JavaDescriptorResolver by container
+}

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.container.tests
 
+import org.jetbrains.kotlin.container.*
 import org.junit.Test
 import java.io.Closeable
 import javax.inject.Inject

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

@@ -0,0 +1,114 @@
+/*
+ * 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.java.di
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.container.*
+import org.jetbrains.kotlin.context.LazyResolveToken
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider
+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.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
+import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
+import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
+import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+
+public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) {
+    useInstance(moduleContentScope)
+
+    useImpl<ResolveSession>()
+
+    useImpl<LazyTopDownAnalyzer>()
+    useImpl<LazyTopDownAnalyzerForTopLevel>()
+    useImpl<JavaDescriptorResolver>()
+    useImpl<DeserializationComponentsForJava>()
+
+    useInstance(JvmVirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope))
+
+    useImpl<JavaClassFinderImpl>()
+    useImpl<TraceBasedExternalSignatureResolver>()
+    useImpl<LazyResolveBasedCache>()
+    useImpl<TraceBasedErrorReporter>()
+    useImpl<PsiBasedExternalAnnotationResolver>()
+    useImpl<JavaPropertyInitializerEvaluatorImpl>()
+    useInstance(SamConversionResolverImpl)
+    useImpl<JavaSourceElementFactoryImpl>()
+    useImpl<JavaLazyAnalyzerPostConstruct>()
+    useImpl<JavaFlexibleTypeCapabilitiesProvider>()
+}
+
+public fun createContainerForLazyResolveWithJava(
+        moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver
+): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
+    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
+
+    useInstance(moduleClassResolver)
+
+    useInstance(declarationProviderFactory)
+    useImpl<ScopeProvider>()
+    useImpl<LazyResolveToken>()
+}.let {
+    it.javaAnalysisInit()
+
+    Pair(it.get<ResolveSession>(), it.get<JavaDescriptorResolver>())
+}
+
+
+public fun createContainerForTopDownAnalyzerForJvm(
+        moduleContext: ModuleContext, bindingTrace: BindingTrace,
+        declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope
+): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
+    configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
+    configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
+    useInstance(declarationProviderFactory)
+
+    useImpl<SingleModuleClassResolver>()
+    useImpl<ScopeProvider>()
+}.let {
+    it.javaAnalysisInit()
+
+    ContainerForTopDownAnalyzerForJvm(it)
+}
+
+private fun StorageComponentContainer.javaAnalysisInit() {
+    get<JavaClassFinderImpl>().initialize()
+    get<JavaClassFinderPostConstruct>().postCreate()
+}
+
+public class ContainerForTopDownAnalyzerForJvm(container: StorageComponentContainer) {
+    val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container
+    val javaDescriptorResolver: JavaDescriptorResolver by container
+    val deserializationComponentsForJava: DeserializationComponentsForJava by container
+}

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

@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
+import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
 import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.psi.JetFile
@@ -66,7 +66,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
             resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
         }
-        val injector = InjectorForLazyResolveWithJava(
+        val (resolveSession, javaDescriptorResolver) = createContainerForLazyResolveWithJava(
                 moduleContext,
                 CodeAnalyzerInitializer.getInstance(project).createTrace(),
                 declarationProviderFactory,
@@ -74,8 +74,6 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
                 moduleClassResolver
         )
 
-        val resolveSession = injector.getResolveSession()!!
-        val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
         val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
         return JvmResolverForModule(resolveSession, CompositePackageFragmentProvider(providersForModule), javaDescriptorResolver)
     }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -28,7 +28,8 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
-import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm;
+import org.jetbrains.kotlin.frontend.java.di.ContainerForTopDownAnalyzerForJvm;
+import org.jetbrains.kotlin.frontend.java.di.DiPackage;
 import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvider;
@@ -121,49 +122,44 @@ public enum TopDownAnalyzerFacadeForJVM {
         FileBasedDeclarationProviderFactory providerFactory =
                 new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles);
 
-        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
+        ContainerForTopDownAnalyzerForJvm container = DiPackage.createContainerForTopDownAnalyzerForJvm(
                 moduleContext,
                 trace,
                 providerFactory,
                 GlobalSearchScope.allScope(project)
         );
 
-        try {
+        List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
-            List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
 
-            if (moduleIds != null && incrementalCacheProvider != null) {
+        if (moduleIds != null && incrementalCacheProvider != null) {
-                for (String moduleId : moduleIds) {
+            for (String moduleId : moduleIds) {
-                    IncrementalCache incrementalCache = incrementalCacheProvider.getIncrementalCache(moduleId);
+                IncrementalCache incrementalCache = incrementalCacheProvider.getIncrementalCache(moduleId);
 
-                    additionalProviders.add(
+                additionalProviders.add(
-                            new IncrementalPackageFragmentProvider(
+                        new IncrementalPackageFragmentProvider(
-                                    files, moduleContext.getModule(), moduleContext.getStorageManager(),
+                                files, moduleContext.getModule(), moduleContext.getStorageManager(),
-                                    injector.getDeserializationComponentsForJava().getComponents(),
+                                container.getDeserializationComponentsForJava().getComponents(),
-                                    incrementalCache, moduleId
+                                incrementalCache, moduleId
-                            )
+                        )
-                    );
+                );
-                }
             }
-            additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
-
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
-
-            BindingContext bindingContext = trace.getBindingContext();
-            ModuleDescriptor module = moduleContext.getModule();
-
-            Collection<AnalysisCompletedHandlerExtension> analysisCompletedHandlerExtensions =
-                    AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject());
-
-            for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) {
-                AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files);
-                if (result != null) return result;
-            }
-
-            return AnalysisResult.success(bindingContext, module);
         }
-        finally {
+        additionalProviders.add(container.getJavaDescriptorResolver().getPackageFragmentProvider());
-            injector.destroy();
+
+        container.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
+
+        BindingContext bindingContext = trace.getBindingContext();
+        ModuleDescriptor module = moduleContext.getModule();
+
+        Collection<AnalysisCompletedHandlerExtension> analysisCompletedHandlerExtensions =
+                AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject());
+
+        for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) {
+            AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files);
+            if (result != null) return result;
         }
+
+        return AnalysisResult.success(bindingContext, module);
     }
 
     @NotNull

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.resolve.BindingContext
-import org.jetbrains.kotlin.di.InjectorForMacros
+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)
+    val expressionTypingServices = createContainerForMacros(getProject(), module).expressionTypingServices
-    return injectorForMacros.getExpressionTypingServices()!!.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
+    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.container.get
-import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
+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

compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.di.InjectorForLazyResolve
+import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
@@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
 
         val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject())
 
-        val resolveSession = InjectorForLazyResolve(
+        val resolveSession = createLazyResolveSession(
                 context,
                 FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
+                KotlinJvmCheckerProvider, DynamicTypesSettings())
 
         context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
 

compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java

@@ -21,7 +21,6 @@ import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -31,6 +30,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
@@ -126,13 +127,13 @@ public class JetExpectedResolveDataUtil {
             JetType... parameterTypes
     ) {
         ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
-        InjectorForTests injector = new InjectorForTests(project, emptyModule);
+        ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
+                container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
                 DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
 
-        OverloadResolutionResults<FunctionDescriptor> functions = injector.getFakeCallResolver().resolveFakeCall(
+        OverloadResolutionResults<FunctionDescriptor> functions = container.getFakeCallResolver().resolveFakeCall(
                 context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes);
 
         for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {

compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt

@@ -16,24 +16,23 @@
 
 package org.jetbrains.kotlin.resolve.constraintSystem
 
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.diagnostics.rendering.Renderers
+import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.SPECIAL
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.TYPE_BOUND_POSITION
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.tests.di.createContainerForTests
-import org.jetbrains.kotlin.di.InjectorForTests
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.diagnostics.rendering.Renderers
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
 import org.jetbrains.kotlin.types.Variance
 import java.io.File
-import java.util.regex.Pattern
-import org.jetbrains.kotlin.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraintKind
-import org.jetbrains.kotlin.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraint
 import java.util.ArrayList
 import java.util.LinkedHashMap
-import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
+import java.util.regex.Pattern
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
 
 abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     private val typePattern = """([\w|<|>|\(|\)]+)"""
@@ -55,8 +54,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     override fun setUp() {
         super.setUp()
 
-        val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule())
+        _typeResolver = createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).typeResolver
-        _typeResolver = injector.getTypeResolver()!!
         _testDeclarations = analyzeDeclarations()
     }
 

compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
@@ -55,13 +55,13 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
         val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project)
         val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
 
-        val injector = InjectorForTopDownAnalyzerForJvm(
+        val container = createContainerForTopDownAnalyzerForJvm(
                 moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                 providerFactory, GlobalSearchScope.allScope(environment.project)
         )
-        moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider)
+        moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
 
-        val components = injector.getDeserializationComponentsForJava().components
+        val components = container.deserializationComponentsForJava.components
 
         val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId)
                               ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})")

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

@@ -0,0 +1,49 @@
+/*
+ * 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.tests.di
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.createContainer
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.container.useImpl
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.DescriptorResolver
+import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver
+import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+import org.jetbrains.kotlin.types.expressions.FakeCallResolver
+
+public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
+    return ContainerForTests(createContainer("Tests") {
+        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider)
+        useImpl<ExpressionTypingServices>()
+    })
+}
+
+class ContainerForTests(container: StorageComponentContainer) {
+    val descriptorResolver: DescriptorResolver by container
+    val functionDescriptorResolver: FunctionDescriptorResolver by container
+    val typeResolver: TypeResolver by container
+    val fakeCallResolver: FakeCallResolver by container
+    val expressionTypingServices: ExpressionTypingServices by container
+    val additionalCheckerProvider: AdditionalCheckerProvider by container
+}

compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java

@@ -23,8 +23,6 @@ import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -38,10 +36,13 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.kotlin.frontend.di.DiPackage.createLazyResolveSession;
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
 public class JetDefaultModalityModifiersTest extends JetLiteFixture {
@@ -71,9 +72,9 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         private JetScope scope;
 
         public void setUp() throws Exception {
-            InjectorForTests injector = new InjectorForTests(getProject(), root);
+            ContainerForTests containerForTests = DiPackage.createContainerForTests(getProject(), root);
-            descriptorResolver = injector.getDescriptorResolver();
+            descriptorResolver = containerForTests.getDescriptorResolver();
-            functionDescriptorResolver = injector.getFunctionDescriptorResolver();
+            functionDescriptorResolver = containerForTests.getFunctionDescriptorResolver();
             scope = createScope(KotlinBuiltIns.getInstance().getBuiltInsPackageScope());
         }
 
@@ -99,14 +100,14 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
             ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject());
-            ResolveSession resolveSession = new InjectorForLazyResolve(
+            ResolveSession resolveSession = createLazyResolveSession(
                     moduleContext,
                     new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
                                                             Collections.singleton(aClass.getContainingJetFile())),
                     new BindingTraceContext(),
                     AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
                     new DynamicTypesSettings()
-            ).getResolveSession();
+            );
 
             return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass);
         }

compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverloadUtil;
@@ -28,6 +27,8 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
@@ -44,8 +45,7 @@ public class JetOverloadTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
+        functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
-        functionDescriptorResolver = injector.getFunctionDescriptorResolver();
     }
 
     @Override

compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
@@ -28,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 
@@ -44,8 +44,7 @@ public class JetOverridingTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
+        functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
-        functionDescriptorResolver = injector.getFunctionDescriptorResolver();
     }
 
     @Override

compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetExpression;
@@ -40,6 +39,8 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 
@@ -72,9 +73,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        ContainerForTests container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
-        typeResolver = injector.getTypeResolver();
+        typeResolver = container.getTypeResolver();
-        expressionTypingServices = injector.getExpressionTypingServices();
+        expressionTypingServices = container.getExpressionTypingServices();
 
         scopeWithImports = getDeclarationsScope("compiler/testData/type-checker-test.kt");
     }

compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.name.FqName;
@@ -45,6 +44,8 @@ import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.*;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 
 import java.io.File;
 import java.io.IOException;
@@ -56,7 +57,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 @SuppressWarnings("unchecked")
 public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     private JetScope scope;
-    private InjectorForTests injector;
+    private ContainerForTests container;
 
     @Override
     protected KotlinCoreEnvironment createEnvironment() {
@@ -67,13 +68,13 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     protected void setUp() throws Exception {
         super.setUp();
 
-        injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
         scope = getContextScope();
     }
 
     @Override
     protected void tearDown() throws Exception {
-        injector = null;
+        container = null;
         scope = null;
         super.tearDown();
     }
@@ -140,7 +141,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
         JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr);
         AnalyzingUtils.checkForSyntacticErrors(jetTypeReference);
         BindingTrace trace = new BindingTraceContext();
-        JetType type = injector.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
+        JetType type = container.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
         if (!trace.getBindingContext().getDiagnostics().isEmpty()) {
             fail("Errors:\n" + StringUtil.join(
                     trace.getBindingContext().getDiagnostics(),

compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java

@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetTypeProjection;
 import org.jetbrains.kotlin.psi.JetTypeReference;
@@ -38,6 +37,8 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 
 import java.util.Map;
 import java.util.Set;
@@ -63,8 +64,7 @@ public class TypeUnifierTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        typeResolver = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).getTypeResolver();
-        typeResolver = injector.getTypeResolver();
         x = createTypeVariable("X");
         y = createTypeVariable("Y");
         variables = Sets.newHashSet(x.getTypeConstructor(), y.getTypeConstructor());

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -17,29 +17,53 @@
 package org.jetbrains.kotlin.load.kotlin.reflect
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.ReflectionTypes
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader
+import org.jetbrains.kotlin.load.java.components.*
+import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext
+import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
+import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
+import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder
+import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator
+import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl
+import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
+import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver
+import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
+import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
 import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
-public class RuntimeModuleData private constructor(private val injector: InjectorForRuntimeDescriptorLoader) {
+public class RuntimeModuleData private constructor(public val module: ModuleDescriptor, public val localClassResolver: LocalClassResolver) {
-    public val module: ModuleDescriptor get() = injector.getModuleDescriptor()
-
-    public val localClassResolver: LocalClassResolver get() = injector.getDeserializationComponentsForJava().components.localClassResolver
-
     companion object {
         public fun create(classLoader: ClassLoader): RuntimeModuleData {
             val storageManager = LockBasedStorageManager()
             val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), storageManager,
                                               ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE))
+
+            val reflectKotlinClassFinder = ReflectKotlinClassFinder(classLoader)
+            val deserializedDescriptorResolver = DeserializedDescriptorResolver(RuntimeErrorReporter)
+            val singleModuleClassResolver = SingleModuleClassResolver()
+            val globalJavaResolverContext = GlobalJavaResolverContext(
+                    storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
+                    ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,
+                    JavaPropertyInitializerEvaluator.DO_NOTHING, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver
+            )
+            val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module))
+            val javaDescriptorResolver = JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module)
+            val javaClassDataFinder = JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver)
+            val binaryClassAnnotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, reflectKotlinClassFinder, RuntimeErrorReporter)
+            val deserializationComponentsForJava = DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider)
+            singleModuleClassResolver.resolver = javaDescriptorResolver
+            deserializedDescriptorResolver.setComponents(deserializationComponentsForJava)
+
             module.setDependencies(module, KotlinBuiltIns.getInstance().getBuiltInsModule())
-            val injector = InjectorForRuntimeDescriptorLoader(classLoader, module, storageManager)
+            module.initialize(javaDescriptorResolver.packageFragmentProvider)
-            module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
+
-            return RuntimeModuleData(injector)
+            return RuntimeModuleData(module, deserializationComponentsForJava.components.localClassResolver)
         }
     }
 }

idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt

@@ -18,9 +18,8 @@ package org.jetbrains.kotlin.idea.util
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.imports.importableFqName
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
@@ -167,7 +166,7 @@ public class ShadowedDeclarationsFilter(
         val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, newCall, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
                                                         ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
                                                         CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
-        val callResolver = InjectorForMacros(project, moduleDescriptor).getCallResolver()
+        val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
         val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context)
         val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }.toSet()
         val filtered = descriptors.filter { it in resultingDescriptors }

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt

@@ -26,7 +26,8 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.di.InjectorForBodyResolve
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.frontend.di.createContainerForBodyResolve
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
@@ -369,11 +370,10 @@ public abstract class ElementResolver protected constructor(
 
     private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
         val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
-        val bodyResolve = InjectorForBodyResolve(
+        return createContainerForBodyResolve(
                 globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor()),
                 trace, getAdditionalCheckerProvider(file), statementFilter
-        )
+        ).get<BodyResolver>()
-        return bodyResolve.getBodyResolver()
     }
 
     private fun createEmptyContext(): BodyResolveContextForLazy {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.di.InjectorForLazyResolve
+import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
 import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
@@ -56,9 +56,9 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
                 project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
         )
 
-        val injector = InjectorForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(),
+        val resolveSession = createLazyResolveSession(
-                                              KotlinJsCheckerProvider, DynamicTypesAllowed())
+                moduleContext, declarationProviderFactory, BindingTraceContext(), KotlinJsCheckerProvider, DynamicTypesAllowed()
-        val resolveSession = injector.getResolveSession()!!
+        )
         var packageFragmentProvider = resolveSession.getPackageFragmentProvider()
 
         if (moduleInfo is LibraryInfo && KotlinJavaScriptLibraryDetectionUtil.isKotlinJavaScriptLibrary(moduleInfo.library)) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt

@@ -33,8 +33,9 @@ import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.context.withProject
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
+import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
+import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
 import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
 import org.jetbrains.kotlin.idea.project.TargetPlatform
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
@@ -232,14 +233,13 @@ private object KotlinResolveDataProvider {
             val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
             val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
             val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor())
-            val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
+            val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
                     moduleContext,
                     resolveSession,
-                    resolveSession.getScopeProvider(),
                     trace,
                     targetPlatform.getAdditionalCheckerProvider(),
                     targetPlatform.getDynamicTypesSettings()
-            ).getLazyTopDownAnalyzerForTopLevel()!!
+            ).get<LazyTopDownAnalyzerForTopLevel>()
 
             lazyTopDownAnalyzer.analyzeDeclarations(
                     TopDownAnalysisMode.TopLevelDeclarations,

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java

@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
+import org.jetbrains.kotlin.frontend.di.DiPackage;
 import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
@@ -250,12 +250,12 @@ public class JetSourceNavigationHelper {
                 getContainingFiles(candidates)
         );
 
-        ResolveSession resolveSession = new InjectorForLazyResolve(
+        ResolveSession resolveSession = DiPackage.createLazyResolveSession(
                 newModuleContext,
                 providerFactory,
                 new BindingTraceContext(),
                 AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
-                new DynamicTypesSettings()).getResolveSession();
+                new DynamicTypesSettings());
 
         newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
         return resolveSession;

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java

@@ -40,7 +40,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
+import org.jetbrains.kotlin.frontend.di.DiPackage;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
 import org.jetbrains.kotlin.resolve.BindingTraceContext;
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils;
 import org.jetbrains.kotlin.resolve.DescriptorUtils;
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.types.DynamicTypesSettings;
@@ -106,19 +107,19 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 FileBasedDeclarationProviderFactory declarationFactory =
                         new FileBasedDeclarationProviderFactory(newModuleContext.getStorageManager(), jetBuiltInsFiles);
 
-                InjectorForLazyResolve injectorForLazyResolve =
+                ResolveSession resolveSession =
-                        new InjectorForLazyResolve(
+                        DiPackage.createLazyResolveSession(
                                 newModuleContext,
                                 declarationFactory, new BindingTraceContext(),
                                 AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
                                 new DynamicTypesSettings()
                         );
 
-                newModuleContext.initializeModuleContents(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider());
+                newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
 
                 if (!ApplicationManager.getApplication().isUnitTestMode()) {
                     // Use lazy initialization in tests
-                    injectorForLazyResolve.getResolveSession().forceResolveAll();
+                    resolveSession.forceResolveAll();
                 }
 
                 PackageViewDescriptor packageView = newModuleContext.getModule().getPackage(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME);

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.completion
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.completion.smart.toList
 import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
@@ -158,10 +158,10 @@ class ExpectedInfos(
                                                         ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
                                                         CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
         val callResolutionContext = context.replaceCollectAllCandidates(true)
-        val callResolver = InjectorForMacros(
+        val callResolver = createContainerForMacros(
                 callElement.getProject(),
                 resolutionFacade.findModuleDescriptor(callElement)
-        ).getCallResolver()
+        ).callResolver
         val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
 
         val expectedInfos = HashSet<ExpectedInfo>()

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -97,11 +97,11 @@ public object HeuristicSignatures {
 
     private fun typeFromText(text: String, typeParameters: Collection<TypeParameterDescriptor>, moduleDescriptor: ModuleDescriptor, project: Project): JetType {
         val typeRef = JetPsiFactory(project).createType(text)
-        val injector = InjectorForMacros(project, moduleDescriptor)
+        val container = createContainerForMacros(project, moduleDescriptor)
         val rootPackagesScope = SubpackagesScope(moduleDescriptor, FqName.ROOT)
         val typeParametersScope = TypeParametersScope(typeParameters)
         val scope = ChainedScope(moduleDescriptor, "Root packages + type parameters", typeParametersScope, rootPackagesScope)
-        val type = injector.getTypeResolver().resolveType(scope, typeRef, BindingTraceContext(), false)
+        val type = container.typeResolver.resolveType(scope, typeRef, BindingTraceContext(), false)
         assert(!type.isError()) { "No type resolved from '$text'" }
         return type
     }

idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.core
 
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.util.FuzzyType
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -38,7 +38,7 @@ public class IterableTypesDetector(
         private val loopVarType: JetType? = null
 ) {
 
-    private val injector = InjectorForMacros(project, moduleDescriptor)
+    private val container = createContainerForMacros(project, moduleDescriptor)
     private val cache = HashMap<FuzzyType, Boolean>()
     private val iteratorName = Name.identifier("iterator")
 
@@ -57,9 +57,10 @@ public class IterableTypesDetector(
 
         val expression = JetPsiFactory(project).createExpression("fake")
         val expressionReceiver = ExpressionReceiver(expression, type.type)
-        val context = ExpressionTypingContext.newContext(injector.getExpressionTypingComponents().getAdditionalCheckerProvider(),
+        val expressionTypingComponents = container.expressionTypingComponents
+        val context = ExpressionTypingContext.newContext(expressionTypingComponents.getAdditionalCheckerProvider(),
                                                          BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
-        val elementType = injector.getExpressionTypingComponents().getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
+        val elementType = expressionTypingComponents.getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
         if (elementType == null) return false
         return loopVarType == null || FuzzyType(elementType, type.freeParameters).checkIsSubtypeOf(loopVarType) != null
     }

idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt

@@ -18,13 +18,11 @@ package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.codeInspection.ProblemHighlightType
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
 import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection
-import org.jetbrains.kotlin.idea.util.approximateFlexibleTypes
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.psiUtil.getTextWithLocation
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
@@ -70,8 +68,8 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe
                 TypeUtils.NO_EXPECTED_TYPE
             }
             val dataFlow = context.getDataFlowInfo(callExpression)
-            val injector = InjectorForMacros(callExpression.getProject(), callExpression.findModuleDescriptor())
+            val container = createContainerForMacros(callExpression.getProject(), callExpression.findModuleDescriptor())
-            val resolutionResults = injector.getCallResolver().resolveFunctionCall(
+            val resolutionResults = container.callResolver.resolveFunctionCall(
                     BindingTraceContext(), scope, untypedCall, expectedType, dataFlow, false)
             if (!resolutionResults.isSingleResult()) {
                 return false

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

@@ -0,0 +1,49 @@
+/*
+ * 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.js.di
+
+import org.jetbrains.kotlin.container.createContainer
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.container.useImpl
+import org.jetbrains.kotlin.container.useInstance
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.DynamicTypesAllowed
+
+public fun createTopDownAnalyzerForJs(
+        moduleContext: ModuleContext,
+        bindingTrace: BindingTrace,
+        declarationProviderFactory: DeclarationProviderFactory
+): LazyTopDownAnalyzerForTopLevel {
+    val storageComponentContainer = createContainer("TopDownAnalyzerForJs") {
+        configureModule(moduleContext, KotlinJsCheckerProvider, bindingTrace)
+
+        useInstance(declarationProviderFactory)
+        useImpl<ScopeProvider>()
+        useImpl<ResolveSession>()
+        useImpl<LazyTopDownAnalyzerForTopLevel>()
+        useImpl<DynamicTypesAllowed>()
+    }
+    return storageComponentContainer.get<LazyTopDownAnalyzerForTopLevel>()
+}
+

js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.context.MutableModuleContext;
 import org.jetbrains.kotlin.descriptors.ModuleParameters;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs;
+import org.jetbrains.kotlin.frontend.js.di.DiPackage;
 import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult;
 import org.jetbrains.kotlin.js.config.Config;
 import org.jetbrains.kotlin.name.Name;
@@ -95,17 +95,12 @@ public final class TopDownAnalyzerFacadeForJS {
     ) {
         Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
 
-        InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
+        LazyTopDownAnalyzerForTopLevel analyzerForJs = DiPackage.createTopDownAnalyzerForJs(
-                moduleContext, trace, new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles)
+                moduleContext, trace,
+                new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles)
         );
-        try {
+        analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.<PackageFragmentProvider>emptyList());
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files,
+        return JsAnalysisResult.success(trace, moduleContext.getModule());
-                                                                      Collections.<PackageFragmentProvider>emptyList());
-            return JsAnalysisResult.success(trace, moduleContext.getModule());
-        }
-        finally {
-            injector.destroy();
-        }
     }
 
     public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {