azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert usages of existing generated injectors to dynamic injectors

Browse Source 
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
This commit is contained in:
Pavel V. Talanov
2015-04-28 19:37:14 +03:00
parent 5db541ee24
commit df529f1a4b
33 changed files with 580 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java
+7 -6
View File
@@ -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()
)
));
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/di/injection.kt
+58
View File
@@ -0,0 +1,58 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.cli.jvm.repl.di
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.container.*
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.frontend.di.configureModule
import org.jetbrains.kotlin.frontend.java.di.configureJavaTopDownAnalysis
import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
public fun createContainerForReplWithJava(
moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
moduleContentScope: GlobalSearchScope, additionalFileScopeProvider: ScopeProvider.AdditionalFileScopeProvider
): ContainerForReplWithJava = createContainer("ReplWithJava") {
configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
useInstance(additionalFileScopeProvider)
useInstance(declarationProviderFactory)
useImpl<ScopeProvider>()
useImpl<SingleModuleClassResolver>()
}.let {
it.get<JavaClassFinderImpl>().initialize()
it.get<JavaClassFinderPostConstruct>().postCreate()
ContainerForReplWithJava(it)
}
public class ContainerForReplWithJava(container: StorageComponentContainer) {
val resolveSession: ResolveSession by container
val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container
val javaDescriptorResolver: JavaDescriptorResolver by container
}
compiler/container/tests/org/jetbrains/kotlin/container/tests/ComponentContainerTest.kt
+1
View File
@@ -16,6 +16,7 @@
package org.jetbrains.kotlin.container.tests
import org.jetbrains.kotlin.container.*
import org.junit.Test
import java.io.Closeable
import javax.inject.Inject
compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
+114
View File
@@ -0,0 +1,114 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.frontend.java.di
import com.intellij.openapi.project.Project
import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.kotlin.container.*
import org.jetbrains.kotlin.context.LazyResolveToken
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.frontend.di.configureModule
import org.jetbrains.kotlin.load.java.JavaClassFinderImpl
import org.jetbrains.kotlin.load.java.JavaFlexibleTypeCapabilitiesProvider
import org.jetbrains.kotlin.load.java.components.*
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver
import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl
import org.jetbrains.kotlin.load.java.structure.impl.JavaPropertyInitializerEvaluatorImpl
import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinderFactory
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
import org.jetbrains.kotlin.resolve.jvm.JavaClassFinderPostConstruct
import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver
import org.jetbrains.kotlin.resolve.jvm.JavaLazyAnalyzerPostConstruct
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentScope: GlobalSearchScope, project: Project) {
useInstance(moduleContentScope)
useImpl<ResolveSession>()
useImpl<LazyTopDownAnalyzer>()
useImpl<LazyTopDownAnalyzerForTopLevel>()
useImpl<JavaDescriptorResolver>()
useImpl<DeserializationComponentsForJava>()
useInstance(JvmVirtualFileFinderFactory.SERVICE.getInstance(project).create(moduleContentScope))
useImpl<JavaClassFinderImpl>()
useImpl<TraceBasedExternalSignatureResolver>()
useImpl<LazyResolveBasedCache>()
useImpl<TraceBasedErrorReporter>()
useImpl<PsiBasedExternalAnnotationResolver>()
useImpl<JavaPropertyInitializerEvaluatorImpl>()
useInstance(SamConversionResolverImpl)
useImpl<JavaSourceElementFactoryImpl>()
useImpl<JavaLazyAnalyzerPostConstruct>()
useImpl<JavaFlexibleTypeCapabilitiesProvider>()
}
public fun createContainerForLazyResolveWithJava(
moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory,
moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver
): Pair<ResolveSession, JavaDescriptorResolver> = createContainer("LazyResolveWithJava") {
configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
useInstance(moduleClassResolver)
useInstance(declarationProviderFactory)
useImpl<ScopeProvider>()
useImpl<LazyResolveToken>()
}.let {
it.javaAnalysisInit()
Pair(it.get<ResolveSession>(), it.get<JavaDescriptorResolver>())
}
public fun createContainerForTopDownAnalyzerForJvm(
moduleContext: ModuleContext, bindingTrace: BindingTrace,
declarationProviderFactory: DeclarationProviderFactory,
moduleContentScope: GlobalSearchScope
): ContainerForTopDownAnalyzerForJvm = createContainer("TopDownAnalyzerForJvm") {
configureModule(moduleContext, KotlinJvmCheckerProvider, bindingTrace)
configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project)
useInstance(declarationProviderFactory)
useImpl<SingleModuleClassResolver>()
useImpl<ScopeProvider>()
}.let {
it.javaAnalysisInit()
ContainerForTopDownAnalyzerForJvm(it)
}
private fun StorageComponentContainer.javaAnalysisInit() {
get<JavaClassFinderImpl>().initialize()
get<JavaClassFinderPostConstruct>().postCreate()
}
public class ContainerForTopDownAnalyzerForJvm(container: StorageComponentContainer) {
val lazyTopDownAnalyzerForTopLevel: LazyTopDownAnalyzerForTopLevel by container
val javaDescriptorResolver: JavaDescriptorResolver by container
val deserializationComponentsForJava: DeserializationComponentsForJava by container
}
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
+2 -4
View File
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyResolveWithJava
import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava
import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolverImpl
import org.jetbrains.kotlin.load.java.structure.JavaClass
import org.jetbrains.kotlin.psi.JetFile
@@ -66,7 +66,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
}
val injector = InjectorForLazyResolveWithJava(
val (resolveSession, javaDescriptorResolver) = createContainerForLazyResolveWithJava(
moduleContext,
CodeAnalyzerInitializer.getInstance(project).createTrace(),
declarationProviderFactory,
@@ -74,8 +74,6 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
moduleClassResolver
)
val resolveSession = injector.getResolveSession()!!
val javaDescriptorResolver = injector.getJavaDescriptorResolver()!!
val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider)
return JvmResolverForModule(resolveSession, CompositePackageFragmentProvider(providersForModule), javaDescriptorResolver)
}
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java
+29 -33
View File
@@ -28,7 +28,8 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleParameters;
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.kotlin.frontend.java.di.ContainerForTopDownAnalyzerForJvm;
import org.jetbrains.kotlin.frontend.java.di.DiPackage;
import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider;
import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCache;
import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvider;
@@ -121,49 +122,44 @@ public enum TopDownAnalyzerFacadeForJVM {
FileBasedDeclarationProviderFactory providerFactory =
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles);
InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(
ContainerForTopDownAnalyzerForJvm container = DiPackage.createContainerForTopDownAnalyzerForJvm(
moduleContext,
trace,
providerFactory,
GlobalSearchScope.allScope(project)
);
try {
List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
if (moduleIds != null && incrementalCacheProvider != null) {
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<AnalysisCompletedHandlerExtension> analysisCompletedHandlerExtensions =
AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject());
for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) {
AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files);
if (result != null) return result;
}
return AnalysisResult.success(bindingContext, module);
}
finally {
injector.destroy();
additionalProviders.add(container.getJavaDescriptorResolver().getPackageFragmentProvider());
container.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(topDownAnalysisMode, allFiles, additionalProviders);
BindingContext bindingContext = trace.getBindingContext();
ModuleDescriptor module = moduleContext.getModule();
Collection<AnalysisCompletedHandlerExtension> analysisCompletedHandlerExtensions =
AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject());
for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) {
AnalysisResult result = extension.analysisCompleted(project, module, bindingContext, files);
if (result != null) return result;
}
return AnalysisResult.success(bindingContext, module);
}
@NotNull
compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerUtil.kt
+10 -10
View File
@@ -16,18 +16,18 @@
package org.jetbrains.kotlin.analyzer
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.psi.JetExpression
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.BindingTraceContext
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
import org.jetbrains.kotlin.resolve.descriptorUtil.module
import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.types.ErrorUtils
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.types.ErrorUtils
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.BindingTraceContext
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.descriptorUtil.module
import org.jetbrains.kotlin.types.expressions.JetTypeInfo
public fun JetExpression.computeTypeInfoInContext(
@@ -37,8 +37,8 @@ public fun JetExpression.computeTypeInfoInContext(
expectedType: JetType = TypeUtils.NO_EXPECTED_TYPE,
module: ModuleDescriptor = scope.getModule()
): JetTypeInfo {
val injectorForMacros = InjectorForMacros(getProject(), module)
return injectorForMacros.getExpressionTypingServices()!!.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
val expressionTypingServices = createContainerForMacros(getProject(), module).expressionTypingServices
return expressionTypingServices.getTypeInfo(scope, this, expectedType, dataFlowInfo, trace)
}
public fun JetExpression.analyzeInContext(
compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt
+131
View File
@@ -0,0 +1,131 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.frontend.di
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.container.*
import org.jetbrains.kotlin.context.LazyResolveToken
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.calls.CallResolver
import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer
import org.jetbrains.kotlin.resolve.lazy.NoFileScopeProvider
import org.jetbrains.kotlin.resolve.lazy.NoTopLevelDescriptorProvider
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
import org.jetbrains.kotlin.types.DynamicTypesSettings
import org.jetbrains.kotlin.types.expressions.*
public fun StorageComponentContainer.configureModule(
moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider
) {
useInstance(moduleContext)
useInstance(moduleContext.module)
useInstance(moduleContext.project)
useInstance(moduleContext.storageManager)
useInstance(moduleContext.builtIns)
useInstance(moduleContext.platformToKotlinClassMap)
useInstance(additionalCheckerProvider)
useInstance(additionalCheckerProvider.symbolUsageValidator)
}
public fun StorageComponentContainer.configureModule(
moduleContext: ModuleContext, additionalCheckerProvider: AdditionalCheckerProvider, trace: BindingTrace
) {
configureModule(moduleContext, additionalCheckerProvider)
useInstance(trace)
}
public fun createContainerForBodyResolve(
moduleContext: ModuleContext, bindingTrace: BindingTrace,
additionalCheckerProvider: AdditionalCheckerProvider, statementFilter: StatementFilter
): StorageComponentContainer = createContainer("BodyResolve") {
configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
useInstance(statementFilter)
useImpl<BodyResolver>()
}
public fun createContainerForLazyBodyResolve(
moduleContext: ModuleContext, kotlinCodeAnalyzer: KotlinCodeAnalyzer,
bindingTrace: BindingTrace, additionalCheckerProvider: AdditionalCheckerProvider,
dynamicTypesSettings: DynamicTypesSettings
): StorageComponentContainer = createContainer("LazyBodyResolve") {
configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
useInstance(kotlinCodeAnalyzer)
useInstance(kotlinCodeAnalyzer.getScopeProvider())
useInstance(dynamicTypesSettings)
useImpl<LazyTopDownAnalyzerForTopLevel>()
}
public fun createContainerForLazyLocalClassifierAnalyzer(
moduleContext: ModuleContext,
bindingTrace: BindingTrace,
additionalCheckerProvider: AdditionalCheckerProvider,
dynamicTypesSettings: DynamicTypesSettings,
localClassDescriptorHolder: LocalClassDescriptorHolder
): StorageComponentContainer = createContainer("LocalClassifierAnalyzer") {
configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
useInstance(dynamicTypesSettings)
useInstance(localClassDescriptorHolder)
useImpl<LazyTopDownAnalyzer>()
useInstance(NoTopLevelDescriptorProvider)
useInstance(NoFileScopeProvider)
useImpl<DeclarationScopeProviderForLocalClassifierAnalyzer>()
useImpl<LocalLazyDeclarationResolver>()
}
private fun createContainerForLazyResolve(
moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
): StorageComponentContainer = createContainer("LazyResolve") {
configureModule(moduleContext, additionalCheckerProvider, bindingTrace)
useInstance(dynamicTypesSettings)
useInstance(declarationProviderFactory)
useImpl<LazyResolveToken>()
useImpl<ResolveSession>()
}
public fun createLazyResolveSession(
moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace,
additionalCheckerProvider: AdditionalCheckerProvider, dynamicTypesSettings: DynamicTypesSettings
): ResolveSession = createContainerForLazyResolve(
moduleContext, declarationProviderFactory, bindingTrace, additionalCheckerProvider, dynamicTypesSettings
).get<ResolveSession>()
public fun createContainerForMacros(project: Project, module: ModuleDescriptor): ContainerForMacros {
val componentContainer = createContainer("Macros") {
configureModule(ModuleContext(module, project), AdditionalCheckerProvider.DefaultProvider)
useImpl<ExpressionTypingServices>()
}
return ContainerForMacros(componentContainer)
}
public class ContainerForMacros(container: StorageComponentContainer) {
val callResolver: CallResolver by container
val typeResolver: TypeResolver by container
val expressionTypingComponents: ExpressionTypingComponents by container
val expressionTypingServices: ExpressionTypingServices by container
}
compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt
+4 -4
View File
@@ -24,8 +24,8 @@ import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyLocalClassifierAnalyzer
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.frontend.di.createContainerForLazyLocalClassifierAnalyzer
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.JetClassOrObject
import org.jetbrains.kotlin.psi.debugText.getDebugText
@@ -64,7 +64,7 @@ public class LocalClassifierAnalyzer(
) {
val module = DescriptorUtils.getContainingModule(containingDeclaration)
val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module)
val injector = InjectorForLazyLocalClassifierAnalyzer(
val container = createContainerForLazyLocalClassifierAnalyzer(
moduleContext,
context.trace,
additionalCheckerProvider,
@@ -83,7 +83,7 @@ public class LocalClassifierAnalyzer(
)
)
injector.getLazyTopDownAnalyzer().analyzeDeclarations(
container.get<LazyTopDownAnalyzer>().analyzeDeclarations(
TopDownAnalysisMode.LocalDeclarations,
listOf(classOrObject),
context.dataFlowInfo
compiler/tests/org/jetbrains/kotlin/renderer/AbstractDescriptorRendererTest.kt
+3 -3
View File
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.PropertyDescriptor
import org.jetbrains.kotlin.di.InjectorForLazyResolve
import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
@@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment
val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject())
val resolveSession = InjectorForLazyResolve(
val resolveSession = createLazyResolveSession(
context,
FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
KotlinJvmCheckerProvider, DynamicTypesSettings())
context.initializeModuleContents(resolveSession.getPackageFragmentProvider())
compiler/tests/org/jetbrains/kotlin/resolve/JetExpectedResolveDataUtil.java
+5 -4
View File
@@ -21,7 +21,6 @@ import com.intellij.psi.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.di.InjectorForTests;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -31,6 +30,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import org.jetbrains.kotlin.types.JetType;
import org.jetbrains.kotlin.types.TypeUtils;
import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
@@ -126,13 +127,13 @@ public class JetExpectedResolveDataUtil {
JetType... parameterTypes
) {
ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
InjectorForTests injector = new InjectorForTests(project, emptyModule);
ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule);
ExpressionTypingContext context = ExpressionTypingContext.newContext(
injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);
OverloadResolutionResults<FunctionDescriptor> functions = injector.getFakeCallResolver().resolveFakeCall(
OverloadResolutionResults<FunctionDescriptor> functions = container.getFakeCallResolver().resolveFakeCall(
context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes);
for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
compiler/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt
+11 -13
View File
@@ -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()
}
compiler/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt
+4 -4
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
import org.jetbrains.kotlin.load.java.JvmAnnotationNames
import org.jetbrains.kotlin.load.java.structure.reflect.classId
@@ -55,13 +55,13 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project)
val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())
val injector = InjectorForTopDownAnalyzerForJvm(
val container = createContainerForTopDownAnalyzerForJvm(
moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
providerFactory, GlobalSearchScope.allScope(environment.project)
)
moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider)
moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)
val components = injector.getDeserializationComponentsForJava().components
val components = container.deserializationComponentsForJava.components
val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId)
?: error("Class is not resolved: $clazz (classId = ${clazz.classId})")
compiler/tests/org/jetbrains/kotlin/tests/di/injection.kt
+49
View File
@@ -0,0 +1,49 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.tests.di
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.container.StorageComponentContainer
import org.jetbrains.kotlin.container.createContainer
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.container.useImpl
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.frontend.di.configureModule
import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
import org.jetbrains.kotlin.resolve.DescriptorResolver
import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver
import org.jetbrains.kotlin.resolve.TypeResolver
import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
import org.jetbrains.kotlin.types.expressions.FakeCallResolver
public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
return ContainerForTests(createContainer("Tests") {
configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider)
useImpl<ExpressionTypingServices>()
})
}
class ContainerForTests(container: StorageComponentContainer) {
val descriptorResolver: DescriptorResolver by container
val functionDescriptorResolver: FunctionDescriptorResolver by container
val typeResolver: TypeResolver by container
val fakeCallResolver: FakeCallResolver by container
val expressionTypingServices: ExpressionTypingServices by container
val additionalCheckerProvider: AdditionalCheckerProvider by container
}
compiler/tests/org/jetbrains/kotlin/types/JetDefaultModalityModifiersTest.java
+8 -7
View File
@@ -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);
}
compiler/tests/org/jetbrains/kotlin/types/JetOverloadTest.java
+3 -3
View File
@@ -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
compiler/tests/org/jetbrains/kotlin/types/JetOverridingTest.java
+2 -3
View File
@@ -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
compiler/tests/org/jetbrains/kotlin/types/JetTypeCheckerTest.java
+5 -4
View File
@@ -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");
}
compiler/tests/org/jetbrains/kotlin/types/TypeSubstitutorTest.java
+6 -5
View File
@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
import org.jetbrains.kotlin.di.InjectorForTests;
import org.jetbrains.kotlin.diagnostics.Diagnostic;
import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
import org.jetbrains.kotlin.name.FqName;
@@ -45,6 +44,8 @@ import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
import org.jetbrains.kotlin.resolve.scopes.*;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.test.JetTestUtils;
import org.jetbrains.kotlin.tests.di.ContainerForTests;
import org.jetbrains.kotlin.tests.di.DiPackage;
import java.io.File;
import java.io.IOException;
@@ -56,7 +57,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@SuppressWarnings("unchecked")
public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
private JetScope scope;
private InjectorForTests injector;
private ContainerForTests container;
@Override
protected KotlinCoreEnvironment createEnvironment() {
@@ -67,13 +68,13 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
protected void setUp() throws Exception {
super.setUp();
injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
scope = getContextScope();
}
@Override
protected void tearDown() throws Exception {
injector = null;
container = null;
scope = null;
super.tearDown();
}
@@ -140,7 +141,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr);
AnalyzingUtils.checkForSyntacticErrors(jetTypeReference);
BindingTrace trace = new BindingTraceContext();
JetType type = injector.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
JetType type = container.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
if (!trace.getBindingContext().getDiagnostics().isEmpty()) {
fail("Errors:\n" + StringUtil.join(
trace.getBindingContext().getDiagnostics(),
compiler/tests/org/jetbrains/kotlin/types/TypeUnifierTest.java
+3 -3
View File
@@ -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());
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
+33 -9
View File
@@ -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("<runtime module for $classLoader>"), storageManager,
ModuleParameters(listOf(), JavaToKotlinClassMap.INSTANCE))
val reflectKotlinClassFinder = ReflectKotlinClassFinder(classLoader)
val deserializedDescriptorResolver = DeserializedDescriptorResolver(RuntimeErrorReporter)
val singleModuleClassResolver = SingleModuleClassResolver()
val globalJavaResolverContext = GlobalJavaResolverContext(
storageManager, ReflectJavaClassFinder(classLoader), reflectKotlinClassFinder, deserializedDescriptorResolver,
ExternalAnnotationResolver.EMPTY, ExternalSignatureResolver.DO_NOTHING, RuntimeErrorReporter, JavaResolverCache.EMPTY,
JavaPropertyInitializerEvaluator.DO_NOTHING, SamConversionResolver, RuntimeSourceElementFactory, singleModuleClassResolver
)
val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(globalJavaResolverContext, module, ReflectionTypes(module))
val javaDescriptorResolver = JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module)
val javaClassDataFinder = JavaClassDataFinder(reflectKotlinClassFinder, deserializedDescriptorResolver)
val binaryClassAnnotationAndConstantLoader = BinaryClassAnnotationAndConstantLoaderImpl(module, storageManager, reflectKotlinClassFinder, RuntimeErrorReporter)
val deserializationComponentsForJava = DeserializationComponentsForJava(storageManager, module, javaClassDataFinder, binaryClassAnnotationAndConstantLoader, lazyJavaPackageFragmentProvider)
singleModuleClassResolver.resolver = javaDescriptorResolver
deserializedDescriptorResolver.setComponents(deserializationComponentsForJava)
module.setDependencies(module, KotlinBuiltIns.getInstance().getBuiltInsModule())
val injector = InjectorForRuntimeDescriptorLoader(classLoader, module, storageManager)
module.initialize(injector.getJavaDescriptorResolver().packageFragmentProvider)
return RuntimeModuleData(injector)
module.initialize(javaDescriptorResolver.packageFragmentProvider)
return RuntimeModuleData(module, deserializationComponentsForJava.components.localClassResolver)
}
}
}
idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
+2 -3
View File
@@ -18,9 +18,8 @@ package org.jetbrains.kotlin.idea.util
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.idea.imports.importableFqName
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
@@ -167,7 +166,7 @@ public class ShadowedDeclarationsFilter(
val context = BasicCallResolutionContext.create(bindingTrace, resolutionScope, newCall, TypeUtils.NO_EXPECTED_TYPE, dataFlowInfo,
ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
val callResolver = InjectorForMacros(project, moduleDescriptor).getCallResolver()
val callResolver = createContainerForMacros(project, moduleDescriptor).callResolver
val results = if (isFunction) callResolver.resolveFunctionCall(context) else callResolver.resolveSimpleProperty(context)
val resultingDescriptors = results.getResultingCalls().map { it.getResultingDescriptor() }.toSet()
val filtered = descriptors.filter { it in resultingDescriptors }
idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/ElementResolver.kt
+4 -4
View File
@@ -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<BodyResolver>()
}
private fun createEmptyContext(): BodyResolveContextForLazy {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsAnalyzerFacade.kt
+4 -4
View File
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ModuleParameters
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.di.InjectorForLazyResolve
import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil
import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
@@ -56,9 +56,9 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope
)
val injector = InjectorForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(),
KotlinJsCheckerProvider, DynamicTypesAllowed())
val resolveSession = injector.getResolveSession()!!
val resolveSession = createLazyResolveSession(
moduleContext, declarationProviderFactory, BindingTraceContext(), KotlinJsCheckerProvider, DynamicTypesAllowed()
)
var packageFragmentProvider = resolveSession.getPackageFragmentProvider()
if (moduleInfo is LibraryInfo && KotlinJavaScriptLibraryDetectionUtil.isKotlinJavaScriptLibrary(moduleInfo.library)) {
idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt
+4 -4
View File
@@ -33,8 +33,9 @@ import org.jetbrains.kotlin.context.SimpleGlobalContext
import org.jetbrains.kotlin.context.withModule
import org.jetbrains.kotlin.context.withProject
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.di.InjectorForLazyBodyResolve
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve
import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies
import org.jetbrains.kotlin.idea.project.TargetPlatform
import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
@@ -232,14 +233,13 @@ private object KotlinResolveDataProvider {
val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile())
val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker())
val moduleContext = globalContext.withProject(project).withModule(resolveSession.getModuleDescriptor())
val lazyTopDownAnalyzer = InjectorForLazyBodyResolve(
val lazyTopDownAnalyzer = createContainerForLazyBodyResolve(
moduleContext,
resolveSession,
resolveSession.getScopeProvider(),
trace,
targetPlatform.getAdditionalCheckerProvider(),
targetPlatform.getDynamicTypesSettings()
).getLazyTopDownAnalyzerForTopLevel()!!
).get<LazyTopDownAnalyzerForTopLevel>()
lazyTopDownAnalyzer.analyzeDeclarations(
TopDownAnalysisMode.TopLevelDeclarations,
idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/navigation/JetSourceNavigationHelper.java
+3 -3
View File
@@ -44,7 +44,7 @@ import org.jetbrains.kotlin.context.ContextPackage;
import org.jetbrains.kotlin.context.MutableModuleContext;
import org.jetbrains.kotlin.descriptors.CallableDescriptor;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.di.InjectorForLazyResolve;
import org.jetbrains.kotlin.frontend.di.DiPackage;
import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex;
import org.jetbrains.kotlin.idea.stubindex.JetSourceFilterScope;
import org.jetbrains.kotlin.idea.stubindex.JetTopLevelFunctionFqnNameIndex;
@@ -250,12 +250,12 @@ public class JetSourceNavigationHelper {
getContainingFiles(candidates)
);
ResolveSession resolveSession = new InjectorForLazyResolve(
ResolveSession resolveSession = DiPackage.createLazyResolveSession(
newModuleContext,
providerFactory,
new BindingTraceContext(),
AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
new DynamicTypesSettings()).getResolveSession();
new DynamicTypesSettings());
newModuleContext.initializeModuleContents(resolveSession.getPackageFragmentProvider());
return resolveSession;
idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/BuiltInsReferenceResolver.java
+6 -5
View File
@@ -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);
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+3 -3
View File
@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.completion
import com.intellij.openapi.util.text.StringUtil
import org.jetbrains.kotlin.builtins.KotlinBuiltIns
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.idea.caches.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.completion.smart.toList
import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
@@ -158,10 +158,10 @@ class ExpectedInfos(
ContextDependency.INDEPENDENT, CheckValueArgumentsMode.ENABLED,
CompositeChecker(listOf()), SymbolUsageValidator.Empty, AdditionalTypeChecker.Composite(listOf()), false)
val callResolutionContext = context.replaceCollectAllCandidates(true)
val callResolver = InjectorForMacros(
val callResolver = createContainerForMacros(
callElement.getProject(),
resolutionFacade.findModuleDescriptor(callElement)
).getCallResolver()
).callResolver
val results: OverloadResolutionResults<FunctionDescriptor> = callResolver.resolveFunctionCall(callResolutionContext)
val expectedInfos = HashSet<ExpectedInfo>()
idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/HeuristicSignatures.kt
+3 -3
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.descriptors.impl.SubpackagesScope
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -97,11 +97,11 @@ public object HeuristicSignatures {
private fun typeFromText(text: String, typeParameters: Collection<TypeParameterDescriptor>, moduleDescriptor: ModuleDescriptor, project: Project): JetType {
val typeRef = JetPsiFactory(project).createType(text)
val injector = InjectorForMacros(project, moduleDescriptor)
val container = createContainerForMacros(project, moduleDescriptor)
val rootPackagesScope = SubpackagesScope(moduleDescriptor, FqName.ROOT)
val typeParametersScope = TypeParametersScope(typeParameters)
val scope = ChainedScope(moduleDescriptor, "Root packages + type parameters", typeParametersScope, rootPackagesScope)
val type = injector.getTypeResolver().resolveType(scope, typeRef, BindingTraceContext(), false)
val type = container.typeResolver.resolveType(scope, typeRef, BindingTraceContext(), false)
assert(!type.isError()) { "No type resolved from '$text'" }
return type
}
idea/idea-core/src/org/jetbrains/kotlin/idea/core/IterableTypesDetector.kt
+5 -4
View File
@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.core
import com.intellij.openapi.project.Project
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.di.InjectorForMacros
import org.jetbrains.kotlin.frontend.di.createContainerForMacros
import org.jetbrains.kotlin.idea.util.FuzzyType
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.JetPsiFactory
@@ -38,7 +38,7 @@ public class IterableTypesDetector(
private val loopVarType: JetType? = null
) {
private val injector = InjectorForMacros(project, moduleDescriptor)
private val container = createContainerForMacros(project, moduleDescriptor)
private val cache = HashMap<FuzzyType, Boolean>()
private val iteratorName = Name.identifier("iterator")
@@ -57,9 +57,10 @@ public class IterableTypesDetector(
val expression = JetPsiFactory(project).createExpression("fake")
val expressionReceiver = ExpressionReceiver(expression, type.type)
val context = ExpressionTypingContext.newContext(injector.getExpressionTypingComponents().getAdditionalCheckerProvider(),
val expressionTypingComponents = container.expressionTypingComponents
val context = ExpressionTypingContext.newContext(expressionTypingComponents.getAdditionalCheckerProvider(),
BindingTraceContext(), scope, DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE)
val elementType = injector.getExpressionTypingComponents().getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
val elementType = expressionTypingComponents.getForLoopConventionsChecker().checkIterableConvention(expressionReceiver, context)
if (elementType == null) return false
return loopVarType == null || FuzzyType(elementType, type.freeParameters).checkIsSubtypeOf(loopVarType) != null
}
idea/src/org/jetbrains/kotlin/idea/intentions/RemoveExplicitTypeArgumentsIntention.kt
+3 -5
View File
@@ -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
js/js.frontend/src/org/jetbrains/kotlin/frontend/js/di/injection.kt
+49
View File
@@ -0,0 +1,49 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.frontend.js.di
import org.jetbrains.kotlin.container.createContainer
import org.jetbrains.kotlin.container.get
import org.jetbrains.kotlin.container.useImpl
import org.jetbrains.kotlin.container.useInstance
import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.frontend.di.configureModule
import org.jetbrains.kotlin.js.resolve.KotlinJsCheckerProvider
import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzerForTopLevel
import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.ScopeProvider
import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
import org.jetbrains.kotlin.types.DynamicTypesAllowed
public fun createTopDownAnalyzerForJs(
moduleContext: ModuleContext,
bindingTrace: BindingTrace,
declarationProviderFactory: DeclarationProviderFactory
): LazyTopDownAnalyzerForTopLevel {
val storageComponentContainer = createContainer("TopDownAnalyzerForJs") {
configureModule(moduleContext, KotlinJsCheckerProvider, bindingTrace)
useInstance(declarationProviderFactory)
useImpl<ScopeProvider>()
useImpl<ResolveSession>()
useImpl<LazyTopDownAnalyzerForTopLevel>()
useImpl<DynamicTypesAllowed>()
}
return storageComponentContainer.get<LazyTopDownAnalyzerForTopLevel>()
}
js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.java
+6 -11
View File
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.context.MutableModuleContext;
import org.jetbrains.kotlin.descriptors.ModuleParameters;
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider;
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJs;
import org.jetbrains.kotlin.frontend.js.di.DiPackage;
import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult;
import org.jetbrains.kotlin.js.config.Config;
import org.jetbrains.kotlin.name.Name;
@@ -95,17 +95,12 @@ public final class TopDownAnalyzerFacadeForJS {
) {
Collection<JetFile> allFiles = Config.withJsLibAdded(files, config);
InjectorForTopDownAnalyzerForJs injector = new InjectorForTopDownAnalyzerForJs(
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.<PackageFragmentProvider>emptyList());
return JsAnalysisResult.success(trace, moduleContext.getModule());
}
finally {
injector.destroy();
}
analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.<PackageFragmentProvider>emptyList());
return JsAnalysisResult.success(trace, moduleContext.getModule());
}
public static void checkForErrors(@NotNull Collection<JetFile> allFiles, @NotNull BindingContext bindingContext) {