Create Native specific LibraryInfo

This LibraryInfo contains KonanLibrary and provides correct
capabilities to ModuleDescriptor

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

@@ -50,28 +50,7 @@ fun createFileStub(project: Project, text: String): PsiFileStub<*> {
 
 fun createLoggingErrorReporter(log: Logger) = LoggingErrorReporter(log)
 
-fun LibraryInfo.createPackageFragmentProviderForLibraryModule(
-    storageManager: StorageManager,
-    languageVersionSettings: LanguageVersionSettings,
-    moduleDescriptor: ModuleDescriptor
-): List<PackageFragmentProvider> {
-
-    if (this.platform != KonanPlatform) return emptyList()
-
-    val libraryRoots = this.getLibraryRoots()
-
-    return libraryRoots.mapNotNull { libraryRoot -> File(libraryRoot).takeIf { it.exists } }.map { libraryRoot ->
-        val konanLibrary =
-            createKonanLibrary(
-                libraryRoot,
-                KOTLIN_NATIVE_CURRENT_ABI_VERSION,
-                metadataReader = CachingIdeMetadataReaderImpl
-            )
-        konanLibrary.createPackageFragmentProvider(storageManager, languageVersionSettings, moduleDescriptor)
-    }
-}
-
-private fun KonanLibrary.createPackageFragmentProvider(
+fun KonanLibrary.createPackageFragmentProvider(
     storageManager: StorageManager,
     languageVersionSettings: LanguageVersionSettings,
     moduleDescriptor: ModuleDescriptor

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

@@ -5,31 +5,40 @@
 
 package org.jetbrains.kotlin.ide.konan
 
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.OrderRootType
+import com.intellij.openapi.roots.libraries.Library
 import com.intellij.openapi.roots.libraries.PersistentLibraryKind
 import com.intellij.openapi.vfs.VfsUtil
 import com.intellij.openapi.vfs.VirtualFile
-import com.intellij.openapi.vfs.VirtualFileManager
-import com.intellij.openapi.vfs.VirtualFileVisitor
+import com.intellij.util.PathUtil
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.caches.resolve.IdePlatformKindResolution
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.ide.konan.analyzer.NativeAnalyzerFacade
 import org.jetbrains.kotlin.idea.caches.project.LibraryInfo
 import org.jetbrains.kotlin.idea.caches.project.getModuleInfosFromIdeaModel
 import org.jetbrains.kotlin.idea.caches.resolve.PlatformAnalysisSettings
 import org.jetbrains.kotlin.konan.file.File
-import org.jetbrains.kotlin.konan.library.KLIB_FILE_EXTENSION
-import org.jetbrains.kotlin.konan.library.KLIB_METADATA_FILE_EXTENSION
-import org.jetbrains.kotlin.konan.library.KONAN_STDLIB_NAME
-import org.jetbrains.kotlin.konan.library.createKonanLibrary
+import org.jetbrains.kotlin.konan.library.*
 import org.jetbrains.kotlin.konan.util.KonanFactories.DefaultDeserializedDescriptorFactory
+import org.jetbrains.kotlin.resolve.ImplicitIntegerCoercion
 import org.jetbrains.kotlin.platform.impl.NativeIdePlatformKind
 import org.jetbrains.kotlin.resolve.konan.platform.KonanPlatform
 
 class NativePlatformKindResolution : IdePlatformKindResolution {
 
+    override fun createLibraryInfo(project: Project, library: Library): List<LibraryInfo> {
+        return library.getFiles(OrderRootType.CLASSES)
+            .mapNotNull { file -> PathUtil.getLocalPath(file) }
+            .map { path -> File(path) }
+            .filter { file -> file.exists }
+            .map { file -> NativeLibraryInfo(project, library, file) }
+    }
+
     override fun isLibraryFileForPlatform(virtualFile: VirtualFile): Boolean {
         return if (virtualFile.isDirectory) {
             val dir = virtualFile.findChild("linkdata") ?: return false
@@ -94,3 +103,27 @@ private fun createKotlinNativeBuiltIns(projectContext: ProjectContext): KotlinBu
 
     return DefaultBuiltIns.Instance
 }
+
+class NativeLibraryInfo(project: Project, library: Library, private val root: File) : LibraryInfo(project, library) {
+
+    private val nativeLibrary = createKonanLibrary(
+        root,
+        KOTLIN_NATIVE_CURRENT_ABI_VERSION,
+        metadataReader = CachingIdeMetadataReaderImpl
+    )
+
+    override fun getLibraryRoots(): Collection<String> {
+        return listOf(root.absolutePath)
+    }
+
+    override val capabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+        get() = super.capabilities +
+                mapOf(
+                    ImplicitIntegerCoercion.MODULE_CAPABILITY to nativeLibrary.isInterop,
+                    NATIVE_LIBRARY_CAPABILITY to nativeLibrary
+                )
+
+    companion object {
+        val NATIVE_LIBRARY_CAPABILITY = ModuleDescriptor.Capability<KonanLibrary>("KonanLibrary")
+    }
+}

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

@@ -13,8 +13,8 @@ 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.createPackageFragmentProviderForLibraryModule
-import org.jetbrains.kotlin.idea.caches.project.LibraryInfo
+import org.jetbrains.kotlin.ide.konan.NativeLibraryInfo
+import org.jetbrains.kotlin.ide.konan.createPackageFragmentProvider
 import org.jetbrains.kotlin.resolve.BindingTraceContext
 import org.jetbrains.kotlin.resolve.TargetEnvironment
 import org.jetbrains.kotlin.resolve.TargetPlatform
@@ -60,13 +60,16 @@ object NativeAnalyzerFacade : ResolverForModuleFactory() {
 
         val moduleInfo = moduleContent.moduleInfo
 
-        if (moduleInfo is LibraryInfo) {
-            val libPackageFragmentProviders = moduleInfo.createPackageFragmentProviderForLibraryModule(
-                moduleContext.storageManager,
-                languageVersionSettings,
-                moduleDescriptor
-            )
-            fragmentProviders.addAll(libPackageFragmentProviders)
+        val konanLibrary = moduleInfo.getCapability(NativeLibraryInfo.NATIVE_LIBRARY_CAPABILITY)
+        if (konanLibrary != null) {
+            val libPackageFragmentProvider =
+                konanLibrary.createPackageFragmentProvider(
+                    moduleContext.storageManager,
+                    languageVersionSettings,
+                    moduleDescriptor
+                )
+
+            fragmentProviders.add(libPackageFragmentProvider)
             //TODO: Forward declarations?
         }