IDE: Refactor NativePlatformKindResolution & NativeResolverForModuleFactory

idea/idea-native/src/org/jetbrains/kotlin/ide/konan/NativePlatformKindResolution.kt

@@ -34,7 +34,6 @@ import org.jetbrains.kotlin.idea.caches.resolve.BuiltInsCacheKey
 import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider
 import org.jetbrains.kotlin.konan.library.KONAN_STDLIB_NAME
 import org.jetbrains.kotlin.konan.util.KlibMetadataFactories
-import org.jetbrains.kotlin.library.KotlinLibrary
 import org.jetbrains.kotlin.library.isInterop
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
@@ -50,30 +49,6 @@ import org.jetbrains.kotlin.idea.klib.readSafe
 import org.jetbrains.kotlin.idea.klib.AbstractKlibLibraryInfo
 import org.jetbrains.kotlin.idea.klib.isKlibLibraryRootForPlatform
 
-private val NativeFactories = KlibMetadataFactories(::KonanBuiltIns, NullFlexibleTypeDeserializer)
-
-fun KotlinLibrary.createPackageFragmentProvider(
-    storageManager: StorageManager,
-    languageVersionSettings: LanguageVersionSettings,
-    moduleDescriptor: ModuleDescriptor
-): PackageFragmentProvider? {
-    if (!getCompatibilityInfo().isCompatible) return null
-
-    val libraryProto = CachingIdeKonanLibraryMetadataLoader.loadModuleHeader(this)
-
-    val deserializationConfiguration = CompilerDeserializationConfiguration(languageVersionSettings)
-
-    return NativeFactories.DefaultDeserializedDescriptorFactory.createPackageFragmentProvider(
-        this,
-        CachingIdeKonanLibraryMetadataLoader,
-        libraryProto.packageFragmentNameList,
-        storageManager,
-        moduleDescriptor,
-        deserializationConfiguration,
-        null
-    )
-}
-
 class NativePlatformKindResolution : IdePlatformKindResolution {
 
     override fun createLibraryInfo(project: Project, library: Library): List<LibraryInfo> {
@@ -89,14 +64,8 @@ class NativePlatformKindResolution : IdePlatformKindResolution {
         storageManager: StorageManager,
         languageVersionSettings: LanguageVersionSettings,
         moduleDescriptor: ModuleDescriptor
-    ): PackageFragmentProvider? {
+    ): PackageFragmentProvider? =
-        val library = (moduleInfo as? NativeKlibLibraryInfo)?.resolvedKotlinLibrary ?: return null
+        createLibraryPackageFragmentProvider(moduleInfo, storageManager, languageVersionSettings, moduleDescriptor)
-        return library.createPackageFragmentProvider(
-            storageManager,
-            languageVersionSettings,
-            moduleDescriptor
-        )
-    }
 
     override fun isLibraryFileForPlatform(virtualFile: VirtualFile): Boolean =
         virtualFile.isKlibLibraryRootForPlatform(KonanPlatforms.defaultKonanPlatform)
@@ -120,59 +89,82 @@ class NativePlatformKindResolution : IdePlatformKindResolution {
         createKotlinNativeBuiltIns(moduleInfo, projectContext)
 
     object NativeBuiltInsCacheKey : BuiltInsCacheKey
-}
 
-private fun createKotlinNativeBuiltIns(moduleInfo: ModuleInfo, projectContext: ProjectContext): KotlinBuiltIns {
+    companion object {
+        private val NativeFactories = KlibMetadataFactories(::KonanBuiltIns, NullFlexibleTypeDeserializer)
 
-    val project = projectContext.project
+        fun createLibraryPackageFragmentProvider(
-    val storageManager = projectContext.storageManager
+            moduleInfo: ModuleInfo,
+            storageManager: StorageManager,
+            languageVersionSettings: LanguageVersionSettings,
+            moduleDescriptor: ModuleDescriptor
+        ): PackageFragmentProvider? {
+            val library = (moduleInfo as? NativeKlibLibraryInfo)?.resolvedKotlinLibrary ?: return null
+            if (!library.getCompatibilityInfo().isCompatible) return null
 
-    val stdlibInfo = moduleInfo.findNativeStdlib() ?: return DefaultBuiltIns.Instance
+            val libraryProto = CachingIdeKonanLibraryMetadataLoader.loadModuleHeader(library)
-    val library = stdlibInfo.resolvedKotlinLibrary
+            val deserializationConfiguration = CompilerDeserializationConfiguration(languageVersionSettings)
 
-    val builtInsModule = NativeFactories.DefaultDescriptorFactory.createDescriptorAndNewBuiltIns(
+            return NativeFactories.DefaultDeserializedDescriptorFactory.createPackageFragmentProvider(
-        KotlinBuiltIns.BUILTINS_MODULE_NAME,
+                library,
-        storageManager,
+                CachingIdeKonanLibraryMetadataLoader,
-        DeserializedKlibModuleOrigin(library),
+                libraryProto.packageFragmentNameList,
-        stdlibInfo.capabilities
+                storageManager,
-    )
+                moduleDescriptor,
-
+                deserializationConfiguration,
-    val languageSettings = IDELanguageSettingsProvider.getLanguageVersionSettings(stdlibInfo, project, isReleaseCoroutines = false)
+                null
-    val deserializationConfiguration = CompilerDeserializationConfiguration(languageSettings)
-
-    val libraryProto = CachingIdeKonanLibraryMetadataLoader.loadModuleHeader(library)
-
-    val stdlibFragmentProvider = NativeFactories.DefaultDeserializedDescriptorFactory.createPackageFragmentProvider(
-        library,
-        CachingIdeKonanLibraryMetadataLoader,
-        libraryProto.packageFragmentNameList,
-        storageManager,
-        builtInsModule,
-        deserializationConfiguration,
-        null
-    )
-
-    builtInsModule.initialize(
-        CompositePackageFragmentProvider(
-            listOf(
-                stdlibFragmentProvider,
-                functionInterfacePackageFragmentProvider(storageManager, builtInsModule),
-                (NativeFactories.DefaultDeserializedDescriptorFactory as KlibMetadataModuleDescriptorFactoryImpl)
-                    .createForwardDeclarationHackPackagePartProvider(storageManager, builtInsModule)
             )
-        )
+        }
-    )
 
-    builtInsModule.setDependencies(listOf(builtInsModule))
+        private fun createKotlinNativeBuiltIns(moduleInfo: ModuleInfo, projectContext: ProjectContext): KotlinBuiltIns {
+            val stdlibInfo = moduleInfo.findNativeStdlib() ?: return DefaultBuiltIns.Instance
 
-    return builtInsModule.builtIns
+            val project = projectContext.project
+            val storageManager = projectContext.storageManager
+
+            val builtInsModule = NativeFactories.DefaultDescriptorFactory.createDescriptorAndNewBuiltIns(
+                KotlinBuiltIns.BUILTINS_MODULE_NAME,
+                storageManager,
+                DeserializedKlibModuleOrigin(stdlibInfo.resolvedKotlinLibrary),
+                stdlibInfo.capabilities
+            )
+
+            val languageVersionSettings = IDELanguageSettingsProvider.getLanguageVersionSettings(
+                stdlibInfo,
+                project,
+                isReleaseCoroutines = false
+            )
+
+            val stdlibPackageFragmentProvider = createLibraryPackageFragmentProvider(
+                stdlibInfo,
+                storageManager,
+                languageVersionSettings,
+                builtInsModule
+            ) ?: return DefaultBuiltIns.Instance
+
+            builtInsModule.initialize(
+                CompositePackageFragmentProvider(
+                    listOf(
+                        stdlibPackageFragmentProvider,
+                        functionInterfacePackageFragmentProvider(storageManager, builtInsModule),
+                        (NativeFactories.DefaultDeserializedDescriptorFactory as KlibMetadataModuleDescriptorFactoryImpl)
+                            .createForwardDeclarationHackPackagePartProvider(storageManager, builtInsModule)
+                    )
+                )
+            )
+
+            builtInsModule.setDependencies(listOf(builtInsModule))
+
+            return builtInsModule.builtIns
+        }
+
+        private fun ModuleInfo.findNativeStdlib(): NativeKlibLibraryInfo? =
+            dependencies().lazyClosure { it.dependencies() }
+                .filterIsInstance<NativeKlibLibraryInfo>()
+                .firstOrNull { it.isStdlib && it.compatibilityInfo.isCompatible }
+    }
 }
 
-private fun ModuleInfo.findNativeStdlib(): NativeKlibLibraryInfo? =
-    dependencies().lazyClosure { it.dependencies() }
-        .filterIsInstance<NativeKlibLibraryInfo>()
-        .firstOrNull { it.isStdlib && it.compatibilityInfo.isCompatible }
-
 class NativeKlibLibraryInfo(project: Project, library: Library, libraryRoot: String) :
     AbstractKlibLibraryInfo(project, library, libraryRoot) {
 

idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt

@@ -12,8 +12,7 @@ import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.frontend.di.createContainerForLazyResolve
-import org.jetbrains.kotlin.ide.konan.NativeKlibLibraryInfo
+import org.jetbrains.kotlin.ide.konan.NativePlatformKindResolution
-import org.jetbrains.kotlin.ide.konan.createPackageFragmentProvider
 import org.jetbrains.kotlin.platform.TargetPlatform
 import org.jetbrains.kotlin.platform.konan.KonanPlatforms
 import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer
@@ -57,18 +56,13 @@ class NativeResolverForModuleFactory(
         val packageFragmentProvider = container.get<ResolveSession>().packageFragmentProvider
         val fragmentProviders = mutableListOf(packageFragmentProvider)
 
-        val moduleInfo = moduleContent.moduleInfo
+        val libraryPackageFragmentProvider = NativePlatformKindResolution.createLibraryPackageFragmentProvider(
-
+            moduleContent.moduleInfo,
-        if (moduleInfo is NativeKlibLibraryInfo) {
+            moduleContext.storageManager,
-            val libPackageFragmentProvider =
+            languageVersionSettings,
-                moduleInfo.resolvedKotlinLibrary.createPackageFragmentProvider(
+            moduleDescriptor
-                    moduleContext.storageManager,
+        )
-                    languageVersionSettings,
+        fragmentProviders.addIfNotNull(libraryPackageFragmentProvider)
-                    moduleDescriptor
-                )
-
-            fragmentProviders.addIfNotNull(libPackageFragmentProvider)
-        }
 
         return ResolverForModule(CompositePackageFragmentProvider(fragmentProviders), container)
     }