From 0c2650c86c9a4f2b48089c76bf32bc6ced2051c7 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 27 Jul 2015 16:44:20 +0300 Subject: [PATCH] Provide API to get frontend services from plugin code via resoltion facade API to create ide-side services using frontend services (for now "ide services" cannot be injected into other ide services) --- .../jetbrains/kotlin/container/Container.kt | 19 ++- .../src/org/jetbrains/kotlin/container/Dsl.kt | 6 +- .../kotlin/frontend/java/di/injection.kt | 8 +- .../kotlin/resolve/jvm/JvmAnalyzerFacade.kt | 22 ++- .../kotlin/analyzer/AnalyzerFacade.kt | 42 ++--- .../jetbrains/kotlin/frontend/di/injection.kt | 2 +- .../MultiModuleJavaAnalysisCustomTest.kt | 7 +- .../resolve/lazy/lazyResolveTestUtil.kt | 7 +- .../IDELightClassGenerationSupport.java | 23 ++- .../caches/resolve/JavaResolveExtension.kt | 7 +- .../idea/caches/resolve/JsAnalyzerFacade.kt | 22 +-- .../idea/caches/resolve/KotlinCacheService.kt | 29 +++- .../idea/caches/resolve/KotlinResolveCache.kt | 58 +++++-- .../caches/resolve/ModuleDependencyMapper.kt | 35 ++-- .../idea/caches/resolve/ResolutionFacade.kt | 20 +++ .../idea/project/AnalyzerFacadeProvider.kt | 3 +- .../idea/project/ResolveSessionForBodies.java | 149 ------------------ 17 files changed, 183 insertions(+), 276 deletions(-) delete mode 100644 idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Container.kt b/compiler/container/src/org/jetbrains/kotlin/container/Container.kt index 07f9223863f..07cf81861a0 100644 --- a/compiler/container/src/org/jetbrains/kotlin/container/Container.kt +++ b/compiler/container/src/org/jetbrains/kotlin/container/Container.kt @@ -28,12 +28,17 @@ public interface ComponentContainer { fun createResolveContext(requestingDescriptor: ValueDescriptor): ValueResolveContext } +public interface ComponentProvider { + public fun resolve(request: Type): ValueDescriptor? + public fun create(request: Class): T +} + object DynamicComponentDescriptor : ValueDescriptor { override fun getValue(): Any = throw UnsupportedOperationException() override fun toString(): String = "Dynamic" } -public class StorageComponentContainer(id: String) : ComponentContainer, Closeable { +public class StorageComponentContainer(id: String) : ComponentContainer, ComponentProvider, Closeable { public val unknownContext: ComponentResolveContext by lazy { ComponentResolveContext(this, DynamicComponentDescriptor) } val componentStorage = ComponentStorage(id) @@ -54,10 +59,14 @@ public class StorageComponentContainer(id: String) : ComponentContainer, Closeab override fun close() = componentStorage.dispose() - jvmOverloads public fun resolve(request: Type, context: ValueResolveContext = unknownContext): ValueDescriptor? { + public fun resolve(request: Type, context: ValueResolveContext): ValueDescriptor? { return componentStorage.resolve(request, context) ?: resolveIterable(request, context) } + override fun resolve(request: Type): ValueDescriptor? { + return resolve(request, unknownContext) + } + private fun resolveIterable(request: Type, context: ValueResolveContext): ValueDescriptor? { if (request !is ParameterizedType) return null val rawType = request.getRawType() @@ -86,6 +95,12 @@ public class StorageComponentContainer(id: String) : ComponentContainer, Closeab componentStorage.registerDescriptors(unknownContext, descriptors) return this } + + override fun create(request: Class): T { + val constructorBinding = request.bindToConstructor(unknownContext) + val args = constructorBinding.argumentDescriptors.map { it.getValue() }.toTypedArray() + return constructorBinding.constructor.newInstance(*args) as T + } } public fun StorageComponentContainer.registerSingleton(klass: Class<*>): StorageComponentContainer { diff --git a/compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt b/compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt index ce99ff345e2..9403002f533 100644 --- a/compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt +++ b/compiler/container/src/org/jetbrains/kotlin/container/Dsl.kt @@ -29,14 +29,14 @@ public inline fun StorageComponentContainer.useImpl() { registerSingleton(javaClass()) } -public inline fun StorageComponentContainer.get(): T { - return resolve(javaClass(), unknownContext)!!.getValue() as T +public inline fun ComponentProvider.get(): T { + return resolve(javaClass())!!.getValue() as T } public fun StorageComponentContainer.useInstance(instance: Any) { registerInstance(instance) } -public inline fun StorageComponentContainer.get(thisRef: Any?, desc: PropertyMetadata): T { +public inline fun ComponentProvider.get(thisRef: Any?, desc: PropertyMetadata): T { return resolve(javaClass())!!.getValue() as T } 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 index 6a72fd0f529..2776981bb26 100644 --- 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 @@ -70,7 +70,7 @@ public fun StorageComponentContainer.configureJavaTopDownAnalysis(moduleContentS public fun createContainerForLazyResolveWithJava( moduleContext: ModuleContext, bindingTrace: BindingTrace, declarationProviderFactory: DeclarationProviderFactory, moduleContentScope: GlobalSearchScope, moduleClassResolver: ModuleClassResolver, targetEnvironment: TargetEnvironment = CompilerEnvironment -): Pair = createContainer("LazyResolveWithJava") { +): ComponentProvider = createContainer("LazyResolveWithJava") { configureModule(moduleContext, JvmPlatform, bindingTrace) configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, LookupTracker.DO_NOTHING) @@ -82,10 +82,8 @@ public fun createContainerForLazyResolveWithJava( useImpl() useImpl() -}.let { - it.javaAnalysisInit() - - Pair(it.get(), it.get()) +}.apply { + javaAnalysisInit() } 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 219dfdd2109..e89a266fa03 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 @@ -19,9 +19,9 @@ package org.jetbrains.kotlin.resolve.jvm import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.analyzer.* +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ModuleContext 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.extensions.ExternalDeclarationsProvider @@ -36,18 +36,12 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory import java.util.ArrayList import kotlin.platform.platformStatic -public class JvmResolverForModule( - override val lazyResolveSession: ResolveSession, - override val packageFragmentProvider: PackageFragmentProvider, - public val javaDescriptorResolver: JavaDescriptorResolver -) : ResolverForModule - public class JvmPlatformParameters( public val moduleByJavaClass: (JavaClass) -> ModuleInfo ) : PlatformAnalysisParameters -public object JvmAnalyzerFacade : AnalyzerFacade { +public object JvmAnalyzerFacade : AnalyzerFacade { override fun createResolverForModule( moduleInfo: M, moduleDescriptor: ModuleDescriptorImpl, @@ -55,8 +49,8 @@ public object JvmAnalyzerFacade : AnalyzerFacade - ): JvmResolverForModule { + resolverForProject: ResolverForProject + ): ResolverForModule { val (syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project val filesToAnalyze = getAllFilesToAnalyze(project, moduleInfo, syntheticFiles) @@ -67,9 +61,9 @@ public object JvmAnalyzerFacade : AnalyzerFacade val moduleInfo = platformParameters.moduleByJavaClass(javaClass) - resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver + resolverForProject.resolverForModule(moduleInfo as M).componentProvider.get() } - val (resolveSession, javaDescriptorResolver) = createContainerForLazyResolveWithJava( + val container = createContainerForLazyResolveWithJava( moduleContext, CodeAnalyzerInitializer.getInstance(project).createTrace(), declarationProviderFactory, @@ -77,9 +71,11 @@ public object JvmAnalyzerFacade : AnalyzerFacade() + val javaDescriptorResolver = container.get() val providersForModule = listOf(resolveSession.getPackageFragmentProvider(), javaDescriptorResolver.packageFragmentProvider) - return JvmResolverForModule(resolveSession, CompositePackageFragmentProvider(providersForModule), javaDescriptorResolver) + return ResolverForModule(CompositePackageFragmentProvider(providersForModule), container) } override val moduleParameters: ModuleParameters diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt index 27cd5e8e382..7bed38433b0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.analyzer import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.container.ComponentProvider import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.context.ProjectContext import org.jetbrains.kotlin.context.withModule @@ -31,34 +32,33 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetFile import org.jetbrains.kotlin.resolve.TargetEnvironment -import org.jetbrains.kotlin.resolve.lazy.ResolveSession import java.util.ArrayList import java.util.HashMap -public interface ResolverForModule { - public val lazyResolveSession: ResolveSession - public val packageFragmentProvider: PackageFragmentProvider -} +public class ResolverForModule( + public val packageFragmentProvider: PackageFragmentProvider, + public val componentProvider: ComponentProvider +) -public interface ResolverForProject { - public fun resolverForModule(moduleInfo: M): R = resolverForModuleDescriptor(descriptorForModule(moduleInfo)) +public interface ResolverForProject { + public fun resolverForModule(moduleInfo: M): ResolverForModule = resolverForModuleDescriptor(descriptorForModule(moduleInfo)) public fun descriptorForModule(moduleInfo: M): ModuleDescriptor - public fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): R + public fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule val allModules: Collection } -public class EmptyResolverForProject : ResolverForProject { - override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): R = throw IllegalStateException("$descriptor is not contained in this resolver") +public class EmptyResolverForProject : ResolverForProject { + override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule = throw IllegalStateException("$descriptor is not contained in this resolver") override fun descriptorForModule(moduleInfo: M) = throw IllegalStateException("Should not be called for $moduleInfo") override val allModules: Collection = listOf() } -public class ResolverForProjectImpl( +public class ResolverForProjectImpl( val descriptorByModule: Map, - val delegateResolver: ResolverForProject = EmptyResolverForProject() -) : ResolverForProject { - val resolverByModuleDescriptor: MutableMap R> = HashMap() + val delegateResolver: ResolverForProject = EmptyResolverForProject() +) : ResolverForProject { + val resolverByModuleDescriptor: MutableMap ResolverForModule> = HashMap() override val allModules: Collection by lazy { (descriptorByModule.keySet() + delegateResolver.allModules).toSet() @@ -70,7 +70,7 @@ public class ResolverForProjectImpl( } } - override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): R { + override fun resolverForModuleDescriptor(descriptor: ModuleDescriptor): ResolverForModule { val computation = resolverByModuleDescriptor[descriptor] ?: return delegateResolver.resolverForModuleDescriptor(descriptor) return computation() } @@ -121,18 +121,18 @@ public interface ModuleInfo { } } -public interface AnalyzerFacade { +public interface AnalyzerFacade { public fun setupResolverForProject( projectContext: ProjectContext, modules: Collection, modulesContent: (M) -> ModuleContent, platformParameters: P, targetEnvironment: TargetEnvironment, - delegateResolver: ResolverForProject = EmptyResolverForProject() - ): ResolverForProject { + delegateResolver: ResolverForProject = EmptyResolverForProject() + ): ResolverForProject { val storageManager = projectContext.storageManager - fun createResolverForProject(): ResolverForProjectImpl { + fun createResolverForProject(): ResolverForProjectImpl { val descriptorByModule = HashMap() modules.forEach { module -> @@ -204,8 +204,8 @@ public interface AnalyzerFacade - ): A + resolverForProject: ResolverForProject + ): ResolverForModule public val moduleParameters: ModuleParameters } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index 06a8da5dd7c..aa47c2698b4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt @@ -101,7 +101,7 @@ public fun createContainerForLazyLocalClassifierAnalyzer( useImpl() } -private fun createContainerForLazyResolve( +public fun createContainerForLazyResolve( moduleContext: ModuleContext, declarationProviderFactory: DeclarationProviderFactory, bindingTrace: BindingTrace, diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt index 57d3087377f..f59afcf7ba6 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt @@ -34,10 +34,10 @@ import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.resolve.CompilerEnvironment import org.jetbrains.kotlin.resolve.descriptorUtil.module import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters -import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule import org.jetbrains.kotlin.test.JetTestUtils import org.jetbrains.kotlin.types.ErrorUtils import org.junit.Assert @@ -64,7 +64,8 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { javaClass -> val moduleName = javaClass.getName().asString().toLowerCase().first().toString() modules.first { it._name == moduleName } - } + }, + CompilerEnvironment ) performChecks(resolverForProject, modules) @@ -101,7 +102,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() { return modules.values().toList() } - private fun performChecks(resolverForProject: ResolverForProject, modules: List) { + private fun performChecks(resolverForProject: ResolverForProject, modules: List) { modules.forEach { module -> val moduleDescriptor = resolverForProject.descriptorForModule(module) diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt index d645934d3ae..21a4c7abdbe 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtil.kt @@ -20,9 +20,11 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.analyzer.ModuleContent import org.jetbrains.kotlin.analyzer.ModuleInfo +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ProjectContext import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.resolve.CompilerEnvironment import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters @@ -36,9 +38,10 @@ public fun createResolveSessionForFiles( val resolverForProject = JvmAnalyzerFacade.setupResolverForProject( projectContext, listOf(testModule), { ModuleContent(syntheticFiles, GlobalSearchScope.allScope(project)) }, - JvmPlatformParameters { testModule } + JvmPlatformParameters { testModule }, + CompilerEnvironment ) - return resolverForProject.resolverForModule(testModule).lazyResolveSession + return resolverForProject.resolverForModule(testModule).componentProvider.get() } private class TestModule(val dependsOnBuiltins: Boolean) : ModuleInfo { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java index 38385d76d97..cc36c4604be 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.java @@ -40,12 +40,8 @@ import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.asJava.*; -import org.jetbrains.kotlin.descriptors.ClassDescriptor; -import org.jetbrains.kotlin.descriptors.FunctionDescriptor; -import org.jetbrains.kotlin.descriptors.PackageViewDescriptor; -import org.jetbrains.kotlin.descriptors.VariableDescriptor; +import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.idea.decompiler.navigation.JetSourceNavigationHelper; -import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies; import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex; import org.jetbrains.kotlin.idea.stubindex.JetTopLevelClassByPackageIndex; import org.jetbrains.kotlin.idea.stubindex.PackageIndexUtil; @@ -60,6 +56,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode; import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil; import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer; +import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.resolve.scopes.JetScope; import java.io.IOException; @@ -93,7 +90,7 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport Collections.sort(sortedFiles, scopeFileComparator); JetFile file = sortedFiles.get(0); - ResolveSessionForBodies session = KotlinCacheService.getInstance(file.getProject()).getLazyResolveSession(file); + ResolveSession session = KotlinCacheService.getInstance(file.getProject()).getLazyResolveSession(file); forceResolvePackageDeclarations(files, session); return new LightClassConstructionContext(session.getBindingContext(), session.getModuleDescriptor()); } @@ -101,24 +98,26 @@ public class IDELightClassGenerationSupport extends LightClassGenerationSupport @NotNull @Override public LightClassConstructionContext getContextForClassOrObject(@NotNull JetClassOrObject classOrObject) { - ResolveSessionForBodies session = KotlinCacheService.getInstance(classOrObject.getProject()).getLazyResolveSession(classOrObject); + ResolutionFacade resolutionFacade = ResolvePackage.getResolutionFacade(classOrObject); + ModuleDescriptor moduleDescriptor = resolutionFacade.findModuleDescriptor(classOrObject); + BindingContext bindingContext = resolutionFacade.analyze(classOrObject, BodyResolveMode.FULL); if (classOrObject.isLocal()) { - BindingContext bindingContext = session.resolveToElement(classOrObject, BodyResolveMode.FULL); ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, classOrObject); + if (descriptor == null) { LOG.warn("No class descriptor in context for class: " + PsiUtilPackage.getElementTextWithContext(classOrObject)); - return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor()); + return new LightClassConstructionContext(bindingContext, moduleDescriptor); } ForceResolveUtil.forceResolveAllContents(descriptor); - return new LightClassConstructionContext(bindingContext, session.getModuleDescriptor()); + return new LightClassConstructionContext(bindingContext, moduleDescriptor); } - ForceResolveUtil.forceResolveAllContents(session.getClassDescriptor(classOrObject)); - return new LightClassConstructionContext(session.getBindingContext(), session.getModuleDescriptor()); + ForceResolveUtil.forceResolveAllContents(resolutionFacade.resolveToDescriptor(classOrObject)); + return new LightClassConstructionContext(bindingContext, moduleDescriptor); } private static void forceResolvePackageDeclarations(@NotNull Collection files, @NotNull KotlinCodeAnalyzer session) { diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt index c8b43d5b41b..d56113c577d 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt @@ -18,15 +18,16 @@ package org.jetbrains.kotlin.idea.caches.resolve import com.intellij.openapi.project.Project import com.intellij.psi.* +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.load.java.sources.JavaSourceElement import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.* import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.TargetPlatform import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver -import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform import org.jetbrains.kotlin.resolve.scopes.JetScope @@ -35,8 +36,8 @@ public object JavaResolveExtension : CacheExtension<(PsiElement) -> Pair Pair { return { - val resolverForModule = resolverProvider.resolverByModule(it.getModuleInfo()) as JvmResolverForModule - Pair(resolverForModule.javaDescriptorResolver, resolverForModule.lazyResolveSession.getBindingContext()) + val componentProvider = resolverProvider.resolverByModule(it.getModuleInfo()).componentProvider + Pair(componentProvider.get(), componentProvider.get().getBindingContext()) } } 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 b05557a0b52..e004bf8cfae 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 @@ -20,12 +20,12 @@ import com.intellij.openapi.roots.OrderRootType import com.intellij.psi.search.GlobalSearchScope import com.intellij.util.PathUtil import org.jetbrains.kotlin.analyzer.* +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ModuleContext 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.frontend.di.createLazyResolveSession +import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve import org.jetbrains.kotlin.idea.framework.KotlinJavaScriptLibraryDetectionUtil import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS import org.jetbrains.kotlin.js.resolve.JsPlatform @@ -34,15 +34,9 @@ import org.jetbrains.kotlin.resolve.TargetEnvironment import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil -import org.jetbrains.kotlin.types.DynamicTypesAllowed import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils -public class JsResolverForModule( - override val lazyResolveSession: ResolveSession, - override val packageFragmentProvider: PackageFragmentProvider -) : ResolverForModule - -public object JsAnalyzerFacade : AnalyzerFacade { +public object JsAnalyzerFacade : AnalyzerFacade { override fun createResolverForModule( moduleInfo: M, @@ -51,16 +45,16 @@ public object JsAnalyzerFacade : AnalyzerFacade - ): JsResolverForModule { + resolverForProject: ResolverForProject + ): ResolverForModule { val (syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory( project, moduleContext.storageManager, syntheticFiles, if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope ) - val resolveSession = createLazyResolveSession(moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatform, targetEnvironment) - var packageFragmentProvider = resolveSession.getPackageFragmentProvider() + val container = createContainerForLazyResolve(moduleContext, declarationProviderFactory, BindingTraceContext(), JsPlatform, targetEnvironment) + var packageFragmentProvider = container.get().getPackageFragmentProvider() if (moduleInfo is LibraryInfo && KotlinJavaScriptLibraryDetectionUtil.isKotlinJavaScriptLibrary(moduleInfo.library)) { val providers = moduleInfo.library.getFiles(OrderRootType.CLASSES) @@ -74,7 +68,7 @@ public object JsAnalyzerFacade : AnalyzerFacade getIdeService(element: JetElement, serviceClass: Class): T { + return cache.getIdeService(element, serviceClass) + } + + override fun getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T { + return cache.getIdeService(moduleDescriptor, serviceClass) + } + override fun analyze(element: JetElement, bodyResolveMode: BodyResolveMode): BindingContext { - return cache.getLazyResolveSession(element).resolveToElement(element, bodyResolveMode) + val resolveElementCache = cache.getService(element, javaClass()) + return resolveElementCache.resolveToElement(element, bodyResolveMode) } override fun findModuleDescriptor(element: JetElement): ModuleDescriptor { @@ -234,11 +244,18 @@ private class ResolutionFacadeImpl(private val project: Project, private val cac return cache.getLazyResolveSession(file).getFileScopeProvider().getFileScope(file) } + override fun getFrontendService(element: JetElement, serviceClass: Class): T { + return cache.getService(element, serviceClass) + } + + override fun getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T { + return cache.getService(moduleDescriptor, serviceClass) + } + override fun resolveImportReference(moduleDescriptor: ModuleDescriptor, fqName: FqName): Collection { val importDirective = JetPsiFactory(project).createImportDirective(ImportPath(fqName, false)) - val resolveSession = cache.getLazyResolveSession(moduleDescriptor) - val resolver = resolveSession.getQualifiedExpressionResolver() - return resolver.processImportReference( + val qualifiedExpressionResolver = this.getService(moduleDescriptor) + return qualifiedExpressionResolver.processImportReference( importDirective, moduleDescriptor, BindingTraceContext(), QualifiedExpressionResolver.LookupMode.EVERYTHING).getAllDescriptors() } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt index 579f88952fa..3414a300c9f 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinResolveCache.kt @@ -29,19 +29,21 @@ import com.intellij.util.containers.SLRUCache import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.analyzer.analyzeInContext import org.jetbrains.kotlin.asJava.LightClassUtil +import org.jetbrains.kotlin.container.ComponentProvider import org.jetbrains.kotlin.container.get -import org.jetbrains.kotlin.context.SimpleGlobalContext +import org.jetbrains.kotlin.context.GlobalContext import org.jetbrains.kotlin.context.withModule import org.jetbrains.kotlin.context.withProject import org.jetbrains.kotlin.descriptors.ModuleDescriptor 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.ResolveElementCache import org.jetbrains.kotlin.idea.project.TargetPlatformDetector import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode +import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.util.getScopeAndDataFlowForAnalyzeFragment import org.jetbrains.kotlin.types.TypeUtils import java.util.HashMap @@ -61,11 +63,31 @@ private class KotlinResolveCache( val moduleResolverProvider: ModuleResolverProvider get() = resolverCache.getValue() - public fun getLazyResolveSession(element: JetElement): ResolveSessionForBodies { - return moduleResolverProvider.resolveSessionForBodiesByModule(element.getModuleInfo()) + public fun getLazyResolveSession(element: JetElement): ResolveSession { + return moduleResolverProvider.resolverByModule(element.getModuleInfo()).componentProvider.get() } - public fun getLazyResolveSession(moduleDescriptor: ModuleDescriptor): ResolveSessionForBodies { + public fun getService(element: JetElement, serviceClass: Class): T { + //TODO_R: + return moduleResolverProvider.resolverForProject.resolverForModule(element.getModuleInfo()).componentProvider.resolve(serviceClass)?.getValue() as T + } + + public fun getService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T { + //TODO_R: + return moduleResolverProvider.resolverForProject.resolverForModuleDescriptor(moduleDescriptor).componentProvider.resolve(serviceClass)?.getValue() as T + } + + public fun getIdeService(element: JetElement, serviceClass: Class): T { + //TODO_R: + return moduleResolverProvider.resolverForProject.resolverForModule(element.getModuleInfo()).componentProvider.create(serviceClass) + } + + public fun getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T { + //TODO_R: + return moduleResolverProvider.resolverForProject.resolverForModuleDescriptor(moduleDescriptor).componentProvider.create(serviceClass) + } + + public fun getLazyResolveSession(moduleDescriptor: ModuleDescriptor): ResolveSession { return moduleResolverProvider.resolveSessionForBodiesByDescriptor(moduleDescriptor) } @@ -78,7 +100,7 @@ private class KotlinResolveCache( val resolverProvider = moduleResolverProvider val results = object : SLRUCache(2, 3) { override fun createValue(file: JetFile?): PerFileAnalysisCache { - return PerFileAnalysisCache(file!!, resolverProvider.resolveSessionForBodiesByModule(file.getModuleInfo())) + return PerFileAnalysisCache(file!!, resolverProvider.resolverByModule(file.getModuleInfo()).componentProvider) } } CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker) @@ -105,7 +127,7 @@ private class KotlinResolveCache( } } -private class PerFileAnalysisCache(val file: JetFile, val resolveSession: ResolveSessionForBodies) { +private class PerFileAnalysisCache(val file: JetFile, val componentProvider: ComponentProvider) { private val cache = HashMap() private fun lookUp(analyzableElement: JetElement): AnalysisResult? { @@ -156,7 +178,7 @@ private class PerFileAnalysisCache(val file: JetFile, val resolveSession: Resolv } try { - return KotlinResolveDataProvider.analyze(project, resolveSession, analyzableElement) + return KotlinResolveDataProvider.analyze(project, componentProvider, analyzableElement) } catch (e: ProcessCanceledException) { throw e @@ -210,11 +232,11 @@ private object KotlinResolveDataProvider { ?: element.getContainingJetFile() } - fun analyze(project: Project, resolveSession: ResolveSessionForBodies, analyzableElement: JetElement): AnalysisResult { + fun analyze(project: Project, componentProvider: ComponentProvider, analyzableElement: JetElement): AnalysisResult { try { - val module = resolveSession.getModuleDescriptor() + val module = componentProvider.get() if (analyzableElement is JetCodeFragment) { - return AnalysisResult.success(analyzeExpressionCodeFragment(resolveSession, analyzableElement), module) + return AnalysisResult.success(analyzeExpressionCodeFragment(componentProvider, analyzableElement), module) } val file = analyzableElement.getContainingJetFile() @@ -223,17 +245,18 @@ private object KotlinResolveDataProvider { file.putUserData(LibrarySourceHacks.SKIP_TOP_LEVEL_MEMBERS, true) } + val resolveSession = componentProvider.get() val trace = DelegatingBindingTrace(resolveSession.getBindingContext(), "Trace for resolution of " + analyzableElement) val targetPlatform = TargetPlatformDetector.getPlatform(analyzableElement.getContainingJetFile()) - val globalContext = SimpleGlobalContext(resolveSession.getStorageManager(), resolveSession.getExceptionTracker()) - val moduleContext = globalContext.withProject(project).withModule(module) + val lazyTopDownAnalyzer = createContainerForLazyBodyResolve( - moduleContext, + //TODO: should get ModuleContext + componentProvider.get().withProject(project).withModule(module), resolveSession, trace, targetPlatform, - resolveSession.getBodyResolveCache() + componentProvider.get() ).get() lazyTopDownAnalyzer.analyzeDeclarations( @@ -259,12 +282,13 @@ private object KotlinResolveDataProvider { } } - private fun analyzeExpressionCodeFragment(resolveSession: ResolveSessionForBodies, codeFragment: JetCodeFragment): BindingContext { + private fun analyzeExpressionCodeFragment(componentProvider: ComponentProvider, codeFragment: JetCodeFragment): BindingContext { val codeFragmentExpression = codeFragment.getContentElement() if (codeFragmentExpression !is JetExpression) return BindingContext.EMPTY + val resolveSession = componentProvider.get() val (scopeForContextElement, dataFlowInfo) = codeFragment.getScopeAndDataFlowForAnalyzeFragment(resolveSession) { - resolveSession.resolveToElement(it, BodyResolveMode.PARTIAL_FOR_COMPLETION) //TODO: discuss it + componentProvider.get().resolveToElement(it, BodyResolveMode.PARTIAL_FOR_COMPLETION) //TODO: discuss it } ?: return BindingContext.EMPTY diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt index 983f4a4452b..1069eaf3461 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt @@ -22,22 +22,22 @@ import com.intellij.openapi.roots.JdkOrderEntry import com.intellij.openapi.roots.LibraryOrderEntry import com.intellij.openapi.roots.ModuleRootManager import org.jetbrains.kotlin.analyzer.* +import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.GlobalContextImpl import org.jetbrains.kotlin.context.withProject import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.idea.project.IdeEnvironment -import org.jetbrains.kotlin.idea.project.ResolveSessionForBodies import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl import org.jetbrains.kotlin.psi.JetFile import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters +import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.storage.ExceptionTracker -import org.jetbrains.kotlin.utils.keysToMap fun createModuleResolverProvider( project: Project, globalContext: GlobalContextImpl, - analyzerFacade: AnalyzerFacade, + analyzerFacade: AnalyzerFacade, syntheticFiles: Collection, delegateProvider: ModuleResolverProvider, moduleFilter: (IdeaModuleInfo) -> Boolean @@ -51,7 +51,7 @@ fun createModuleResolverProvider( val modulesToCreateResolversFor = allModuleInfos.filter(moduleFilter) - fun createResolverForProject(): ResolverForProject { + fun createResolverForProject(): ResolverForProject { val modulesContent = { module: IdeaModuleInfo -> ModuleContent(syntheticFilesByModule[module] ?: listOf(), module.contentScope()) } @@ -71,17 +71,8 @@ fun createModuleResolverProvider( val resolverForProject = createResolverForProject() - val moduleDescriptors = modulesToCreateResolversFor.map { resolverForProject.descriptorForModule(it) } - val resolveSessionsForBodyByDescriptor = moduleDescriptors.keysToMap { - descriptor -> - globalContext.storageManager.createLazyValue { - val analyzer = resolverForProject.resolverForModuleDescriptor(descriptor) - ResolveSessionForBodies(project, analyzer.lazyResolveSession) - } - } return ModuleResolverProviderImpl( resolverForProject, - resolveSessionsForBodyByDescriptor, globalContext, delegateProvider ) @@ -116,36 +107,34 @@ interface ModuleResolverProvider { val exceptionTracker: ExceptionTracker fun resolverByModule(module: IdeaModuleInfo): ResolverForModule = resolverForProject.resolverForModule(module) - fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSessionForBodies { + fun resolveSessionForBodiesByModule(module: IdeaModuleInfo): ResolveSession { return resolveSessionForBodiesByDescriptor(resolverForProject.descriptorForModule(module)) } - fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies - val resolverForProject: ResolverForProject + fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession + val resolverForProject: ResolverForProject } object EmptyModuleResolverProvider: ModuleResolverProvider { override val exceptionTracker: ExceptionTracker get() = throw IllegalStateException("Should not be called") - override val resolverForProject: ResolverForProject = EmptyResolverForProject() + override val resolverForProject: ResolverForProject = EmptyResolverForProject() - override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies { + override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession { throw IllegalStateException("Trying to obtain resolve session for $descriptor not present in this resolver") } } class ModuleResolverProviderImpl( - override val resolverForProject: ResolverForProject, - private val bodiesResolveByDescriptor: Map ResolveSessionForBodies>, + override val resolverForProject: ResolverForProject, val globalContext: GlobalContextImpl, val delegateProvider: ModuleResolverProvider = EmptyModuleResolverProvider ): ModuleResolverProvider { override val exceptionTracker: ExceptionTracker = globalContext.exceptionTracker - override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSessionForBodies { - val computation = bodiesResolveByDescriptor[descriptor] ?: return delegateProvider.resolveSessionForBodiesByDescriptor(descriptor) - return computation() + override fun resolveSessionForBodiesByDescriptor(descriptor: ModuleDescriptor): ResolveSession { + return resolverForProject.resolverForModuleDescriptor(descriptor).componentProvider.get() } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacade.kt index 8552943d200..9c784e2f3fb 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ResolutionFacade.kt @@ -44,6 +44,14 @@ public interface ResolutionFacade { public fun get(extension: CacheExtension): T + public fun getFrontendService(element: JetElement, serviceClass: Class): T + + public fun getFrontendService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T + + public fun getIdeService(element: JetElement, serviceClass: Class): T + + public fun getIdeService(moduleDescriptor: ModuleDescriptor, serviceClass: Class): T + companion object { //NOTE: idea default API returns module search scope for file under module but not in source or production source (for example, test data ) // this scope can't be used to search for kotlin declarations in index in order to resolve in that case @@ -56,3 +64,15 @@ public interface ResolutionFacade { } } } + +public inline fun ResolutionFacade.getService(element: JetElement): T + = this.getFrontendService(element, javaClass()) + +public inline fun ResolutionFacade.getService(moduleDescriptor: ModuleDescriptor): T + = this.getFrontendService(moduleDescriptor, javaClass()) + +public inline fun ResolutionFacade.ideService(element: JetElement): T + = this.getIdeService(element, javaClass()) + +public inline fun ResolutionFacade.ideService(moduleDescriptor: ModuleDescriptor): T + = this.getIdeService(moduleDescriptor, javaClass()) \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/AnalyzerFacadeProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/AnalyzerFacadeProvider.kt index f4f319fac5f..5ea76364adf 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/AnalyzerFacadeProvider.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/AnalyzerFacadeProvider.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.idea.project import org.jetbrains.kotlin.analyzer.AnalyzerFacade -import org.jetbrains.kotlin.analyzer.ResolverForModule import org.jetbrains.kotlin.idea.caches.resolve.JsAnalyzerFacade import org.jetbrains.kotlin.js.resolve.JsPlatform import org.jetbrains.kotlin.resolve.TargetPlatform @@ -28,7 +27,7 @@ import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform public object AnalyzerFacadeProvider { //NOTE: it's convenient that JS backend doesn't have platform parameters (for now) // otherwise we would be forced to add casts on the call site of setupResolverForProject - public fun getAnalyzerFacade(targetPlatform: TargetPlatform): AnalyzerFacade { + public fun getAnalyzerFacade(targetPlatform: TargetPlatform): AnalyzerFacade { return when (targetPlatform) { JvmPlatform -> JvmAnalyzerFacade JsPlatform -> JsAnalyzerFacade diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java deleted file mode 100644 index f0800c429ce..00000000000 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveSessionForBodies.java +++ /dev/null @@ -1,149 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.idea.project; - -import com.intellij.openapi.project.Project; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.annotations.ReadOnly; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.psi.psiUtil.PsiUtilPackage; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.BindingContextUtils; -import org.jetbrains.kotlin.resolve.BodyResolveCache; -import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; -import org.jetbrains.kotlin.resolve.lazy.*; -import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor; -import org.jetbrains.kotlin.storage.ExceptionTracker; -import org.jetbrains.kotlin.storage.StorageManager; - -import java.util.Collection; - -public class ResolveSessionForBodies implements KotlinCodeAnalyzer { - private final Object createdForObject; - private final ResolveSession resolveSession; - private final ResolveElementCache resolveElementCache; - - public ResolveSessionForBodies(@NotNull Project project, @NotNull ResolveSession resolveSession) { - this(project, project, resolveSession); - } - - private ResolveSessionForBodies(Object createdForObject, Project project, ResolveSession resolveSession) { - this.createdForObject = createdForObject; - this.resolveSession = resolveSession; - this.resolveElementCache = new ResolveElementCache(resolveSession, project); - } - - @NotNull - public BindingContext resolveToElement(JetElement element, BodyResolveMode bodyResolveMode) { - return resolveElementCache.resolveToElement(element, bodyResolveMode); - } - - @NotNull - @Override - public ModuleDescriptor getModuleDescriptor() { - return resolveSession.getModuleDescriptor(); - } - - @NotNull - @Override - public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) { - return resolveSession.getClassDescriptor(classOrObject); - } - - @NotNull - @Override - public BindingContext getBindingContext() { - return resolveSession.getBindingContext(); - } - - @NotNull - @Override - public DeclarationDescriptor resolveToDescriptor(@NotNull JetDeclaration declaration) { - return resolveSession.resolveToDescriptor(declaration); - } - - @Override - public void forceResolveAll() { - resolveSession.forceResolveAll(); - } - - @Override - public String toString() { - return "ResolveSessionForBodies: " + resolveSession.getExceptionTracker().getModificationCount() - + " " + createdForObject + " " + createdForObject.hashCode(); - } - - @Override - @Nullable - public LazyPackageDescriptor getPackageFragment(@NotNull FqName fqName) { - return resolveSession.getPackageFragment(fqName); - } - - @Override - @NotNull - @ReadOnly - public Collection getTopLevelClassDescriptors(@NotNull FqName fqName) { - return resolveSession.getTopLevelClassDescriptors(fqName); - } - - @Override - @NotNull - public ScriptDescriptor getScriptDescriptor(@NotNull JetScript script) { - return resolveSession.getScriptDescriptor(script); - } - - @NotNull - @Override - public DeclarationScopeProvider getDeclarationScopeProvider() { - return resolveSession.getDeclarationScopeProvider(); - } - - @NotNull - @Override - public FileScopeProvider getFileScopeProvider() { - return resolveSession.getFileScopeProvider(); - } - - @NotNull - public StorageManager getStorageManager() { - return resolveSession.getStorageManager(); - } - - @NotNull - public ExceptionTracker getExceptionTracker() { - return resolveSession.getExceptionTracker(); - } - - @NotNull - public BodyResolveCache getBodyResolveCache() { - return resolveElementCache; - } - - @NotNull - @Override - public PackageFragmentProvider getPackageFragmentProvider() { - return resolveSession.getPackageFragmentProvider(); - } - - @NotNull - public QualifiedExpressionResolver getQualifiedExpressionResolver() { - return resolveSession.getQualifiedExpressionResolver(); - } -}