~ bug

(cherry picked from commit 2d78be1)

.idea/artifacts/KotlinPlugin.xml

@@ -42,6 +42,7 @@
           <element id="module-output" name="serialization" />
           <element id="module-output" name="idea-completion" />
           <element id="module-output" name="idea-core" />
+          <element id="module-output" name="container" />
         </element>
         <element id="library" level="project" name="javax.inject" />
         <element id="directory" name="jps">

.idea/modules.xml

@@ -17,6 +17,7 @@
       <module fileurl="file://$PROJECT_DIR$/compiler/cli/cli.iml" filepath="$PROJECT_DIR$/compiler/cli/cli.iml" group="compiler/cli" />
       <module fileurl="file://$PROJECT_DIR$/compiler/cli/cli-common/cli-common.iml" filepath="$PROJECT_DIR$/compiler/cli/cli-common/cli-common.iml" group="compiler/cli" />
       <module fileurl="file://$PROJECT_DIR$/compiler/tests/compiler-tests.iml" filepath="$PROJECT_DIR$/compiler/tests/compiler-tests.iml" group="compiler" />
+      <module fileurl="file://$PROJECT_DIR$/core/container/container.iml" filepath="$PROJECT_DIR$/core/container/container.iml" />
       <module fileurl="file://$PROJECT_DIR$/core/descriptor.loader.java/descriptor.loader.java.iml" filepath="$PROJECT_DIR$/core/descriptor.loader.java/descriptor.loader.java.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/core/descriptors/descriptors.iml" filepath="$PROJECT_DIR$/core/descriptors/descriptors.iml" group="core" />
       <module fileurl="file://$PROJECT_DIR$/core/descriptors.runtime/descriptors.runtime.iml" filepath="$PROJECT_DIR$/core/descriptors.runtime/descriptors.runtime.iml" group="core" />

build.xml

@@ -81,6 +81,7 @@
         <include name="core/descriptors/src"/>
         <include name="core/deserialization/src"/>
         <include name="core/util.runtime/src"/>
+        <include name="core/container/src"/>
         <include name="compiler/backend/src"/>
         <include name="compiler/backend-common/src"/>
         <include name="compiler/builtins-serializer/src"/>
@@ -804,6 +805,7 @@
                 <include name="core/descriptors.runtime/src"/>
                 <include name="core/deserialization/src"/>
                 <include name="core/util.runtime/src"/>
+                <include name="core/container/src"/>
             </src>
             <class-path>
                 <pathelement path="${output}/classes/builtins"/>

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -48,7 +48,8 @@ import org.jetbrains.kotlin.context.GlobalContextImpl;
 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.frontend.java.di.ContainerForReplWithJava;
+import org.jetbrains.kotlin.frontend.java.di.DiPackage;
 import org.jetbrains.kotlin.idea.JetLanguage;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.parsing.JetParserDefinition;
@@ -129,7 +130,7 @@ public class ReplInterpreter {
             }
         };
 
-        InjectorForReplWithJava injector = new InjectorForReplWithJava(
+        ContainerForReplWithJava injector = DiPackage.createContainerForReplWithJava(
                 project,
                 topDownAnalysisParameters,
                 trace,

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

@@ -0,0 +1,59 @@
+/*
+ * 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.context.GlobalContext
+import org.jetbrains.kotlin.context.LazyResolveToken
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.get
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+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 createContainerForLazyResolveWithJava(
+        project: Project, globalContext: GlobalContext, bindingTrace: BindingTrace,
+        module: ModuleDescriptorImpl, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope,  moduleClassResolver: ModuleClassResolver
+): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("REPL") { //TODO: name
+    configureModule(project, globalContext, module, bindingTrace, KotlinJvmCheckerProvider)
+    configureJavaTopDownAnalysis(moduleContentScope, project)
+
+    useInstance(moduleClassResolver)
+
+    useInstance(declarationProviderFactory)
+    useImpl<ScopeProvider>()
+    useImpl<LazyResolveToken>()
+}.let {
+    it.get<JavaClassFinderImpl>().initialize()
+    it.get<JavaClassFinderPostConstruct>().postCreate()
+
+    Pair(it.get<ResolveSession>(), it.get<JavaDescriptorResolver>())
+}
+
+

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

@@ -0,0 +1,94 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.di.*
+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.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.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
+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 createContainerForReplWithJava(
+        project: Project, globalContext: GlobalContext, bindingTrace: BindingTrace,
+        module: ModuleDescriptorImpl, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: ScopeProvider.AdditionalFileScopeProvider
+): ContainerForReplWithJava = createContainer("REPL") { //TODO: name
+    configureModule(project, globalContext, module, bindingTrace, KotlinJvmCheckerProvider)
+    configureJavaTopDownAnalysis(moduleContentScope, project)
+
+
+    useInstance(additionalFileScopeProvider)
+    useInstance(declarationProviderFactory)
+
+    useImpl<ScopeProvider>()
+    useImpl<SingleModuleClassResolver>()
+}.let {
+    it.get<JavaClassFinderImpl>().initialize()
+    it.get<JavaClassFinderPostConstruct>().postCreate()
+    ContainerForReplWithJava(it)
+}
+
+private fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) {
+    useInstance(moduleContentScope)
+
+    useImpl<ResolveSession>()
+
+    useImpl<LazyTopDownAnalyzer>()
+    useImpl<LazyTopDownAnalyzerForTopLevel>()
+    useImpl<JavaDescriptorResolver>()
+    useImpl<DeserializationComponentsForJava>()
+
+    useInstance(VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope))
+
+    useImpl<JavaClassFinderImpl>()
+    useImpl<TraceBasedExternalSignatureResolver>()
+    useImpl<LazyResolveBasedCache>()
+    useImpl<TraceBasedErrorReporter>()
+    useImpl<PsiBasedMethodSignatureChecker>()
+    useImpl<PsiBasedExternalAnnotationResolver>()
+    useImpl<JavaPropertyInitializerEvaluatorImpl>()
+    useInstance(SamConversionResolverImpl)
+    useImpl<JavaSourceElementFactoryImpl>()
+    useImpl<JavaLazyAnalyzerPostConstruct>()
+    useImpl<JavaFlexibleTypeCapabilitiesProvider>()
+}
+
+public class ContainerForReplWithJava(container: StorageComponentContainer) {
+    val resolveSession: ResolveSession by injected(container)
+    val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by injected(container)
+    val javaDescriptorResolver: JavaDescriptorResolver by injected(container)
+}

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

@@ -0,0 +1,60 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.di.*
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
+import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
+import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
+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.ScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+
+public fun createContainerForTopDownAnalyzerForJvm(
+        project: Project, globalContext: GlobalContext, bindingTrace: BindingTrace,
+        module: ModuleDescriptorImpl, declarationProviderFactory: DeclarationProviderFactory,
+        moduleContentScope: GlobalSearchScope
+): ContainerForTopDownAnalyzerForJvm = createContainer("REPL") { //TODO: name
+    configureModule(project, globalContext, module, bindingTrace, KotlinJvmCheckerProvider)
+    configureJavaTopDownAnalysis(moduleContentScope, project)
+    useInstance(declarationProviderFactory)
+
+    useImpl<SingleModuleClassResolver>()
+    useImpl<ScopeProvider>()
+}.let {
+    it.get<JavaClassFinderImpl>().initialize()
+    it.get<JavaClassFinderPostConstruct>().postCreate()
+
+    ContainerForTopDownAnalyzerForJvm(it)
+}
+
+public class ContainerForTopDownAnalyzerForJvm(container: StorageComponentContainer) {
+    val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by injected(container)
+    val javaDescriptorResolver: JavaDescriptorResolver by injected(container)
+    val deserializationComponentsForJava: DeserializationComponentsForJava by injected(container)
+}
+

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForLazyResolveWithJava.java

@@ -1,349 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import com.intellij.psi.search.GlobalSearchScope;
-import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver;
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
-import org.jetbrains.kotlin.load.java.JavaClassFinderImpl;
-import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver;
-import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache;
-import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter;
-import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker;
-import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver;
-import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
-import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
-import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
-import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.LazyResolveToken;
-import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
-import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
-import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
-import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder;
-import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForLazyResolveWithJava {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final ResolveSession resolveSession;
-    private final ScopeProvider scopeProvider;
-    private final GlobalSearchScope moduleContentScope;
-    private final ModuleClassResolver moduleClassResolver;
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private final VirtualFileFinder virtualFileFinder;
-    private final JavaClassFinderImpl javaClassFinder;
-    private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
-    private final LazyResolveBasedCache lazyResolveBasedCache;
-    private final TraceBasedErrorReporter traceBasedErrorReporter;
-    private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
-    private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
-    private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
-    private final SamConversionResolverImpl samConversionResolver;
-    private final JavaSourceElementFactoryImpl javaSourceElementFactory;
-    private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
-    private final LazyResolveToken lazyResolveToken;
-    private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
-    private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
-    private final GlobalJavaResolverContext globalJavaResolverContext;
-    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final DeserializationComponentsForJava deserializationComponentsForJava;
-    private final JavaClassDataFinder javaClassDataFinder;
-    private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
-
-    public InjectorForLazyResolveWithJava(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
-        @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull GlobalSearchScope moduleContentScope,
-        @NotNull ModuleClassResolver moduleClassResolver
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.moduleContentScope = moduleContentScope;
-        this.moduleClassResolver = moduleClassResolver;
-        this.javaClassFinder = new JavaClassFinderImpl();
-        this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
-        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter);
-        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
-        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
-        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
-        this.lazyResolveBasedCache = new LazyResolveBasedCache();
-        this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
-        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
-        this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, moduleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
-        this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
-        this.lazyResolveToken = new LazyResolveToken();
-        this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
-        this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
-        this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-        this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
-
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
-
-        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
-        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
-
-        javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
-        javaClassFinder.setProject(project);
-        javaClassFinder.setScope(moduleContentScope);
-
-        traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        traceBasedExternalSignatureResolver.setProject(project);
-        traceBasedExternalSignatureResolver.setTrace(bindingTrace);
-
-        lazyResolveBasedCache.setSession(resolveSession);
-
-        traceBasedErrorReporter.setTrace(bindingTrace);
-
-        psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-
-        javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession);
-        javaLazyAnalyzerPostConstruct.setProject(project);
-        javaLazyAnalyzerPostConstruct.setTrace(bindingTrace);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        jetImportsFactory.setProject(project);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
-
-        javaClassFinder.initialize();
-
-        javaLazyAnalyzerPostConstruct.postCreate();
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ModuleDescriptorImpl getModule() {
-        return this.module;
-    }
-
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
-    public JavaDescriptorResolver getJavaDescriptorResolver() {
-        return this.javaDescriptorResolver;
-    }
-
-}

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java

@@ -1,438 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import com.intellij.psi.search.GlobalSearchScope;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
-import org.jetbrains.kotlin.load.java.JavaClassFinderImpl;
-import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver;
-import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache;
-import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter;
-import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker;
-import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver;
-import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
-import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
-import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
-import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
-import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
-import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
-import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
-import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder;
-import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForReplWithJava {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final ResolveSession resolveSession;
-    private final ScopeProvider scopeProvider;
-    private final GlobalSearchScope moduleContentScope;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
-    private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private final DeserializationComponentsForJava deserializationComponentsForJava;
-    private final VirtualFileFinder virtualFileFinder;
-    private final JavaClassFinderImpl javaClassFinder;
-    private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
-    private final LazyResolveBasedCache lazyResolveBasedCache;
-    private final TraceBasedErrorReporter traceBasedErrorReporter;
-    private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
-    private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
-    private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
-    private final SamConversionResolverImpl samConversionResolver;
-    private final JavaSourceElementFactoryImpl javaSourceElementFactory;
-    private final SingleModuleClassResolver singleModuleClassResolver;
-    private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
-    private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
-    private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final TypeLazinessToken typeLazinessToken;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final BodyResolver bodyResolver;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final DeclarationResolver declarationResolver;
-    private final OverloadResolver overloadResolver;
-    private final OverrideResolver overrideResolver;
-    private final VarianceChecker varianceChecker;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
-    private final GlobalJavaResolverContext globalJavaResolverContext;
-    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final JavaClassDataFinder javaClassDataFinder;
-    private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
-
-    public InjectorForReplWithJava(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
-        @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull GlobalSearchScope moduleContentScope,
-        @NotNull AdditionalFileScopeProvider additionalFileScopeProvider
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.moduleContentScope = moduleContentScope;
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
-        this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
-        this.javaClassFinder = new JavaClassFinderImpl();
-        this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
-        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter);
-        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
-        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
-        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
-        this.lazyResolveBasedCache = new LazyResolveBasedCache();
-        this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
-        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
-        this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
-        this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
-        this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
-        this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
-        this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
-        this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
-        this.additionalFileScopeProvider = additionalFileScopeProvider;
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.bodyResolver = new BodyResolver();
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.declarationResolver = new DeclarationResolver();
-        this.overloadResolver = new OverloadResolver();
-        this.overrideResolver = new OverrideResolver();
-        this.varianceChecker = new VarianceChecker(bindingTrace);
-
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
-
-        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
-        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
-
-        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
-        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
-        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
-        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
-        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
-        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
-
-        this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
-        this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
-
-        javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
-        javaClassFinder.setProject(project);
-        javaClassFinder.setScope(moduleContentScope);
-
-        traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        traceBasedExternalSignatureResolver.setProject(project);
-        traceBasedExternalSignatureResolver.setTrace(bindingTrace);
-
-        lazyResolveBasedCache.setSession(resolveSession);
-
-        traceBasedErrorReporter.setTrace(bindingTrace);
-
-        psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-
-        singleModuleClassResolver.setResolver(javaDescriptorResolver);
-
-        javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession);
-        javaLazyAnalyzerPostConstruct.setProject(project);
-        javaLazyAnalyzerPostConstruct.setTrace(bindingTrace);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        jetImportsFactory.setProject(project);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        bodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-        bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setTrace(bindingTrace);
-
-        overloadResolver.setTrace(bindingTrace);
-
-        overrideResolver.setTrace(bindingTrace);
-
-        deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
-
-        javaClassFinder.initialize();
-
-        javaLazyAnalyzerPostConstruct.postCreate();
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ModuleDescriptorImpl getModule() {
-        return this.module;
-    }
-
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
-    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
-        return this.lazyTopDownAnalyzer;
-    }
-
-    public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
-        return this.lazyTopDownAnalyzerForTopLevel;
-    }
-
-    public JavaDescriptorResolver getJavaDescriptorResolver() {
-        return this.javaDescriptorResolver;
-    }
-
-    public DeserializationComponentsForJava getDeserializationComponentsForJava() {
-        return this.deserializationComponentsForJava;
-    }
-
-}

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java

@@ -1,437 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import com.intellij.psi.search.GlobalSearchScope;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder;
-import org.jetbrains.kotlin.load.java.JavaClassFinderImpl;
-import org.jetbrains.kotlin.load.java.components.TraceBasedExternalSignatureResolver;
-import org.jetbrains.kotlin.load.java.components.LazyResolveBasedCache;
-import org.jetbrains.kotlin.load.java.components.TraceBasedErrorReporter;
-import org.jetbrains.kotlin.load.java.components.PsiBasedMethodSignatureChecker;
-import org.jetbrains.kotlin.load.java.components.PsiBasedExternalAnnotationResolver;
-import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
-import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl;
-import org.jetbrains.kotlin.load.java.components.JavaSourceElementFactoryImpl;
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
-import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct;
-import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
-import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
-import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
-import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder;
-import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForTopDownAnalyzerForJvm {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final ResolveSession resolveSession;
-    private final ScopeProvider scopeProvider;
-    private final GlobalSearchScope moduleContentScope;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
-    private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private final DeserializationComponentsForJava deserializationComponentsForJava;
-    private final VirtualFileFinder virtualFileFinder;
-    private final JavaClassFinderImpl javaClassFinder;
-    private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
-    private final LazyResolveBasedCache lazyResolveBasedCache;
-    private final TraceBasedErrorReporter traceBasedErrorReporter;
-    private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
-    private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
-    private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
-    private final SamConversionResolverImpl samConversionResolver;
-    private final JavaSourceElementFactoryImpl javaSourceElementFactory;
-    private final SingleModuleClassResolver singleModuleClassResolver;
-    private final JavaLazyAnalyzerPostConstruct javaLazyAnalyzerPostConstruct;
-    private final JavaFlexibleTypeCapabilitiesProvider javaFlexibleTypeCapabilitiesProvider;
-    private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final TypeLazinessToken typeLazinessToken;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final BodyResolver bodyResolver;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final DeclarationResolver declarationResolver;
-    private final OverloadResolver overloadResolver;
-    private final OverrideResolver overrideResolver;
-    private final VarianceChecker varianceChecker;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
-    private final GlobalJavaResolverContext globalJavaResolverContext;
-    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final JavaClassDataFinder javaClassDataFinder;
-    private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
-
-    public InjectorForTopDownAnalyzerForJvm(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
-        @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull GlobalSearchScope moduleContentScope
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.moduleContentScope = moduleContentScope;
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
-        this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
-        this.javaClassFinder = new JavaClassFinderImpl();
-        this.virtualFileFinder = org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope);
-        this.traceBasedErrorReporter = new TraceBasedErrorReporter();
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(traceBasedErrorReporter);
-        this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
-        this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
-        this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
-        this.lazyResolveBasedCache = new LazyResolveBasedCache();
-        this.javaPropertyInitializerEvaluator = new JavaPropertyInitializerEvaluatorImpl();
-        this.samConversionResolver = SamConversionResolverImpl.INSTANCE$;
-        this.javaSourceElementFactory = new JavaSourceElementFactoryImpl();
-        this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, samConversionResolver, javaSourceElementFactory, singleModuleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModule());
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModule(), reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModule());
-        this.javaClassDataFinder = new JavaClassDataFinder(virtualFileFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModule(), storageManager, virtualFileFinder, traceBasedErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(storageManager, getModule(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
-        this.javaLazyAnalyzerPostConstruct = new JavaLazyAnalyzerPostConstruct();
-        this.javaFlexibleTypeCapabilitiesProvider = new JavaFlexibleTypeCapabilitiesProvider();
-        this.kotlinJvmCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
-        this.symbolUsageValidator = kotlinJvmCheckerProvider.getSymbolUsageValidator();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), javaFlexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.valueParameterResolver = new ValueParameterResolver(kotlinJvmCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-        this.bodyResolver = new BodyResolver();
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.declarationResolver = new DeclarationResolver();
-        this.overloadResolver = new OverloadResolver();
-        this.overrideResolver = new OverrideResolver();
-        this.varianceChecker = new VarianceChecker(bindingTrace);
-
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
-
-        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
-        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
-
-        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
-        this.lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
-        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
-        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
-        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
-        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
-
-        this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
-        this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
-
-        javaClassFinder.setComponentPostConstruct(javaLazyAnalyzerPostConstruct);
-        javaClassFinder.setProject(project);
-        javaClassFinder.setScope(moduleContentScope);
-
-        traceBasedExternalSignatureResolver.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        traceBasedExternalSignatureResolver.setProject(project);
-        traceBasedExternalSignatureResolver.setTrace(bindingTrace);
-
-        lazyResolveBasedCache.setSession(resolveSession);
-
-        traceBasedErrorReporter.setTrace(bindingTrace);
-
-        psiBasedMethodSignatureChecker.setExternalAnnotationResolver(psiBasedExternalAnnotationResolver);
-        psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-
-        singleModuleClassResolver.setResolver(javaDescriptorResolver);
-
-        javaLazyAnalyzerPostConstruct.setCodeAnalyzer(resolveSession);
-        javaLazyAnalyzerPostConstruct.setProject(project);
-        javaLazyAnalyzerPostConstruct.setTrace(bindingTrace);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        jetImportsFactory.setProject(project);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        bodyResolver.setAdditionalCheckerProvider(kotlinJvmCheckerProvider);
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-        bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setTrace(bindingTrace);
-
-        overloadResolver.setTrace(bindingTrace);
-
-        overrideResolver.setTrace(bindingTrace);
-
-        deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
-
-        javaClassFinder.initialize();
-
-        javaLazyAnalyzerPostConstruct.postCreate();
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ModuleDescriptorImpl getModule() {
-        return this.module;
-    }
-
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
-    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
-        return this.lazyTopDownAnalyzer;
-    }
-
-    public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
-        return this.lazyTopDownAnalyzerForTopLevel;
-    }
-
-    public JavaDescriptorResolver getJavaDescriptorResolver() {
-        return this.javaDescriptorResolver;
-    }
-
-    public DeserializationComponentsForJava getDeserializationComponentsForJava() {
-        return this.deserializationComponentsForJava;
-    }
-
-}

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

@@ -16,29 +16,23 @@
 
 package org.jetbrains.kotlin.resolve.jvm
 
-import org.jetbrains.kotlin.analyzer.AnalyzerFacade
-import org.jetbrains.kotlin.analyzer.ResolverForModule
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.analyzer.PlatformAnalysisParameters
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.platform.JavaToKotlinClassMap
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import com.intellij.openapi.project.Project
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
-import org.jetbrains.kotlin.load.java.structure.JavaClass
-import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import org.jetbrains.kotlin.analyzer.ModuleContent
-import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
-import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
-import com.intellij.psi.search.GlobalSearchScope
-import java.util.ArrayList
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
-import kotlin.platform.platformStatic
-import com.intellij.openapi.module.Module
+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.platform.JavaToKotlinClassMap
 import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
+import java.util.ArrayList
+import kotlin.platform.platformStatic
 
 public class JvmResolverForModule(
         override val lazyResolveSession: ResolveSession,
@@ -71,15 +65,13 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
             resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
         }
-        val injector = InjectorForLazyResolveWithJava(
+        val (resolveSession, javaDescriptorResolver) = createContainerForLazyResolveWithJava(
                 project, globalContext,
                 CodeAnalyzerInitializer.getInstance(project).createTrace(),
                 moduleDescriptor, declarationProviderFactory,
                 moduleContentScope, moduleClassResolver
         )
 
-        val resolveSession = injector.getResolveSession()!!
-        val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
         val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
         moduleDescriptor.initialize(CompositePackageFragmentProvider(providersForModule))
         return JvmResolverForModule(resolveSession, javaDescriptorResolver)

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

@@ -26,7 +26,8 @@ import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-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;
@@ -117,7 +118,7 @@ public enum TopDownAnalyzerFacadeForJVM {
         FileBasedDeclarationProviderFactory providerFactory =
                 new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles);
 
-        InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
+        ContainerForTopDownAnalyzerForJvm injector = DiPackage.createContainerForTopDownAnalyzerForJvm(
                 project,
                 topDownAnalysisParameters,
                 trace,
@@ -126,30 +127,25 @@ public enum TopDownAnalyzerFacadeForJVM {
                 GlobalSearchScope.allScope(project)
         );
 
-        try {
-            List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
+        List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
 
-            if (moduleIds != null && incrementalCacheProvider != null) {
-                for (String moduleId : moduleIds) {
-                    IncrementalCache incrementalCache = incrementalCacheProvider.getIncrementalCache(moduleId);
+        if (moduleIds != null && incrementalCacheProvider != null) {
+            for (String moduleId : moduleIds) {
+                IncrementalCache incrementalCache = incrementalCacheProvider.getIncrementalCache(moduleId);
 
-                    additionalProviders.add(
-                            new IncrementalPackageFragmentProvider(
-                                    files, module, topDownAnalysisParameters.getStorageManager(),
-                                    injector.getDeserializationComponentsForJava().getComponents(),
-                                    incrementalCache, moduleId
-                            )
-                    );
-                }
+                additionalProviders.add(
+                        new IncrementalPackageFragmentProvider(
+                                files, module, topDownAnalysisParameters.getStorageManager(),
+                                injector.getDeserializationComponentsForJava().getComponents(),
+                                incrementalCache, moduleId
+                        )
+                );
             }
-            additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
+        }
+        additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
 
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles, additionalProviders);
-            return AnalysisResult.success(trace.getBindingContext(), module);
-        }
-        finally {
-            injector.destroy();
-        }
+        injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, allFiles, additionalProviders);
+        return AnalysisResult.success(trace.getBindingContext(), module);
     }
 
     @NotNull

compiler/frontend/frontend.iml

@@ -13,5 +13,6 @@
     <orderEntry type="module" module-name="descriptors" exported="" />
     <orderEntry type="module" module-name="util" />
     <orderEntry type="module" module-name="plugin-api" exported="" />
+    <orderEntry type="module" module-name="container" exported="" />
   </component>
 </module>

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

@@ -16,18 +16,20 @@
 
 package org.jetbrains.kotlin.analyzer
 
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.get
+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.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.JetTypeInfo
 
 public fun JetExpression.computeTypeInfoInContext(
@@ -37,8 +39,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 injectorForMacros = createContainerForMacros(getProject(), module)
+    return injectorForMacros.get<ExpressionTypingServices>().getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
 }
 
 public fun JetExpression.analyzeInContext(

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

@@ -0,0 +1,54 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.BodyResolver
+import org.jetbrains.kotlin.resolve.StatementFilter
+
+public fun createContainerForBodyResolve(
+        project: Project, globalContext: GlobalContext, bindingTrace: BindingTrace, module: ModuleDescriptor,
+        additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter
+): StorageComponentContainer = createContainer("BodyResolve") {
+    configureModule(project, globalContext, module, bindingTrace, additionalCheckerProvider)
+
+    useInstance(statementFilter)
+    useImpl<BodyResolver>()
+}
+
+public fun StorageComponentContainer.configureModule(
+        project: Project, globalContext: GlobalContext,
+        module: ModuleDescriptor, bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider
+) {
+    useInstance(project)
+    useInstance(globalContext)
+    useInstance(globalContext.storageManager)
+    useInstance(bindingTrace)
+    useInstance(module)
+    useInstance(module.builtIns)
+    useInstance(module.platformToKotlinClassMap)
+    useInstance(additionalCheckerProvider)
+    useInstance(additionalCheckerProvider.symbolUsageValidator)
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
+import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+
+public fun createContainerForLazyBodyResolve(
+        project: Project, globalContext: GlobalContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
+        bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider,
+        dynamicTypesSettings: DynamicTypesSettings
+): StorageComponentContainer = createContainer("BodyResolve") { //TODO: name
+    configureModule(project, globalContext, kotlinCodeAnalyzer.getModuleDescriptor(), bindingTrace, additionalCheckerProvider)
+
+    useInstance(kotlinCodeAnalyzer)
+    useInstance(kotlinCodeAnalyzer.getScopeProvider())
+    useInstance(dynamicTypesSettings)
+    useImpl<LazyTopDownAnalyzerForTopLevel>()
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
+import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer
+import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder
+import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver
+
+public fun createContainerForLazyLocalClassifierAnalyzer(
+        project: Project, globalContext: GlobalContext,
+        bindingTrace: BindingTrace, moduleDescriptor: ModuleDescriptor,
+        additionalCheckerProvider: AdditionalCheckerProvider,
+        dynamicTypesSettings: DynamicTypesSettings, localClassDescriptorHolder: LocalClassDescriptorHolder
+): StorageComponentContainer = createContainer("BodyResolve") { //TODO: name
+    configureModule(project, globalContext, moduleDescriptor, bindingTrace, additionalCheckerProvider)
+
+    useInstance(dynamicTypesSettings)
+    useInstance(localClassDescriptorHolder)
+
+    useImpl<LazyTopDownAnalyzer>()
+
+    useInstance(NoTopLevelDescriptorProvider)
+    useInstance(NoFileScopeProvider)
+
+    useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
+    useImpl<LocalLazyDeclarationResolver>()
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.context.LazyResolveToken
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.get
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.BindingTrace
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.types.DynamicTypesSettings
+
+public fun createContainerForLazyResolve(
+        project: Project, globalContext: GlobalContext, module: ModuleDescriptor,
+        declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+): StorageComponentContainer = createContainer("Macros") {
+    configureModule(project, globalContext, module, bindingTrace, additionalCheckerProvider)
+
+    useInstance(dynamicTypesSettings)
+    useInstance(declarationProviderFactory)
+
+    useImpl<LazyResolveToken>()
+    useImpl<ResolveSession>()
+}
+
+public fun createLazyResolveSession(
+        project: Project, globalContext: GlobalContext, module: ModuleDescriptor,
+        declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
+        additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
+): ResolveSession = createContainerForLazyResolve(
+        project, globalContext, module, declarationProviderFactory, bindingTrace, additionalCheckerProvider, dynamicTypesSettings
+).get<ResolveSession>()

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

@@ -0,0 +1,46 @@
+/*
+ * 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.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+
+public fun createContainerForMacros(project: Project, module: ModuleDescriptor): StorageComponentContainer = createContainer("Macros") {
+
+    //TODO_R: extract this logic
+
+    useInstance(project)
+    useInstance(module)
+
+    val globalContext = GlobalContext()
+    useInstance(globalContext)
+    useInstance(globalContext.storageManager)
+    useInstance(module.builtIns)
+    useInstance(module.platformToKotlinClassMap)
+
+    useInstance(AdditionalCheckerProvider.DefaultProvider)
+    useInstance(AdditionalCheckerProvider.DefaultProvider.symbolUsageValidator)
+
+    useImpl<ExpressionTypingServices>()
+}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForBodyResolve.java

@@ -1,249 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForBodyResolve {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptor moduleDescriptor;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final AdditionalCheckerProvider additionalCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final StatementFilter statementFilter;
-    private final BodyResolver bodyResolver;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final ScriptBodyResolver scriptBodyResolver;
-
-    public InjectorForBodyResolve(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-        @NotNull StatementFilter statementFilter
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.moduleDescriptor = moduleDescriptor;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.additionalCheckerProvider = additionalCheckerProvider;
-        this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
-        this.statementFilter = statementFilter;
-        this.bodyResolver = new BodyResolver();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.scriptBodyResolver = new ScriptBodyResolver();
-
-        this.bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        this.bodyResolver.setAnnotationResolver(annotationResolver);
-        this.bodyResolver.setCallResolver(callResolver);
-        this.bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        this.bodyResolver.setDeclarationsChecker(declarationsChecker);
-        this.bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        this.bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        this.bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        this.bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        this.bodyResolver.setTrace(bindingTrace);
-        this.bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public BodyResolver getBodyResolver() {
-        return this.bodyResolver;
-    }
-
-}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java

@@ -1,309 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForLazyBodyResolve {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final KotlinCodeAnalyzer analyzer;
-    private final ModuleDescriptor moduleDescriptor;
-    private final ScopeProvider scopeProvider;
-    private final BindingTrace bindingTrace;
-    private final AdditionalCheckerProvider additionalCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
-    private final BodyResolver bodyResolver;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final DeclarationResolver declarationResolver;
-    private final OverloadResolver overloadResolver;
-    private final OverrideResolver overrideResolver;
-    private final VarianceChecker varianceChecker;
-
-    public InjectorForLazyBodyResolve(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull KotlinCodeAnalyzer analyzer,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-        @NotNull DynamicTypesSettings dynamicTypesSettings
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.analyzer = analyzer;
-        this.moduleDescriptor = analyzer.getModuleDescriptor();
-        this.scopeProvider = analyzer.getScopeProvider();
-        this.bindingTrace = bindingTrace;
-        this.additionalCheckerProvider = additionalCheckerProvider;
-        this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
-        this.dynamicTypesSettings = dynamicTypesSettings;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
-        this.bodyResolver = new BodyResolver();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.declarationResolver = new DeclarationResolver();
-        this.overloadResolver = new OverloadResolver();
-        this.overrideResolver = new OverrideResolver();
-        this.varianceChecker = new VarianceChecker(bindingTrace);
-
-        this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(analyzer);
-        this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(analyzer);
-
-        lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
-        lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        lazyTopDownAnalyzer.setModuleDescriptor(moduleDescriptor);
-        lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        lazyTopDownAnalyzer.setTopLevelDescriptorProvider(analyzer);
-        lazyTopDownAnalyzer.setTrace(bindingTrace);
-        lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
-
-        bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-        bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setTrace(bindingTrace);
-
-        overloadResolver.setTrace(bindingTrace);
-
-        overrideResolver.setTrace(bindingTrace);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
-        return this.lazyTopDownAnalyzerForTopLevel;
-    }
-
-}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java

@@ -1,304 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.LocalClassDescriptorHolder;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider;
-import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider;
-import org.jetbrains.kotlin.types.expressions.DeclarationScopeProviderForLocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.LocalLazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForLazyLocalClassifierAnalyzer {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptor module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final AdditionalCheckerProvider additionalCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final LocalClassDescriptorHolder localClassDescriptorHolder;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
-    private final NoTopLevelDescriptorProvider noTopLevelDescriptorProvider;
-    private final NoFileScopeProvider noFileScopeProvider;
-    private final DeclarationScopeProviderForLocalClassifierAnalyzer declarationScopeProviderForLocalClassifierAnalyzer;
-    private final LocalLazyDeclarationResolver localLazyDeclarationResolver;
-    private final BodyResolver bodyResolver;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final DeclarationResolver declarationResolver;
-    private final OverloadResolver overloadResolver;
-    private final OverrideResolver overrideResolver;
-    private final VarianceChecker varianceChecker;
-
-    public InjectorForLazyLocalClassifierAnalyzer(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor module,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-        @NotNull DynamicTypesSettings dynamicTypesSettings,
-        @NotNull LocalClassDescriptorHolder localClassDescriptorHolder
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.additionalCheckerProvider = additionalCheckerProvider;
-        this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
-        this.dynamicTypesSettings = dynamicTypesSettings;
-        this.localClassDescriptorHolder = localClassDescriptorHolder;
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
-        this.noTopLevelDescriptorProvider = NoTopLevelDescriptorProvider.INSTANCE$;
-        this.noFileScopeProvider = NoFileScopeProvider.INSTANCE$;
-        this.localLazyDeclarationResolver = new LocalLazyDeclarationResolver(globalContext, bindingTrace, localClassDescriptorHolder);
-        this.declarationScopeProviderForLocalClassifierAnalyzer = new DeclarationScopeProviderForLocalClassifierAnalyzer(localLazyDeclarationResolver, localClassDescriptorHolder);
-        this.bodyResolver = new BodyResolver();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, module, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(module);
-        this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.declarationResolver = new DeclarationResolver();
-        this.overloadResolver = new OverloadResolver();
-        this.overrideResolver = new OverrideResolver();
-        this.varianceChecker = new VarianceChecker(bindingTrace);
-
-        this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        this.lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
-        this.lazyTopDownAnalyzer.setFileScopeProvider(noFileScopeProvider);
-        this.lazyTopDownAnalyzer.setLazyDeclarationResolver(localLazyDeclarationResolver);
-        this.lazyTopDownAnalyzer.setModuleDescriptor(module);
-        this.lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        this.lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        this.lazyTopDownAnalyzer.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
-        this.lazyTopDownAnalyzer.setTrace(bindingTrace);
-        this.lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
-
-        declarationScopeProviderForLocalClassifierAnalyzer.setFileScopeProvider(noFileScopeProvider);
-
-        localLazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProviderForLocalClassifierAnalyzer);
-        localLazyDeclarationResolver.setTopLevelDescriptorProvider(noTopLevelDescriptorProvider);
-
-        bodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-        bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setTrace(bindingTrace);
-
-        overloadResolver.setTrace(bindingTrace);
-
-        overrideResolver.setTrace(bindingTrace);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
-        return this.lazyTopDownAnalyzer;
-    }
-
-}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyResolve.java

@@ -1,256 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import org.jetbrains.kotlin.context.LazyResolveToken;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForLazyResolve {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final ModuleDescriptorImpl moduleDescriptor;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final BindingTrace bindingTrace;
-    private final AdditionalCheckerProvider additionalCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ResolveSession resolveSession;
-    private final ScopeProvider scopeProvider;
-    private final LazyResolveToken lazyResolveToken;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-
-    public InjectorForLazyResolve(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull ModuleDescriptorImpl moduleDescriptor,
-        @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull AdditionalCheckerProvider additionalCheckerProvider,
-        @NotNull DynamicTypesSettings dynamicTypesSettings
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.moduleDescriptor = moduleDescriptor;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.bindingTrace = bindingTrace;
-        this.additionalCheckerProvider = additionalCheckerProvider;
-        this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
-        this.dynamicTypesSettings = dynamicTypesSettings;
-        this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.lazyResolveToken = new LazyResolveToken();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, lazyResolveToken, dynamicTypesSettings);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.valueParameterResolver = new ValueParameterResolver(additionalCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
-
-        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
-        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        jetImportsFactory.setProject(project);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
-}

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForMacros.java

@@ -1,213 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider.DefaultProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForMacros {
-
-    private final Project project;
-    private final ModuleDescriptor moduleDescriptor;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallResolver callResolver;
-    private final TypeResolver typeResolver;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final DefaultProvider defaultProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final StatementFilter statementFilter;
-    private final AnnotationResolver annotationResolver;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-
-    public InjectorForMacros(
-        @NotNull Project project,
-        @NotNull ModuleDescriptor moduleDescriptor
-    ) {
-        this.project = project;
-        this.moduleDescriptor = moduleDescriptor;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(getExpressionTypingComponents());
-        this.callResolver = new CallResolver();
-        this.annotationResolver = new AnnotationResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.globalContext = org.jetbrains.kotlin.context.ContextPackage.GlobalContext();
-        this.storageManager = globalContext.getStorageManager();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.defaultProvider = DefaultProvider.INSTANCE$;
-        this.symbolUsageValidator = defaultProvider.getSymbolUsageValidator();
-        this.statementFilter = new StatementFilter();
-        this.callExpressionResolver = new CallExpressionResolver(getCallResolver(), kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(getCallResolver());
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, getCallResolver());
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), descriptorResolver, annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, getTypeResolver(), annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, getTypeResolver(), symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.valueParameterResolver = new ValueParameterResolver(defaultProvider, getExpressionTypingServices());
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-
-        this.expressionTypingServices.setStatementFilter(statementFilter);
-
-        this.expressionTypingComponents.setAdditionalCheckerProvider(defaultProvider);
-        this.expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        this.expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        this.expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        this.expressionTypingComponents.setCallResolver(callResolver);
-        this.expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        this.expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        this.expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        this.expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        this.expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        this.expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.expressionTypingComponents.setGlobalContext(globalContext);
-        this.expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        this.expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        this.expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        this.expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        this.expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        this.expressionTypingComponents.setTypeResolver(typeResolver);
-        this.expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        this.callResolver.setAdditionalCheckerProvider(defaultProvider);
-        this.callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        this.callResolver.setCallCompleter(callCompleter);
-        this.callResolver.setCandidateResolver(candidateResolver);
-        this.callResolver.setExpressionTypingServices(expressionTypingServices);
-        this.callResolver.setTaskPrioritizer(taskPrioritizer);
-        this.callResolver.setTypeResolver(typeResolver);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(defaultProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ExpressionTypingServices getExpressionTypingServices() {
-        return this.expressionTypingServices;
-    }
-
-    public ExpressionTypingComponents getExpressionTypingComponents() {
-        return this.expressionTypingComponents;
-    }
-
-    public CallResolver getCallResolver() {
-        return this.callResolver;
-    }
-
-    public TypeResolver getTypeResolver() {
-        return this.typeResolver;
-    }
-
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalysisParameters.java

@@ -16,18 +16,15 @@
 
 package org.jetbrains.kotlin.resolve;
 
-import com.google.common.base.Predicate;
-import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
 import org.jetbrains.kotlin.storage.ExceptionTracker;
 import org.jetbrains.kotlin.storage.StorageManager;
 
 /**
  * Various junk that cannot be placed into context (yet).
  */
-public class TopDownAnalysisParameters extends TypeLazinessToken implements GlobalContext {
+public class TopDownAnalysisParameters implements GlobalContext {
 
     @NotNull
     public static TopDownAnalysisParameters create(
@@ -36,8 +33,7 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob
             boolean analyzingBootstrapLibrary,
             boolean declaredLocally
     ) {
-        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzingBootstrapLibrary,
-                                             declaredLocally, true);
+        return new TopDownAnalysisParameters(storageManager, exceptionTracker, analyzingBootstrapLibrary, declaredLocally);
     }
 
     @NotNull
@@ -45,27 +41,24 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob
             @NotNull StorageManager storageManager,
             @NotNull ExceptionTracker exceptionTracker
     ) {
-        return new TopDownAnalysisParameters(storageManager, exceptionTracker, false, true, false);
+        return new TopDownAnalysisParameters(storageManager, exceptionTracker, false, true);
     }
 
     @NotNull private final StorageManager storageManager;
     @NotNull private final ExceptionTracker exceptionTracker;
     private final boolean analyzingBootstrapLibrary;
     private final boolean declaredLocally;
-    private final boolean lazyTopDownAnalysis;
 
     private TopDownAnalysisParameters(
             @NotNull StorageManager storageManager,
             @NotNull ExceptionTracker exceptionTracker,
             boolean analyzingBootstrapLibrary,
-            boolean declaredLocally,
-            boolean lazyTopDownAnalysis
+            boolean declaredLocally
     ) {
         this.storageManager = storageManager;
         this.exceptionTracker = exceptionTracker;
         this.analyzingBootstrapLibrary = analyzingBootstrapLibrary;
         this.declaredLocally = declaredLocally;
-        this.lazyTopDownAnalysis = lazyTopDownAnalysis;
     }
 
     @Override
@@ -87,11 +80,4 @@ public class TopDownAnalysisParameters extends TypeLazinessToken implements Glob
     public boolean isDeclaredLocally() {
         return declaredLocally;
     }
-
-    // Used temporarily while we are transitioning from eager to lazy analysis of headers in the IDE
-    @Override
-    @Deprecated
-    public boolean isLazy() {
-        return lazyTopDownAnalysis;
-    }
 }

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

@@ -16,36 +16,34 @@
 
 package org.jetbrains.kotlin.types.expressions
 
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.resolve.scopes.WritableScope
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.types.DynamicTypesSettings
-import com.google.common.base.Predicates
-import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
+import com.intellij.psi.util.PsiTreeUtil
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.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
-import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
+import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProvider
+import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
+import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
+import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
 import org.jetbrains.kotlin.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider
-import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider
-import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.PackageMemberDeclarationProvider
-import org.jetbrains.kotlin.psi.psiUtil.isObjectLiteral
-import org.jetbrains.kotlin.name.SpecialNames
-import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil
+import org.jetbrains.kotlin.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider
+import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl
-import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.lazy.LazyClassContext
+import org.jetbrains.kotlin.resolve.scopes.WritableScope
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.types.DynamicTypesSettings
 
 public class LocalClassifierAnalyzer(
         val descriptorResolver: DescriptorResolver,
@@ -62,10 +60,9 @@ public class LocalClassifierAnalyzer(
             additionalCheckerProvider: AdditionalCheckerProvider,
             dynamicTypesSettings: DynamicTypesSettings
     ) {
-        val topDownAnalysisParameters = TopDownAnalysisParameters.create(globalContext.storageManager, globalContext.exceptionTracker, false, true)
 
         val moduleDescriptor = DescriptorUtils.getContainingModule(containingDeclaration)
-        val injector = InjectorForLazyLocalClassifierAnalyzer(
+        val injector = createContainerForLazyLocalClassifierAnalyzer(
                 classOrObject.getProject(),
                 globalContext,
                 context.trace,
@@ -86,7 +83,8 @@ public class LocalClassifierAnalyzer(
                 )
         )
 
-        injector.getLazyTopDownAnalyzer().analyzeDeclarations(
+        val topDownAnalysisParameters = TopDownAnalysisParameters.create(globalContext.storageManager, globalContext.exceptionTracker, false, true)
+        injector.get<LazyTopDownAnalyzer>().analyzeDeclarations(
                 topDownAnalysisParameters,
                 listOf(classOrObject),
                 context.dataFlowInfo

compiler/tests/compiler-tests.iml

@@ -26,5 +26,6 @@
     <orderEntry type="module" module-name="android-compiler-plugin" scope="TEST" />
     <orderEntry type="module" module-name="js.serializer" />
     <orderEntry type="module" module-name="js.translator" scope="TEST" />
+    <orderEntry type="module" module-name="container" />
   </component>
 </module>

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

@@ -0,0 +1,156 @@
+package org.jetbrains.container
+
+import org.junit.Test
+import java.io.Closeable
+import kotlin.test.*
+
+trait TestComponentInterface {
+    public val disposed: Boolean
+    fun foo()
+}
+
+trait TestClientComponentInterface {
+}
+
+class TestComponent : TestComponentInterface, Closeable {
+    public override var disposed: Boolean = false
+    override fun close() {
+        disposed = true
+    }
+
+    override fun foo() {
+        throw UnsupportedOperationException()
+    }
+}
+
+class ManualTestComponent(val name: String) : TestComponentInterface, Closeable {
+    public override var disposed: Boolean = false
+    override fun close() {
+        disposed = true
+    }
+
+    override fun foo() {
+        throw UnsupportedOperationException()
+    }
+}
+
+class TestClientComponent(val dep: TestComponentInterface) : TestClientComponentInterface, Closeable {
+    override fun close() {
+        if (dep.disposed)
+            throw Exception("Dependency shouldn't be disposed before dependee")
+        disposed = true
+    }
+
+    var disposed: Boolean = false
+}
+
+class TestClientComponent2() : TestClientComponentInterface {
+}
+
+class ComponentContainerTests {
+    Test fun should_throw_when_not_composed() {
+        val container = StorageComponentContainer("test")
+        fails {
+            container.resolve<TestComponentInterface>()
+        }
+    }
+
+    Test fun should_resolve_to_null_when_empty() {
+        val container = StorageComponentContainer("test").compose()
+        assertNull(container.resolve<TestComponentInterface>())
+    }
+
+    Test fun should_resolve_to_instance_when_registered() {
+        val container = StorageComponentContainer("test").register<TestComponent>().compose()
+        val descriptor = container.resolve<TestComponentInterface>()
+        assertNotNull(descriptor)
+        val instance = descriptor!!.getValue() as TestComponentInterface
+        assertNotNull(instance)
+        fails {
+            instance.foo()
+        }
+    }
+
+    Test fun should_resolve_instance_dependency() {
+        val container = StorageComponentContainer("test")
+                .registerInstance(ManualTestComponent("name"))
+                .register<TestClientComponent>()
+                .compose()
+        val descriptor = container.resolve<TestClientComponent>()
+        assertNotNull(descriptor)
+        val instance = descriptor!!.getValue() as TestClientComponent
+        assertNotNull(instance)
+        assertNotNull(instance.dep)
+        fails {
+            instance.dep.foo()
+        }
+        assertTrue(instance.dep is ManualTestComponent)
+        assertEquals("name", (instance.dep as ManualTestComponent).name)
+        container.close()
+        assertTrue(instance.disposed)
+        assertFalse(instance.dep.disposed) // should not dispose manually passed instances
+    }
+
+    Test fun should_resolve_type_dependency() {
+        val container = StorageComponentContainer("test")
+                .register<TestComponent>()
+                .register<TestClientComponent>()
+                .compose()
+
+        val descriptor = container.resolve<TestClientComponent>()
+        assertNotNull(descriptor)
+        val instance = descriptor!!.getValue() as TestClientComponent
+        assertNotNull(instance)
+        assertNotNull(instance.dep)
+        fails {
+            instance.dep.foo()
+        }
+        container.close()
+        assertTrue(instance.disposed)
+        assertTrue(instance.dep.disposed)
+    }
+
+    Test fun should_resolve_multiple_types() {
+        StorageComponentContainer("test")
+                .register<TestComponent>()
+                .register<TestClientComponent>()
+                .register<TestClientComponent2>()
+                .compose()
+                .use {
+                    val descriptor = it.resolveMultiple<TestClientComponentInterface>()
+                    assertNotNull(descriptor)
+                    assertEquals(2, descriptor.count())
+                }
+    }
+
+    Test fun should_resolve_transient_types_to_different_instances() {
+        StorageComponentContainer("test")
+                .register<TestComponent>()
+                .register<TestClientComponent>(ComponentLifetime.Transient)
+                .compose()
+                .use {
+                    val descriptor1 = it.resolve<TestClientComponentInterface>()
+                    assertNotNull(descriptor1)
+                    val descriptor2 = it.resolve<TestClientComponentInterface>()
+                    assertNotNull(descriptor2)
+                    assertTrue(descriptor1 == descriptor2)
+                    assertFalse(descriptor1!!.getValue() == descriptor2!!.getValue())
+                }
+    }
+
+    Test fun should_resolve_singleton_types_to_same_instances() {
+        StorageComponentContainer("test")
+                .register<TestComponent>()
+                .register<TestClientComponent>(ComponentLifetime.Singleton)
+                .compose()
+                .use {
+                    val descriptor1 = it.resolve<TestClientComponentInterface>()
+                    assertNotNull(descriptor1)
+                    val descriptor2 = it.resolve<TestClientComponentInterface>()
+                    assertNotNull(descriptor2)
+                    assertTrue(descriptor1 == descriptor2)
+                    assertTrue(descriptor1!!.getValue() == descriptor2!!.getValue())
+                }
+    }
+
+}

compiler/tests/org/jetbrains/kotlin/di/ContainerForTests.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.tests.di
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.container.StorageComponentContainer
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.injected
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.*
+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("Macros") {
+        useInstance(project)
+        useInstance(module)
+
+        val globalContext = GlobalContext()
+        useInstance(globalContext)
+        useInstance(globalContext.storageManager)
+        useInstance(module.builtIns)
+        useInstance(module.platformToKotlinClassMap)
+
+        useInstance(KotlinJvmCheckerProvider)
+        useInstance(KotlinJvmCheckerProvider.symbolUsageValidator)
+
+        useImpl<ExpressionTypingServices>()
+    })
+}
+
+class ContainerForTests(container: StorageComponentContainer) {
+    val descriptorResolver: DescriptorResolver by injected(container)
+    val functionDescriptorResolver: FunctionDescriptorResolver by injected(container)
+    val typeResolver: TypeResolver by injected(container)
+    val fakeCallResolver: FakeCallResolver by injected(container)
+    val expressionTypingServices: ExpressionTypingServices by injected(container)
+    val qualifiedExpressionResolver: QualifiedExpressionResolver by injected(container)
+    val additionalCheckerProvider: AdditionalCheckerProvider by injected(container)
+}

compiler/tests/org/jetbrains/kotlin/di/InjectorForTests.java

@@ -1,225 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.DynamicTypesSettings;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForTests {
-
-    private final Project project;
-    private final ModuleDescriptor moduleDescriptor;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DescriptorResolver descriptorResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final TypeResolver typeResolver;
-    private final FakeCallResolver fakeCallResolver;
-    private final KotlinJvmCheckerProvider additionalCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-    private final DynamicTypesSettings dynamicTypesSettings;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-
-    public InjectorForTests(
-        @NotNull Project project,
-        @NotNull ModuleDescriptor moduleDescriptor
-    ) {
-        this.project = project;
-        this.moduleDescriptor = moduleDescriptor;
-        this.kotlinBuiltIns = moduleDescriptor.getBuiltIns();
-        this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
-        this.descriptorResolver = new DescriptorResolver();
-        this.annotationResolver = new AnnotationResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.globalContext = org.jetbrains.kotlin.context.ContextPackage.GlobalContext();
-        this.storageManager = globalContext.getStorageManager();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, getQualifiedExpressionResolver(), moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), getDescriptorResolver(), annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
-        this.callResolver = new CallResolver();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.additionalCheckerProvider = KotlinJvmCheckerProvider.INSTANCE$;
-        this.symbolUsageValidator = additionalCheckerProvider.getSymbolUsageValidator();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(getDescriptorResolver(), getFunctionDescriptorResolver(), getTypeResolver(), annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(getFakeCallResolver(), getDescriptorResolver(), getTypeResolver(), symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(moduleDescriptor);
-        this.valueParameterResolver = new ValueParameterResolver(getAdditionalCheckerProvider(), getExpressionTypingServices());
-        this.statementFilter = new StatementFilter();
-
-        this.descriptorResolver.setAnnotationResolver(annotationResolver);
-        this.descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        this.descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        this.descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        this.descriptorResolver.setStorageManager(storageManager);
-        this.descriptorResolver.setTypeResolver(typeResolver);
-
-        this.expressionTypingServices.setStatementFilter(statementFilter);
-
-        this.qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(additionalCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public DescriptorResolver getDescriptorResolver() {
-        return this.descriptorResolver;
-    }
-
-    public FunctionDescriptorResolver getFunctionDescriptorResolver() {
-        return this.functionDescriptorResolver;
-    }
-
-    public TypeResolver getTypeResolver() {
-        return this.typeResolver;
-    }
-
-    public FakeCallResolver getFakeCallResolver() {
-        return this.fakeCallResolver;
-    }
-
-    public KotlinJvmCheckerProvider getAdditionalCheckerProvider() {
-        return this.additionalCheckerProvider;
-    }
-
-    public ExpressionTypingServices getExpressionTypingServices() {
-        return this.expressionTypingServices;
-    }
-
-    public QualifiedExpressionResolver getQualifiedExpressionResolver() {
-        return this.qualifiedExpressionResolver;
-    }
-
-}

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

@@ -16,28 +16,28 @@
 
 package org.jetbrains.kotlin.renderer
 
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.openapi.editor.impl.DocumentImpl
-import org.jetbrains.kotlin.test.JetTestUtils
-import java.util.ArrayList
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.test.ConfigurationKind
+import com.intellij.openapi.util.io.FileUtil
 import com.intellij.testFramework.UsefulTestCase
-import java.io.File
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
-import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.di.InjectorForLazyResolve
-import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.context.GlobalContext
+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.frontend.di.createLazyResolveSession
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment
-import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.test.ConfigurationKind
+import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.types.DynamicTypesSettings
+import java.io.File
+import java.util.ArrayList
 
 public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment() {
     protected open fun getDescriptor(declaration: JetDeclaration, resolveSession: ResolveSession): DeclarationDescriptor {
@@ -51,11 +51,12 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
         val lazyModule = TopDownAnalyzerFacadeForJVM.createSealedJavaModule()
         val globalContext = GlobalContext()
 
-        val resolveSession = InjectorForLazyResolve(
+        val resolveSession = createLazyResolveSession(
                 getProject(), globalContext, lazyModule,
                 FileBasedDeclarationProviderFactory(globalContext.storageManager, listOf(psiFile)),
                 CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
+                KotlinJvmCheckerProvider, DynamicTypesSettings()
+        )
 
         lazyModule.initialize(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,7 +127,7 @@ public class JetExpectedResolveDataUtil {
             JetType... parameterTypes
     ) {
         ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
-        InjectorForTests injector = new InjectorForTests(project, emptyModule);
+        ContainerForTests injector = DiPackage.createContainerForTests(project, emptyModule);
 
         ExpressionTypingContext context = ExpressionTypingContext.newContext(
                 injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),

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.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.tests.di.createContainerForTests
 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 org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
+import java.util.regex.Pattern
 
 abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     private val typePattern = """([\w|<|>|\(|\)]+)"""
@@ -55,8 +54,8 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     override fun setUp() {
         super.setUp()
 
-        val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule())
-        _typeResolver = injector.getTypeResolver()!!
+        val injector = createContainerForTests(getProject(), JetTestUtils.createEmptyModule())
+        _typeResolver = injector.typeResolver
         _testDeclarations = analyzeDeclarations()
     }
 

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

@@ -16,14 +16,13 @@
 
 package org.jetbrains.kotlin.serialization
 
-import com.google.common.base.Predicates
 import com.intellij.psi.search.GlobalSearchScope
 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.context.GlobalContext
-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
@@ -62,13 +61,13 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
         )
         val providerFactory = FileBasedDeclarationProviderFactory(globalContext.storageManager, emptyList())
 
-        val injector = InjectorForTopDownAnalyzerForJvm(
+        val injector = createContainerForTopDownAnalyzerForJvm(
                 environment.project, params, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), module,
                 providerFactory, GlobalSearchScope.allScope(environment.project)
         )
-        module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
+        module.initialize(injector.javaDescriptorResolver.packageFragmentProvider)
 
-        val components = injector.getDeserializationComponentsForJava().components
+        val components = injector.deserializationComponentsForJava.components
 
         val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId)
                               ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})")

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

@@ -23,14 +23,9 @@ import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.GlobalContextImpl;
 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.frontend.di.DiPackage;
 import org.jetbrains.kotlin.psi.*;
-import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider;
-import org.jetbrains.kotlin.resolve.BindingContext;
-import org.jetbrains.kotlin.resolve.BindingTraceContext;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
+import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
@@ -42,11 +37,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 java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
+import static org.jetbrains.kotlin.tests.di.DiPackage.createContainerForTests;
 
 public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     private final JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase();
@@ -75,7 +72,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
         private JetScope scope;
 
         public void setUp() throws Exception {
-            InjectorForTests injector = new InjectorForTests(getProject(), root);
+            ContainerForTests injector = createContainerForTests(getProject(), root);
             descriptorResolver = injector.getDescriptorResolver();
             functionDescriptorResolver = injector.getFunctionDescriptorResolver();
             scope = createScope(KotlinBuiltIns.getInstance().getBuiltInsPackageScope());
@@ -103,7 +100,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
 
         private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
             GlobalContextImpl globalContext = ContextPackage.GlobalContext();
-            ResolveSession resolveSession = new InjectorForLazyResolve(
+            ResolveSession resolveSession = DiPackage.createLazyResolveSession(
                     getProject(),
                     globalContext,
                     root,
@@ -112,7 +109,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
                     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,7 +45,7 @@ public class JetOverloadTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
+        ContainerForTests injector = DiPackage.createContainerForTests(getProject(), root);
         functionDescriptorResolver = injector.getFunctionDescriptorResolver();
     }
 

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,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,7 +45,7 @@ public class JetOverridingTest extends JetLiteFixture {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
+        ContainerForTests injector = DiPackage.createContainerForTests(getProject(), root);
         functionDescriptorResolver = injector.getFunctionDescriptorResolver();
     }
 

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,7 +73,7 @@ public class JetTypeCheckerTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        ContainerForTests injector = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
         typeResolver = injector.getTypeResolver();
         expressionTypingServices = injector.getExpressionTypingServices();
 

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 injector;
 
     @Override
     protected KotlinCoreEnvironment createEnvironment() {
@@ -67,7 +68,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
     protected void setUp() throws Exception {
         super.setUp();
 
-        injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        injector = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
         scope = getContextScope();
     }
 

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,7 +64,7 @@ public class TypeUnifierTest extends JetLiteFixture {
 
         builtIns = KotlinBuiltIns.getInstance();
 
-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        ContainerForTests injector = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
         typeResolver = injector.getTypeResolver();
         x = createTypeVariable("X");
         y = createTypeVariable("Y");

core/container/container.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="kotlin-runtime" level="project" />
+    <orderEntry type="library" name="intellij-core" level="project" />
+  </component>
+</module>

core/container/src/Cache.kt

@@ -0,0 +1,118 @@
+/*
+ * 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.di
+
+import com.intellij.util.containers.ContainerUtil
+import gnu.trove.TObjectHashingStrategy
+import java.lang.reflect.Constructor
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import java.util.ArrayList
+import java.util.LinkedHashSet
+
+
+//TODO_R: package
+
+private object ClassTraversalCache {
+    //TODO_R: parameters
+    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<Class<*>, ClassInfo>(50, 0.5f, 3, TObjectHashingStrategy.CANONICAL as TObjectHashingStrategy<Class<*>>)
+
+    fun getClassInfo(c: Class<*>): ClassInfo {
+        val classInfo = cache.get(c)
+        if (classInfo == null) {
+            val newClassInfo = traverseClass(c)
+            cache.put(c, newClassInfo)
+            return newClassInfo
+        }
+        return classInfo
+    }
+}
+
+fun Class<*>.getInfo(): ClassInfo {
+    return ClassTraversalCache.getClassInfo(this)
+}
+
+data class ClassInfo(
+        val constructorInfo: ConstructorInfo?,
+        val setterInfos: List<SetterInfo>,
+        val registrations: List<Class<*>>
+)
+
+data class ConstructorInfo(
+        val constructor: Constructor<*>,
+        val parameters: List<Class<*>>
+)
+
+data class SetterInfo(
+        val method: Method,
+        val parameters: List<Class<*>>)
+
+private fun traverseClass(c: Class<*>): ClassInfo {
+    return ClassInfo(getConstructorInfo(c), getSetterInfos(c), getRegistrations(c))
+}
+
+private fun getSetterInfos(c: Class<*>): List<SetterInfo> {
+    val setterInfos = ArrayList<SetterInfo>()
+    for (member in c.getMethods()) {
+        val annotations = member.getDeclaredAnnotations()
+        for (annotation in annotations) {
+            val annotationType = annotation.annotationType()
+            if (annotationType.getName().substringAfterLast('.') == "Inject") {
+                setterInfos.add(SetterInfo(member, member.getParameterTypes().toList()))
+            }
+        }
+    }
+    return setterInfos
+}
+
+private fun getConstructorInfo(c: Class<*>): ConstructorInfo? {
+    val modifiers = c.getModifiers()
+    if (Modifier.isInterface(modifiers) || Modifier.isAbstract(modifiers) || c.isPrimitive())
+        return null
+
+    val constructors = c.getConstructors()
+    val hasSinglePublicConstructor = constructors.singleOrNull()?.let { Modifier.isPublic(it.getModifiers()) } ?: false
+    if (!hasSinglePublicConstructor)
+        return null
+
+
+    val constructor = constructors.single()
+    return ConstructorInfo(constructor, constructor.getParameterTypes().toList())
+}
+
+
+private fun collectInterfacesRecursive(cl: Class<*>, result: MutableSet<Class<*>>) {
+    val interfaces = cl.getInterfaces()
+    interfaces.forEach {
+        if (result.add(it)) {
+            collectInterfacesRecursive(it, result)
+        }
+    }
+}
+
+private fun getRegistrations(klass: Class<*>): List<Class<*>> {
+    val registrations = ArrayList<Class<*>>()
+    val superClasses = sequence(klass) { it: Class<*> ->
+        (it as Class<Any>).getSuperclass()
+    }
+    registrations.addAll(superClasses)
+    val interfaces = LinkedHashSet<Class<*>>()
+    superClasses.forEach { collectInterfacesRecursive(it, interfaces) }
+    registrations.addAll(interfaces)
+    registrations.remove(javaClass<java.lang.Object>())
+    return registrations
+}

core/container/src/Components.kt

@@ -0,0 +1,26 @@
+package org.jetbrains.container
+
+import org.jetbrains.kotlin.di.getInfo
+import java.io.Closeable
+import java.lang.reflect.Method
+
+public class InstanceComponentDescriptor(val instance: Any) : ComponentDescriptor {
+
+    override fun getValue(): Any = instance
+    override fun getRegistrations(): Iterable<Class<*>> {
+        return instance.javaClass.getInfo().registrations
+    }
+
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = emptyList()
+}
+
+public class ProviderComponentDescriptor(val instance: Any, val method: Method) : ComponentDescriptor {
+    override fun getValue(): Any = method.invoke(instance)
+    override fun getRegistrations(): Iterable<Class<*>> {
+        return method.getReturnType().getInfo().registrations
+    }
+
+    // TODO: method parameters could be dependencies, for now we assume no params
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = emptyList()
+}
+

core/container/src/Container.kt

@@ -0,0 +1,107 @@
+package org.jetbrains.container
+
+import java.io.Closeable
+import java.lang.reflect.Modifier
+import kotlin.properties.Delegates
+
+class ContainerConsistencyException(message: String) : Exception(message)
+
+public trait ComponentContainer {
+    fun createResolveContext(requestingDescriptor: ValueDescriptor): ValueResolveContext
+}
+
+object DynamicComponentDescriptor : ComponentDescriptor {
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = throw UnsupportedOperationException()
+    override fun getRegistrations(): Iterable<Class<*>> = throw UnsupportedOperationException()
+    override fun getValue(): Any = throw UnsupportedOperationException()
+}
+
+object UnidentifiedComponentDescriptor : ComponentDescriptor {
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> = throw UnsupportedOperationException()
+    override fun getRegistrations(): Iterable<Class<*>> = throw UnsupportedOperationException()
+    override fun getValue(): Any = throw UnsupportedOperationException()
+}
+
+public class StorageComponentContainer(id: String) : ComponentContainer, Closeable {
+    public val unknownContext: ComponentResolveContext by Delegates.lazy { ComponentResolveContext(this, DynamicComponentDescriptor) }
+    val componentStorage = ComponentStorage(id)
+
+    override fun createResolveContext(requestingDescriptor: ValueDescriptor): ValueResolveContext {
+        if (requestingDescriptor == DynamicComponentDescriptor) // cache unknown component descriptor
+            return unknownContext
+        return ComponentResolveContext(this, requestingDescriptor)
+    }
+
+    fun compose(): StorageComponentContainer {
+        componentStorage.compose(unknownContext)
+        return this
+    }
+
+    override fun close() = componentStorage.dispose()
+
+    overloads public fun resolve(request: Class<*>, context: ValueResolveContext = unknownContext): ValueDescriptor? {
+        val storageResolve = componentStorage.resolve(request, context)
+        if (storageResolve != null)
+            return storageResolve
+
+        val hasSinglePublicConstructor = request.getConstructors().singleOrNull()?.let { Modifier.isPublic(it.getModifiers()) } ?: false
+        if (!hasSinglePublicConstructor)
+            return null
+
+        val modifiers = request.getModifiers()
+        if (Modifier.isInterface(modifiers) || Modifier.isAbstract(modifiers) || request.isPrimitive())
+            return null
+
+        return SingletonTypeComponentDescriptor(this, request)
+    }
+
+    public fun resolveMultiple(request: Class<*>, context: ValueResolveContext = unknownContext): Iterable<ValueDescriptor> {
+        return componentStorage.resolveMultiple(request, context)
+    }
+
+    public fun registerDescriptors(descriptors: List<ComponentDescriptor>): StorageComponentContainer {
+        componentStorage.registerDescriptors(unknownContext, descriptors)
+        return this
+    }
+
+}
+
+public fun StorageComponentContainer.register(klass: Class<*>, lifetime: ComponentLifetime = ComponentLifetime.Singleton): StorageComponentContainer =
+        when (lifetime) {
+            ComponentLifetime.Singleton -> registerSingleton(klass)
+            ComponentLifetime.Transient -> registerTransient(klass)
+        }
+
+
+public fun StorageComponentContainer.registerSingleton(klass: Class<*>): StorageComponentContainer {
+    return registerDescriptors(listOf(SingletonTypeComponentDescriptor(this, klass)))
+}
+
+public fun StorageComponentContainer.registerTransient(klass: Class<*>): StorageComponentContainer {
+    return registerDescriptors(listOf(TransientTypeComponentDescriptor(this, klass)))
+}
+
+public fun StorageComponentContainer.registerInstance(instance: Any): StorageComponentContainer {
+    return registerDescriptors(listOf(InstanceComponentDescriptor(instance)))
+}
+
+public inline fun <reified T> StorageComponentContainer.register(lifetime: ComponentLifetime = ComponentLifetime.Singleton): StorageComponentContainer =
+        if (lifetime == ComponentLifetime.Singleton) registerSingleton<T>()
+        else if (lifetime == ComponentLifetime.Transient) registerTransient<T>()
+        else throw IllegalStateException("Unknown lifetime: ${lifetime}}")
+
+public inline fun <reified T> StorageComponentContainer.registerSingleton(): StorageComponentContainer {
+    return registerDescriptors(listOf(SingletonTypeComponentDescriptor(this, javaClass<T>())))
+}
+
+public inline fun <reified T>  StorageComponentContainer.registerTransient(): StorageComponentContainer {
+    return registerDescriptors(listOf(TransientTypeComponentDescriptor(this, javaClass<T>())))
+}
+
+public inline fun <reified T> StorageComponentContainer.resolve(context: ValueResolveContext = unknownContext): ValueDescriptor? {
+    return resolve(javaClass<T>(), context)
+}
+
+public inline fun <reified T> StorageComponentContainer.resolveMultiple(context: ValueResolveContext = unknownContext): Iterable<ValueDescriptor> {
+    return resolveMultiple(javaClass<T>(), context)
+}

core/container/src/DataStructures.kt

@@ -0,0 +1,34 @@
+package org.jetbrains.container
+
+import java.util.*
+
+public fun topologicalSort<T>(items: Iterable<T>, dependencies: (T) -> Iterable<T>): List<T> {
+    val itemsInProgress = HashSet<T>();
+    val completedItems = HashSet<T>();
+    val result = ArrayList<T>()
+
+    fun DfsVisit(item: T) {
+        if (completedItems.contains(item))
+            return;
+
+        if (itemsInProgress.contains(item))
+            throw CycleInTopoSortException();
+
+        itemsInProgress.add(item);
+
+        for (dependency in dependencies(item)) {
+            DfsVisit(dependency);
+        }
+
+        itemsInProgress.remove(item);
+        completedItems.add(item);
+        result.add(item);
+    }
+
+    for (item in items)
+        DfsVisit(item)
+
+    return result.reverse();
+}
+
+public class CycleInTopoSortException : Exception()

core/container/src/Descriptors.kt

@@ -0,0 +1,15 @@
+package org.jetbrains.container
+
+import java.lang.reflect.ParameterizedType
+import java.util.ArrayList
+import java.util.LinkedHashSet
+
+
+public trait ValueDescriptor {
+    public fun getValue(): Any
+}
+
+public trait ComponentDescriptor : ValueDescriptor {
+    fun getRegistrations(): Iterable<Class<*>>
+    fun getDependencies(context: ValueResolveContext): Collection<Class<*>>
+}

core/container/src/Dsl.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.di
+
+import org.jetbrains.container.StorageComponentContainer
+import org.jetbrains.container.registerInstance
+import org.jetbrains.container.registerSingleton
+import kotlin.properties.ReadOnlyProperty
+
+public fun createContainer(id: String, init: StorageComponentContainer.() -> Unit): StorageComponentContainer {
+    val c = StorageComponentContainer(id)
+    c.init()
+    c.compose()
+    return c
+}
+
+public inline fun <reified T> StorageComponentContainer.useImpl() {
+    registerSingleton(javaClass<T>())
+}
+
+public inline fun <reified T> StorageComponentContainer.get(): T {
+    return resolve(javaClass<T>(), unknownContext)!!.getValue() as T
+}
+
+public fun StorageComponentContainer.useInstance(instance: Any) {
+    registerInstance(instance)
+}
+
+public class InjectedProperty<T>(
+        private val container: StorageComponentContainer, private val requestedComponent: Class<T>
+) : ReadOnlyProperty<Any?, T> {
+    override fun get(thisRef: Any?, desc: PropertyMetadata): T {
+        return container.resolve(requestedComponent)!!.getValue() as T
+    }
+}
+
+public inline fun <R, reified T> injected(container: StorageComponentContainer): ReadOnlyProperty<R, T>
+        = InjectedProperty(container, javaClass<T>())

core/container/src/Reflection.kt

@@ -0,0 +1,121 @@
+package org.jetbrains.container
+
+import java.beans.Introspector
+import java.lang.reflect.Method
+import java.lang.reflect.Modifier
+import java.util.ArrayList
+
+/**
+ * Thrown by the form builder if an invalid model property is specified.
+ */
+class InvalidPropertyException(val modelClass : Class<out Any>, val property : String) : RuntimeException("Invalid property ${property} on type ${modelClass.getName()}") {
+
+}
+
+fun Class<out Any>.objectInstance(): Any? {
+    try {
+        val field = getDeclaredField("INSTANCE\$")
+        if (Modifier.isStatic(field.getModifiers()) && Modifier.isPublic(field.getModifiers())) {
+            return field.get(null)
+        }
+        return null
+    }
+    catch (e: NoSuchFieldException) {
+        return null
+    }
+}
+
+fun Class<out Any>.classObjectInstance(): Any? {
+    try {
+        val field = getDeclaredField("OBJECT\$")
+        if (Modifier.isStatic(field.getModifiers()) && Modifier.isPublic(field.getModifiers())) {
+            return field.get(null)
+        }
+        return null
+    }
+    catch (e: NoSuchFieldException) {
+        return null
+    }
+}
+
+fun String?.asNotEmpty(): String? = if (this == null) null else if (!isEmpty()) this else null
+
+fun String.appendPathElement(part : String) : String {
+    val b = StringBuilder()
+    b.append(this)
+    if (!this.endsWith("/")) {
+        b.append("/")
+    }
+
+    if (part.startsWith('/')) {
+        b.append(part.substring(1))
+    }
+    else {
+        b.append(part)
+    }
+
+    return b.toString()
+}
+
+fun Class<out Any>.propertyGetter(property: String): Method {
+    try {
+        return getMethod("get${when {
+            property.length() == 1 && property[0].isLowerCase() -> property.capitalize()
+            property.length() > 2 && property[1].isLowerCase() -> property.capitalize()
+            else -> property
+        }}")
+    }
+    catch (e: Exception) {
+        throw InvalidPropertyException(this, property)
+    }
+}
+
+fun Class<out Any>.propertySetter(property: String): Method {
+    try {
+        return getMethod("set${when {
+            property.length() == 1 && property[0].isLowerCase() -> property.capitalize()
+            property.length() > 2 && property[1].isLowerCase() -> property.capitalize()
+            else -> property
+        }}")
+    }
+    catch (e: Exception) {
+        throw InvalidPropertyException(this, property)
+    }
+}
+
+fun Class<out Any>.propertyReadonly(property: String): Boolean {
+    try {
+        val getter = propertyGetter(property)
+        val valueType = getter.getReturnType()
+        if (valueType == null)
+            return true
+
+        getMethod("set${when {
+            property.length() == 1 && property[0].isLowerCase() -> property.capitalize()
+            property.length() > 2 && property[1].isLowerCase() -> property.capitalize()
+            else -> property
+        }}", valueType)
+        return false
+    }
+    catch (e: Exception) {
+        return true
+    }
+}
+
+fun Any.propertyValue(property: String): Any? {
+    val getter = javaClass.propertyGetter(property)
+    return getter.invoke(this)
+}
+
+fun Class<out Any>.properties(): List<String> {
+    val answer = ArrayList<String>()
+
+    for (method in getDeclaredMethods()) {
+        val name = method.getName()
+        if (name.startsWith("get") && method.getParameterTypes().size() == 0) {
+            answer.add(Introspector.decapitalize(name.substring(3)))
+        }
+    }
+
+    return answer.sort()
+}

core/container/src/Registry.kt

@@ -0,0 +1,64 @@
+package org.jetbrains.container
+
+import com.intellij.util.containers.MultiMap
+import java.util.*
+
+public fun ComponentRegisterEntry(value: ComponentRegisterEntry): ComponentRegisterEntry {
+    val entry = ComponentRegisterEntry()
+    entry.descriptors.addAll(value.descriptors)
+    return entry
+}
+
+
+class ComponentRegisterEntry() : Iterable<ComponentDescriptor> {
+    val descriptors: MutableList<ComponentDescriptor> = ArrayList()
+
+    override fun iterator(): Iterator<ComponentDescriptor> = descriptors.iterator()
+
+    public fun singleOrNull(): ComponentDescriptor? {
+        if (descriptors.size() == 1)
+            return descriptors[0]
+        else if (descriptors.size() == 0)
+            return null
+
+        throw UnresolvedDependenciesException("Invalid arity")
+    }
+
+    public fun add(item: ComponentDescriptor) {
+        descriptors.add(item)
+    }
+
+    public fun addAll(items: Collection<ComponentDescriptor>) {
+        descriptors.addAll(items)
+    }
+
+    public fun remove(item: ComponentDescriptor) {
+        descriptors.remove(item)
+    }
+
+    public fun removeAll(items: Collection<ComponentDescriptor>) {
+        descriptors.removeAll(items)
+    }
+}
+
+internal class ComponentRegistry {
+    fun buildRegistrationMap(descriptors: Collection<ComponentDescriptor>): MultiMap<Class<*>, ComponentDescriptor> {
+        val registrationMap = MultiMap<Class<*>, ComponentDescriptor>()
+        for (descriptor in descriptors) {
+            for (registration in descriptor.getRegistrations()) {
+                registrationMap.putValue(registration, descriptor)
+            }
+        }
+        return registrationMap
+    }
+
+    private var registrationMap = MultiMap.createLinkedSet<Class<*>, ComponentDescriptor>()
+
+    public fun addAll(descriptors: Collection<ComponentDescriptor>) {
+        registrationMap.putAllValues(buildRegistrationMap(descriptors))
+    }
+
+    public fun tryGetEntry(request: Class<*>): Collection<ComponentDescriptor> {
+        return registrationMap.get(request)
+    }
+}

core/container/src/Resolve.kt

@@ -0,0 +1,90 @@
+package org.jetbrains.container
+
+import org.jetbrains.kotlin.di.getInfo
+import java.lang.reflect.Constructor
+import java.lang.reflect.Method
+import java.lang.reflect.Type
+import java.util.ArrayList
+
+public trait ValueResolver {
+    fun resolve(request: Class<*>, context: ValueResolveContext): ValueDescriptor?
+}
+
+public trait ValueResolveContext {
+    fun resolve(registration: Class<*>): ValueDescriptor?
+}
+
+internal class ComponentResolveContext(val container: StorageComponentContainer, val requestingDescriptor: ValueDescriptor) : ValueResolveContext {
+    override fun resolve(registration: Class<*>): ValueDescriptor? = container.resolve(registration, this)
+    public override fun toString(): String = "for $requestingDescriptor in $container"
+}
+
+fun ComponentContainer.createInstance(klass: Class<*>): Any {
+    val context = createResolveContext(DynamicComponentDescriptor)
+    return klass.bindToConstructor(context).createInstance()
+}
+
+public class ConstructorBinding(val constructor: Constructor<*>, val argumentDescriptors: List<ValueDescriptor>) {
+    fun createInstance(): Any = constructor.createInstance(argumentDescriptors)
+}
+
+public class MethodBinding(val method: Method, val argumentDescriptors: List<ValueDescriptor>) {
+    fun invoke(instance: Any) {
+        val arguments = bindArguments(argumentDescriptors).toTypedArray()
+        method.invoke(instance, *arguments)
+    }
+}
+
+fun Constructor<*>.createInstance(argumentDescriptors: List<ValueDescriptor>) = newInstance(bindArguments(argumentDescriptors))!!
+
+public fun bindArguments(argumentDescriptors: List<ValueDescriptor>): List<Any> = argumentDescriptors.map { it.getValue() }
+
+fun Class<*>.bindToConstructor(context: ValueResolveContext): ConstructorBinding {
+    val constructorInfo = getInfo().constructorInfo!!
+    val candidate = constructorInfo.constructor
+    val arguments = ArrayList<ValueDescriptor>(constructorInfo.parameters.size())
+    var unsatisfied: MutableList<Type>? = null
+
+    for (parameter in constructorInfo.parameters) {
+        val descriptor = context.resolve(parameter)
+        if (descriptor == null) {
+            if (unsatisfied == null)
+                unsatisfied = ArrayList<Type>()
+            unsatisfied.add(parameter)
+        }
+        else {
+            arguments.add(descriptor)
+        }
+    }
+
+    if (unsatisfied == null) // constructor is satisfied with arguments
+        return ConstructorBinding(candidate, arguments)
+
+    throw UnresolvedDependenciesException("Dependencies for type `$this` cannot be satisfied:\n  ${unsatisfied}")
+}
+
+fun Method.bindToMethod(context: ValueResolveContext): MethodBinding {
+    val parameters = getParameterTypes()!!
+    val arguments = ArrayList<ValueDescriptor>(parameters.size())
+    var unsatisfied: MutableList<Type>? = null
+
+    for (parameter in parameters) {
+        val descriptor = context.resolve(parameter)
+        if (descriptor == null) {
+            if (unsatisfied == null)
+                unsatisfied = ArrayList<Type>()
+            unsatisfied.add(parameter)
+        }
+        else {
+            arguments.add(descriptor)
+        }
+    }
+
+    if (unsatisfied == null) // constructor is satisfied with arguments
+        return MethodBinding(this, arguments)
+
+    throw UnresolvedDependenciesException("Dependencies for method `$this` cannot be satisfied:\n  ${unsatisfied}")
+}
+
+class UnresolvedDependenciesException(message: String) : Exception(message)
+

core/container/src/Singletons.kt

@@ -0,0 +1,128 @@
+package org.jetbrains.container
+
+import org.jetbrains.kotlin.di.getInfo
+import java.io.Closeable
+import java.util.ArrayList
+import kotlin.properties.Delegates
+
+enum class ComponentState {
+    Null
+    Initializing
+    Initialized
+    Corrupted
+    Disposing
+    Disposed
+}
+
+public abstract class SingletonDescriptor(val container: ComponentContainer) : ComponentDescriptor, Closeable {
+    private var instance: Any? = null
+    protected var state: ComponentState = ComponentState.Null
+    private val disposableObjects by Delegates.lazy { ArrayList<Closeable>() }
+
+    public override fun getValue(): Any {
+        if (state == ComponentState.Corrupted)
+            throw ContainerConsistencyException("Component descriptor $this is corrupted and cannot be accessed")
+        if (state == ComponentState.Disposed)
+            throw ContainerConsistencyException("Component descriptor $this is disposed and cannot be accessed");
+        if (instance == null)
+            createInstance(container);
+        return instance!!
+    }
+
+    protected fun registerDisposableObject(ownedObject: Closeable) {
+        disposableObjects.add(ownedObject);
+    }
+
+    protected abstract fun createInstance(context: ValueResolveContext): Any
+
+    private fun createInstance(container: ComponentContainer) {
+        when (state) {
+            ComponentState.Null -> {
+                try {
+                    instance = createInstance(container.createResolveContext(this));
+                    return;
+                }
+                catch (ex: Throwable) {
+                    state = ComponentState.Corrupted;
+                    for (disposable in disposableObjects)
+                        disposable.close();
+                    throw ex
+                }
+            }
+            ComponentState.Initializing ->
+                throw ContainerConsistencyException("Could not create the component $this because it is being initialized. Do we have undetected circular dependency?");
+            ComponentState.Initialized ->
+                throw ContainerConsistencyException("Could not get the component $this. Instance is null in Initialized state");
+            ComponentState.Corrupted ->
+                throw ContainerConsistencyException("Could not get the component $this because it is corrupted");
+            ComponentState.Disposing ->
+                throw ContainerConsistencyException("Could not get the component $this because it is being disposed");
+            ComponentState.Disposed ->
+                throw ContainerConsistencyException("Could not get the component $this because it is already disposed");
+        }
+    }
+
+    private fun disposeImpl() {
+        val wereInstance = instance;
+        state = ComponentState.Disposing;
+        instance = null; // cannot get instance any more
+        try {
+            if (wereInstance is Closeable)
+                wereInstance.close();
+            for (disposable in disposableObjects)
+                disposable.close();
+        }
+        catch(ex: Throwable) {
+            state = ComponentState.Corrupted;
+            throw ex;
+        }
+        state = ComponentState.Disposed;
+    }
+
+    override fun close() {
+        when (state) {
+            ComponentState.Initialized ->
+                disposeImpl();
+            ComponentState.Corrupted -> {
+            } // corrupted component is in the undefined state, ignore
+            ComponentState.Null -> {
+            } // it's ok to to remove null component, it may have been never needed
+
+            ComponentState.Initializing ->
+                throw ContainerConsistencyException("The component is being initialized and cannot be disposed.");
+            ComponentState.Disposing ->
+                throw ContainerConsistencyException("The component is already in disposing state.");
+            ComponentState.Disposed ->
+                throw ContainerConsistencyException("The component has already been destroyed.");
+        }
+    }
+}
+
+public abstract class SingletonComponentDescriptor(container: ComponentContainer, val klass: Class<*>) : SingletonDescriptor(container) {
+    public override fun getRegistrations(): Iterable<Class<*>> = klass.getInfo().registrations
+}
+
+public class SingletonTypeComponentDescriptor(container: ComponentContainer, klass: Class<*>) : SingletonComponentDescriptor(container, klass) {
+    override fun createInstance(context: ValueResolveContext): Any = createInstanceOf(klass, context)
+    private fun createInstanceOf(klass: Class<*>, context: ValueResolveContext): Any {
+        val binding = klass.bindToConstructor(context)
+        state = ComponentState.Initializing
+        for (argumentDescriptor in binding.argumentDescriptors) {
+            if (argumentDescriptor is Closeable && argumentDescriptor !is SingletonDescriptor) {
+                registerDisposableObject(argumentDescriptor)
+            }
+        }
+
+        val constructor = binding.constructor
+        val arguments = bindArguments(binding.argumentDescriptors)
+
+        val instance = constructor.newInstance(*arguments.copyToArray())!!
+        state = ComponentState.Initialized
+        return instance
+    }
+
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> {
+        val classInfo = klass.getInfo()
+        return classInfo.constructorInfo?.parameters.orEmpty() + classInfo.setterInfos.flatMap { it.parameters }
+    }
+}

core/container/src/Storage.kt

@@ -0,0 +1,176 @@
+package org.jetbrains.container
+
+import com.intellij.util.containers.MultiMap
+import org.jetbrains.kotlin.di.getInfo
+import java.io.Closeable
+import java.lang.reflect.Modifier
+import java.util.ArrayList
+import java.util.HashSet
+import java.util.LinkedHashSet
+
+public enum class ComponentStorageState {
+    Initial
+    Initialized
+    Disposing
+    Disposed
+}
+
+public enum class ComponentInstantiation {
+    WithEnvironment
+    OnDemand
+}
+
+public enum class ComponentLifetime {
+    Singleton
+    Transient
+}
+
+public class ComponentStorage(val myId: String) : ValueResolver {
+    var state = ComponentStorageState.Initial
+    val registry = ComponentRegistry()
+    val descriptors = LinkedHashSet<ComponentDescriptor>()
+    val dependencies = MultiMap.createLinkedSet<ComponentDescriptor, Class<*>>()
+
+    override fun resolve(request: Class<*>, context: ValueResolveContext): ValueDescriptor? {
+        if (state == ComponentStorageState.Initial)
+            throw ContainerConsistencyException("Container was not composed before resolving")
+
+        val entry = registry.tryGetEntry(request)
+        if (entry.isNotEmpty()) {
+            registerDependency(request, context)
+
+            val descriptor = entry.singleOrNull()
+            return descriptor // we have single component or null (none or multiple)
+        }
+        return null
+    }
+
+    private fun registerDependency(request: Class<*>, context: ValueResolveContext) {
+        if (context is ComponentResolveContext) {
+            val descriptor = context.requestingDescriptor
+            if (descriptor is ComponentDescriptor) {
+                /*
+                        var requestingDescriptor = componentContext.RequestingDescriptor as IComponentDescriptor;
+                        if (requestingDescriptor == null || requestingDescriptor == DynamicComponentDescriptor.Instance || requestingDescriptor == UnidentifiedComponentDescriptor.Instance)
+                            return;
+                */
+
+                // CheckCircularDependencies(requestingDescriptor, requestingDescriptor, request, Stack<Pair<IComponentDescriptor, Any>>(), HashSet<Any>());
+                dependencies.putValue(descriptor, request);
+            }
+        }
+    }
+
+    public fun resolveMultiple(request: Class<*>, context: ValueResolveContext): Iterable<ValueDescriptor> {
+        registerDependency(request, context)
+        return registry.tryGetEntry(request)
+    }
+
+    public fun registerDescriptors(context: ComponentResolveContext, items: List<ComponentDescriptor>) {
+        if (state == ComponentStorageState.Disposed) {
+            throw ContainerConsistencyException("Cannot register descriptors in $state state")
+        }
+
+        for (descriptor in items)
+            descriptors.add(descriptor);
+
+        if (state == ComponentStorageState.Initialized)
+            composeDescriptors(context, items);
+
+    }
+
+    public fun compose(context: ComponentResolveContext) {
+        if (state != ComponentStorageState.Initial)
+            throw ContainerConsistencyException("Container $myId was already composed.");
+
+        state = ComponentStorageState.Initialized;
+        composeDescriptors(context, descriptors);
+    }
+
+    private fun composeDescriptors(context: ComponentResolveContext, descriptors: Collection<ComponentDescriptor>) {
+        if (descriptors.isEmpty()) return
+
+        registry.addAll(descriptors);
+
+        // inspect descriptors and register providers
+        // TODO
+
+        // inspect dependencies and register implicit
+        val implicits = LinkedHashSet<ComponentDescriptor>()
+        val visitedTypes = HashSet<Class<*>>()
+        for (descriptor in descriptors) {
+            registerImplicits(context, descriptor, visitedTypes, implicits)
+        }
+        registry.addAll(implicits)
+
+        // instantiate and inject properties
+        for (value in (descriptors + implicits).map { it.getValue() }) {
+            injectProperties(value, context)
+        }
+    }
+
+    private fun registerImplicits(
+            context: ComponentResolveContext, descriptor: ComponentDescriptor,
+            visitedTypes: HashSet<Class<*>>, implicitDescriptors: LinkedHashSet<ComponentDescriptor>
+    ) {
+        val dependencies = descriptor.getDependencies(context)
+        for (type in dependencies) {
+            if (!visitedTypes.add(type))
+                continue
+            visitedTypes.add(type)
+            val entry = registry.tryGetEntry(type)
+            if (entry.isEmpty()) {
+                val modifiers = type.getModifiers()
+                if (!Modifier.isInterface(modifiers) && !Modifier.isAbstract(modifiers) && !type.isPrimitive()) {
+                    val implicitDescriptor = SingletonTypeComponentDescriptor(context.container, type)
+                    implicitDescriptors.add(implicitDescriptor)
+                    registerImplicits(context, implicitDescriptor, visitedTypes, implicitDescriptors)
+                }
+            }
+        }
+    }
+
+    private fun injectProperties(instance: Any, context: ValueResolveContext) {
+        val classInfo = instance.javaClass.getInfo()
+
+        classInfo.setterInfos.forEach { setterInfo ->
+            val methodBinding = setterInfo.method.bindToMethod(context)
+            methodBinding.invoke(instance)
+        }
+    }
+
+    public fun dispose() {
+        if (state != ComponentStorageState.Initialized) {
+            if (state == ComponentStorageState.Initial)
+                return; // it is valid to dispose container which was not initialized
+            throw ContainerConsistencyException("Component container cannot be disposed in the $state state.");
+        }
+
+        state = ComponentStorageState.Disposing;
+        val disposeList = getDescriptorsInDisposeOrder()
+        for (descriptor in disposeList)
+            disposeDescriptor(descriptor);
+        state = ComponentStorageState.Disposed;
+    }
+
+    fun getDescriptorsInDisposeOrder(): List<ComponentDescriptor> {
+        return topologicalSort(descriptors)
+        {
+            val dependent = ArrayList<ComponentDescriptor>();
+            for (interfaceType in dependencies[it]) {
+                val entry = registry.tryGetEntry(interfaceType)
+                if (entry.isEmpty())
+                    continue
+                for (dependency in entry) {
+                    dependent.add(dependency)
+                }
+            }
+            dependent
+        }
+    }
+
+    fun disposeDescriptor(descriptor: ComponentDescriptor) {
+        if (descriptor is Closeable)
+            descriptor.close();
+    }
+}

core/container/src/Transients.kt

@@ -0,0 +1,26 @@
+package org.jetbrains.container
+
+public abstract class TransientDescriptor(val container: ComponentContainer) : ComponentDescriptor {
+    public override fun getValue(): Any = createInstance(container.createResolveContext(this));
+
+    protected abstract fun createInstance(context: ValueResolveContext): Any
+}
+
+public class TransientTypeComponentDescriptor(container: ComponentContainer, val klass: Class<*>) : TransientDescriptor(container) {
+    override fun getDependencies(context: ValueResolveContext): Collection<Class<*>> {
+        // TODO: impl
+        throw UnsupportedOperationException()
+    }
+
+    protected override fun createInstance(context: ValueResolveContext): Any {
+        val binding = klass.bindToConstructor(context)
+        val constructor = binding.constructor
+        val arguments = bindArguments(binding.argumentDescriptors)
+        val instance = constructor.newInstance(*arguments.copyToArray())!!
+        return instance
+    }
+
+    public override fun getRegistrations(): Iterable<Class<*>> {
+        return (klass.getInterfaces() + klass).toList()
+    }
+}

core/descriptors.runtime/descriptors.runtime.iml

@@ -11,5 +11,6 @@
     <orderEntry type="module" module-name="descriptors" exported="" />
     <orderEntry type="module" module-name="deserialization" exported="" />
     <orderEntry type="module" module-name="util.runtime" />
+    <orderEntry type="module" module-name="container" />
   </component>
 </module>

core/descriptors.runtime/src/org/jetbrains/kotlin/di/InjectorForRuntimeDescriptorLoader.java

@@ -1,119 +0,0 @@
-/*
- * 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.di;
-
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver;
-import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava;
-import org.jetbrains.kotlin.load.java.components.ExternalSignatureResolver;
-import org.jetbrains.kotlin.load.java.components.MethodSignatureChecker;
-import org.jetbrains.kotlin.load.java.components.JavaResolverCache;
-import org.jetbrains.kotlin.load.java.components.ExternalAnnotationResolver;
-import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator;
-import org.jetbrains.kotlin.load.java.components.SamConversionResolver;
-import org.jetbrains.kotlin.load.java.components.RuntimeErrorReporter;
-import org.jetbrains.kotlin.load.java.components.RuntimeSourceElementFactory;
-import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver;
-import org.jetbrains.kotlin.storage.LockBasedStorageManager;
-import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder;
-import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder;
-import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider;
-import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext;
-import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder;
-import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForRuntimeDescriptorLoader {
-
-    private final ClassLoader classLoader;
-    private final ModuleDescriptor moduleDescriptor;
-    private final JavaDescriptorResolver javaDescriptorResolver;
-    private final DeserializationComponentsForJava deserializationComponentsForJava;
-    private final ExternalSignatureResolver externalSignatureResolver;
-    private final MethodSignatureChecker methodSignatureChecker;
-    private final JavaResolverCache javaResolverCache;
-    private final ExternalAnnotationResolver externalAnnotationResolver;
-    private final JavaPropertyInitializerEvaluator javaPropertyInitializerEvaluator;
-    private final SamConversionResolver samConversionResolver;
-    private final RuntimeErrorReporter runtimeErrorReporter;
-    private final RuntimeSourceElementFactory runtimeSourceElementFactory;
-    private final SingleModuleClassResolver singleModuleClassResolver;
-    private final LockBasedStorageManager lockBasedStorageManager;
-    private final ReflectJavaClassFinder reflectJavaClassFinder;
-    private final ReflectKotlinClassFinder reflectKotlinClassFinder;
-    private final LazyJavaPackageFragmentProvider lazyJavaPackageFragmentProvider;
-    private final GlobalJavaResolverContext globalJavaResolverContext;
-    private final DeserializedDescriptorResolver deserializedDescriptorResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final JavaClassDataFinder javaClassDataFinder;
-    private final BinaryClassAnnotationAndConstantLoaderImpl binaryClassAnnotationAndConstantLoader;
-
-    public InjectorForRuntimeDescriptorLoader(
-        @NotNull ClassLoader classLoader,
-        @NotNull ModuleDescriptor moduleDescriptor
-    ) {
-        this.classLoader = classLoader;
-        this.moduleDescriptor = moduleDescriptor;
-        this.lockBasedStorageManager = new LockBasedStorageManager();
-        this.reflectJavaClassFinder = new ReflectJavaClassFinder(classLoader);
-        this.reflectKotlinClassFinder = new ReflectKotlinClassFinder(classLoader);
-        this.runtimeErrorReporter = RuntimeErrorReporter.INSTANCE$;
-        this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(runtimeErrorReporter);
-        this.externalAnnotationResolver = ExternalAnnotationResolver.EMPTY;
-        this.externalSignatureResolver = ExternalSignatureResolver.DO_NOTHING;
-        this.methodSignatureChecker = MethodSignatureChecker.DO_NOTHING;
-        this.javaResolverCache = JavaResolverCache.EMPTY;
-        this.javaPropertyInitializerEvaluator = JavaPropertyInitializerEvaluator.DO_NOTHING;
-        this.samConversionResolver = SamConversionResolver.EMPTY;
-        this.runtimeSourceElementFactory = RuntimeSourceElementFactory.INSTANCE$;
-        this.singleModuleClassResolver = new SingleModuleClassResolver();
-        this.globalJavaResolverContext = new GlobalJavaResolverContext(lockBasedStorageManager, reflectJavaClassFinder, reflectKotlinClassFinder, deserializedDescriptorResolver, externalAnnotationResolver, externalSignatureResolver, runtimeErrorReporter, methodSignatureChecker, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, runtimeSourceElementFactory, singleModuleClassResolver);
-        this.reflectionTypes = new ReflectionTypes(getModuleDescriptor());
-        this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, getModuleDescriptor(), reflectionTypes);
-        this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, getModuleDescriptor());
-        this.javaClassDataFinder = new JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver);
-        this.binaryClassAnnotationAndConstantLoader = new BinaryClassAnnotationAndConstantLoaderImpl(getModuleDescriptor(), lockBasedStorageManager, reflectKotlinClassFinder, runtimeErrorReporter);
-        this.deserializationComponentsForJava = new DeserializationComponentsForJava(lockBasedStorageManager, getModuleDescriptor(), javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider);
-
-        singleModuleClassResolver.setResolver(javaDescriptorResolver);
-
-        deserializedDescriptorResolver.setComponents(deserializationComponentsForJava);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ModuleDescriptor getModuleDescriptor() {
-        return this.moduleDescriptor;
-    }
-
-    public JavaDescriptorResolver getJavaDescriptorResolver() {
-        return this.javaDescriptorResolver;
-    }
-
-    public DeserializationComponentsForJava getDeserializationComponentsForJava() {
-        return this.deserializationComponentsForJava;
-    }
-
-}

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

@@ -16,27 +16,59 @@
 
 package org.jetbrains.kotlin.load.kotlin.reflect
 
+import org.jetbrains.container.*
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.ReflectionTypes
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader
+import org.jetbrains.kotlin.di.*
+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.DeserializationComponentsForJava
+import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver
 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(private val injector: InjectorForRuntimeDescriptorLoader) {
-    public val module: ModuleDescriptor get() = injector.getModuleDescriptor()
-
-    public val localClassResolver: LocalClassResolver get() = injector.getDeserializationComponentsForJava().components.localClassResolver
+public class RuntimeModuleData private(public val module: ModuleDescriptor, public val localClassResolver: LocalClassResolver) {
 
     companion object {
         public fun create(classLoader: ClassLoader): RuntimeModuleData {
             val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), listOf(), JavaToKotlinClassMap.INSTANCE)
             module.addDependencyOnModule(module)
             module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
-            val injector = InjectorForRuntimeDescriptorLoader(classLoader, module)
-            module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
-            return RuntimeModuleData(injector)
+
+            val container = createContainer("RuntimeDescriptorLoader") {
+                useInstance(classLoader)
+                useInstance(module)
+
+                useInstance(ExternalSignatureResolver.DO_NOTHING)
+                useInstance(MethodSignatureChecker.DO_NOTHING)
+                useInstance(JavaResolverCache.EMPTY)
+                useInstance(ExternalAnnotationResolver.EMPTY)
+                useInstance(JavaPropertyInitializerEvaluator.DO_NOTHING)
+                useInstance(SamConversionResolver.EMPTY)
+                useInstance(RuntimeSourceElementFactory)
+                useInstance(RuntimeErrorReporter)
+
+                useImpl<DeserializedDescriptorResolver>()
+                useImpl<SingleModuleClassResolver>()
+                useImpl<LockBasedStorageManager>()
+                useImpl<ReflectJavaClassFinder>()
+                useImpl<ReflectKotlinClassFinder>()
+            }
+
+            val descriptorResolver = container.get<JavaDescriptorResolver>()
+            val localClassResolver = container.get<DeserializationComponentsForJava>().components.localClassResolver
+
+            module.initialize(descriptorResolver.packageFragmentProvider)
+            return RuntimeModuleData(module, localClassResolver)
         }
     }
 }

generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt

@@ -16,38 +16,8 @@
 
 package org.jetbrains.kotlin.generators.injectors
 
-import com.intellij.openapi.project.Project
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.context.LazyResolveToken
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.generators.di.*
-import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
-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.reflect.ReflectJavaClassFinder
-import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
-import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator
-import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
-import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
-import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder
-import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
-import org.jetbrains.kotlin.load.kotlin.reflect.ReflectKotlinClassFinder
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.CallResolver
-import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
-import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
-import org.jetbrains.kotlin.resolve.lazy.*
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.types.DynamicTypesAllowed
-import org.jetbrains.kotlin.types.DynamicTypesSettings
-import org.jetbrains.kotlin.types.expressions.*
+import org.jetbrains.kotlin.generators.di.DependencyInjectorGenerator
+import org.jetbrains.kotlin.generators.di.generator
 
 // NOTE: After making changes, you need to re-generate the injectors.
 //       To do that, you can run main in this file.
@@ -66,231 +36,7 @@ public fun main(args: Array<String>) {
 private val DI_DEFAULT_PACKAGE = "org.jetbrains.kotlin.di"
 
 public fun createInjectorGenerators(): List<DependencyInjectorGenerator> =
-        listOf(
-                generatorForLazyLocalClassifierAnalyzer(),
-                generatorForTopDownAnalyzerForJvm(),
-                generatorForRuntimeDescriptorLoader(),
-                generatorForLazyResolveWithJava(),
-                generatorForTopDownAnalyzerForJs(),
-                generatorForMacro(),
-                generatorForTests(),
-                generatorForLazyResolve(),
-                generatorForBodyResolve(),
-                generatorForLazyBodyResolve(),
-                generatorForReplWithJava()
-        )
-
-private fun generatorForLazyLocalClassifierAnalyzer() =
-        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyLocalClassifierAnalyzer") {
-            parameter<Project>()
-            parameter<GlobalContext>(useAsContext = true)
-            parameter<BindingTrace>()
-            parameter<ModuleDescriptor>(name = "module", useAsContext = true)
-            parameter<AdditionalCheckerProvider>(useAsContext = true)
-            parameter<DynamicTypesSettings>()
-            parameter<LocalClassDescriptorHolder>()
-
-            publicField<LazyTopDownAnalyzer>()
-
-            field<NoTopLevelDescriptorProvider>()
-            field<NoFileScopeProvider>()
-            field<DeclarationScopeProviderForLocalClassifierAnalyzer>()
-            field<LocalLazyDeclarationResolver>()
-        }
-
-private fun generatorForLazyBodyResolve() =
-        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyBodyResolve") {
-            parameter<Project>()
-            parameter<GlobalContext>(useAsContext = true)
-            parameter<KotlinCodeAnalyzer>(name = "analyzer", useAsContext = true)
-            parameter<BindingTrace>()
-            parameter<AdditionalCheckerProvider>(useAsContext = true)
-            parameter<DynamicTypesSettings>()
-
-            field<ModuleDescriptor>(init = GivenExpression("analyzer.getModuleDescriptor()"), useAsContext = true)
-
-            publicField<LazyTopDownAnalyzerForTopLevel>()
-        }
-
-private fun generatorForTopDownAnalyzerForJs() =
-        generator("js/js.frontend/src", DI_DEFAULT_PACKAGE, "InjectorForTopDownAnalyzerForJs") {
-            commonForResolveSessionBased()
-
-            publicField<LazyTopDownAnalyzerForTopLevel>()
-
-            field<KotlinJsCheckerProvider>(useAsContext = true)
-            field<DynamicTypesAllowed>()
-        }
-
-private fun generatorForTopDownAnalyzerForJvm() =
-        generator("compiler/frontend.java/src", DI_DEFAULT_PACKAGE, "InjectorForTopDownAnalyzerForJvm") {
-            commonForJavaTopDownAnalyzer()
-        }
-
-private fun generatorForRuntimeDescriptorLoader() =
-        generator("core/descriptors.runtime/src", DI_DEFAULT_PACKAGE, "InjectorForRuntimeDescriptorLoader") {
-            parameter<ClassLoader>()
-            publicParameter<ModuleDescriptor>()
-
-            publicField<JavaDescriptorResolver>()
-            publicField<DeserializationComponentsForJava>()
-
-            field<ExternalSignatureResolver>(init = GetSingleton.byField(javaClass<ExternalSignatureResolver>(), "DO_NOTHING"))
-            field<MethodSignatureChecker>(init = GetSingleton.byField(javaClass<MethodSignatureChecker>(), "DO_NOTHING"))
-            field<JavaResolverCache>(init = GetSingleton.byField(javaClass<JavaResolverCache>(), "EMPTY"))
-            field<ExternalAnnotationResolver>(init = GetSingleton.byField(javaClass<ExternalAnnotationResolver>(), "EMPTY"))
-            field<JavaPropertyInitializerEvaluator>(init = GetSingleton.byField(javaClass<JavaPropertyInitializerEvaluator>(), "DO_NOTHING"))
-            field<SamConversionResolver>(init = GetSingleton.byField(javaClass<SamConversionResolver>(), "EMPTY"))
-
-            field<RuntimeErrorReporter>()
-            field<RuntimeSourceElementFactory>()
-            field<SingleModuleClassResolver>()
-
-            field<LockBasedStorageManager>()
-            field<ReflectJavaClassFinder>()
-            field<ReflectKotlinClassFinder>()
-        }
-
-private fun generatorForLazyResolveWithJava() =
-        generator("compiler/frontend.java/src", DI_DEFAULT_PACKAGE, "InjectorForLazyResolveWithJava") {
-            commonForResolveSessionBased()
-
-            parameter<GlobalSearchScope>(name = "moduleContentScope")
-            parameter<ModuleClassResolver>()
-
-            publicField<JavaDescriptorResolver>()
-
-            field<VirtualFileFinder>(
-                  init = GivenExpression(javaClass<VirtualFileFinderFactory>().getName()
-                                         + ".SERVICE.getInstance(project).create(moduleContentScope)")
-            )
-
-            field<JavaClassFinderImpl>()
-            field<TraceBasedExternalSignatureResolver>()
-            field<LazyResolveBasedCache>()
-            field<TraceBasedErrorReporter>()
-            field<PsiBasedMethodSignatureChecker>()
-            field<PsiBasedExternalAnnotationResolver>()
-            field<JavaPropertyInitializerEvaluatorImpl>()
-            field<SamConversionResolverImpl>()
-            field<JavaSourceElementFactoryImpl>()
-            field<JavaFlexibleTypeCapabilitiesProvider>()
-            field<LazyResolveToken>()
-            field<JavaLazyAnalyzerPostConstruct>()
-
-            field<KotlinJvmCheckerProvider>(useAsContext = true)
-        }
-
-private fun generatorForReplWithJava() =
-        generator("compiler/frontend.java/src", DI_DEFAULT_PACKAGE, "InjectorForReplWithJava") {
-            commonForJavaTopDownAnalyzer()
-            parameter<ScopeProvider.AdditionalFileScopeProvider>()
-        }
-
-private fun generatorForMacro() =
-        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForMacros") {
-            parameter<Project>()
-            parameter<ModuleDescriptor>(useAsContext = true)
-
-            publicField<ExpressionTypingServices>()
-            publicField<ExpressionTypingComponents>()
-            publicField<CallResolver>()
-            publicField<TypeResolver>()
-
-            field<GlobalContext>(useAsContext = true,
-                  init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"))
-
-            field<AdditionalCheckerProvider.DefaultProvider>(useAsContext = true)
-        }
-
-private fun generatorForTests() =
-        generator("compiler/tests", DI_DEFAULT_PACKAGE, "InjectorForTests") {
-            parameter<Project>()
-            parameter<ModuleDescriptor>(useAsContext = true)
-
-            publicField<DescriptorResolver>()
-            publicField<FunctionDescriptorResolver>()
-            publicField<TypeResolver>()
-            publicField<FakeCallResolver>()
-            publicField<KotlinJvmCheckerProvider>(name = "additionalCheckerProvider", useAsContext = true)
-            publicField<ExpressionTypingServices>()
-            publicField<QualifiedExpressionResolver>()
-
-            field<GlobalContext>(init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"),
-                  useAsContext = true)
-        }
-
-private fun generatorForBodyResolve() =
-        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForBodyResolve") {
-            parameter<Project>()
-            parameter<GlobalContext>(useAsContext = true)
-            parameter<BindingTrace>()
-            parameter<ModuleDescriptor>(useAsContext = true)
-            parameter<AdditionalCheckerProvider>(useAsContext = true)
-            parameter<StatementFilter>()
-
-            publicField<BodyResolver>()
-        }
-
-private fun generatorForLazyResolve() =
-        generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyResolve") {
-            parameter<Project>()
-            parameter<GlobalContext>(useAsContext = true)
-            parameter<ModuleDescriptorImpl>(useAsContext = true)
-            parameter<DeclarationProviderFactory>()
-            parameter<BindingTrace>()
-            parameter<AdditionalCheckerProvider>(useAsContext = true)
-            parameter<DynamicTypesSettings>()
-
-            publicField<ResolveSession>()
-
-            field<ScopeProvider>()
-            field<LazyResolveToken>()
-        }
-
-private fun DependencyInjectorGenerator.commonForResolveSessionBased() {
-    parameter<Project>()
-    parameter<GlobalContext>(useAsContext = true)
-    parameter<BindingTrace>()
-    publicParameter<ModuleDescriptorImpl>(name = "module", useAsContext = true)
-    parameter<DeclarationProviderFactory>()
-
-    publicField<ResolveSession>()
-    field<ScopeProvider>()
-}
-
-private fun DependencyInjectorGenerator.commonForJavaTopDownAnalyzer() {
-    commonForResolveSessionBased()
-
-    parameter<GlobalSearchScope>(name = "moduleContentScope")
-
-    publicField<LazyTopDownAnalyzer>()
-    publicField<LazyTopDownAnalyzerForTopLevel>()
-    publicField<JavaDescriptorResolver>()
-    publicField<DeserializationComponentsForJava>()
-
-    field<VirtualFileFinder>(
-          init = GivenExpression(javaClass<VirtualFileFinderFactory>().getName()
-                                 + ".SERVICE.getInstance(project).create(moduleContentScope)")
-    )
-
-    field<JavaClassFinderImpl>()
-    field<TraceBasedExternalSignatureResolver>()
-    field<LazyResolveBasedCache>()
-    field<TraceBasedErrorReporter>()
-    field<PsiBasedMethodSignatureChecker>()
-    field<PsiBasedExternalAnnotationResolver>()
-    field<JavaPropertyInitializerEvaluatorImpl>()
-    field<SamConversionResolverImpl>()
-    field<JavaSourceElementFactoryImpl>()
-    field<SingleModuleClassResolver>()
-    field<JavaLazyAnalyzerPostConstruct>()
-    field<JavaFlexibleTypeCapabilitiesProvider>()
-
-    field<KotlinJvmCheckerProvider>(useAsContext = true)
-
-    field<VirtualFileFinder>(init = GivenExpression(javaClass<VirtualFileFinder>().getName() + ".SERVICE.getInstance(project)"))
-}
+        listOf()
 
 
 private fun generator(

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

@@ -19,19 +19,19 @@ package org.jetbrains.kotlin.resolve.lazy
 import com.google.common.base.Function
 import com.google.common.base.Functions
 import com.intellij.psi.PsiElement
-import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.analyzer.*
+import org.jetbrains.kotlin.analyzer.computeTypeInContext
 import org.jetbrains.kotlin.cfg.JetFlowInformationProvider
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
-import org.jetbrains.kotlin.di.InjectorForBodyResolve
+import org.jetbrains.kotlin.di.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.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.psi.psiUtil.getParentOfType
 import org.jetbrains.kotlin.resolve.*
+import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyClassDescriptor
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor
@@ -39,11 +39,7 @@ import org.jetbrains.kotlin.resolve.scopes.ChainedScope
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.storage.ExceptionTracker
 import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.types.TypeConstructor
 import org.jetbrains.kotlin.types.TypeUtils
-import java.util.Collections
-
-import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 
 public abstract class ElementResolver protected(
@@ -376,9 +372,13 @@ public abstract class ElementResolver protected(
     }
 
     private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver {
-        val bodyResolve = InjectorForBodyResolve(file.getProject(), createParameters(resolveSession), trace,
-                                                 resolveSession.getModuleDescriptor(), getAdditionalCheckerProvider(file), statementFilter)
-        return bodyResolve.getBodyResolver()
+        val project = file.getProject()
+        val analysisParameters = createParameters(resolveSession)
+        val moduleDescriptor = resolveSession.getModuleDescriptor()
+        val additionalCheckerProvider = getAdditionalCheckerProvider(file)
+        val bodyResolve = createContainerForBodyResolve(project, analysisParameters, trace,
+                                                        moduleDescriptor, additionalCheckerProvider, statementFilter)
+        return bodyResolve.get<BodyResolver>()
     }
 
     private fun createParameters(resolveSession: ResolveSession): TopDownAnalysisParameters {

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.context.GlobalContext
 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.JsHeaderLibraryDetectionUtil
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
 import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
@@ -56,9 +56,10 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
                 project, globalContext.storageManager, syntheticFiles, moduleContentScope
         )
 
-        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(),
-                                              KotlinJsCheckerProvider, DynamicTypesAllowed())
-        val resolveSession = injector.getResolveSession()!!
+        val resolveSession = createLazyResolveSession(
+                project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(),
+                KotlinJsCheckerProvider, DynamicTypesAllowed()
+        )
         var packageFragmentProvider = resolveSession.getPackageFragmentProvider()
 
         if (moduleInfo is LibraryInfo) {

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

@@ -30,8 +30,9 @@ import org.jetbrains.kotlin.analyzer.AnalysisResult
 import org.jetbrains.kotlin.analyzer.analyzeInContext
 import org.jetbrains.kotlin.asJava.LightClassUtil
 import org.jetbrains.kotlin.context.SimpleGlobalContext
-import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
+import org.jetbrains.kotlin.di.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
@@ -223,14 +224,14 @@ private object KotlinResolveDataProvider {
             val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement)
 
             val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
-            val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
+            val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
                     project,
                     SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()),
                     resolveSession,
                     trace,
                     targetPlatform.getAdditionalCheckerProvider(),
                     targetPlatform.getDynamicTypesSettings()
-            ).getLazyTopDownAnalyzerForTopLevel()!!
+            ).get<LazyTopDownAnalyzerForTopLevel>()
 
             lazyTopDownAnalyzer.analyzeDeclarations(
                     TopDownAnalysisParameters.create(resolveSession.getStorageManager(), resolveSession.getExceptionTracker(), false, false),

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

@@ -34,6 +34,8 @@ import org.jetbrains.kotlin.analyzer.ResolverForProject
 import org.jetbrains.kotlin.analyzer.ModuleContent
 import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
 import org.jetbrains.kotlin.context.GlobalContextImpl
+import org.jetbrains.kotlin.storage.MemoizedFunctionToNullable
+import org.jetbrains.kotlin.storage.StorageManager
 
 fun createModuleResolverProvider(
         project: Project,
@@ -71,14 +73,9 @@ fun createModuleResolverProvider(
 
     val resolverForProject = createResolverForProject()
 
-    val moduleToBodiesResolveSession = modulesToCreateResolversFor.keysToMap {
-        module ->
-        val analyzer = resolverForProject.resolverForModule(module)
-        ResolveSessionForBodies(project, analyzer.lazyResolveSession)
-    }
     return ModuleResolverProviderImpl(
             resolverForProject,
-            moduleToBodiesResolveSession,
+            modulesToCreateResolversFor,
             globalContext,
             delegateProvider
     )
@@ -128,14 +125,25 @@ object EmptyModuleResolverProvider: ModuleResolverProvider {
 }
 
 class ModuleResolverProviderImpl(
+        val project: Project,
         override val resolverForProject: ResolverForProject<IdeaModuleInfo, ResolverForModule>,
-        private val bodiesResolveByModule: Map<IdeaModuleInfo, ResolveSessionForBodies>,
+        private val moduleInfos: Set<IdeaModuleInfo>,
         val globalContext: GlobalContextImpl,
         val delegateProvider: ModuleResolverProvider = EmptyModuleResolverProvider
 ): ModuleResolverProvider {
+    val x: MemoizedFunctionToNullable<IdeaModuleInfo, ResolveSessionForBodies> = globalContext.storageManager.createMemoizedFunctionWithNullableValues {
+        module: IdeaModuleInfo ->
+        if (module !in moduleInfos) null
+        else {
+            val analyzer = resolverForProject.resolverForModule(module)
+            ResolveSessionForBodies(project, analyzer.lazyResolveSession)
+        }
+    }
+
     override val exceptionTracker: ExceptionTracker = globalContext.exceptionTracker
 
     override fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies =
-            bodiesResolveByModule[module] ?:
+            x[module] ?:
             delegateProvider.resolveSessionForBodiesByModule(module)
+
 }

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

@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.context.GlobalContextImpl;
 import org.jetbrains.kotlin.descriptors.CallableDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
+import org.jetbrains.kotlin.frontend.di.DiPackage;
 import org.jetbrains.kotlin.idea.caches.resolve.JsProjectDetector;
 import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
 import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
@@ -247,14 +247,15 @@ public class JetSourceNavigationHelper {
         moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
         moduleDescriptor.seal();
 
-        ResolveSession resolveSession = new InjectorForLazyResolve(
+        ResolveSession resolveSession = DiPackage.createLazyResolveSession(
                 project,
                 globalContext,
                 moduleDescriptor,
                 providerFactory,
                 new BindingTraceContext(),
                 AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
-                new DynamicTypesSettings()).getResolveSession();
+                new DynamicTypesSettings()
+        );
 
         moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
         return resolveSession;

idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArguments.kt

@@ -17,25 +17,21 @@
 package org.jetbrains.kotlin.idea.intentions
 
 import com.intellij.openapi.editor.Editor
-import org.jetbrains.kotlin.psi.JetCallExpression
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
-import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.resolve.scopes.JetScope
-import org.jetbrains.kotlin.psi.JetTypeProjection
-import org.jetbrains.kotlin.psi.Call
-import org.jetbrains.kotlin.di.InjectorForMacros
-import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.psi.JetProperty
-import org.jetbrains.kotlin.psi.JetTypeArgumentList
-import org.jetbrains.kotlin.psi.JetReturnExpression
-import org.jetbrains.kotlin.psi.JetDeclarationWithBody
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
-import org.jetbrains.kotlin.psi.psiUtil.getTextWithLocation
-import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
-import org.jetbrains.kotlin.idea.util.approximateFlexibleTypes
-import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
+import org.jetbrains.kotlin.di.get
+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.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
+import org.jetbrains.kotlin.resolve.calls.CallResolver
+import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
+import org.jetbrains.kotlin.resolve.calls.util.DelegatingCall
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.TypeUtils
 
 public class RemoveExplicitTypeArguments : JetSelfTargetingOffsetIndependentIntention<JetTypeArgumentList>(
         "remove.explicit.type.arguments", javaClass()) {
@@ -47,8 +43,6 @@ public class RemoveExplicitTypeArguments : JetSelfTargetingOffsetIndependentInte
         val context = callExpression.analyze()
         if (callExpression.getTypeArguments().isEmpty()) return false
 
-        val injector = InjectorForMacros(callExpression.getProject(), callExpression.findModuleDescriptor())
-
         val scope = context[BindingContext.RESOLUTION_SCOPE, callExpression]
         val originalCall = callExpression.getResolvedCall(context)
         if (originalCall == null || scope !is JetScope) return false
@@ -72,7 +66,8 @@ public class RemoveExplicitTypeArguments : JetSelfTargetingOffsetIndependentInte
             TypeUtils.NO_EXPECTED_TYPE
         }
         val dataFlow = context.getDataFlowInfo(callExpression)
-        val resolutionResults = injector.getCallResolver().resolveFunctionCall(
+        val container = createContainerForMacros(callExpression.getProject(), callExpression.findModuleDescriptor())
+        val resolutionResults = container.get<CallResolver>().resolveFunctionCall(
                 BindingTraceContext(), scope, untypedCall, jType, dataFlow, false)
         assert (resolutionResults.isSingleResult()) { "Removing type arguments changed resolve for: " +
                 "${callExpression.getTextWithLocation()} to ${resolutionResults.getResultCode()}" }

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

@@ -35,18 +35,20 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
+import org.jetbrains.container.StorageComponentContainer;
 import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.GlobalContextImpl;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
+import org.jetbrains.kotlin.frontend.di.DiPackage;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.renderer.DescriptorRenderer;
 import org.jetbrains.kotlin.resolve.*;
+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,16 +108,16 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 FileBasedDeclarationProviderFactory declarationFactory =
                         new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), jetBuiltInsFiles);
 
-                InjectorForLazyResolve injectorForLazyResolve =
-                        new InjectorForLazyResolve(myProject, globalContext, module, declarationFactory, new BindingTraceContext(),
-                                                   AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
-                                                   new DynamicTypesSettings());
+                ResolveSession resolveSession = DiPackage.createLazyResolveSession(
+                        myProject, globalContext, module, declarationFactory,
+                        new BindingTraceContext(), AdditionalCheckerProvider.DefaultProvider.INSTANCE$, new DynamicTypesSettings()
+                );
 
-                module.initialize(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider());
+                module.initialize(resolveSession.getPackageFragmentProvider());
 
                 if (!ApplicationManager.getApplication().isUnitTestMode()) {
                     // Use lazy initialization in tests
-                    injectorForLazyResolve.getResolveSession().forceResolveAll();
+                    resolveSession.forceResolveAll();
                 }
 
                 List<PackageFragmentDescriptor> fragments =

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

@@ -19,7 +19,8 @@ package org.jetbrains.kotlin.idea.completion
 import com.intellij.lang.ASTNode
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.di.InjectorForMacros
+import org.jetbrains.kotlin.di.get
+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.util.makeNotNullable
@@ -29,6 +30,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.kotlin.resolve.bindingContextUtil.getTargetFunctionDescriptor
+import org.jetbrains.kotlin.resolve.calls.CallResolver
 import org.jetbrains.kotlin.resolve.calls.callUtil.noErrorsInValueArguments
 import org.jetbrains.kotlin.resolve.calls.checkers.AdditionalTypeChecker
 import org.jetbrains.kotlin.resolve.calls.checkers.CompositeChecker
@@ -152,10 +154,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()
+        ).get<CallResolver>()
         val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
 
         val expectedInfos = HashSet<ExpectedInfo>()

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

@@ -16,24 +16,26 @@
 
 package org.jetbrains.kotlin.idea.completion
 
+import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
-import java.util.HashMap
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.di.get
+import org.jetbrains.kotlin.frontend.di.createContainerForMacros
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.types.SubstitutionUtils
-import org.jetbrains.kotlin.types.Variance
-import org.jetbrains.kotlin.di.InjectorForMacros
-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.types.JetType
-import org.jetbrains.kotlin.resolve.JetModuleUtil
 import org.jetbrains.kotlin.psi.JetPsiFactory
 import org.jetbrains.kotlin.resolve.BindingTraceContext
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.JetModuleUtil
+import org.jetbrains.kotlin.resolve.TypeResolver
 import org.jetbrains.kotlin.resolve.scopes.ChainedScope
+import org.jetbrains.kotlin.resolve.scopes.JetScope
+import org.jetbrains.kotlin.types.JetType
+import org.jetbrains.kotlin.types.SubstitutionUtils
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.Variance
+import java.util.HashMap
 
 public object HeuristicSignatures {
     private val signatures = HashMap<Pair<FqName, Name>, List<String>>()
@@ -91,11 +93,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 rootPackagesScope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
         val typeParametersScope = TypeParametersScope(typeParameters)
         val scope = ChainedScope(moduleDescriptor, "Root packages + type parameters", typeParametersScope, rootPackagesScope)
-        val type = injector.getTypeResolver().resolveType(scope, typeRef, BindingTraceContext(), false)
+        val injector = createContainerForMacros(project, moduleDescriptor)
+        val type = injector.get<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,8 @@ 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.di.get
+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
@@ -28,6 +29,7 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
 import org.jetbrains.kotlin.types.JetType
 import org.jetbrains.kotlin.types.TypeUtils
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext
 import java.util.HashMap
 
@@ -38,7 +40,7 @@ public class IterableTypesDetector(
         private val loopVarType: JetType? = null
 ) {
 
-    private val injector = InjectorForMacros(project, moduleDescriptor)
+    private val injector = createContainerForMacros(project, moduleDescriptor)
     private val cache = HashMap<FuzzyType, Boolean>()
     private val iteratorName = Name.identifier("iterator")
 
@@ -57,9 +59,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 = injector.get<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/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt

@@ -16,22 +16,20 @@
 
 package org.jetbrains.kotlin.addImport
 
+import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.AbstractImportsTest
-import org.jetbrains.kotlin.psi.JetFile
-import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
+import org.jetbrains.kotlin.psi.JetFile
 import org.jetbrains.kotlin.psi.JetPsiFactory
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
-import org.jetbrains.kotlin.resolve.JetModuleUtil
-import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
-import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import com.intellij.psi.PsiDocumentManager
-import org.jetbrains.kotlin.di.InjectorForTests
-import org.jetbrains.kotlin.test.JetTestUtils
+import org.jetbrains.kotlin.resolve.BindingTraceContext
+import org.jetbrains.kotlin.resolve.JetModuleUtil
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
+import org.jetbrains.kotlin.test.InTextDirectivesUtils
+import org.jetbrains.kotlin.tests.di.createContainerForTests
 
 public abstract class AbstractAddImportTest : AbstractImportsTest() {
     override fun doTest(file: JetFile) {
@@ -47,7 +45,7 @@ public abstract class AbstractAddImportTest : AbstractImportsTest() {
         val importDirective = JetPsiFactory(getProject()).createImportDirective(descriptorName)
         val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
         val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-        val descriptors = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
+        val descriptors = createContainerForTests(getProject(), moduleDescriptor).qualifiedExpressionResolver
                 .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
                 .getAllDescriptors()
                 .filter(filter)

idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt

@@ -23,7 +23,6 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import org.jetbrains.kotlin.checkers.AbstractJetPsiCheckerTest
-import org.jetbrains.kotlin.di.InjectorForTests
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.completion.test.AbstractJvmBasicCompletionTest
@@ -35,10 +34,10 @@ import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.JetModuleUtil
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
 import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
+import org.jetbrains.kotlin.tests.di.createContainerForTests
 import java.io.File
 import kotlin.test.fail
 
@@ -58,7 +57,7 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck
                 val importDirective = JetPsiFactory(getProject()).createImportDirective(it)
                 val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
                 val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-                val descriptor = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
+                val descriptor = createContainerForTests(getProject(), moduleDescriptor).qualifiedExpressionResolver
                                          .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
                                          .getAllDescriptors()
                                          .singleOrNull() ?: error("Could not resolve descriptor to import: $it")

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

@@ -0,0 +1,50 @@
+/*
+ * 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 com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.di.createContainer
+import org.jetbrains.kotlin.di.get
+import org.jetbrains.kotlin.di.useImpl
+import org.jetbrains.kotlin.di.useInstance
+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(
+        project: Project, globalContext: GlobalContext, bindingTrace: BindingTrace,
+        module: ModuleDescriptorImpl, declarationProviderFactory: DeclarationProviderFactory
+): LazyTopDownAnalyzerForTopLevel {
+    val storageComponentContainer = createContainer("REPL") { //TODO: name
+        configureModule(project, globalContext, module, bindingTrace, KotlinJsCheckerProvider)
+
+        useInstance(declarationProviderFactory)
+        useImpl<ScopeProvider>()
+        useImpl<ResolveSession>()
+        useImpl<LazyTopDownAnalyzerForTopLevel>()
+        useImpl<DynamicTypesAllowed>()
+    }
+    return storageComponentContainer.get<LazyTopDownAnalyzerForTopLevel>()
+}
+

js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java

@@ -1,337 +0,0 @@
-/*
- * 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.di;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.kotlin.context.GlobalContext;
-import org.jetbrains.kotlin.storage.StorageManager;
-import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
-import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
-import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory;
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel;
-import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider;
-import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
-import org.jetbrains.kotlin.types.DynamicTypesAllowed;
-import org.jetbrains.kotlin.resolve.AnnotationResolver;
-import org.jetbrains.kotlin.resolve.calls.CallResolver;
-import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
-import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents;
-import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
-import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils;
-import org.jetbrains.kotlin.resolve.DescriptorResolver;
-import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
-import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
-import org.jetbrains.kotlin.context.TypeLazinessToken;
-import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker;
-import org.jetbrains.kotlin.types.expressions.FakeCallResolver;
-import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
-import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
-import org.jetbrains.kotlin.types.expressions.MultiDeclarationResolver;
-import org.jetbrains.kotlin.builtins.ReflectionTypes;
-import org.jetbrains.kotlin.types.expressions.ValueParameterResolver;
-import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.calls.CallCompleter;
-import org.jetbrains.kotlin.resolve.calls.CandidateResolver;
-import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
-import org.jetbrains.kotlin.resolve.lazy.LazyDeclarationResolver;
-import org.jetbrains.kotlin.resolve.lazy.DeclarationScopeProviderImpl;
-import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
-import org.jetbrains.kotlin.resolve.lazy.ScopeProvider.AdditionalFileScopeProvider;
-import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer;
-import org.jetbrains.kotlin.resolve.BodyResolver;
-import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer;
-import org.jetbrains.kotlin.resolve.DeclarationsChecker;
-import org.jetbrains.kotlin.resolve.ModifiersChecker;
-import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
-import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.OverloadResolver;
-import org.jetbrains.kotlin.resolve.OverrideResolver;
-import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */
-@SuppressWarnings("all")
-public class InjectorForTopDownAnalyzerForJs {
-
-    private final Project project;
-    private final GlobalContext globalContext;
-    private final StorageManager storageManager;
-    private final BindingTrace bindingTrace;
-    private final ModuleDescriptorImpl module;
-    private final KotlinBuiltIns kotlinBuiltIns;
-    private final PlatformToKotlinClassMap platformToKotlinClassMap;
-    private final DeclarationProviderFactory declarationProviderFactory;
-    private final ResolveSession resolveSession;
-    private final ScopeProvider scopeProvider;
-    private final LazyTopDownAnalyzerForTopLevel lazyTopDownAnalyzerForTopLevel;
-    private final KotlinJsCheckerProvider kotlinJsCheckerProvider;
-    private final SymbolUsageValidator symbolUsageValidator;
-    private final DynamicTypesAllowed dynamicTypesAllowed;
-    private final AnnotationResolver annotationResolver;
-    private final CallResolver callResolver;
-    private final ArgumentTypeResolver argumentTypeResolver;
-    private final ExpressionTypingServices expressionTypingServices;
-    private final ExpressionTypingComponents expressionTypingComponents;
-    private final CallExpressionResolver callExpressionResolver;
-    private final ControlStructureTypingUtils controlStructureTypingUtils;
-    private final DescriptorResolver descriptorResolver;
-    private final DelegatedPropertyResolver delegatedPropertyResolver;
-    private final TypeResolver typeResolver;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
-    private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
-    private final TypeLazinessToken typeLazinessToken;
-    private final ForLoopConventionsChecker forLoopConventionsChecker;
-    private final FakeCallResolver fakeCallResolver;
-    private final FunctionDescriptorResolver functionDescriptorResolver;
-    private final LocalClassifierAnalyzer localClassifierAnalyzer;
-    private final MultiDeclarationResolver multiDeclarationResolver;
-    private final ReflectionTypes reflectionTypes;
-    private final ValueParameterResolver valueParameterResolver;
-    private final StatementFilter statementFilter;
-    private final CallCompleter callCompleter;
-    private final CandidateResolver candidateResolver;
-    private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final LazyDeclarationResolver lazyDeclarationResolver;
-    private final DeclarationScopeProviderImpl declarationScopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final AdditionalFileScopeProvider additionalFileScopeProvider;
-    private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
-    private final BodyResolver bodyResolver;
-    private final ControlFlowAnalyzer controlFlowAnalyzer;
-    private final DeclarationsChecker declarationsChecker;
-    private final ModifiersChecker modifiersChecker;
-    private final FunctionAnalyzerExtension functionAnalyzerExtension;
-    private final DeclarationResolver declarationResolver;
-    private final OverloadResolver overloadResolver;
-    private final OverrideResolver overrideResolver;
-    private final VarianceChecker varianceChecker;
-
-    public InjectorForTopDownAnalyzerForJs(
-        @NotNull Project project,
-        @NotNull GlobalContext globalContext,
-        @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptorImpl module,
-        @NotNull DeclarationProviderFactory declarationProviderFactory
-    ) {
-        this.project = project;
-        this.globalContext = globalContext;
-        this.storageManager = globalContext.getStorageManager();
-        this.bindingTrace = bindingTrace;
-        this.module = module;
-        this.kotlinBuiltIns = module.getBuiltIns();
-        this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
-        this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, getModule(), declarationProviderFactory, bindingTrace);
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.lazyTopDownAnalyzerForTopLevel = new LazyTopDownAnalyzerForTopLevel();
-        this.kotlinJsCheckerProvider = KotlinJsCheckerProvider.INSTANCE$;
-        this.symbolUsageValidator = kotlinJsCheckerProvider.getSymbolUsageValidator();
-        this.dynamicTypesAllowed = new DynamicTypesAllowed();
-        this.annotationResolver = new AnnotationResolver();
-        this.callResolver = new CallResolver();
-        this.argumentTypeResolver = new ArgumentTypeResolver();
-        this.expressionTypingComponents = new ExpressionTypingComponents();
-        this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
-        this.callExpressionResolver = new CallExpressionResolver(callResolver, kotlinBuiltIns);
-        this.controlStructureTypingUtils = new ControlStructureTypingUtils(callResolver);
-        this.descriptorResolver = new DescriptorResolver();
-        this.delegatedPropertyResolver = new DelegatedPropertyResolver();
-        this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
-        this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider();
-        this.typeLazinessToken = new TypeLazinessToken();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModule(), flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesAllowed);
-        this.forLoopConventionsChecker = new ForLoopConventionsChecker();
-        this.fakeCallResolver = new FakeCallResolver(project, callResolver);
-        this.functionDescriptorResolver = new FunctionDescriptorResolver(typeResolver, descriptorResolver, annotationResolver, storageManager, expressionTypingServices, kotlinBuiltIns);
-        this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, functionDescriptorResolver, typeResolver, annotationResolver);
-        this.multiDeclarationResolver = new MultiDeclarationResolver(fakeCallResolver, descriptorResolver, typeResolver, symbolUsageValidator);
-        this.reflectionTypes = new ReflectionTypes(getModule());
-        this.valueParameterResolver = new ValueParameterResolver(kotlinJsCheckerProvider, expressionTypingServices);
-        this.statementFilter = new StatementFilter();
-        this.candidateResolver = new CandidateResolver();
-        this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
-        this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.lazyDeclarationResolver = new LazyDeclarationResolver(globalContext, bindingTrace);
-        this.declarationScopeProvider = new DeclarationScopeProviderImpl(lazyDeclarationResolver);
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.additionalFileScopeProvider = new AdditionalFileScopeProvider();
-        this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
-        this.bodyResolver = new BodyResolver();
-        this.controlFlowAnalyzer = new ControlFlowAnalyzer();
-        this.declarationsChecker = new DeclarationsChecker();
-        this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJsCheckerProvider);
-        this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
-        this.declarationResolver = new DeclarationResolver();
-        this.overloadResolver = new OverloadResolver();
-        this.overrideResolver = new OverrideResolver();
-        this.varianceChecker = new VarianceChecker(bindingTrace);
-
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setFunctionDescriptorResolver(functionDescriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setLazyDeclarationResolver(lazyDeclarationResolver);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
-
-        scopeProvider.setAdditionalFileScopesProvider(additionalFileScopeProvider);
-        scopeProvider.setDeclarationScopeProvider(declarationScopeProvider);
-
-        this.lazyTopDownAnalyzerForTopLevel.setKotlinCodeAnalyzer(resolveSession);
-        this.lazyTopDownAnalyzerForTopLevel.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
-
-        annotationResolver.setCallResolver(callResolver);
-        annotationResolver.setStorageManager(storageManager);
-        annotationResolver.setTypeResolver(typeResolver);
-
-        callResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
-        callResolver.setArgumentTypeResolver(argumentTypeResolver);
-        callResolver.setCallCompleter(callCompleter);
-        callResolver.setCandidateResolver(candidateResolver);
-        callResolver.setExpressionTypingServices(expressionTypingServices);
-        callResolver.setTaskPrioritizer(taskPrioritizer);
-        callResolver.setTypeResolver(typeResolver);
-
-        argumentTypeResolver.setBuiltIns(kotlinBuiltIns);
-        argumentTypeResolver.setExpressionTypingServices(expressionTypingServices);
-        argumentTypeResolver.setTypeResolver(typeResolver);
-
-        expressionTypingServices.setStatementFilter(statementFilter);
-
-        expressionTypingComponents.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
-        expressionTypingComponents.setAnnotationResolver(annotationResolver);
-        expressionTypingComponents.setBuiltIns(kotlinBuiltIns);
-        expressionTypingComponents.setCallExpressionResolver(callExpressionResolver);
-        expressionTypingComponents.setCallResolver(callResolver);
-        expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
-        expressionTypingComponents.setDescriptorResolver(descriptorResolver);
-        expressionTypingComponents.setDynamicTypesSettings(dynamicTypesAllowed);
-        expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
-        expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker);
-        expressionTypingComponents.setFunctionDescriptorResolver(functionDescriptorResolver);
-        expressionTypingComponents.setGlobalContext(globalContext);
-        expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer);
-        expressionTypingComponents.setMultiDeclarationResolver(multiDeclarationResolver);
-        expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap);
-        expressionTypingComponents.setReflectionTypes(reflectionTypes);
-        expressionTypingComponents.setSymbolUsageValidator(symbolUsageValidator);
-        expressionTypingComponents.setTypeResolver(typeResolver);
-        expressionTypingComponents.setValueParameterResolver(valueParameterResolver);
-
-        callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
-
-        descriptorResolver.setAnnotationResolver(annotationResolver);
-        descriptorResolver.setBuiltIns(kotlinBuiltIns);
-        descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        descriptorResolver.setExpressionTypingServices(expressionTypingServices);
-        descriptorResolver.setStorageManager(storageManager);
-        descriptorResolver.setTypeResolver(typeResolver);
-
-        delegatedPropertyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
-        delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns);
-        delegatedPropertyResolver.setCallResolver(callResolver);
-        delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        qualifiedExpressionResolver.setSymbolUsageValidator(symbolUsageValidator);
-
-        forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns);
-        forLoopConventionsChecker.setFakeCallResolver(fakeCallResolver);
-        forLoopConventionsChecker.setSymbolUsageValidator(symbolUsageValidator);
-
-        candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
-
-        jetImportsFactory.setProject(project);
-
-        lazyDeclarationResolver.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyDeclarationResolver.setTopLevelDescriptorProvider(resolveSession);
-
-        declarationScopeProvider.setFileScopeProvider(scopeProvider);
-
-        scriptBodyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
-        lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
-        lazyTopDownAnalyzer.setDeclarationScopeProvider(declarationScopeProvider);
-        lazyTopDownAnalyzer.setFileScopeProvider(scopeProvider);
-        lazyTopDownAnalyzer.setLazyDeclarationResolver(lazyDeclarationResolver);
-        lazyTopDownAnalyzer.setModuleDescriptor(module);
-        lazyTopDownAnalyzer.setOverloadResolver(overloadResolver);
-        lazyTopDownAnalyzer.setOverrideResolver(overrideResolver);
-        lazyTopDownAnalyzer.setTopLevelDescriptorProvider(resolveSession);
-        lazyTopDownAnalyzer.setTrace(bindingTrace);
-        lazyTopDownAnalyzer.setVarianceChecker(varianceChecker);
-
-        bodyResolver.setAdditionalCheckerProvider(kotlinJsCheckerProvider);
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-        bodyResolver.setValueParameterResolver(valueParameterResolver);
-
-        controlFlowAnalyzer.setTrace(bindingTrace);
-
-        declarationsChecker.setDescriptorResolver(descriptorResolver);
-        declarationsChecker.setModifiersChecker(modifiersChecker);
-        declarationsChecker.setTrace(bindingTrace);
-
-        functionAnalyzerExtension.setTrace(bindingTrace);
-
-        declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setTrace(bindingTrace);
-
-        overloadResolver.setTrace(bindingTrace);
-
-        overrideResolver.setTrace(bindingTrace);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public ModuleDescriptorImpl getModule() {
-        return this.module;
-    }
-
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
-    public LazyTopDownAnalyzerForTopLevel getLazyTopDownAnalyzerForTopLevel() {
-        return this.lazyTopDownAnalyzerForTopLevel;
-    }
-
-}

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.GlobalContextImpl;
 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;
@@ -83,17 +83,12 @@ public final class TopDownAnalyzerFacadeForJS {
 
         Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
 
-        InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
+        LazyTopDownAnalyzerForTopLevel analyzer = DiPackage.createTopDownAnalyzerForJs(
                 project, topDownAnalysisParameters, trace, module,
                 new FileBasedDeclarationProviderFactory(topDownAnalysisParameters.getStorageManager(), allFiles));
-        try {
-            injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisParameters, files,
-                                                           Collections.<PackageFragmentProvider>emptyList());
-            return JsAnalysisResult.success(trace, module);
-        }
-        finally {
-            injector.destroy();
-        }
+        analyzer.analyzeFiles(topDownAnalysisParameters, files,
+                              Collections.<PackageFragmentProvider>emptyList());
+        return JsAnalysisResult.success(trace, module);
     }
 
     public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {