diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt index 7ca87171a3c..dd387be18a0 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt @@ -124,35 +124,22 @@ class CommonResolverForModuleFactory( else languageVersionSettings.getFeatureSupport(feature) } + val resolverForModuleFactory = CommonResolverForModuleFactory( + CommonAnalysisParameters(metadataPartProviderFactory), + CompilerEnvironment, + CommonPlatforms.defaultCommonPlatform, + shouldCheckExpectActual = false + ) + @Suppress("NAME_SHADOWING") - val resolver = ResolverForProjectImpl( + val resolver = ResolverForSingleModuleProject( "sources for metadata serializer", ProjectContext(project, "metadata serializer"), - listOf(moduleInfo), - invalidateOnOOCB = false, - modulesContent = { ModuleContent(it, files, GlobalSearchScope.allScope(project)) }, - moduleLanguageSettingsProvider = object : LanguageSettingsProvider { - override fun getLanguageVersionSettings( - moduleInfo: ModuleInfo, - project: Project, - isReleaseCoroutines: Boolean? - ) = multiplatformLanguageSettings - - override fun getTargetPlatform( - moduleInfo: ModuleInfo, - project: Project - ) = TargetPlatformVersion.NoVersion - }, - resolverForModuleFactoryByPlatform = { - CommonResolverForModuleFactory( - CommonAnalysisParameters(metadataPartProviderFactory), - CompilerEnvironment, - CommonPlatforms.defaultCommonPlatform, - shouldCheckExpectActual = false - ) - }, - builtInsProvider = { DefaultBuiltIns.Instance }, - sdkDependency = { null } + moduleInfo, + resolverForModuleFactory, + GlobalSearchScope.allScope(project), + languageVersionSettings = multiplatformLanguageSettings, + syntheticFiles = files ) val moduleDescriptor = resolver.descriptorForModule(moduleInfo) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt index 0acccf62d7b..429d9a397bc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt @@ -54,7 +54,6 @@ abstract class ResolverForProject { abstract val name: String abstract val allModules: Collection - abstract val builtInsProvider: (M) -> KotlinBuiltIns override fun toString() = name @@ -79,7 +78,6 @@ class EmptyResolverForProject : ResolverForProject() { override fun descriptorForModule(moduleInfo: M) = diagnoseUnknownModuleInfo(listOf(moduleInfo)) override val allModules: Collection = listOf() override fun diagnoseUnknownModuleInfo(infos: List) = throw IllegalStateException("Should not be called for $infos") - override val builtInsProvider: (M) -> KotlinBuiltIns = { DefaultBuiltIns.Instance } } data class ModuleContent( @@ -128,7 +126,7 @@ class LazyModuleDependencies( storageManager: StorageManager, private val module: M, firstDependency: M? = null, - private val resolverForProject: ResolverForProjectImpl + private val resolverForProject: AbstractResolverForProject ) : ModuleDependencies { private val dependencies = storageManager.createLazyValue { val moduleDescriptor = resolverForProject.descriptorForModule(module) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForProjectImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForProjectImpl.kt index 6cf9ba9ef31..bed1f9f0cd1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForProjectImpl.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForProjectImpl.kt @@ -16,20 +16,15 @@ import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.psi.KtFile -class ResolverForProjectImpl( +abstract class AbstractResolverForProject( private val debugName: String, - private val projectContext: ProjectContext, + protected val projectContext: ProjectContext, modules: Collection, - private val modulesContent: (M) -> ModuleContent, - private val moduleLanguageSettingsProvider: LanguageSettingsProvider, - private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory, - private val invalidateOnOOCB: Boolean, - override val builtInsProvider: (M) -> KotlinBuiltIns, + private val fallbackModificationTracker: ModificationTracker? = null, private val delegateResolver: ResolverForProject = EmptyResolverForProject(), - private val sdkDependency: (M) -> M?, - private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory, - private val isReleaseCoroutines: Boolean? = null + private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory ) : ResolverForProject() { private class ModuleData( @@ -58,6 +53,11 @@ class ResolverForProjectImpl( assert(moduleInfoToResolvableInfo.values.toSet() == modules.toSet()) } + abstract fun sdkDependency(module: M): M? + abstract fun modulesContent(module: M): ModuleContent + abstract fun builtInsForModule(module: M): KotlinBuiltIns + abstract fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: M): ResolverForModule + override fun tryGetResolverForModule(moduleInfo: M): ResolverForModule? { if (!isCorrectModuleInfo(moduleInfo)) { return null @@ -108,25 +108,9 @@ class ResolverForProjectImpl( resolverByModuleDescriptor.getOrPut(descriptor) { checkModuleIsCorrect(module) - ResolverForModuleComputationTracker.getInstance(projectContext.project) - ?.onResolverComputed(module) + ResolverForModuleComputationTracker.getInstance(projectContext.project)?.onResolverComputed(module) - val moduleContent = modulesContent(module) - - val languageVersionSettings = - moduleLanguageSettingsProvider.getLanguageVersionSettings(module, projectContext.project, isReleaseCoroutines) - - // FIXME(dsavvinov): make sure that module.platform returns platform with the same JvmTarget as this one - val targetPlatformVersion = moduleLanguageSettingsProvider.getTargetPlatform(module, projectContext.project) - - val resolverForModuleFactory = resolverForModuleFactoryByPlatform(module.platform) - resolverForModuleFactory.createResolverForModule( - descriptor as ModuleDescriptorImpl, - projectContext.withModule(descriptor), - moduleContent, - this@ResolverForProjectImpl, - languageVersionSettings - ) + createResolverForModule(descriptor, module) } } } @@ -153,7 +137,7 @@ class ResolverForProjectImpl( private fun doGetDescriptorForModule(module: M): ModuleDescriptorImpl { val moduleFromThisResolver = moduleInfoToResolvableInfo[module] - ?: return delegateResolver.descriptorForModule(module) as ModuleDescriptorImpl + ?: return delegateResolver.descriptorForModule(module) as ModuleDescriptorImpl return projectContext.storageManager.compute { var moduleData = descriptorByModule.getOrPut(moduleFromThisResolver) { @@ -183,24 +167,20 @@ class ResolverForProjectImpl( val moduleDescriptor = ModuleDescriptorImpl( module.name, projectContext.storageManager, - builtInsProvider(module), + builtInsForModule(module), module.platform, module.capabilities, module.stableName ) moduleInfoByDescriptor[moduleDescriptor] = module setupModuleDescriptor(module, moduleDescriptor) - val modificationTracker = (module as? TrackableModuleInfo)?.createModificationTracker() ?: if (invalidateOnOOCB) { - KotlinModificationTrackerService.getInstance(projectContext.project).outOfBlockModificationTracker - } else { - null - } + val modificationTracker = (module as? TrackableModuleInfo)?.createModificationTracker() ?: fallbackModificationTracker return ModuleData(moduleDescriptor, modificationTracker) } } private class DelegatingPackageFragmentProvider( - private val resolverForProject: ResolverForProjectImpl, + private val resolverForProject: AbstractResolverForProject, private val module: ModuleDescriptor, moduleContent: ModuleContent, private val packageOracle: PackageOracle diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt new file mode 100644 index 00000000000..cec29dc293c --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.analyzer + +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl +import org.jetbrains.kotlin.context.ProjectContext +import org.jetbrains.kotlin.context.withModule +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.psi.KtFile + +class ResolverForSingleModuleProject( + debugName: String, + projectContext: ProjectContext, + module: M, + private val resolverForModuleFactory: ResolverForModuleFactory, + private val searchScope: GlobalSearchScope, + private val builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance, + private val languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT, + private val syntheticFiles: Collection = emptyList(), + private val sdkDependency: M? = null +) : AbstractResolverForProject( + debugName, + projectContext, + listOf(module), + null, + EmptyResolverForProject(), + PackageOracleFactory.OptimisticFactory +) { + override fun sdkDependency(module: M): M? = sdkDependency + + override fun modulesContent(module: M): ModuleContent = ModuleContent(module, syntheticFiles, searchScope) + + override fun builtInsForModule(module: M): KotlinBuiltIns = builtIns + + override fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: M): ResolverForModule = + resolverForModuleFactory.createResolverForModule( + descriptor as ModuleDescriptorImpl, + projectContext.withModule(descriptor), + modulesContent(moduleInfo), + this, + languageVersionSettings + ) +} \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt index 69d3d65d6fe..e7d7e747a99 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt @@ -46,18 +46,16 @@ fun createResolveSessionForFiles( packagePartProviderFactory = { PackagePartProvider.Empty }, moduleByJavaClass = { testModule } ) - val resolverForProject = ResolverForProjectImpl( + + val resolverForProject = ResolverForSingleModuleProject( "test", - projectContext, listOf(testModule), - { ModuleContent(it, syntheticFiles, GlobalSearchScope.allScope(project)) }, - invalidateOnOOCB = false, - moduleLanguageSettingsProvider = LanguageSettingsProvider.Default, - resolverForModuleFactoryByPlatform = { - JvmResolverForModuleFactory(platformParameters, CompilerEnvironment, JvmPlatforms.defaultJvmPlatform) - }, - builtInsProvider = { DefaultBuiltIns.Instance }, - sdkDependency = { null } + projectContext, + testModule, + JvmResolverForModuleFactory(platformParameters, CompilerEnvironment, JvmPlatforms.defaultJvmPlatform), + GlobalSearchScope.allScope(project), + syntheticFiles = syntheticFiles ) + return resolverForProject.resolverForModule(testModule).componentProvider.get() } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt index d3f56106ca6..1e449e6e4bc 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt @@ -28,9 +28,12 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.context.ProjectContext +import org.jetbrains.kotlin.context.withModule import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.load.kotlin.PackagePartProvider import org.jetbrains.kotlin.name.FqName @@ -87,24 +90,39 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() { modules.first { it._name == moduleName } } ) - val resolverForProject = ResolverForProjectImpl( + + val resolverForProject = object : AbstractResolverForProject( "test", - projectContext, modules, - invalidateOnOOCB = false, - modulesContent = { module -> ModuleContent(module, module.kotlinFiles, module.javaFilesScope) }, - moduleLanguageSettingsProvider = LanguageSettingsProvider.Default, - resolverForModuleFactoryByPlatform = { - JvmResolverForModuleFactory(platformParameters, CompilerEnvironment, JvmPlatforms.defaultJvmPlatform) - }, - sdkDependency = { null }, - builtInsProvider = { builtIns } - ) + projectContext, + modules + ) { + override fun sdkDependency(module: TestModule): TestModule? = null + + override fun modulesContent(module: TestModule): ModuleContent = + ModuleContent(module, module.kotlinFiles, module.javaFilesScope) + + override fun builtInsForModule(module: TestModule): KotlinBuiltIns = builtIns + + override fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: TestModule): ResolverForModule = + JvmResolverForModuleFactory( + platformParameters, + CompilerEnvironment, + JvmPlatforms.defaultJvmPlatform + ).createResolverForModule( + descriptor as ModuleDescriptorImpl, + projectContext.withModule(descriptor), + modulesContent(moduleInfo), + this, + LanguageVersionSettingsImpl.DEFAULT + ) + } builtIns.initialize( - resolverForProject.descriptorForModule(resolverForProject.allModules.first()), - resolverForProject.resolverForModule(resolverForProject.allModules.first()) - .componentProvider.get() - .supportsFeature(LanguageFeature.AdditionalBuiltInsMembers)) + resolverForProject.descriptorForModule(resolverForProject.allModules.first()), + resolverForProject.resolverForModule(resolverForProject.allModules.first()) + .componentProvider.get() + .supportsFeature(LanguageFeature.AdditionalBuiltInsMembers) + ) performChecks(resolverForProject, modules) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt new file mode 100644 index 00000000000..cd1108693c4 --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt @@ -0,0 +1,124 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.caches.resolve + +import com.intellij.openapi.components.ServiceManager +import com.intellij.openapi.util.ModificationTracker +import org.jetbrains.kotlin.analyzer.* +import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns +import org.jetbrains.kotlin.caches.resolve.CompositeAnalyzerServices +import org.jetbrains.kotlin.caches.resolve.CompositeResolverForModuleFactory +import org.jetbrains.kotlin.caches.resolve.resolution +import org.jetbrains.kotlin.context.ProjectContext +import org.jetbrains.kotlin.context.withModule +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo +import org.jetbrains.kotlin.idea.caches.project.findSdkAcrossDependencies +import org.jetbrains.kotlin.idea.caches.project.getNullableModuleInfo +import org.jetbrains.kotlin.idea.caches.project.getPlatformModuleInfo +import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider +import org.jetbrains.kotlin.idea.project.IdeaEnvironment +import org.jetbrains.kotlin.idea.project.findAnalyzerServices +import org.jetbrains.kotlin.idea.project.useCompositeAnalysis +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl +import org.jetbrains.kotlin.platform.idePlatformKind +import org.jetbrains.kotlin.platform.isCommon +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.platform.toTargetPlatform +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters + +class IdeaResolverForProject( + debugName: String, + projectContext: ProjectContext, + private val modules: Collection, + private val syntheticFilesByModule: Map>, + delegateResolver: ResolverForProject, + private val builtInsCache: BuiltInsCache, + fallbackModificationTracker: ModificationTracker? = null, + private val isReleaseCoroutines: Boolean? = null, + // TODO(dsavvinov): this is needed only for non-composite analysis, extract separate resolver implementation instead + private val constantSdkDependencyIfAny: IdeaModuleInfo? = null +) : AbstractResolverForProject( + debugName, + projectContext, + modules, + fallbackModificationTracker, + delegateResolver, + ServiceManager.getService(projectContext.project, IdePackageOracleFactory::class.java) +) { + override fun sdkDependency(module: IdeaModuleInfo): IdeaModuleInfo? { + if (projectContext.project.useCompositeAnalysis) { + require(constantSdkDependencyIfAny == null) { "Shouldn't pass SDK dependency manually for composite analysis mode" } + } + return constantSdkDependencyIfAny ?: module.findSdkAcrossDependencies() + } + + override fun modulesContent(module: IdeaModuleInfo): ModuleContent = + ModuleContent(module, syntheticFilesByModule[module] ?: emptyList(), module.contentScope()) + + override fun builtInsForModule(module: IdeaModuleInfo): KotlinBuiltIns { + require(module in modules) + val key = module.platform.idePlatformKind.resolution.getKeyForBuiltIns(module) + return builtInsCache.getOrPut(key) { throw IllegalStateException("Can't find builtIns by key $key for module $module") } + } + + override fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: IdeaModuleInfo): ResolverForModule { + val moduleContent = ModuleContent(moduleInfo, syntheticFilesByModule[moduleInfo] ?: listOf(), moduleInfo.contentScope()) + + val languageVersionSettings = + IDELanguageSettingsProvider.getLanguageVersionSettings(moduleInfo, projectContext.project, isReleaseCoroutines) + + val resolverForModuleFactory = getResolverForModuleFactory(moduleInfo) + + return resolverForModuleFactory.createResolverForModule( + descriptor as ModuleDescriptorImpl, + projectContext.withModule(descriptor), + moduleContent, + this, + languageVersionSettings + ) + } + + private fun getResolverForModuleFactory(moduleInfo: IdeaModuleInfo): ResolverForModuleFactory { + val platform = moduleInfo.platform + + val jvmPlatformParameters = JvmPlatformParameters( + packagePartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) }, + moduleByJavaClass = { javaClass: JavaClass -> + val psiClass = (javaClass as JavaClassImpl).psi + psiClass.getPlatformModuleInfo(JvmPlatforms.unspecifiedJvmPlatform)?.platformModule ?: psiClass.getNullableModuleInfo() + } + ) + + val commonPlatformParameters = CommonAnalysisParameters( + metadataPartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) } + ) + + return if (!projectContext.project.useCompositeAnalysis) { + val parameters = when { + platform.isJvm() -> jvmPlatformParameters + platform.isCommon() -> commonPlatformParameters + else -> PlatformAnalysisParameters.Empty + } + + platform.idePlatformKind.resolution.createResolverForModuleFactory(parameters, IdeaEnvironment, platform) + } else { + CompositeResolverForModuleFactory( + commonPlatformParameters, + jvmPlatformParameters, + platform, + CompositeAnalyzerServices(platform.componentPlatforms.map { it.toTargetPlatform().findAnalyzerServices }) + ) + } + } +} \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt index 0595088412e..b0b3420a01a 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt @@ -16,7 +16,6 @@ package org.jetbrains.kotlin.idea.caches.resolve -import com.intellij.openapi.components.ServiceManager import com.intellij.openapi.project.Project import com.intellij.psi.PsiElement import com.intellij.psi.util.CachedValueProvider @@ -24,36 +23,18 @@ import com.intellij.psi.util.CachedValuesManager import com.intellij.psi.util.PsiModificationTracker import com.intellij.util.containers.SLRUCache import org.jetbrains.kotlin.analyzer.* -import org.jetbrains.kotlin.analyzer.common.CommonAnalysisParameters -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns -import org.jetbrains.kotlin.caches.resolve.CompositeAnalyzerServices -import org.jetbrains.kotlin.caches.resolve.CompositeResolverForModuleFactory import org.jetbrains.kotlin.caches.resolve.resolution import org.jetbrains.kotlin.context.GlobalContextImpl -import org.jetbrains.kotlin.context.ProjectContext import org.jetbrains.kotlin.context.withProject import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.idea.caches.project.* import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo -import org.jetbrains.kotlin.idea.caches.project.getNullableModuleInfo -import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider -import org.jetbrains.kotlin.idea.project.IdeaEnvironment -import org.jetbrains.kotlin.idea.project.findAnalyzerServices -import org.jetbrains.kotlin.idea.project.useCompositeAnalysis -import org.jetbrains.kotlin.load.java.structure.JavaClass -import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl import org.jetbrains.kotlin.platform.idePlatformKind -import org.jetbrains.kotlin.platform.isCommon -import org.jetbrains.kotlin.platform.jvm.JvmPlatforms -import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.CompositeBindingContext -import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult -import org.jetbrains.kotlin.platform.DefaultIdeTargetPlatformKindProvider -import org.jetbrains.kotlin.platform.toTargetPlatform internal class ProjectResolutionFacade( private val debugString: String, @@ -101,7 +82,6 @@ internal class ProjectResolutionFacade( private fun computeModuleResolverProvider(): ResolverForProject { val delegateResolverForProject: ResolverForProject - val delegateBuiltIns: KotlinBuiltIns? if (reuseDataFrom != null) { delegateResolverForProject = reuseDataFrom.cachedResolverForProject @@ -119,61 +99,16 @@ internal class ProjectResolutionFacade( val modulesToCreateResolversFor = allModuleInfos.filter(moduleFilter) - val modulesContentFactory = { module: IdeaModuleInfo -> - ModuleContent(module, syntheticFilesByModule[module] ?: listOf(), module.contentScope()) - } - - val jvmPlatformParameters = JvmPlatformParameters( - packagePartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) }, - moduleByJavaClass = { javaClass: JavaClass -> - val psiClass = (javaClass as JavaClassImpl).psi - psiClass.getPlatformModuleInfo(JvmPlatforms.unspecifiedJvmPlatform)?.platformModule ?: psiClass.getNullableModuleInfo() - } - ) - - val commonPlatformParameters = CommonAnalysisParameters( - metadataPartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) } - ) - - val resolverForProject = ResolverForProjectImpl( + val resolverForProject = IdeaResolverForProject( resolverDebugName, projectContext, modulesToCreateResolversFor, - modulesContentFactory, - moduleLanguageSettingsProvider = IDELanguageSettingsProvider, - resolverForModuleFactoryByPlatform = { modulePlatform -> - val platform = modulePlatform ?: DefaultIdeTargetPlatformKindProvider.defaultPlatform - val parameters = when { - platform.isJvm() -> jvmPlatformParameters - platform.isCommon() -> commonPlatformParameters - else -> PlatformAnalysisParameters.Empty - } - - if (!project.useCompositeAnalysis) - platform.idePlatformKind.resolution.createResolverForModuleFactory(parameters, IdeaEnvironment, platform) - else - CompositeResolverForModuleFactory( - commonPlatformParameters, - jvmPlatformParameters, - modulePlatform!!, - CompositeAnalyzerServices(modulePlatform.componentPlatforms.map { it.toTargetPlatform().findAnalyzerServices }) - ) - }, - builtInsProvider = { module -> - require(module in modulesToCreateResolversFor) - val key = module.platform.idePlatformKind.resolution.getKeyForBuiltIns(module) - builtInsCache.getOrPut(key) { throw IllegalStateException("Can't find builtIns by key $key for module $module") } - }, - delegateResolver = delegateResolverForProject, - sdkDependency = { module -> - if (settings is PlatformAnalysisSettingsImpl) - settings.sdk?.let { SdkInfo(project, it) } - else - module.findSdkAcrossDependencies() - }, - packageOracleFactory = ServiceManager.getService(project, IdePackageOracleFactory::class.java), - invalidateOnOOCB = invalidateOnOOCB, - isReleaseCoroutines = settings.isReleaseCoroutines + syntheticFilesByModule, + delegateResolverForProject, + builtInsCache, + if (invalidateOnOOCB) KotlinModificationTrackerService.getInstance(project).outOfBlockModificationTracker else null, + settings.isReleaseCoroutines, + constantSdkDependencyIfAny = if (settings is PlatformAnalysisSettingsImpl) settings.sdk?.let { SdkInfo(project, it) } else null ) // Fill builtInsCache