From df529f1a4b40975aa5b038dbfcd13e0c2980bce5 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Tue, 28 Apr 2015 19:37:14 +0300 Subject: [PATCH] Convert usages of existing generated injectors to dynamic injectors Rewrite RuntimeModuleData to use hand-written code as we do not pack container module into runtime This change introduces some overhead (up to 10% for the tests I ran) in some scenarios in IDE, that should be addressed later --- .../kotlin/cli/jvm/repl/ReplInterpreter.java | 13 +- .../kotlin/cli/jvm/repl/di/injection.kt | 58 ++++++++ .../container/tests/ComponentContainerTest.kt | 1 + .../kotlin/frontend/java/di/injection.kt | 114 +++++++++++++++ .../kotlin/resolve/jvm/JvmAnalyzerFacade.kt | 6 +- .../jvm/TopDownAnalyzerFacadeForJVM.java | 62 ++++----- .../jetbrains/kotlin/analyzer/AnalyzerUtil.kt | 20 +-- .../jetbrains/kotlin/frontend/di/injection.kt | 131 ++++++++++++++++++ .../expressions/LocalClassifierAnalyzer.kt | 8 +- .../AbstractDescriptorRendererTest.kt | 6 +- .../resolve/JetExpectedResolveDataUtil.java | 9 +- .../AbstractConstraintSystemTest.kt | 24 ++-- .../AbstractLocalClassProtoTest.kt | 8 +- .../jetbrains/kotlin/tests/di/injection.kt | 49 +++++++ .../JetDefaultModalityModifiersTest.java | 15 +- .../kotlin/types/JetOverloadTest.java | 6 +- .../kotlin/types/JetOverridingTest.java | 5 +- .../kotlin/types/JetTypeCheckerTest.java | 9 +- .../kotlin/types/TypeSubstitutorTest.java | 11 +- .../kotlin/types/TypeUnifierTest.java | 6 +- .../load/kotlin/reflect/RuntimeModuleData.kt | 42 ++++-- .../idea/util/ShadowedDeclarationsFilter.kt | 5 +- .../kotlin/resolve/lazy/ElementResolver.kt | 8 +- .../idea/caches/resolve/JsAnalyzerFacade.kt | 8 +- .../idea/caches/resolve/KotlinResolveCache.kt | 8 +- .../navigation/JetSourceNavigationHelper.java | 6 +- .../references/BuiltInsReferenceResolver.java | 11 +- .../kotlin/idea/completion/ExpectedInfos.kt | 6 +- .../idea/completion/HeuristicSignatures.kt | 6 +- .../kotlin/idea/core/IterableTypesDetector.kt | 9 +- .../RemoveExplicitTypeArgumentsIntention.kt | 8 +- .../kotlin/frontend/js/di/injection.kt | 49 +++++++ .../analyze/TopDownAnalyzerFacadeForJS.java | 17 +-- 33 files changed, 580 insertions(+), 164 deletions(-) create mode 100644 compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt create mode 100644 compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt create mode 100644 compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt create mode 100644 js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java index 43d59e2122b..eaceaf3d4cd 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java @@ -36,6 +36,8 @@ import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport; import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; +import org.jetbrains.kotlin.cli.jvm.repl.di.ContainerForReplWithJava; +import org.jetbrains.kotlin.cli.jvm.repl.di.DiPackage; import org.jetbrains.kotlin.codegen.ClassBuilderFactories; import org.jetbrains.kotlin.codegen.CompilationErrorHandler; import org.jetbrains.kotlin.codegen.KotlinCodegenFacade; @@ -45,7 +47,6 @@ import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.ScriptDescriptor; import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.kotlin.di.InjectorForReplWithJava; import org.jetbrains.kotlin.idea.JetLanguage; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.parsing.JetParserDefinition; @@ -118,7 +119,7 @@ public class ReplInterpreter { } }; - InjectorForReplWithJava injector = new InjectorForReplWithJava( + ContainerForReplWithJava container = DiPackage.createContainerForReplWithJava( moduleContext, trace, scriptDeclarationFactory, @@ -127,13 +128,13 @@ public class ReplInterpreter { ); this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfo.EMPTY); - this.topDownAnalyzer = injector.getLazyTopDownAnalyzerForTopLevel(); - this.resolveSession = injector.getResolveSession(); + this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel(); + this.resolveSession = container.getResolveSession(); moduleContext.initializeModuleContents(new CompositePackageFragmentProvider( Arrays.asList( - injector.getResolveSession().getPackageFragmentProvider(), - injector.getJavaDescriptorResolver().getPackageFragmentProvider() + container.getResolveSession().getPackageFragmentProvider(), + container.getJavaDescriptorResolver().getPackageFragmentProvider() ) )); diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt new file mode 100644 index 00000000000..8dbfd81baa2 --- /dev/null +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt @@ -0,0 +1,58 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.cli.jvm.repl.di + +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.container.* +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.frontend.di.configureModule +import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis +import org.jetbrains.kotlin.load.java.JavaClassFinderImpl +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver +import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel +import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.ScopeProvider +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory + +public fun createContainerForReplWithJava( + moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory, + moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: ScopeProvider.AdditionalFileScopeProvider +): ContainerForReplWithJava = createContainer("ReplWithJava") { + configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace) + configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project) + + + useInstance(additionalFileScopeProvider) + useInstance(declarationProviderFactory) + + useImpl() + useImpl() +}.let { + it.get().initialize() + it.get().postCreate() + ContainerForReplWithJava(it) +} + +public class ContainerForReplWithJava(container: StorageComponentContainer) { + val resolveSession: ResolveSession by container + val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container + val javaDescriptorResolver: JavaDescriptorResolver by container +} diff --git a/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt b/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt index 38d2a851b5e..4b4021af5b3 100644 --- a/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt +++ b/compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.container.tests +import org.jetbrains.kotlin.container.* import org.junit.Test import java.io.Closeable import javax.inject.Inject diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt new file mode 100644 index 00000000000..79e33ae0cb7 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -0,0 +1,114 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.frontend.java.di + +import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.container.* +import org.jetbrains.kotlin.context.LazyResolveToken +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.frontend.di.configureModule +import org.jetbrains.kotlin.load.java.JavaClassFinderImpl +import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider +import org.jetbrains.kotlin.load.java.components.* +import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver +import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl +import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl +import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava +import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory +import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer +import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel +import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver +import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.ScopeProvider +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory + +public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) { + useInstance(moduleContentScope) + + useImpl() + + useImpl() + useImpl() + useImpl() + useImpl() + + useInstance(JvmVirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope)) + + useImpl() + useImpl() + useImpl() + useImpl() + useImpl() + useImpl() + useInstance(SamConversionResolverImpl) + useImpl() + useImpl() + useImpl() +} + +public fun createContainerForLazyResolveWithJava( + moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory, + moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver +): Pair = createContainer("LazyResolveWithJava") { + configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace) + configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project) + + useInstance(moduleClassResolver) + + useInstance(declarationProviderFactory) + useImpl() + useImpl() +}.let { + it.javaAnalysisInit() + + Pair(it.get(), it.get()) +} + + +public fun createContainerForTopDownAnalyzerForJvm( + moduleContext: ModuleContext, bindingTrace: BindingTrace, + declarationProviderFactory: DeclarationProviderFactory, + moduleContentScope: GlobalSearchScope +): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") { + configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace) + configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project) + useInstance(declarationProviderFactory) + + useImpl() + useImpl() +}.let { + it.javaAnalysisInit() + + ContainerForTopDownAnalyzerForJvm(it) +} + +private fun StorageComponentContainer.javaAnalysisInit() { + get().initialize() + get().postCreate() +} + +public class ContainerForTopDownAnalyzerForJvm(container: StorageComponentContainer) { + val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container + val javaDescriptorResolver: JavaDescriptorResolver by container + val deserializationComponentsForJava: DeserializationComponentsForJava by container +} \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt index d1fbdb5de46..a81ea1b60e0 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt @@ -24,8 +24,8 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl -import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider +import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.psi.JetFile @@ -66,7 +66,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade additionalProviders = new ArrayList(); + List additionalProviders = new ArrayList(); - 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, moduleContext.getModule(), moduleContext.getStorageManager(), - injector.getDeserializationComponentsForJava().getComponents(), - incrementalCache, moduleId - ) - ); - } + additionalProviders.add( + new IncrementalPackageFragmentProvider( + files, moduleContext.getModule(), moduleContext.getStorageManager(), + container.getDeserializationComponentsForJava().getComponents(), + incrementalCache, moduleId + ) + ); } - additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider()); - - injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders); - - BindingContext bindingContext = trace.getBindingContext(); - ModuleDescriptor module = moduleContext.getModule(); - - Collection analysisCompletedHandlerExtensions = - AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject()); - - for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) { - AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files); - if (result != null) return result; - } - - return AnalysisResult.success(bindingContext, module); } - finally { - injector.destroy(); + additionalProviders.add(container.getJavaDescriptorResolver().getPackageFragmentProvider()); + + container.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders); + + BindingContext bindingContext = trace.getBindingContext(); + ModuleDescriptor module = moduleContext.getModule(); + + Collection analysisCompletedHandlerExtensions = + AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject()); + + for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) { + AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files); + if (result != null) return result; } + + return AnalysisResult.success(bindingContext, module); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt index cd5d4dd1082..b0ed6795ef7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt @@ -16,18 +16,18 @@ package org.jetbrains.kotlin.analyzer +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.psi.JetExpression -import org.jetbrains.kotlin.resolve.scopes.JetScope -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.BindingTraceContext import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo +import org.jetbrains.kotlin.resolve.descriptorUtil.module +import org.jetbrains.kotlin.resolve.scopes.JetScope +import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.JetType import org.jetbrains.kotlin.types.TypeUtils -import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.types.ErrorUtils -import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.BindingTraceContext -import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.types.expressions.JetTypeInfo public fun JetExpression.computeTypeInfoInContext( @@ -37,8 +37,8 @@ public fun JetExpression.computeTypeInfoInContext( expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE, module: ModuleDescriptor = scope.getModule() ): JetTypeInfo { - val injectorForMacros = InjectorForMacros(getProject(), module) - return injectorForMacros.getExpressionTypingServices()!!.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace) + val expressionTypingServices = createContainerForMacros(getProject(), module).expressionTypingServices + return expressionTypingServices.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace) } public fun JetExpression.analyzeInContext( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt new file mode 100644 index 00000000000..46b4f5fb4d5 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt @@ -0,0 +1,131 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.frontend.di + +import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.container.* +import org.jetbrains.kotlin.context.LazyResolveToken +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.calls.CallResolver +import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer +import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider +import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.types.DynamicTypesSettings +import org.jetbrains.kotlin.types.expressions.* + +public fun StorageComponentContainer.configureModule( + moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider +) { + useInstance(moduleContext) + useInstance(moduleContext.module) + useInstance(moduleContext.project) + useInstance(moduleContext.storageManager) + useInstance(moduleContext.builtIns) + useInstance(moduleContext.platformToKotlinClassMap) + useInstance(additionalCheckerProvider) + useInstance(additionalCheckerProvider.symbolUsageValidator) +} + +public fun StorageComponentContainer.configureModule( + moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider, trace: BindingTrace +) { + configureModule(moduleContext, additionalCheckerProvider) + useInstance(trace) +} + +public fun createContainerForBodyResolve( + moduleContext: ModuleContext, bindingTrace: BindingTrace, + additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter +): StorageComponentContainer = createContainer("BodyResolve") { + configureModule(moduleContext, additionalCheckerProvider, bindingTrace) + + useInstance(statementFilter) + useImpl() +} + +public fun createContainerForLazyBodyResolve( + moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer, + bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider, + dynamicTypesSettings: DynamicTypesSettings +): StorageComponentContainer = createContainer("LazyBodyResolve") { + configureModule(moduleContext, additionalCheckerProvider, bindingTrace) + + useInstance(kotlinCodeAnalyzer) + useInstance(kotlinCodeAnalyzer.getScopeProvider()) + useInstance(dynamicTypesSettings) + useImpl() +} + +public fun createContainerForLazyLocalClassifierAnalyzer( + moduleContext: ModuleContext, + bindingTrace: BindingTrace, + additionalCheckerProvider: AdditionalCheckerProvider, + dynamicTypesSettings: DynamicTypesSettings, + localClassDescriptorHolder: LocalClassDescriptorHolder +): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") { + configureModule(moduleContext, additionalCheckerProvider, bindingTrace) + + useInstance(dynamicTypesSettings) + useInstance(localClassDescriptorHolder) + + useImpl() + + useInstance(NoTopLevelDescriptorProvider) + useInstance(NoFileScopeProvider) + + useImpl() + useImpl() +} + +private fun createContainerForLazyResolve( + moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace, + additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings +): StorageComponentContainer = createContainer("LazyResolve") { + configureModule(moduleContext, additionalCheckerProvider, bindingTrace) + + useInstance(dynamicTypesSettings) + useInstance(declarationProviderFactory) + + useImpl() + useImpl() +} + +public fun createLazyResolveSession( + moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace, + additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings +): ResolveSession = createContainerForLazyResolve( + moduleContext, declarationProviderFactory, bindingTrace, additionalCheckerProvider, dynamicTypesSettings +).get() + +public fun createContainerForMacros(project: Project, module: ModuleDescriptor): ContainerForMacros { + val componentContainer = createContainer("Macros") { + configureModule(ModuleContext(module, project), AdditionalCheckerProvider.DefaultProvider) + useImpl() + } + return ContainerForMacros(componentContainer) +} + +public class ContainerForMacros(container: StorageComponentContainer) { + val callResolver: CallResolver by container + val typeResolver: TypeResolver by container + val expressionTypingComponents: ExpressionTypingComponents by container + val expressionTypingServices: ExpressionTypingServices by container +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index c566ea59ad3..c410eb7ea6e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -24,8 +24,8 @@ import org.jetbrains.kotlin.context.withProject import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl -import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.frontend.di.createContainerForLazyLocalClassifierAnalyzer import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.JetClassOrObject import org.jetbrains.kotlin.psi.debugText.getDebugText @@ -64,7 +64,7 @@ public class LocalClassifierAnalyzer( ) { val module = DescriptorUtils.getContainingModule(containingDeclaration) val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module) - val injector = InjectorForLazyLocalClassifierAnalyzer( + val container = createContainerForLazyLocalClassifierAnalyzer( moduleContext, context.trace, additionalCheckerProvider, @@ -83,7 +83,7 @@ public class LocalClassifierAnalyzer( ) ) - injector.getLazyTopDownAnalyzer().analyzeDeclarations( + container.get().analyzeDeclarations( TopDownAnalysisMode.LocalDeclarations, listOf(classOrObject), context.dataFlowInfo diff --git a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt index 4bd2e850cc6..7ba11e2b160 100644 --- a/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor -import org.jetbrains.kotlin.di.InjectorForLazyResolve +import org.jetbrains.kotlin.frontend.di.createLazyResolveSession import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM @@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject()) - val resolveSession = InjectorForLazyResolve( + val resolveSession = createLazyResolveSession( context, FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)), CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), - KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession() + KotlinJvmCheckerProvider, DynamicTypesSettings()) context.initializeModuleContents(resolveSession.getPackageFragmentProvider()) diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java index ee0957594d0..9d5af24634e 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java @@ -21,7 +21,6 @@ import com.intellij.psi.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; @@ -31,6 +30,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage; import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import org.jetbrains.kotlin.types.JetType; import org.jetbrains.kotlin.types.TypeUtils; import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext; @@ -126,13 +127,13 @@ public class JetExpectedResolveDataUtil { JetType... parameterTypes ) { ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule(); - InjectorForTests injector = new InjectorForTests(project, emptyModule); + ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule); ExpressionTypingContext context = ExpressionTypingContext.newContext( - injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), + container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(), DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE); - OverloadResolutionResults functions = injector.getFakeCallResolver().resolveFakeCall( + OverloadResolutionResults functions = container.getFakeCallResolver().resolveFakeCall( context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes); for (ResolvedCall resolvedCall : functions.getResultingCalls()) { diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt index 3019236bb52..780dd7557e1 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt +++ b/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,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() { override fun setUp() { super.setUp() - val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule()) - _typeResolver = injector.getTypeResolver()!! + _typeResolver = createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).typeResolver _testDeclarations = analyzeDeclarations() } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index c167539f2ad..7bebb0a6663 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime -import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm +import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.java.structure.reflect.classId @@ -55,13 +55,13 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() { val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project) val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList()) - val injector = InjectorForTopDownAnalyzerForJvm( + val container = createContainerForTopDownAnalyzerForJvm( moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(), providerFactory, GlobalSearchScope.allScope(environment.project) ) - moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider) + moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider) - val components = injector.getDeserializationComponentsForJava().components + val components = container.deserializationComponentsForJava.components val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId) ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})") diff --git a/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt b/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt new file mode 100644 index 00000000000..37e60cb697d --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.tests.di + +import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.container.StorageComponentContainer +import org.jetbrains.kotlin.container.createContainer +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.container.useImpl +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.frontend.di.configureModule +import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider +import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider +import org.jetbrains.kotlin.resolve.DescriptorResolver +import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver +import org.jetbrains.kotlin.resolve.TypeResolver +import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices +import org.jetbrains.kotlin.types.expressions.FakeCallResolver + +public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests { + return ContainerForTests(createContainer("Tests") { + configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider) + useImpl() + }) +} + +class ContainerForTests(container: StorageComponentContainer) { + val descriptorResolver: DescriptorResolver by container + val functionDescriptorResolver: FunctionDescriptorResolver by container + val typeResolver: TypeResolver by container + val fakeCallResolver: FakeCallResolver by container + val expressionTypingServices: ExpressionTypingServices by container + val additionalCheckerProvider: AdditionalCheckerProvider by container +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java index a5228a63921..2a8b79a0e40 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java @@ -23,8 +23,6 @@ import org.jetbrains.kotlin.context.ContextPackage; import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.kotlin.di.InjectorForLazyResolve; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; @@ -38,10 +36,13 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import java.util.Collections; import java.util.List; +import static org.jetbrains.kotlin.frontend.di.DiPackage.createLazyResolveSession; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; public class JetDefaultModalityModifiersTest extends JetLiteFixture { @@ -71,9 +72,9 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private JetScope scope; public void setUp() throws Exception { - InjectorForTests injector = new InjectorForTests(getProject(), root); - descriptorResolver = injector.getDescriptorResolver(); - functionDescriptorResolver = injector.getFunctionDescriptorResolver(); + ContainerForTests containerForTests = DiPackage.createContainerForTests(getProject(), root); + descriptorResolver = containerForTests.getDescriptorResolver(); + functionDescriptorResolver = containerForTests.getFunctionDescriptorResolver(); scope = createScope(KotlinBuiltIns.getInstance().getBuiltInsPackageScope()); } @@ -99,14 +100,14 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) { ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject()); - ResolveSession resolveSession = new InjectorForLazyResolve( + ResolveSession resolveSession = createLazyResolveSession( moduleContext, new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), Collections.singleton(aClass.getContainingJetFile())), new BindingTraceContext(), AdditionalCheckerProvider.DefaultProvider.INSTANCE$, new DynamicTypesSettings() - ).getResolveSession(); + ); return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass); } diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java index baca089c974..40c135094e7 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.psi.JetNamedFunction; import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.resolve.OverloadUtil; @@ -28,6 +27,8 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; @@ -44,8 +45,7 @@ public class JetOverloadTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); - InjectorForTests injector = new InjectorForTests(getProject(), root); - functionDescriptorResolver = injector.getFunctionDescriptorResolver(); + functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver(); } @Override diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java index 3ab7903015c..7919cfc7119 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java @@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.descriptors.FunctionDescriptor; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.psi.JetNamedFunction; import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver; import org.jetbrains.kotlin.resolve.OverridingUtil; @@ -28,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.DiPackage; import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; @@ -44,8 +44,7 @@ public class JetOverridingTest extends JetLiteFixture { @Override public void setUp() throws Exception { super.setUp(); - InjectorForTests injector = new InjectorForTests(getProject(), root); - functionDescriptorResolver = injector.getFunctionDescriptorResolver(); + functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver(); } @Override diff --git a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java index 17892b67441..7f99415756d 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor; import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetExpression; @@ -40,6 +39,8 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import org.jetbrains.kotlin.types.checker.JetTypeChecker; import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; @@ -72,9 +73,9 @@ public class JetTypeCheckerTest extends JetLiteFixture { builtIns = KotlinBuiltIns.getInstance(); - InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule()); - typeResolver = injector.getTypeResolver(); - expressionTypingServices = injector.getExpressionTypingServices(); + ContainerForTests container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule()); + typeResolver = container.getTypeResolver(); + expressionTypingServices = container.getExpressionTypingServices(); scopeWithImports = getDeclarationsScope("compiler/testData/type-checker-test.kt"); } diff --git a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java index 1b902f580ff..b7cddf77cf2 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java @@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.ClassifierDescriptor; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.diagnostics.Diagnostic; import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages; import org.jetbrains.kotlin.name.FqName; @@ -45,6 +44,8 @@ import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil; import org.jetbrains.kotlin.resolve.scopes.*; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import java.io.File; import java.io.IOException; @@ -56,7 +57,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; @SuppressWarnings("unchecked") public class TypeSubstitutorTest extends KotlinTestWithEnvironment { private JetScope scope; - private InjectorForTests injector; + private ContainerForTests container; @Override protected KotlinCoreEnvironment createEnvironment() { @@ -67,13 +68,13 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { protected void setUp() throws Exception { super.setUp(); - injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule()); + container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule()); scope = getContextScope(); } @Override protected void tearDown() throws Exception { - injector = null; + container = null; scope = null; super.tearDown(); } @@ -140,7 +141,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr); AnalyzingUtils.checkForSyntacticErrors(jetTypeReference); BindingTrace trace = new BindingTraceContext(); - JetType type = injector.getTypeResolver().resolveType(scope, jetTypeReference, trace, true); + JetType type = container.getTypeResolver().resolveType(scope, jetTypeReference, trace, true); if (!trace.getBindingContext().getDiagnostics().isEmpty()) { fail("Errors:\n" + StringUtil.join( trace.getBindingContext().getDiagnostics(), diff --git a/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java b/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java index ce674db4625..d92cb52247e 100644 --- a/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java +++ b/compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl; -import org.jetbrains.kotlin.di.InjectorForTests; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetTypeProjection; import org.jetbrains.kotlin.psi.JetTypeReference; @@ -38,6 +37,8 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.JetLiteFixture; import org.jetbrains.kotlin.test.JetTestUtils; +import org.jetbrains.kotlin.tests.di.ContainerForTests; +import org.jetbrains.kotlin.tests.di.DiPackage; import java.util.Map; import java.util.Set; @@ -63,8 +64,7 @@ public class TypeUnifierTest extends JetLiteFixture { builtIns = KotlinBuiltIns.getInstance(); - InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule()); - typeResolver = injector.getTypeResolver(); + typeResolver = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).getTypeResolver(); x = createTypeVariable("X"); y = createTypeVariable("Y"); variables = Sets.newHashSet(x.getTypeConstructor(), y.getTypeConstructor()); diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt index 240b7a40061..b581f3b1c5c 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt @@ -17,29 +17,53 @@ package org.jetbrains.kotlin.load.kotlin.reflect import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.ReflectionTypes import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl -import org.jetbrains.kotlin.di.InjectorForRuntimeDescriptorLoader +import org.jetbrains.kotlin.load.java.components.* +import org.jetbrains.kotlin.load.java.lazy.GlobalJavaResolverContext +import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver +import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder +import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator +import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl +import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava +import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver +import org.jetbrains.kotlin.load.kotlin.JavaClassDataFinder import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.JavaToKotlinClassMap +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver import org.jetbrains.kotlin.storage.LockBasedStorageManager -public class RuntimeModuleData private constructor(private val injector: InjectorForRuntimeDescriptorLoader) { - public val module: ModuleDescriptor get() = injector.getModuleDescriptor() - - public val localClassResolver: LocalClassResolver get() = injector.getDeserializationComponentsForJava().components.localClassResolver - +public class RuntimeModuleData private constructor(public val module: ModuleDescriptor, public val localClassResolver: LocalClassResolver) { companion object { public fun create(classLoader: ClassLoader): RuntimeModuleData { val storageManager = LockBasedStorageManager() val module = ModuleDescriptorImpl(Name.special(""), storageManager, ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE)) + + val reflectKotlinClassFinder = ReflectKotlinClassFinder(classLoader) + val deserializedDescriptorResolver = DeserializedDescriptorResolver(RuntimeErrorReporter) + val singleModuleClassResolver = SingleModuleClassResolver() + val globalJavaResolverContext = GlobalJavaResolverContext( + storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver, + ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY, + JavaPropertyInitializerEvaluator.DO_NOTHING, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver + ) + val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module)) + val javaDescriptorResolver = JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module) + val javaClassDataFinder = JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver) + val binaryClassAnnotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, reflectKotlinClassFinder, RuntimeErrorReporter) + val deserializationComponentsForJava = DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider) + singleModuleClassResolver.resolver = javaDescriptorResolver + deserializedDescriptorResolver.setComponents(deserializationComponentsForJava) + module.setDependencies(module, KotlinBuiltIns.getInstance().getBuiltInsModule()) - val injector = InjectorForRuntimeDescriptorLoader(classLoader, module, storageManager) - module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider) - return RuntimeModuleData(injector) + module.initialize(javaDescriptorResolver.packageFragmentProvider) + + return RuntimeModuleData(module, deserializationComponentsForJava.components.localClassResolver) } } } diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt index 1efb156fb67..fc6551a2fc9 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt @@ -18,9 +18,8 @@ package org.jetbrains.kotlin.idea.util import com.intellij.openapi.project.Project import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.idea.imports.importableFqName -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DelegatingBindingTrace @@ -167,7 +166,7 @@ public class ShadowedDeclarationsFilter( val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, newCall, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo, ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false) - val callResolver = InjectorForMacros(project, moduleDescriptor).getCallResolver() + val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context) val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }.toSet() val filtered = descriptors.filter { it in resultingDescriptors } diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt index 8f7940423be..a2478f3f1a1 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt @@ -26,7 +26,8 @@ import org.jetbrains.kotlin.context.withModule import org.jetbrains.kotlin.context.withProject import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.di.InjectorForBodyResolve +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.frontend.di.createContainerForBodyResolve import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* @@ -369,11 +370,10 @@ public abstract class ElementResolver protected constructor( private fun createBodyResolver(resolveSession: ResolveSession, trace: BindingTrace, file: JetFile, statementFilter: StatementFilter): BodyResolver { val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()) - val bodyResolve = InjectorForBodyResolve( + return createContainerForBodyResolve( globalContext.withProject(file.getProject()).withModule(resolveSession.getModuleDescriptor()), trace, getAdditionalCheckerProvider(file), statementFilter - ) - return bodyResolve.getBodyResolver() + ).get() } private fun createEmptyContext(): BodyResolveContextForLazy { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt index 055b2bcb57c..e65ade57bfa 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl -import org.jetbrains.kotlin.di.InjectorForLazyResolve +import org.jetbrains.kotlin.frontend.di.createLazyResolveSession import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider @@ -56,9 +56,9 @@ public object JsAnalyzerFacade : AnalyzerFacade() lazyTopDownAnalyzer.analyzeDeclarations( TopDownAnalysisMode.TopLevelDeclarations, diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java index ed346f2dfa2..ba74ea95f45 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java @@ -44,7 +44,7 @@ import org.jetbrains.kotlin.context.ContextPackage; import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.descriptors.ClassDescriptor; -import org.jetbrains.kotlin.di.InjectorForLazyResolve; +import org.jetbrains.kotlin.frontend.di.DiPackage; import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex; import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope; import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex; @@ -250,12 +250,12 @@ public class JetSourceNavigationHelper { getContainingFiles(candidates) ); - ResolveSession resolveSession = new InjectorForLazyResolve( + ResolveSession resolveSession = DiPackage.createLazyResolveSession( newModuleContext, providerFactory, new BindingTraceContext(), AdditionalCheckerProvider.DefaultProvider.INSTANCE$, - new DynamicTypesSettings()).getResolveSession(); + new DynamicTypesSettings()); newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider()); return resolveSession; diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java index 1d9cc76bfd0..0b7d0ed322e 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java @@ -40,7 +40,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.context.ContextPackage; import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.di.InjectorForLazyResolve; +import org.jetbrains.kotlin.frontend.di.DiPackage; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.renderer.DescriptorRenderer; @@ -48,6 +48,7 @@ import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.resolve.BindingTraceContext; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; +import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.kotlin.resolve.scopes.JetScope; import org.jetbrains.kotlin.types.DynamicTypesSettings; @@ -106,19 +107,19 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { FileBasedDeclarationProviderFactory declarationFactory = new FileBasedDeclarationProviderFactory(newModuleContext.getStorageManager(), jetBuiltInsFiles); - InjectorForLazyResolve injectorForLazyResolve = - new InjectorForLazyResolve( + ResolveSession resolveSession = + DiPackage.createLazyResolveSession( newModuleContext, declarationFactory, new BindingTraceContext(), AdditionalCheckerProvider.DefaultProvider.INSTANCE$, new DynamicTypesSettings() ); - newModuleContext.initializeModuleContents(injectorForLazyResolve.getResolveSession().getPackageFragmentProvider()); + newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider()); if (!ApplicationManager.getApplication().isUnitTestMode()) { // Use lazy initialization in tests - injectorForLazyResolve.getResolveSession().forceResolveAll(); + resolveSession.forceResolveAll(); } PackageViewDescriptor packageView = newModuleContext.getModule().getPackage(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME); diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt index 1bf7e2a80e8..06bcd5885ad 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.completion import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade import org.jetbrains.kotlin.idea.completion.smart.toList import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters @@ -158,10 +158,10 @@ class ExpectedInfos( ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED, CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false) val callResolutionContext = context.replaceCollectAllCandidates(true) - val callResolver = InjectorForMacros( + val callResolver = createContainerForMacros( callElement.getProject(), resolutionFacade.findModuleDescriptor(callElement) - ).getCallResolver() + ).callResolver val results: OverloadResolutionResults = callResolver.resolveFunctionCall(callResolutionContext) val expectedInfos = HashSet() diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt index 9e97eeae3fc..b1b305b7aa3 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetPsiFactory @@ -97,11 +97,11 @@ public object HeuristicSignatures { private fun typeFromText(text: String, typeParameters: Collection, moduleDescriptor: ModuleDescriptor, project: Project): JetType { val typeRef = JetPsiFactory(project).createType(text) - val injector = InjectorForMacros(project, moduleDescriptor) + val container = createContainerForMacros(project, moduleDescriptor) val rootPackagesScope = SubpackagesScope(moduleDescriptor, FqName.ROOT) val typeParametersScope = TypeParametersScope(typeParameters) val scope = ChainedScope(moduleDescriptor, "Root packages + type parameters", typeParametersScope, rootPackagesScope) - val type = injector.getTypeResolver().resolveType(scope, typeRef, BindingTraceContext(), false) + val type = container.typeResolver.resolveType(scope, typeRef, BindingTraceContext(), false) assert(!type.isError()) { "No type resolved from '$text'" } return type } diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt index 4e138b9785d..58b922de711 100644 --- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt +++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.core import com.intellij.openapi.project.Project import org.jetbrains.kotlin.descriptors.ModuleDescriptor -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.idea.util.FuzzyType import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetPsiFactory @@ -38,7 +38,7 @@ public class IterableTypesDetector( private val loopVarType: JetType? = null ) { - private val injector = InjectorForMacros(project, moduleDescriptor) + private val container = createContainerForMacros(project, moduleDescriptor) private val cache = HashMap() private val iteratorName = Name.identifier("iterator") @@ -57,9 +57,10 @@ public class IterableTypesDetector( val expression = JetPsiFactory(project).createExpression("fake") val expressionReceiver = ExpressionReceiver(expression, type.type) - val context = ExpressionTypingContext.newContext(injector.getExpressionTypingComponents().getAdditionalCheckerProvider(), + val expressionTypingComponents = container.expressionTypingComponents + val context = ExpressionTypingContext.newContext(expressionTypingComponents.getAdditionalCheckerProvider(), BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE) - val elementType = injector.getExpressionTypingComponents().getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context) + val elementType = expressionTypingComponents.getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context) if (elementType == null) return false return loopVarType == null || FuzzyType(elementType, type.freeParameters).checkIsSubtypeOf(loopVarType) != null } diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt index e5bca162587..522d8d76201 100644 --- a/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt +++ b/idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt @@ -18,13 +18,11 @@ package org.jetbrains.kotlin.idea.intentions import com.intellij.codeInspection.ProblemHighlightType import com.intellij.openapi.editor.Editor -import org.jetbrains.kotlin.di.InjectorForMacros +import org.jetbrains.kotlin.frontend.di.createContainerForMacros import org.jetbrains.kotlin.idea.caches.resolve.analyze import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor import org.jetbrains.kotlin.idea.inspections.IntentionBasedInspection -import org.jetbrains.kotlin.idea.util.approximateFlexibleTypes import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.psi.psiUtil.getTextWithLocation import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.BindingTraceContext import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfo @@ -70,8 +68,8 @@ public class RemoveExplicitTypeArgumentsIntention : JetSelfTargetingOffsetIndepe TypeUtils.NO_EXPECTED_TYPE } val dataFlow = context.getDataFlowInfo(callExpression) - val injector = InjectorForMacros(callExpression.getProject(), callExpression.findModuleDescriptor()) - val resolutionResults = injector.getCallResolver().resolveFunctionCall( + val container = createContainerForMacros(callExpression.getProject(), callExpression.findModuleDescriptor()) + val resolutionResults = container.callResolver.resolveFunctionCall( BindingTraceContext(), scope, untypedCall, expectedType, dataFlow, false) if (!resolutionResults.isSingleResult()) { return false diff --git a/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt new file mode 100644 index 00000000000..9973f21f391 --- /dev/null +++ b/js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.frontend.js.di + +import org.jetbrains.kotlin.container.createContainer +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.container.useImpl +import org.jetbrains.kotlin.container.useInstance +import org.jetbrains.kotlin.context.ModuleContext +import org.jetbrains.kotlin.frontend.di.configureModule +import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.ScopeProvider +import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.kotlin.types.DynamicTypesAllowed + +public fun createTopDownAnalyzerForJs( + moduleContext: ModuleContext, + bindingTrace: BindingTrace, + declarationProviderFactory: DeclarationProviderFactory +): LazyTopDownAnalyzerForTopLevel { + val storageComponentContainer = createContainer("TopDownAnalyzerForJs") { + configureModule(moduleContext, KotlinJsCheckerProvider, bindingTrace) + + useInstance(declarationProviderFactory) + useImpl() + useImpl() + useImpl() + useImpl() + } + return storageComponentContainer.get() +} + diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java index 0932699ff31..cec630a64a6 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.ModuleParameters; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs; +import org.jetbrains.kotlin.frontend.js.di.DiPackage; import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult; import org.jetbrains.kotlin.js.config.Config; import org.jetbrains.kotlin.name.Name; @@ -95,17 +95,12 @@ public final class TopDownAnalyzerFacadeForJS { ) { Collection allFiles = Config.withJsLibAdded(files, config); - InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs( - moduleContext, trace, new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles) + LazyTopDownAnalyzerForTopLevel analyzerForJs = DiPackage.createTopDownAnalyzerForJs( + moduleContext, trace, + new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles) ); - try { - injector.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, - Collections.emptyList()); - return JsAnalysisResult.success(trace, moduleContext.getModule()); - } - finally { - injector.destroy(); - } + analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.emptyList()); + return JsAnalysisResult.success(trace, moduleContext.getModule()); } public static void checkForErrors(@NotNull Collection allFiles, @NotNull BindingContext bindingContext) {