From 3051c367807a287edeabc1b6d4d42e4ea7de336f Mon Sep 17 00:00:00 2001
From: Pavel Kirpichenkov <pavel.kirpichenkov@jetbrains.com>
Date: Thu, 14 Jul 2022 15:22:23 +0300
Subject: [PATCH] [MPP] add extension for non-HMPP common KLIBs

Add an analysis parameter that can be used to create a
package fragment provider for a common KLIB library
when composite analysis aka HMPP support in IDE is disabled.
Such KLIBs can appear since 1.6.20, when hierarchical
project structure was enabled by default. This means, that even
if HMPP is explicitly disabled in KGP via the Gradle property,
common code is still represented by KLIBs and not by
.kotlin_metadata as it used to be. IDE can't resolve
agains common KLIB dependencies without a corresponding
package fragment provider that can read KLIB libraries.

KT-53164
---
 .../common/CommonResolverForModuleFactory.kt  | 29 ++++++++++++++++---
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt
index dae8d5d6c43..cb976ee52d0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt
@@ -47,9 +47,11 @@ import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPackageFragmentProvider
 import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider
+import org.jetbrains.kotlin.storage.StorageManager
 
 class CommonAnalysisParameters(
-    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider
+    val metadataPartProviderFactory: (ModuleContent<*>) -> MetadataPartProvider,
+    val klibMetadataPackageFragmentProviderFactory: KlibMetadataPackageFragmentProviderFactory? = null,
 ) : PlatformAnalysisParameters
 
 /**
@@ -105,12 +107,18 @@ class CommonResolverForModuleFactory(
             languageVersionSettings, targetPlatform, CommonPlatformAnalyzerServices, shouldCheckExpectActual
         )
 
+        val klibMetadataPackageFragmentProvider =
+            platformParameters.klibMetadataPackageFragmentProviderFactory?.createPackageFragmentProvider(
+                PackageFragmentProviderCreationContext(moduleInfo, moduleContext.storageManager, languageVersionSettings, moduleDescriptor)
+            )
+
         val packageFragmentProviders =
             /** If this is a dependency module that [commonDependenciesContainer] knows about, get the package fragments from there */
             commonDependenciesContainer?.packageFragmentProviderForModuleInfo(moduleInfo)?.let(::listOf)
-                ?: listOf(
+                ?: listOfNotNull(
                     container.get<ResolveSession>().packageFragmentProvider,
-                    container.get<MetadataPackageFragmentProvider>()
+                    container.get<MetadataPackageFragmentProvider>(),
+                    klibMetadataPackageFragmentProvider,
                 )
 
         return ResolverForModule(
@@ -154,7 +162,7 @@ class CommonResolverForModuleFactory(
             )
 
             val projectContext = ProjectContext(project, "metadata serializer")
-            @Suppress("NAME_SHADOWING")
+
             val resolver = ResolverForSingleModuleProject<ModuleInfo>(
                 "sources for metadata serializer",
                 projectContext,
@@ -210,6 +218,19 @@ interface CommonDependenciesContainer {
     val refinesModuleInfos: List<ModuleInfo>
 }
 
+fun interface KlibMetadataPackageFragmentProviderFactory {
+    fun createPackageFragmentProvider(
+        context: PackageFragmentProviderCreationContext
+    ): PackageFragmentProvider?
+}
+
+class PackageFragmentProviderCreationContext(
+    val moduleInfo: ModuleInfo,
+    val storageManager: StorageManager,
+    val languageVersionSettings: LanguageVersionSettings,
+    val moduleDescriptor: ModuleDescriptor,
+)
+
 private fun createContainerToResolveCommonCode(
     moduleContext: ModuleContext,
     bindingTrace: BindingTrace,