Remove PackagePartProvider from ResolverForProjectImpl

To be able to move it to JVM-specific modules, and to provide a
replacement for common module analysis

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

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.resolve.lazy.ResolveSession
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 
 class JvmPlatformParameters(
+    val packagePartProviderFactory: (ModuleContent<*>) -> PackagePartProvider,
     val moduleByJavaClass: (JavaClass) -> ModuleInfo?
 ) : PlatformAnalysisParameters
 
@@ -52,8 +53,7 @@ object JvmAnalyzerFacade : ResolverForModuleFactory() {
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion,
+        targetPlatformVersion: TargetPlatformVersion
-        packagePartProvider: PackagePartProvider
     ): ResolverForModule {
         val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
@@ -86,6 +86,7 @@ object JvmAnalyzerFacade : ResolverForModuleFactory() {
         val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
 
         val lookupTracker = LookupTracker.DO_NOTHING
+        val packagePartProvider = (platformParameters as JvmPlatformParameters).packagePartProviderFactory(moduleContent)
         val container = createContainerForLazyResolveWithJava(
             moduleContext,
             trace,

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

@@ -33,7 +33,6 @@ import org.jetbrains.kotlin.context.withModule
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDependencies
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.name.FqName
@@ -89,11 +88,10 @@ class ResolverForProjectImpl<M : ModuleInfo>(
     private val modulePlatforms: (M) -> MultiTargetPlatform?,
     private val moduleLanguageSettingsProvider: LanguageSettingsProvider,
     private val resolverForModuleFactoryByPlatform: (TargetPlatform?) -> ResolverForModuleFactory,
-    private val platformParameters: PlatformAnalysisParameters,
+    private val platformParameters: (TargetPlatform) -> PlatformAnalysisParameters,
     private val targetEnvironment: TargetEnvironment = CompilerEnvironment,
     override val builtIns: KotlinBuiltIns = DefaultBuiltIns.Instance,
     private val delegateResolver: ResolverForProject<M> = EmptyResolverForProject(),
-    private val packagePartProviderFactory: (ModuleContent<M>) -> PackagePartProvider = { _ -> PackagePartProvider.Empty },
     private val firstDependency: M? = null,
     private val packageOracleFactory: PackageOracleFactory = PackageOracleFactory.OptimisticFactory,
     private val invalidateOnOOCB: Boolean = true
@@ -176,7 +174,6 @@ class ResolverForProjectImpl<M : ModuleInfo>(
                 ResolverForModuleComputationTracker.getInstance(projectContext.project)?.onResolverComputed(module)
 
                 val moduleContent = modulesContent(module)
-                val packagePartProvider = packagePartProviderFactory(moduleContent)
                 val resolverForModuleFactory = resolverForModuleFactoryByPlatform(module.platform)
 
                 val languageVersionSettings = moduleLanguageSettingsProvider.getLanguageVersionSettings(module, projectContext.project)
@@ -186,12 +183,11 @@ class ResolverForProjectImpl<M : ModuleInfo>(
                     descriptor as ModuleDescriptorImpl,
                     projectContext.withModule(descriptor),
                     moduleContent,
-                    platformParameters,
+                    platformParameters(resolverForModuleFactory.targetPlatform),
                     targetEnvironment,
                     this@ResolverForProjectImpl,
                     languageVersionSettings,
-                    targetPlatformVersion,
+                    targetPlatformVersion
-                    packagePartProvider
                 )
             }
         }
@@ -267,7 +263,9 @@ data class ModuleContent<out M : ModuleInfo>(
     val moduleContentScope: GlobalSearchScope
 )
 
-interface PlatformAnalysisParameters
+interface PlatformAnalysisParameters {
+    object Empty : PlatformAnalysisParameters
+}
 
 interface ModuleInfo {
     val name: Name
@@ -322,8 +320,7 @@ abstract class ResolverForModuleFactory {
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion,
+        targetPlatformVersion: TargetPlatformVersion
-        packagePartProvider: PackagePartProvider
     ): ResolverForModule
 
     abstract val targetPlatform: TargetPlatform

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonAnalyzerFacade.kt

@@ -45,6 +45,10 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmentProvider
 
+class CommonAnalysisParameters(
+    val packagePartProviderFactory: (ModuleContent<*>) -> PackagePartProvider
+) : PlatformAnalysisParameters
+
 /**
  * A facade that is used to analyze common (platform-independent) modules in multi-platform projects.
  * See [TargetPlatform.Common]
@@ -87,8 +91,7 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
                 override fun getTargetPlatform(moduleInfo: ModuleInfo) = TargetPlatformVersion.NoVersion
             },
             resolverForModuleFactoryByPlatform = { CommonAnalyzerFacade },
-            platformParameters = object : PlatformAnalysisParameters {},
+            platformParameters = { _ -> CommonAnalysisParameters(packagePartProviderFactory) }
-            packagePartProviderFactory = packagePartProviderFactory
         )
 
         val moduleDescriptor = resolver.descriptorForModule(moduleInfo)
@@ -107,8 +110,7 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion,
+        targetPlatformVersion: TargetPlatformVersion
-        packagePartProvider: PackagePartProvider
     ): ResolverForModule {
         val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project
@@ -118,6 +120,7 @@ object CommonAnalyzerFacade : ResolverForModuleFactory() {
             moduleInfo
         )
 
+        val packagePartProvider = (platformParameters as CommonAnalysisParameters).packagePartProviderFactory(moduleContent)
         val trace = CodeAnalyzerInitializer.getInstance(project).createTrace()
         val container = createContainerToResolveCommonCode(
             moduleContext, trace, declarationProviderFactory, moduleContentScope, targetEnvironment, packagePartProvider,

compiler/tests-common/tests/org/jetbrains/kotlin/resolve/lazy/lazyResolveTestUtils.kt

@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.ResolverForProjectImpl
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
@@ -44,7 +45,12 @@ fun createResolveSessionForFiles(
         modulePlatforms = { JvmPlatform.multiTargetPlatform },
         moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
         resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-        platformParameters = JvmPlatformParameters { testModule }
+        platformParameters = { _ ->
+            JvmPlatformParameters(
+                packagePartProviderFactory = { PackagePartProvider.Empty },
+                moduleByJavaClass = { testModule }
+            )
+        }
     )
     return resolverForProject.resolverForModule(testModule).componentProvider.get<ResolveSession>()
 }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -71,10 +71,14 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() {
             modulePlatforms = { JvmPlatform.multiTargetPlatform },
             moduleLanguageSettingsProvider = LanguageSettingsProvider.Default,
             resolverForModuleFactoryByPlatform = { JvmAnalyzerFacade },
-            platformParameters = JvmPlatformParameters {
+            platformParameters = { _ ->
-                javaClass ->
+                JvmPlatformParameters(
-                val moduleName = javaClass.name.asString().toLowerCase().first().toString()
+                    packagePartProviderFactory = { PackagePartProvider.Empty },
-                modules.first { it._name == moduleName }
+                    moduleByJavaClass = { javaClass ->
+                        val moduleName = javaClass.name.asString().toLowerCase().first().toString()
+                        modules.first { it._name == moduleName }
+                    }
+                )
             },
             builtIns = builtIns
         )

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

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.TargetPlatformVersion
 import org.jetbrains.kotlin.container.get
 import org.jetbrains.kotlin.context.ModuleContext
-import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
@@ -38,7 +37,6 @@ import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 
 object JsAnalyzerFacade : ResolverForModuleFactory() {
-
     override fun <M : ModuleInfo> createResolverForModule(
         moduleDescriptor: ModuleDescriptorImpl,
         moduleContext: ModuleContext,
@@ -47,8 +45,7 @@ object JsAnalyzerFacade : ResolverForModuleFactory() {
         targetEnvironment: TargetEnvironment,
         resolverForProject: ResolverForProject<M>,
         languageVersionSettings: LanguageVersionSettings,
-        targetPlatformVersion: TargetPlatformVersion,
+        targetPlatformVersion: TargetPlatformVersion
-        packagePartProvider: PackagePartProvider
     ): ResolverForModule {
         val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent
         val project = moduleContext.project

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

@@ -24,6 +24,7 @@ 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.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns
@@ -41,7 +42,9 @@ import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.CompositeBindingContext
+import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
 internal class ProjectResolutionFacade(
@@ -116,10 +119,17 @@ internal class ProjectResolutionFacade(
             ModuleContent(module, syntheticFilesByModule[module] ?: listOf(), module.contentScope())
         }
 
-        val jvmPlatformParameters = JvmPlatformParameters { javaClass: JavaClass ->
+        val jvmPlatformParameters = JvmPlatformParameters(
-            val psiClass = (javaClass as JavaClassImpl).psi
+            packagePartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) },
-            psiClass.getNullableModuleInfo()
+            moduleByJavaClass = { javaClass: JavaClass ->
-        }
+                val psiClass = (javaClass as JavaClassImpl).psi
+                psiClass.getNullableModuleInfo()
+            }
+        )
+
+        val commonPlatformParameters = CommonAnalysisParameters(
+            packagePartProviderFactory = { IDEPackagePartProvider(it.moduleContentScope) }
+        )
 
         val resolverForProject = ResolverForProjectImpl(
             resolverDebugName,
@@ -132,11 +142,16 @@ internal class ProjectResolutionFacade(
                 val platform = modulePlatform ?: settings.platform
                 IdePlatformSupport.facades[platform] ?: throw UnsupportedOperationException("Unsupported platform $platform")
             },
-            platformParameters = jvmPlatformParameters,
+            platformParameters = { platform ->
+                when (platform) {
+                    is JvmPlatform -> jvmPlatformParameters
+                    is TargetPlatform.Common -> commonPlatformParameters
+                    else -> PlatformAnalysisParameters.Empty
+                }
+            },
             targetEnvironment = IdeaEnvironment,
             builtIns = builtIns,
             delegateResolver = delegateResolverForProject,
-            packagePartProviderFactory = { moduleContent -> IDEPackagePartProvider(moduleContent.moduleContentScope) },
             firstDependency = settings.sdk?.let { SdkInfo(project, it) },
             packageOracleFactory = ServiceManager.getService(project, IdePackageOracleFactory::class.java),
             invalidateOnOOCB = invalidateOnOOCB