Add factory function to create platform specific LibraryInfo's

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

@@ -16,12 +16,15 @@
 
 package org.jetbrains.kotlin.caches.resolve
 
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.analyzer.ResolverForModuleFactory
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.context.ProjectContext
 import org.jetbrains.kotlin.extensions.ApplicationExtensionDescriptor
+import org.jetbrains.kotlin.idea.caches.project.LibraryInfo
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
 import org.jetbrains.kotlin.platform.IdePlatformKind
 
@@ -36,6 +39,10 @@ interface IdePlatformKindResolution {
 
     val libraryKind: PersistentLibraryKind<*>?
 
+    fun createLibraryInfo(project: Project, library: Library): List<LibraryInfo> {
+        return listOf(LibraryInfo(project, library))
+    }
+
     companion object : ApplicationExtensionDescriptor<IdePlatformKindResolution>(
         "org.jetbrains.kotlin.idePlatformKindResolution", IdePlatformKindResolution::class.java
     ) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/project/IdeaModuleInfos.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.analyzer.CombinedModuleInfo
 import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.analyzer.TrackableModuleInfo
 import org.jetbrains.kotlin.caches.project.LibraryModuleInfo
+import org.jetbrains.kotlin.caches.resolve.resolution
 import org.jetbrains.kotlin.config.KotlinSourceRootType
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.configuration.BuildSystemType
@@ -40,6 +41,7 @@ import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.idea.util.isInSourceContentWithoutInjected
 import org.jetbrains.kotlin.idea.util.rootManager
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.platform.idePlatformKind
 import org.jetbrains.kotlin.resolve.TargetPlatform
 import org.jetbrains.kotlin.resolve.jvm.GlobalSearchScopeWithModuleSources
 import org.jetbrains.kotlin.utils.addIfNotNull
@@ -86,7 +88,7 @@ private fun orderEntryToModuleInfo(project: Project, orderEntry: OrderEntry, for
         }
         is LibraryOrderEntry -> {
             val library = orderEntry.library ?: return listOf()
-            listOfNotNull(LibraryInfo(project, library))
+            createLibraryInfo(project, library)
         }
         is JdkOrderEntry -> {
             val sdk = orderEntry.jdk ?: return listOf()
@@ -98,6 +100,11 @@ private fun orderEntryToModuleInfo(project: Project, orderEntry: OrderEntry, for
     }
 }
 
+fun createLibraryInfo(project: Project, library: Library): List<LibraryInfo> {
+    return getLibraryPlatform(project, library).idePlatformKind.resolution.createLibraryInfo(project, library)
+}
+
+
 private fun OrderEntry.acceptAsDependency(forProduction: Boolean): Boolean {
     return this !is ExportableOrderEntry
             || !forProduction
@@ -256,7 +263,7 @@ private class ModuleTestSourceScope(module: Module) : ModuleSourceScope(module)
     override fun toString() = "ModuleTestSourceScope($module)"
 }
 
-class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo, LibraryModuleInfo, BinaryModuleInfo {
+open class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo, LibraryModuleInfo, BinaryModuleInfo {
     override val moduleOrigin: ModuleOrigin
         get() = ModuleOrigin.LIBRARY
 
@@ -271,11 +278,8 @@ class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo,
         val (libraries, sdks) = LibraryDependenciesCache.getInstance(project).getLibrariesAndSdksUsedWith(library)
 
         sdks.mapTo(result) { SdkInfo(project, it) }
-        libraries.filter { it is LibraryEx && !it.isDisposed }.mapTo(result) {
-            LibraryInfo(
-                project,
-                it
-            )
+        libraries.filter { it is LibraryEx && !it.isDisposed }.flatMapTo(result) {
+            createLibraryInfo(project, it)
         }
 
         return result.toList()
@@ -285,7 +289,7 @@ class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo,
         get() = getLibraryPlatform(project, library)
 
     override val sourcesModuleInfo: SourceForBinaryModuleInfo
-        get() = LibrarySourceInfo(project, library)
+        get() = LibrarySourceInfo(project, library, this)
 
     override fun getLibraryRoots(): Collection<String> =
         library.getFiles(OrderRootType.CLASSES).mapNotNull(PathUtil::getLocalPath)
@@ -300,7 +304,7 @@ class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo,
     override fun hashCode(): Int = 43 * library.hashCode()
 }
 
-data class LibrarySourceInfo(val project: Project, val library: Library) : IdeaModuleInfo, SourceForBinaryModuleInfo {
+data class LibrarySourceInfo(val project: Project, val library: Library, override val binariesModuleInfo: BinaryModuleInfo) : IdeaModuleInfo, SourceForBinaryModuleInfo {
 
     override val name: Name = Name.special("<sources for library ${library.name}>")
 
@@ -311,12 +315,9 @@ data class LibrarySourceInfo(val project: Project, val library: Library) : IdeaM
         ), project)
 
     override fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> {
-        return listOf(LibraryInfo(project, library))
+        return createLibraryInfo(project, library)
     }
 
-    override val binariesModuleInfo: BinaryModuleInfo
-        get() = LibraryInfo(project, library)
-
     override fun toString() = "LibrarySourceInfo(libraryName=${library.name})"
 }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/project/getModuleInfo.kt

@@ -217,7 +217,7 @@ private inline fun <T> collectInfosByVirtualFile(
     }
 
     projectFileIndex.getOrderEntriesForFile(virtualFile).forEach {
-        it.toIdeaModuleInfo(project, virtualFile, treatAsLibrarySource)?.let(onOccurrence)
+        it.toIdeaModuleInfo(project, virtualFile, treatAsLibrarySource).map(onOccurrence)
     }
 
     val isBinary = virtualFile.fileType.isKotlinBinary()
@@ -262,23 +262,23 @@ private fun OrderEntry.toIdeaModuleInfo(
     project: Project,
     virtualFile: VirtualFile,
     treatAsLibrarySource: Boolean = false
-): IdeaModuleInfo? {
-    if (this is ModuleOrderEntry) return null
-    if (!isValid) return null
+): List<IdeaModuleInfo> {
+    if (this is ModuleOrderEntry) return emptyList()
+    if (!isValid) return emptyList()
 
     when (this) {
         is LibraryOrderEntry -> {
-            val library = library ?: return null
+            val library = library ?: return emptyList()
             if (ProjectRootsUtil.isLibraryClassFile(project, virtualFile) && !treatAsLibrarySource) {
-                return LibraryInfo(project, library)
+                return createLibraryInfo(project, library)
             } else if (ProjectRootsUtil.isLibraryFile(project, virtualFile) || treatAsLibrarySource) {
-                return LibrarySourceInfo(project, library)
+                return createLibraryInfo(project, library).map { it.sourcesModuleInfo }
             }
         }
         is JdkOrderEntry -> {
-            return SdkInfo(project, jdk ?: return null)
+            return listOf(SdkInfo(project, jdk ?: return emptyList()))
         }
-        else -> return null
+        else -> return emptyList()
     }
-    return null
+    return emptyList()
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/project/moduleInfosFromIdeaModel.kt

@@ -60,7 +60,7 @@ private fun collectModuleInfosFromIdeaModel(
 
     return IdeaModelInfosCache(
         moduleSourceInfos = ideaModules.flatMap(Module::correspondingModuleInfos),
-        libraryInfos = ideaLibraries.map { LibraryInfo(project, it) },
+        libraryInfos = ideaLibraries.flatMap { createLibraryInfo(project, it) },
         sdkInfos = (sdksFromModulesDependencies + getAllProjectSdks()).filterNotNull().toSet().map { SdkInfo(project, it) }
     )
 }