KLIB reader: uniform API for obtaining module descriptors from Kotlin/Native libraries (#1932)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/InlineClasses.kt

@@ -17,10 +17,8 @@
 package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.backend.konan.irasdescriptors.containsNull
-import org.jetbrains.kotlin.backend.konan.irasdescriptors.fqNameSafe
 import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.konan.interop.InteropFqNames
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/InteropUtils.kt

@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.UnsignedType
 import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
-import org.jetbrains.kotlin.descriptors.konan.interop.InteropFqNames
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -28,6 +27,17 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.util.OperatorNameConventions
 
+object InteropFqNames {
+
+    const val cPointerName = "CPointer"
+    const val nativePointedName = "NativePointed"
+
+    val packageName = FqName("kotlinx.cinterop")
+
+    val cPointer = packageName.child(Name.identifier(cPointerName)).toUnsafe()
+    val nativePointed = packageName.child(Name.identifier(nativePointedName)).toUnsafe()
+}
+
 internal class InteropBuiltIns(builtIns: KonanBuiltIns, vararg konanPrimitives: ClassDescriptor) {
 
     val packageScope = builtIns.builtInsModule.getPackage(InteropFqNames.packageName).memberScope

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.backend.konan
 
 import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.kotlinSourceRoots
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
@@ -25,18 +24,12 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.STRONG_W
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.descriptors.konan.interop.createForwardDeclarationsModule
 import org.jetbrains.kotlin.konan.TempFiles
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.library.KonanLibrary
 import org.jetbrains.kotlin.konan.library.defaultResolver
 import org.jetbrains.kotlin.konan.library.libraryResolver
 import org.jetbrains.kotlin.konan.target.*
-import org.jetbrains.kotlin.konan.util.profile
-import org.jetbrains.kotlin.serialization.konan.DefaultKonanModuleDescriptorFactory
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.storage.StorageManager
 
 class KonanConfig(val project: Project, val configuration: CompilerConfiguration) {
 
@@ -105,10 +98,6 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         return resolvedLibraries.filterRoots { (!it.isDefault && !this.purgeUserLibs) || it.isNeededForLink }.getFullList()
     }
 
-    private val loadedDescriptors = loadLibMetadata()
-
-    internal lateinit var friends: Set<ModuleDescriptorImpl>
-
     internal val defaultNativeLibraries = 
         if (produce == CompilerOutputKind.PROGRAM) 
             File(distribution.defaultNatives(target)).listFiles.map { it.absolutePath } 
@@ -120,53 +109,11 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
     internal val includeBinaries: List<String> = 
         configuration.getList(KonanConfigKeys.INCLUDED_BINARY_FILES)
 
-    fun loadLibMetadata(): List<ModuleDescriptorImpl> {
+    internal val languageVersionSettings =
+            configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)!!
 
-        val specifics = configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)!!
+    internal val friendModuleFiles: Set<File> =
-        val friendLibsSet = configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet()
+            configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet() ?: emptySet()
-
-        val allMetadata = mutableListOf<ModuleDescriptorImpl>()
-        val friends = mutableListOf<ModuleDescriptorImpl>()
-
-        resolvedLibraries.forEach { library, packageAccessedHandler ->
-            profile("Loading ${library.libraryName}") {
-                // MutableModuleContext needs ModuleDescriptorImpl, rather than ModuleDescriptor.
-                val moduleDescriptor = DefaultKonanModuleDescriptorFactory.createModuleDescriptor(library, specifics, packageAccessedHandler)
-                allMetadata.add(moduleDescriptor)
-                friendLibsSet?.apply {
-                    if (contains(library.libraryFile)) friends.add(moduleDescriptor)
-                }
-            }
-        }
-
-        this.friends = friends.toSet()
-
-        return allMetadata
-    }
-
-    private var forwardDeclarationsModule: ModuleDescriptorImpl? = null
-
-    internal fun getOrCreateForwardDeclarationsModule(
-            builtIns: KotlinBuiltIns, storageManager: StorageManager? = null
-    ): ModuleDescriptorImpl {
-        forwardDeclarationsModule?.let { return it }
-        val result = createForwardDeclarationsModule(
-                builtIns,
-                storageManager ?: LockBasedStorageManager()
-        )
-
-        forwardDeclarationsModule = result
-        return result
-    }
-
-    internal val moduleDescriptors: List<ModuleDescriptorImpl> by lazy {
-        for (module in loadedDescriptors) {
-            // Yes, just to all of them.
-            module.setDependencies(loadedDescriptors + getOrCreateForwardDeclarationsModule(module.builtIns))
-        }
-
-        loadedDescriptors
-    }
 }
 
 fun CompilerConfiguration.report(priority: CompilerMessageSeverity, message: String) 

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ObjCInterop.kt

@@ -22,7 +22,6 @@ import org.jetbrains.kotlin.backend.konan.irasdescriptors.constructedClass
 import org.jetbrains.kotlin.backend.konan.irasdescriptors.getExternalObjCMethodInfo
 import org.jetbrains.kotlin.backend.konan.irasdescriptors.isReal
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.konan.interop.InteropFqNames
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.ir.declarations.IrConstructor
 import org.jetbrains.kotlin.ir.declarations.IrFunction

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/TopDownAnalyzerFacadeForKonan.kt

@@ -17,34 +17,51 @@
 package org.jetbrains.kotlin.backend.konan
 
 import org.jetbrains.kotlin.analyzer.AnalysisResult
-import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.context.ModuleContext
 import org.jetbrains.kotlin.context.MutableModuleContextImpl
 import org.jetbrains.kotlin.context.ProjectContext
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.descriptors.konan.CurrentKonanModuleOrigin
-import org.jetbrains.kotlin.descriptors.konan.createKonanModuleDescriptor
 import org.jetbrains.kotlin.descriptors.konan.isKonanStdlib
+import org.jetbrains.kotlin.konan.file.File
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.KonanLibraryResolveResult
 import org.jetbrains.kotlin.konan.util.visibleName
+import org.jetbrains.kotlin.konan.utils.KonanFactories
+import org.jetbrains.kotlin.konan.utils.KonanFactories.DefaultDescriptorFactory
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
+import org.jetbrains.kotlin.serialization.konan.KonanResolvedModuleDescriptors
+import org.jetbrains.kotlin.storage.StorageManager
 
 object TopDownAnalyzerFacadeForKonan {
+
     fun analyzeFiles(files: Collection<KtFile>, config: KonanConfig): AnalysisResult {
         val moduleName = Name.special("<${config.moduleId}>") 
 
         val projectContext = ProjectContext(config.project)
 
-        val module = createKonanModuleDescriptor(moduleName, projectContext.storageManager, origin = CurrentKonanModuleOrigin)
+        val module = DefaultDescriptorFactory.createDescriptorAndNewBuiltIns(
+                moduleName, projectContext.storageManager, origin = CurrentKonanModuleOrigin)
         val context = MutableModuleContextImpl(module, projectContext)
 
+        val resolvedDependencies = ResolvedDependencies(
+                config.resolvedLibraries,
+                projectContext.storageManager,
+                module.builtIns,
+                config.languageVersionSettings,
+                config.friendModuleFiles)
+
         if (!module.isKonanStdlib()) {
-            val dependencies = listOf(module) + config.moduleDescriptors +
+            val dependencies = listOf(module) + resolvedDependencies.moduleDescriptors.resolvedDescriptors + resolvedDependencies.moduleDescriptors.forwardDeclarationsModule
-                    config.getOrCreateForwardDeclarationsModule(module.builtIns, projectContext.storageManager)
+            module.setDependencies(dependencies, resolvedDependencies.friends)
-            module.setDependencies(dependencies, config.friends)
         } else {
-            assert (config.moduleDescriptors.isEmpty())
+            assert (resolvedDependencies.moduleDescriptors.resolvedDescriptors.isEmpty())
             context.setDependencies(module)
         }
 
@@ -80,3 +97,32 @@ object TopDownAnalyzerFacadeForKonan {
         }
     }
 }
+
+private class ResolvedDependencies(
+        resolvedLibraries: KonanLibraryResolveResult,
+        storageManager: StorageManager,
+        builtIns: KotlinBuiltIns,
+        specifics: LanguageVersionSettings,
+        friendModuleFiles: Set<File>
+) {
+
+    val moduleDescriptors: KonanResolvedModuleDescriptors
+    val friends: Set<ModuleDescriptorImpl>
+
+    init {
+
+        val collectedFriends = mutableListOf<ModuleDescriptorImpl>()
+
+        val customAction: (KonanLibrary, ModuleDescriptorImpl) -> Unit = { library, moduleDescriptor ->
+            if (friendModuleFiles.contains(library.libraryFile)) {
+                collectedFriends.add(moduleDescriptor)
+            }
+        }
+
+        this.moduleDescriptors = KonanFactories.DefaultResolvedDescriptorsFactory.createResolved(
+                resolvedLibraries, storageManager, builtIns, specifics, customAction)
+
+        this.friends = collectedFriends.toSet()
+    }
+}
+

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt

@@ -332,7 +332,7 @@ internal class Llvm(val context: Context, val llvmModule: LLVMModuleRef) {
         override fun add(origin: CompiledKonanModuleOrigin) {
             val library = when (origin) {
                 CurrentKonanModuleOrigin -> return
-                is DeserializedKonanModuleOrigin -> origin.library as KonanLibrary
+                is DeserializedKonanModuleOrigin -> origin.library
             }
 
             if (library !in allLibraries) {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGSerializer.kt

@@ -19,7 +19,8 @@ package org.jetbrains.kotlin.backend.konan.optimizations
 import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.backend.konan.PrimitiveBinaryType
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.serialization.konan.DefaultKonanModuleDescriptorFactory
+import org.jetbrains.kotlin.konan.utils.KonanFactories.DefaultDeserializedDescriptorFactory
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import sun.misc.Unsafe
 import kotlin.reflect.KClass
 import kotlin.reflect.full.memberProperties
@@ -940,6 +941,7 @@ internal object DFGSerializer {
         val publicFunctionsMap = mutableMapOf<Long, DataFlowIR.FunctionSymbol.Public>()
         val functions = mutableMapOf<DataFlowIR.FunctionSymbol, DataFlowIR.Function>()
         val specifics = context.config.configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)!!
+        val storageManager = LockBasedStorageManager()
         context.librariesWithDependencies.forEach { library ->
             val libraryDataFlowGraph = library.dataFlowGraph
 
@@ -949,7 +951,7 @@ internal object DFGSerializer {
 
             if (libraryDataFlowGraph != null) {
                 val module = DataFlowIR.Module(
-                        DefaultKonanModuleDescriptorFactory.createModuleDescriptor(library, specifics))
+                        DefaultDeserializedDescriptorFactory.createDescriptorAndNewBuiltIns(library, specifics, storageManager))
                 val reader = ArraySlice(libraryDataFlowGraph)
                 val dataLayoutHash = reader.readLong()
                 val expectedHash = computeDataLayoutHash(Module::class)

build.gradle

@@ -251,10 +251,6 @@ task distCompiler(type: Copy) {
         into('konan/lib')
     }
 
-    from(file("${gradle.includedBuild('konan.descriptors').projectDir}/build/libs")) {
-        into('konan/lib')
-    }
-
     from(file("${gradle.includedBuild('konan.metadata').projectDir}/build/libs")) {
         into('konan/lib')
     }

cmd/run_konan

@@ -85,12 +85,11 @@ STUB_GENERATOR_JAR="${KONAN_HOME}/konan/lib/StubGenerator.jar"
 INTEROP_INDEXER_JAR="${KONAN_HOME}/konan/lib/Indexer.jar"
 INTEROP_JAR="${KONAN_HOME}/konan/lib/Runtime.jar"
 SHARED_JAR="${KONAN_HOME}/konan/lib/shared.jar"
-EXTRACTED_DESCRIPTORS_JAR="${KONAN_HOME}/konan/lib/konan.descriptors.jar"
 EXTRACTED_METADATA_JAR="${KONAN_HOME}/konan/lib/konan.metadata.jar"
 EXTRACTED_SERIALIZER_JAR="${KONAN_HOME}/konan/lib/konan.serializer.jar"
 KLIB_JAR="${KONAN_HOME}/konan/lib/klib.jar"
 UTILITIES_JAR="${KONAN_HOME}/konan/lib/utilities.jar"
-KONAN_CLASSPATH="$KOTLIN_JAR:$KOTLIN_STDLIB_JAR:$KOTLIN_REFLECT_JAR:$KOTLIN_SCRIPT_RUNTIME_JAR:$INTEROP_JAR:$STUB_GENERATOR_JAR:$INTEROP_INDEXER_JAR:$KONAN_JAR:$KLIB_JAR:$UTILITIES_JAR:$SHARED_JAR:$EXTRACTED_DESCRIPTORS_JAR:$EXTRACTED_METADATA_JAR:$EXTRACTED_SERIALIZER_JAR"
+KONAN_CLASSPATH="$KOTLIN_JAR:$KOTLIN_STDLIB_JAR:$KOTLIN_REFLECT_JAR:$KOTLIN_SCRIPT_RUNTIME_JAR:$INTEROP_JAR:$STUB_GENERATOR_JAR:$INTEROP_INDEXER_JAR:$KONAN_JAR:$KLIB_JAR:$UTILITIES_JAR:$SHARED_JAR:$EXTRACTED_METADATA_JAR:$EXTRACTED_SERIALIZER_JAR"
 TOOL_CLASS=org.jetbrains.kotlin.cli.utilities.MainKt
 
 LIBCLANG_DISABLE_CRASH_RECOVERY=1 \

cmd/run_konan.bat

@@ -55,7 +55,6 @@ set "NATIVE_LIB=%_KONAN_HOME%\konan\nativelib"
 set "KONAN_LIB=%_KONAN_HOME%\konan\lib"
 
 set "SHARED_JAR=%KONAN_LIB%\shared.jar"
-set "EXTRACTED_DESCRIPTORS_JAR=%KONAN_LIB%\konan.descriptors.jar"
 set "EXTRACTED_METADATA_JAR=%KONAN_LIB%\konan.metadata.jar"
 set "EXTRACTED_SERIALIZER_JAR=%KONAN_LIB%\konan.serializer.jar"
 set "INTEROP_INDEXER_JAR=%KONAN_LIB%\Indexer.jar"
@@ -69,7 +68,7 @@ set "KOTLIN_SCRIPT_RUNTIME_JAR=%KONAN_LIB%\kotlin-script-runtime.jar"
 set "STUB_GENERATOR_JAR=%KONAN_LIB%\StubGenerator.jar"
 set "UTILITIES_JAR=%KONAN_LIB%\utilities.jar"
 
-set "KONAN_CLASSPATH=%KOTLIN_JAR%;%KOTLIN_STDLIB_JAR%;%KOTLIN_REFLECT_JAR%;%KOTLIN_SCRIPT_RUNTIME_JAR%;%INTEROP_RUNTIME_JAR%;%KONAN_JAR%;%STUB_GENERATOR_JAR%;%INTEROP_INDEXER_JAR%;%SHARED_JAR%;%EXTRACTED_DESCRIPTORS_JAR%;%EXTRACTED_METADATA_JAR%;%EXTRACTED_SERIALIZER_JAR%;%KLIB_JAR%;%UTILITIES_JAR%"
+set "KONAN_CLASSPATH=%KOTLIN_JAR%;%KOTLIN_STDLIB_JAR%;%KOTLIN_REFLECT_JAR%;%KOTLIN_SCRIPT_RUNTIME_JAR%;%INTEROP_RUNTIME_JAR%;%KONAN_JAR%;%STUB_GENERATOR_JAR%;%INTEROP_INDEXER_JAR%;%SHARED_JAR%;%EXTRACTED_METADATA_JAR%;%EXTRACTED_SERIALIZER_JAR%;%KLIB_JAR%;%UTILITIES_JAR%"
 
 set JAVA_OPTS=-ea ^
     -Xmx3G ^

extracted/konan.descriptors/build.gradle

@@ -1,40 +0,0 @@
-buildscript {
-    ext.rootBuildDirectory = file('../..')
-
-    apply from: "$rootBuildDirectory/gradle/loadRootProperties.gradle"
-    apply from: "$rootBuildDirectory/gradle/kotlinGradlePlugin.gradle"
-}
-
-apply plugin: 'kotlin'
-
-group = 'org.jetbrains.kotlin'
-version = konanVersion
-
-repositories {
-    mavenCentral()
-    maven {
-        url kotlinCompilerRepo
-    }
-}
-
-sourceSets {
-    main.kotlin {
-        srcDir 'src/main/kotlin'
-    }
-}
-
-jar {
-    archiveName = "${project.name}.jar"
-}
-
-repositories {
-    maven {
-        url buildKotlinCompilerRepo
-    }
-}
-
-dependencies {
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$buildKotlinVersion"
-    compile "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
-    compile "org.jetbrains.kotlin:kotlin-compiler:$kotlinVersion"
-}

extracted/konan.descriptors/settings.gradle

@@ -1 +0,0 @@
-rootProject.name = "konan.descriptors"

extracted/konan.descriptors/src/main/kotlin/org/jetbrains/kotlin/descriptors/konan/KonanModuleDescriptors.kt

@@ -1,38 +0,0 @@
-package org.jetbrains.kotlin.descriptors.konan
-
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
-import org.jetbrains.kotlin.descriptors.ModuleDescriptor
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.konan.library.KONAN_STDLIB_NAME
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.storage.StorageManager
-
-fun createKonanModuleDescriptor(
-        name: Name,
-        storageManager: StorageManager,
-        origin: KonanModuleOrigin
-): ModuleDescriptorImpl {
-    val builtIns = KonanBuiltIns(storageManager)
-
-    val moduleDescriptor = createKonanModuleDescriptor(name, storageManager, builtIns, origin)
-
-    builtIns.builtInsModule = moduleDescriptor
-    // It is mostly correct because any module should depend on stdlib.
-
-    return moduleDescriptor
-}
-
-fun createKonanModuleDescriptor(
-        name: Name,
-        storageManager: StorageManager,
-        builtIns: KotlinBuiltIns,
-        origin: KonanModuleOrigin
-) = ModuleDescriptorImpl(
-        name, storageManager, builtIns,
-        capabilities = mapOf(KonanModuleOrigin.CAPABILITY to origin)
-)
-
-private val STDLIB_MODULE_NAME = Name.special("<$KONAN_STDLIB_NAME>")
-
-fun ModuleDescriptor.isKonanStdlib() = name == STDLIB_MODULE_NAME

extracted/konan.descriptors/src/main/kotlin/org/jetbrains/kotlin/descriptors/konan/interop/InteropDescriptors.kt

@@ -1,113 +0,0 @@
-package org.jetbrains.kotlin.descriptors.konan.interop
-
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
-import org.jetbrains.kotlin.descriptors.konan.SyntheticModulesOrigin
-import org.jetbrains.kotlin.descriptors.konan.createKonanModuleDescriptor
-import org.jetbrains.kotlin.incremental.components.LookupLocation
-import org.jetbrains.kotlin.incremental.components.NoLookupLocation
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
-import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.storage.getValue
-import org.jetbrains.kotlin.utils.Printer
-
-/**
- * Creates module which "contains" forward declarations.
- * Note: this module should be unique per compilation and should always be the last dependency of any module.
- */
-fun createForwardDeclarationsModule(builtIns: KotlinBuiltIns, storageManager: StorageManager): ModuleDescriptorImpl {
-    val module = createKonanModuleDescriptor(
-            Name.special("<forward declarations>"),
-            storageManager,
-            builtIns,
-            origin = SyntheticModulesOrigin
-    )
-
-    fun createPackage(fqName: FqName, supertypeName: String, classKind: ClassKind = ClassKind.CLASS) =
-            ForwardDeclarationsPackageFragmentDescriptor(
-                    storageManager,
-                    module,
-                    fqName,
-                    Name.identifier(supertypeName),
-                    classKind
-            )
-
-    val packageFragmentProvider = PackageFragmentProviderImpl(
-            listOf(
-                    createPackage(InteropFqNames.cNamesStructs, "COpaque"),
-                    createPackage(InteropFqNames.objCNamesClasses, "ObjCObjectBase"),
-                    createPackage(InteropFqNames.objCNamesProtocols, "ObjCObject", ClassKind.INTERFACE)
-            )
-    )
-
-    module.initialize(packageFragmentProvider)
-    module.setDependencies(module)
-
-    return module
-}
-
-/**
- * Package fragment which creates descriptors for forward declarations on demand.
- */
-private class ForwardDeclarationsPackageFragmentDescriptor(
-        storageManager: StorageManager,
-        module: ModuleDescriptor, fqName: FqName, supertypeName: Name, classKind: ClassKind
-) : PackageFragmentDescriptorImpl(module, fqName) {
-
-    private val memberScope = object : MemberScopeImpl() {
-
-        private val declarations = storageManager.createMemoizedFunction(this::createDeclaration)
-
-        private val supertype by storageManager.createLazyValue {
-            val descriptor = builtIns.builtInsModule.getPackage(InteropFqNames.packageName)
-                    .memberScope
-                    .getContributedClassifier(supertypeName, NoLookupLocation.FROM_BACKEND) as ClassDescriptor
-
-            descriptor.defaultType
-        }
-
-        private fun createDeclaration(name: Name): ClassDescriptor {
-            return ClassDescriptorImpl(
-                    this@ForwardDeclarationsPackageFragmentDescriptor,
-                    name, Modality.FINAL, classKind,
-                    listOf(supertype), SourceElement.NO_SOURCE, false, LockBasedStorageManager.NO_LOCKS
-            ).apply {
-                this.initialize(MemberScope.Empty, emptySet(), null)
-            }
-        }
-
-        override fun getContributedClassifier(name: Name, location: LookupLocation) = declarations(name)
-
-        override fun printScopeStructure(p: Printer) {
-            p.println(this::class.java.simpleName, "{}")
-        }
-    }
-
-    override fun getMemberScope(): MemberScope = memberScope
-}
-
-object InteropFqNames {
-
-    const val cPointerName = "CPointer"
-    const val nativePointedName = "NativePointed"
-
-    val packageName = FqName("kotlinx.cinterop")
-
-    val cPointer = packageName.child(Name.identifier(cPointerName)).toUnsafe()
-    val nativePointed = packageName.child(Name.identifier(nativePointedName)).toUnsafe()
-
-    val cNames = FqName("cnames")
-    val cNamesStructs = cNames.child(Name.identifier("structs"))
-
-    val objCNames = FqName("objcnames")
-    val objCNamesClasses = objCNames.child(Name.identifier("classes"))
-    val objCNamesProtocols = objCNames.child(Name.identifier("protocols"))
-}

extracted/konan.serializer/build.gradle

@@ -34,6 +34,8 @@ repositories {
 }
 
 dependencies {
-    compile "org.jetbrains.kotlin:konan.descriptors:$konanVersion"
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$buildKotlinVersion"
+    compile "org.jetbrains.kotlin:kotlin-native-shared:$konanVersion"
+    compile "org.jetbrains.kotlin:kotlin-compiler:$kotlinVersion"
     compile "org.jetbrains.kotlin:konan.metadata:$konanVersion"
 }

extracted/konan.serializer/src/org/jetbrains/kotlin/builtins/konan/KonanBuiltIns.kt

@@ -9,4 +9,3 @@ class KonanBuiltIns(storageManager: StorageManager) : KotlinBuiltIns(storageMana
     override fun getSuspendFunction(parameterCount: Int) =
             getBuiltInClassByName(Name.identifier("SuspendFunction$parameterCount"))
 }
-

extracted/konan.serializer/src/org/jetbrains/kotlin/descriptors/konan/KonanModuleDescriptorFactory.kt

@@ -0,0 +1,32 @@
+package org.jetbrains.kotlin.descriptors.konan
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.storage.StorageManager
+
+interface KonanModuleDescriptorFactory {
+
+    /**
+     * Base method for creation of any Kotlin/Native [ModuleDescriptor].
+     */
+    fun createDescriptor(
+            name: Name,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns,
+            origin: KonanModuleOrigin,
+            customCapabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap()
+    ): ModuleDescriptorImpl
+
+    /**
+     * Please use this method with care: As far as it creates an instance of [KotlinBuiltIns] it should be
+     * normally used for creation of the very first (e.g. "stdlib") module in the set of created modules.
+     */
+    fun createDescriptorAndNewBuiltIns(
+            name: Name,
+            storageManager: StorageManager,
+            origin: KonanModuleOrigin,
+            customCapabilities: Map<ModuleDescriptor.Capability<*>, Any?> = emptyMap()
+    ): ModuleDescriptorImpl
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/descriptors/konan/KonanModuleDescriptorUtils.kt

@@ -0,0 +1,9 @@
+package org.jetbrains.kotlin.descriptors.konan
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.konan.library.KONAN_STDLIB_NAME
+import org.jetbrains.kotlin.name.Name
+
+private val STDLIB_MODULE_NAME = Name.special("<$KONAN_STDLIB_NAME>")
+
+fun ModuleDescriptor.isKonanStdlib() = name == STDLIB_MODULE_NAME

extracted/konan.serializer/src/org/jetbrains/kotlin/descriptors/konan/KonanModuleOrigin.kt

@@ -1,6 +1,7 @@
 package org.jetbrains.kotlin.descriptors.konan
 
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.konan.library.KonanLibrary
 
 sealed class KonanModuleOrigin {
 
@@ -11,8 +12,7 @@ sealed class KonanModuleOrigin {
 
 sealed class CompiledKonanModuleOrigin: KonanModuleOrigin()
 
-// FIXME(ddol): replace `Any` by `KonanLibrary` when ready
+class DeserializedKonanModuleOrigin(val library: KonanLibrary) : CompiledKonanModuleOrigin()
-class DeserializedKonanModuleOrigin(val library: Any) : CompiledKonanModuleOrigin()
 
 object CurrentKonanModuleOrigin: CompiledKonanModuleOrigin()
 

extracted/konan.serializer/src/org/jetbrains/kotlin/descriptors/konan/impl/KonanModuleDescriptorFactoryImpl.kt

@@ -0,0 +1,40 @@
+package org.jetbrains.kotlin.descriptors.konan.impl
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.builtins.konan.KonanBuiltIns
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleDescriptorFactory
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleOrigin
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.storage.StorageManager
+
+internal object KonanModuleDescriptorFactoryImpl: KonanModuleDescriptorFactory {
+
+    override fun createDescriptor(
+            name: Name,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns,
+            origin: KonanModuleOrigin,
+            customCapabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+    ) = ModuleDescriptorImpl(
+            name,
+            storageManager,
+            builtIns,
+            capabilities = customCapabilities + mapOf(KonanModuleOrigin.CAPABILITY to origin))
+
+    override fun createDescriptorAndNewBuiltIns(
+            name: Name,
+            storageManager: StorageManager,
+            origin: KonanModuleOrigin,
+            customCapabilities: Map<ModuleDescriptor.Capability<*>, Any?>
+    ): ModuleDescriptorImpl {
+
+        val builtIns = KonanBuiltIns(storageManager)
+
+        val moduleDescriptor = createDescriptor(name, storageManager, builtIns, origin, customCapabilities)
+        builtIns.builtInsModule = moduleDescriptor
+
+        return moduleDescriptor
+    }
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/KonanLibrary.kt

@@ -22,15 +22,15 @@ interface KonanLibrary {
     val libraryName: String
     val libraryFile: File
 
-    // whether this library is default (provided by Kotlin/Native distribution)
+    // Whether this library is default (provided by Kotlin/Native distribution)?
     val isDefault: Boolean
 
-    // properties:
+    // Properties:
     val manifestProperties: Properties
     val abiVersion: String
     val linkerOpts: List<String>
 
-    // paths:
+    // Paths:
     val bitcodePaths: List<String>
     val includedPaths: List<String>
 

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/KonanLibraryLayout.kt

@@ -3,7 +3,9 @@ package org.jetbrains.kotlin.konan.library
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
-// This scheme describes the Kotlin/Native Library (klib) layout.
+/**
+ * This scheme describes the Kotlin/Native Library (KLIB) layout.
+ */
 interface KonanLibraryLayout {
 
     val libraryName: String

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/KonanLibraryUtils.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.konan.target.KonanTarget
 
 fun File.unpackZippedKonanLibraryTo(newDir: File) {
 
-    // first run validity checks for the given KLIB file
+    // First, run validity checks for the given KLIB file.
     zippedKonanLibraryChecks(this)
 
     if (newDir.exists) {

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/impl/KonanLibraryLayoutImpl.kt

@@ -33,10 +33,10 @@ private class UnzippedKonanLibraryLayout(override val libDir: File, override val
     override val libraryName = libDir.path
 }
 
-// This class automatically extracts pieces of
+/**
-// the library on first access. Use it if you need
+ * This class automatically extracts pieces of the library on first access. Use it if you need
-// to pass extracted files to an external tool.
+ * to pass extracted files to an external tool. Otherwise, stick to [ZippedKonanLibraryLayout].
-// Otherwise, stick to ZippedKonanLibrary.
+ */
 private class FileExtractor(zippedLibraryLayout: KonanLibraryLayout): KonanLibraryLayout by zippedLibraryLayout {
 
     override val manifestFile: File by lazy { extract(super.manifestFile) }

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/resolver/KonanResolvedLibrary.kt

@@ -13,15 +13,15 @@ interface PackageAccessedHandler {
  */
 interface KonanResolvedLibrary: PackageAccessedHandler {
 
-    // the library itself
+    // The library itself.
     val library: KonanLibrary
 
-    // dependencies on other libraries
+    // Dependencies on other libraries.
     val resolvedDependencies: List<KonanResolvedLibrary>
 
-    // if it's needed to linker
+    // Whether it is needed to linker.
     val isNeededForLink: Boolean
 
-    // is provided by the distribution
+    // Is provided by the distribution?
     val isDefault: Boolean
 }

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/resolver/impl/KonanLibraryResolverImpl.kt

@@ -73,8 +73,8 @@ internal class KonanLibraryResolverImpl(
 
         val rootLibraries = this.map { KonanResolvedLibraryImpl(it) }
 
-        // as far as the list of root libraries is known from the very beginning, the result can be
+        // As far as the list of root libraries is known from the very beginning, the result can be
-        // constructed from the very beginning as well
+        // constructed from the very beginning as well.
         val result = KonanLibraryResolverResultImpl(rootLibraries)
 
         val cache = mutableMapOf<File, KonanResolvedLibrary>()

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/library/resolver/impl/KonanResolvedLibraryImpl.kt

@@ -3,14 +3,14 @@ package org.jetbrains.kotlin.konan.library.resolver.impl
 import org.jetbrains.kotlin.konan.library.KonanLibrary
 import org.jetbrains.kotlin.konan.library.resolver.KonanResolvedLibrary
 import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.serialization.konan.emptyPackages
+import org.jetbrains.kotlin.serialization.konan.parseModuleHeader
 
 internal class KonanResolvedLibraryImpl(
         override val library: KonanLibrary
 ): KonanResolvedLibrary {
 
     private val _resolvedDependencies = mutableListOf<KonanResolvedLibrary>()
-    private val _emptyPackages by lazy { emptyPackages(library.moduleHeaderData) }
+    private val _emptyPackages by lazy { parseModuleHeader(library.moduleHeaderData).emptyPackageList }
 
     override val resolvedDependencies: List<KonanResolvedLibrary>
         get() = _resolvedDependencies

extracted/konan.serializer/src/org/jetbrains/kotlin/konan/utils/KonanFactories.kt

@@ -0,0 +1,50 @@
+package org.jetbrains.kotlin.konan.utils
+
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleDescriptorFactory
+import org.jetbrains.kotlin.descriptors.konan.impl.KonanModuleDescriptorFactoryImpl
+import org.jetbrains.kotlin.serialization.konan.KonanDeserializedModuleDescriptorFactory
+import org.jetbrains.kotlin.serialization.konan.KonanDeserializedPackageFragmentsFactory
+import org.jetbrains.kotlin.serialization.konan.KonanResolvedModuleDescriptorsFactory
+import org.jetbrains.kotlin.serialization.konan.impl.KonanDeserializedModuleDescriptorFactoryImpl
+import org.jetbrains.kotlin.serialization.konan.impl.KonanDeserializedPackageFragmentsFactoryImpl
+import org.jetbrains.kotlin.serialization.konan.impl.KonanResolvedModuleDescriptorsFactoryImpl
+
+/**
+ * The default Kotlin/Native factories.
+ */
+object KonanFactories {
+
+    /**
+     * The default [KonanModuleDescriptorFactory] factory instance.
+     */
+    val DefaultDescriptorFactory: KonanModuleDescriptorFactory = KonanModuleDescriptorFactoryImpl
+
+    /**
+     * The default [KonanDeserializedPackageFragmentsFactory] factory instance.
+     */
+    val DefaultPackageFragmentsFactory: KonanDeserializedPackageFragmentsFactory =
+            KonanDeserializedPackageFragmentsFactoryImpl
+
+    /**
+     * The default [KonanDeserializedModuleDescriptorFactory] factory instance.
+     */
+    val DefaultDeserializedDescriptorFactory: KonanDeserializedModuleDescriptorFactory =
+            createDefaultKonanDeserializedModuleDescriptorFactory(
+                    DefaultDescriptorFactory, DefaultPackageFragmentsFactory)
+
+    /**
+     * The default [KonanResolvedModuleDescriptorsFactory] factory instance.
+     */
+    val DefaultResolvedDescriptorsFactory: KonanResolvedModuleDescriptorsFactory =
+            createDefaultKonanResolvedModuleDescriptorsFactory(DefaultDeserializedDescriptorFactory)
+
+    fun createDefaultKonanDeserializedModuleDescriptorFactory(
+            descriptorFactory: KonanModuleDescriptorFactory,
+            packageFragmentsFactory: KonanDeserializedPackageFragmentsFactory
+    ): KonanDeserializedModuleDescriptorFactory =
+            KonanDeserializedModuleDescriptorFactoryImpl(descriptorFactory, packageFragmentsFactory)
+
+    fun createDefaultKonanResolvedModuleDescriptorsFactory(
+            moduleDescriptorFactory: KonanDeserializedModuleDescriptorFactory
+    ): KonanResolvedModuleDescriptorsFactory = KonanResolvedModuleDescriptorsFactoryImpl(moduleDescriptorFactory)
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/KonanDeserializationUtils.kt

@@ -2,10 +2,8 @@ package org.jetbrains.kotlin.serialization.konan
 
 import org.jetbrains.kotlin.metadata.konan.KonanProtoBuf
 
-fun parsePackageFragment(packageData: ByteArray): KonanProtoBuf.LinkDataPackageFragment =
+fun parsePackageFragment(packageMetadata: ByteArray): KonanProtoBuf.LinkDataPackageFragment =
-        KonanProtoBuf.LinkDataPackageFragment.parseFrom(packageData, KonanSerializerProtocol.extensionRegistry)
+        KonanProtoBuf.LinkDataPackageFragment.parseFrom(packageMetadata, KonanSerializerProtocol.extensionRegistry)
 
-fun parseModuleHeader(libraryData: ByteArray): KonanProtoBuf.LinkDataLibrary =
+fun parseModuleHeader(libraryMetadata: ByteArray): KonanProtoBuf.LinkDataLibrary =
-        KonanProtoBuf.LinkDataLibrary.parseFrom(libraryData, KonanSerializerProtocol.extensionRegistry)
+        KonanProtoBuf.LinkDataLibrary.parseFrom(libraryMetadata, KonanSerializerProtocol.extensionRegistry)
-
-fun emptyPackages(libraryData: ByteArray) = parseModuleHeader(libraryData).emptyPackageList

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/KonanDeserializedModuleDescriptorFactory.kt

@@ -0,0 +1,35 @@
+package org.jetbrains.kotlin.serialization.konan
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleDescriptorFactory
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+
+interface KonanDeserializedModuleDescriptorFactory {
+
+    val descriptorFactory: KonanModuleDescriptorFactory
+    val packageFragmentsFactory: KonanDeserializedPackageFragmentsFactory
+
+    fun createDescriptor(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns,
+            packageAccessedHandler: PackageAccessedHandler? = null
+    ): ModuleDescriptorImpl
+
+    /**
+     * Please use this method with care: As far as it creates an instance of [KotlinBuiltIns] it should be
+     * normally used for creation of the very first (e.g. "stdlib") module in the set of created modules.
+     */
+    fun createDescriptorAndNewBuiltIns(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            packageAccessedHandler: PackageAccessedHandler? = null
+    ): ModuleDescriptorImpl
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/KonanDeserializedPackageFragmentsFactory.kt

@@ -0,0 +1,24 @@
+package org.jetbrains.kotlin.serialization.konan
+
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
+import org.jetbrains.kotlin.storage.StorageManager
+
+interface KonanDeserializedPackageFragmentsFactory {
+
+    fun createDeserializedPackageFragments(
+            library: KonanLibrary,
+            packageFragmentNames: List<String>,
+            moduleDescriptor: ModuleDescriptor,
+            packageAccessedHandler: PackageAccessedHandler?,
+            storageManager: StorageManager
+    ): List<KonanPackageFragment>
+
+    fun createSyntheticPackageFragments(
+            library: KonanLibrary,
+            deserializedPackageFragments: List<KonanPackageFragment>,
+            moduleDescriptor: ModuleDescriptor
+    ): List<PackageFragmentDescriptor>
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/KonanModuleDescriptorFactory.kt

@@ -1,143 +0,0 @@
-package org.jetbrains.kotlin.serialization.konan
-
-import org.jetbrains.kotlin.config.LanguageVersionSettings
-import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.descriptors.konan.DeserializedKonanModuleOrigin
-import org.jetbrains.kotlin.descriptors.konan.createKonanModuleDescriptor
-import org.jetbrains.kotlin.descriptors.konan.interop.InteropFqNames
-import org.jetbrains.kotlin.incremental.components.LookupTracker
-import org.jetbrains.kotlin.konan.library.KonanLibrary
-import org.jetbrains.kotlin.konan.library.exportForwardDeclarations
-import org.jetbrains.kotlin.konan.library.isInterop
-import org.jetbrains.kotlin.konan.library.packageFqName
-import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
-import org.jetbrains.kotlin.serialization.deserialization.*
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import org.jetbrains.kotlin.storage.StorageManager
-
-// FIXME(ddol): this is a temporary solution, to be refactored into some global resolution context
-interface KonanModuleDescriptorFactory {
-
-    fun createModuleDescriptor(
-            library: KonanLibrary,
-            specifics: LanguageVersionSettings,
-            packageAccessedHandler: PackageAccessedHandler? = null,
-            storageManager: StorageManager = LockBasedStorageManager()
-    ): ModuleDescriptor
-}
-
-object DefaultKonanModuleDescriptorFactory: KonanModuleDescriptorFactory {
-
-    override fun createModuleDescriptor(
-            library: KonanLibrary,
-            specifics: LanguageVersionSettings,
-            packageAccessedHandler: PackageAccessedHandler?,
-            storageManager: StorageManager
-    ): ModuleDescriptorImpl {
-
-        val libraryProto = parseModuleHeader(library.moduleHeaderData)
-
-        val moduleName = libraryProto.moduleName
-
-        val moduleDescriptor = createKonanModuleDescriptor(
-                Name.special(moduleName),
-                storageManager,
-                origin = DeserializedKonanModuleOrigin(library)
-        )
-        val deserializationConfiguration = CompilerDeserializationConfiguration(specifics)
-
-        val provider = createPackageFragmentProvider(
-                library,
-                packageAccessedHandler,
-                libraryProto.packageFragmentNameList,
-                storageManager,
-                moduleDescriptor,
-                deserializationConfiguration)
-
-        moduleDescriptor.initialize(provider)
-
-        return moduleDescriptor
-    }
-
-    private fun createPackageFragmentProvider(
-            library: KonanLibrary,
-            packageAccessedHandler: PackageAccessedHandler?,
-            fragmentNames: List<String>,
-            storageManager: StorageManager,
-            moduleDescriptor: ModuleDescriptor,
-            configuration: DeserializationConfiguration
-    ): PackageFragmentProvider {
-
-        val deserializedPackageFragments = fragmentNames.map{
-            KonanPackageFragment(FqName(it), library, packageAccessedHandler, storageManager, moduleDescriptor)
-        }
-
-        val syntheticPackageFragments = getSyntheticPackageFragments(
-                library,
-                moduleDescriptor,
-                deserializedPackageFragments)
-
-        val provider = PackageFragmentProviderImpl(deserializedPackageFragments + syntheticPackageFragments)
-
-        val notFoundClasses = NotFoundClasses(storageManager, moduleDescriptor)
-
-        val annotationAndConstantLoader = AnnotationAndConstantLoaderImpl(
-                moduleDescriptor,
-                notFoundClasses,
-                KonanSerializerProtocol)
-
-        val components = DeserializationComponents(
-                storageManager,
-                moduleDescriptor,
-                configuration,
-                DeserializedClassDataFinder(provider),
-                annotationAndConstantLoader,
-                provider,
-                LocalClassifierTypeSettings.Default,
-                ErrorReporter.DO_NOTHING,
-                LookupTracker.DO_NOTHING,
-                NullFlexibleTypeDeserializer,
-                emptyList(),
-                notFoundClasses,
-                ContractDeserializer.DEFAULT,
-                extensionRegistryLite = KonanSerializerProtocol.extensionRegistry)
-
-        for (packageFragment in deserializedPackageFragments) {
-            packageFragment.initialize(components)
-        }
-
-        return provider
-    }
-
-    private fun getSyntheticPackageFragments(
-            library: KonanLibrary,
-            moduleDescriptor: ModuleDescriptor,
-            konanPackageFragments: List<KonanPackageFragment>
-    ): List<PackageFragmentDescriptor> {
-
-        if (!library.isInterop) return emptyList()
-
-        val packageFqName = library.packageFqName
-                ?: error("Inconsistent manifest: interop library ${library.libraryName} should have `package` specified")
-
-        val exportForwardDeclarations = library.exportForwardDeclarations
-
-        val interopPackageFragments = konanPackageFragments.filter { it.fqName == packageFqName }
-
-        val result = mutableListOf<PackageFragmentDescriptor>()
-
-        // Allow references to forwarding declarations to be resolved into classifiers declared in this library:
-        listOf(InteropFqNames.cNamesStructs, InteropFqNames.objCNamesClasses, InteropFqNames.objCNamesProtocols).mapTo(result) { fqName ->
-            ClassifierAliasingPackageFragmentDescriptor(interopPackageFragments, moduleDescriptor, fqName)
-        }
-        // TODO: use separate namespaces for structs, enums, Objective-C protocols etc.
-
-        result.add(ExportedForwardDeclarationsPackageFragmentDescriptor(moduleDescriptor, packageFqName, exportForwardDeclarations))
-
-        return result
-    }
-}

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/KonanResolvedModuleDescriptorsFactory.kt

@@ -0,0 +1,32 @@
+package org.jetbrains.kotlin.serialization.konan
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.KonanLibraryResolveResult
+import org.jetbrains.kotlin.storage.StorageManager
+
+interface KonanResolvedModuleDescriptorsFactory {
+
+    val moduleDescriptorFactory: KonanDeserializedModuleDescriptorFactory
+
+    fun createResolved(
+            resolvedLibraries: KonanLibraryResolveResult,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns?,
+            languageVersionSettings: LanguageVersionSettings,
+            customAction: ((KonanLibrary, ModuleDescriptorImpl) -> Unit)? = null
+    ): KonanResolvedModuleDescriptors
+}
+
+class KonanResolvedModuleDescriptors(
+
+        val resolvedDescriptors: List<ModuleDescriptorImpl>,
+
+        /**
+         * This is a module which "contains" forward declarations.
+         * Note: this module should be unique per compilation and should always be the last dependency of any module.
+         */
+        val forwardDeclarationsModule: ModuleDescriptorImpl
+)

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/impl/KonanDeserializedModuleDescriptorFactoryImpl.kt

@@ -0,0 +1,120 @@
+package org.jetbrains.kotlin.serialization.konan.impl
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.NotFoundClasses
+import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
+import org.jetbrains.kotlin.descriptors.PackageFragmentProviderImpl
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.konan.DeserializedKonanModuleOrigin
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleDescriptorFactory
+import org.jetbrains.kotlin.incremental.components.LookupTracker
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration
+import org.jetbrains.kotlin.serialization.deserialization.*
+import org.jetbrains.kotlin.serialization.konan.*
+import org.jetbrains.kotlin.storage.StorageManager
+
+internal class KonanDeserializedModuleDescriptorFactoryImpl(
+        override val descriptorFactory: KonanModuleDescriptorFactory,
+        override val packageFragmentsFactory: KonanDeserializedPackageFragmentsFactory
+): KonanDeserializedModuleDescriptorFactory {
+
+    override fun createDescriptor(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns,
+            packageAccessedHandler: PackageAccessedHandler?
+    ) = createDescriptorOptionalBuiltIns(library, languageVersionSettings, storageManager, builtIns, packageAccessedHandler)
+
+    override fun createDescriptorAndNewBuiltIns(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            packageAccessedHandler: PackageAccessedHandler?
+    ) = createDescriptorOptionalBuiltIns(library, languageVersionSettings, storageManager, null, packageAccessedHandler)
+
+    private fun createDescriptorOptionalBuiltIns(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns?,
+            packageAccessedHandler: PackageAccessedHandler?
+    ): ModuleDescriptorImpl {
+
+        val libraryProto = parseModuleHeader(library.moduleHeaderData)
+
+        val moduleName = Name.special(libraryProto.moduleName)
+        val moduleOrigin = DeserializedKonanModuleOrigin(library)
+
+        val moduleDescriptor = if (builtIns != null )
+            descriptorFactory.createDescriptor(moduleName, storageManager, builtIns, moduleOrigin)
+        else
+            descriptorFactory.createDescriptorAndNewBuiltIns(moduleName, storageManager, moduleOrigin)
+
+        val deserializationConfiguration = CompilerDeserializationConfiguration(languageVersionSettings)
+
+        val provider = createPackageFragmentProvider(
+                library,
+                packageAccessedHandler,
+                libraryProto.packageFragmentNameList,
+                storageManager,
+                moduleDescriptor,
+                deserializationConfiguration)
+
+        moduleDescriptor.initialize(provider)
+
+        return moduleDescriptor
+    }
+
+    private fun createPackageFragmentProvider(
+            library: KonanLibrary,
+            packageAccessedHandler: PackageAccessedHandler?,
+            packageFragmentNames: List<String>,
+            storageManager: StorageManager,
+            moduleDescriptor: ModuleDescriptor,
+            configuration: DeserializationConfiguration
+    ): PackageFragmentProvider {
+
+        val deserializedPackageFragments = packageFragmentsFactory.createDeserializedPackageFragments(
+                library, packageFragmentNames, moduleDescriptor, packageAccessedHandler, storageManager)
+
+        val syntheticPackageFragments = packageFragmentsFactory.createSyntheticPackageFragments(
+                library, deserializedPackageFragments, moduleDescriptor)
+
+        val provider = PackageFragmentProviderImpl(deserializedPackageFragments + syntheticPackageFragments)
+
+        val notFoundClasses = NotFoundClasses(storageManager, moduleDescriptor)
+
+        val annotationAndConstantLoader = AnnotationAndConstantLoaderImpl(
+                moduleDescriptor,
+                notFoundClasses,
+                KonanSerializerProtocol)
+
+        val components = DeserializationComponents(
+                storageManager,
+                moduleDescriptor,
+                configuration,
+                DeserializedClassDataFinder(provider),
+                annotationAndConstantLoader,
+                provider,
+                LocalClassifierTypeSettings.Default,
+                ErrorReporter.DO_NOTHING,
+                LookupTracker.DO_NOTHING,
+                NullFlexibleTypeDeserializer,
+                emptyList(),
+                notFoundClasses,
+                ContractDeserializer.DEFAULT,
+                extensionRegistryLite = KonanSerializerProtocol.extensionRegistry)
+
+        for (packageFragment in deserializedPackageFragments) {
+            packageFragment.initialize(components)
+        }
+
+        return provider
+    }
+}

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/impl/KonanDeserializedPackageFragmentsFactoryImpl.kt

@@ -1,16 +1,63 @@
-package org.jetbrains.kotlin.serialization.konan
+package org.jetbrains.kotlin.serialization.konan.impl
 
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
 import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.exportForwardDeclarations
+import org.jetbrains.kotlin.konan.library.isInterop
+import org.jetbrains.kotlin.konan.library.packageFqName
+import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
 import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl
+import org.jetbrains.kotlin.serialization.konan.KonanDeserializedPackageFragmentsFactory
+import org.jetbrains.kotlin.serialization.konan.KonanPackageFragment
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
 
+// FIXME(ddol): decouple and move interop-specific logic back to Kotlin/Native.
+internal object KonanDeserializedPackageFragmentsFactoryImpl: KonanDeserializedPackageFragmentsFactory {
+
+    override fun createDeserializedPackageFragments(
+            library: KonanLibrary,
+            packageFragmentNames: List<String>,
+            moduleDescriptor: ModuleDescriptor,
+            packageAccessedHandler: PackageAccessedHandler?,
+            storageManager: StorageManager
+    ) = packageFragmentNames.map {
+        KonanPackageFragment(FqName(it), library, packageAccessedHandler, storageManager, moduleDescriptor)
+    }
+
+    override fun createSyntheticPackageFragments(
+            library: KonanLibrary,
+            deserializedPackageFragments: List<KonanPackageFragment>,
+            moduleDescriptor: ModuleDescriptor
+    ): List<PackageFragmentDescriptor> {
+
+        if (!library.isInterop) return emptyList()
+
+        val mainPackageFqName = library.packageFqName
+                ?: error("Inconsistent manifest: interop library ${library.libraryName} should have `package` specified")
+        val exportForwardDeclarations = library.exportForwardDeclarations
+
+        val aliasedPackageFragments = deserializedPackageFragments.filter { it.fqName == mainPackageFqName }
+
+        val result = mutableListOf<PackageFragmentDescriptor>()
+        listOf(ForwardDeclarationsFqNames.cNamesStructs, ForwardDeclarationsFqNames.objCNamesClasses, ForwardDeclarationsFqNames.objCNamesProtocols).mapTo(result) { fqName ->
+            ClassifierAliasingPackageFragmentDescriptor(aliasedPackageFragments, moduleDescriptor, fqName)
+        }
+
+        result.add(ExportedForwardDeclarationsPackageFragmentDescriptor(moduleDescriptor, mainPackageFqName, exportForwardDeclarations))
+
+        return result
+    }
+}
+
 /**
  * The package fragment to export forward declarations from interop package namespace, i.e.
  * redirect "$pkg.$name" to e.g. "cnames.structs.$name".

extracted/konan.serializer/src/org/jetbrains/kotlin/serialization/konan/impl/KonanResolvedModuleDescriptorsFactoryImpl.kt

@@ -0,0 +1,181 @@
+package org.jetbrains.kotlin.serialization.konan.impl
+
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.descriptors.impl.PackageFragmentDescriptorImpl
+import org.jetbrains.kotlin.descriptors.konan.KonanModuleOrigin
+import org.jetbrains.kotlin.descriptors.konan.SyntheticModulesOrigin
+import org.jetbrains.kotlin.incremental.components.LookupLocation
+import org.jetbrains.kotlin.incremental.components.NoLookupLocation
+import org.jetbrains.kotlin.konan.library.KonanLibrary
+import org.jetbrains.kotlin.konan.library.resolver.KonanLibraryResolveResult
+import org.jetbrains.kotlin.konan.library.resolver.PackageAccessedHandler
+import org.jetbrains.kotlin.konan.util.profile
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
+import org.jetbrains.kotlin.resolve.scopes.MemberScope
+import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl
+import org.jetbrains.kotlin.serialization.konan.KonanDeserializedModuleDescriptorFactory
+import org.jetbrains.kotlin.serialization.konan.KonanResolvedModuleDescriptors
+import org.jetbrains.kotlin.serialization.konan.KonanResolvedModuleDescriptorsFactory
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
+import org.jetbrains.kotlin.storage.getValue
+import org.jetbrains.kotlin.utils.Printer
+
+class KonanResolvedModuleDescriptorsFactoryImpl(
+        override val moduleDescriptorFactory: KonanDeserializedModuleDescriptorFactory
+): KonanResolvedModuleDescriptorsFactory {
+
+    override fun createResolved(
+            resolvedLibraries: KonanLibraryResolveResult,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns?,
+            languageVersionSettings: LanguageVersionSettings,
+            customAction: ((KonanLibrary, ModuleDescriptorImpl) -> Unit)?
+    ): KonanResolvedModuleDescriptors {
+
+        val moduleDescriptors = mutableListOf<ModuleDescriptorImpl>()
+        @Suppress("NAME_SHADOWING")
+        var builtIns = builtIns
+
+        // Build module descriptors.
+        resolvedLibraries.forEach { library, packageAccessedHandler ->
+            profile("Loading ${library.libraryName}") {
+
+                // MutableModuleContext needs ModuleDescriptorImpl, rather than ModuleDescriptor.
+                val moduleDescriptor = createDescriptorOptionalBuiltsIns(
+                        library, languageVersionSettings, storageManager, builtIns, packageAccessedHandler)
+                builtIns = moduleDescriptor.builtIns
+                moduleDescriptors.add(moduleDescriptor)
+
+                customAction?.invoke(library, moduleDescriptor)
+            }
+        }
+
+        val forwardDeclarationsModule = createForwardDeclarationsModule(builtIns, storageManager)
+
+        // Set inter-dependencies between module descriptors, add forwarding declarations module.
+        for (module in moduleDescriptors) {
+            // Yes, just to all of them.
+            module.setDependencies(moduleDescriptors + forwardDeclarationsModule)
+        }
+
+        return KonanResolvedModuleDescriptors(moduleDescriptors, forwardDeclarationsModule)
+    }
+
+    private fun createForwardDeclarationsModule(
+            builtIns: KotlinBuiltIns?,
+            storageManager: StorageManager): ModuleDescriptorImpl {
+
+        val name = Name.special("<forward declarations>")
+        val module = createDescriptorOptionalBuiltsIns(name, storageManager, builtIns, SyntheticModulesOrigin)
+
+        fun createPackage(fqName: FqName, supertypeName: String, classKind: ClassKind) =
+                ForwardDeclarationsPackageFragmentDescriptor(
+                        storageManager,
+                        module,
+                        fqName,
+                        Name.identifier(supertypeName),
+                        classKind)
+
+        val packageFragmentProvider = PackageFragmentProviderImpl(
+                listOf(
+                        createPackage(ForwardDeclarationsFqNames.cNamesStructs, "COpaque", ClassKind.CLASS),
+                        createPackage(ForwardDeclarationsFqNames.objCNamesClasses, "ObjCObjectBase", ClassKind.CLASS),
+                        createPackage(ForwardDeclarationsFqNames.objCNamesProtocols, "ObjCObject", ClassKind.INTERFACE)
+                )
+        )
+
+        module.initialize(packageFragmentProvider)
+        module.setDependencies(module)
+
+        return module
+    }
+
+    private fun createDescriptorOptionalBuiltsIns(
+            name: Name,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns?,
+            moduleOrigin: KonanModuleOrigin
+    ) = if (builtIns != null)
+        moduleDescriptorFactory.descriptorFactory.createDescriptor(name, storageManager, builtIns, moduleOrigin)
+    else
+        moduleDescriptorFactory.descriptorFactory.createDescriptorAndNewBuiltIns(name, storageManager, moduleOrigin)
+
+    private fun createDescriptorOptionalBuiltsIns(
+            library: KonanLibrary,
+            languageVersionSettings: LanguageVersionSettings,
+            storageManager: StorageManager,
+            builtIns: KotlinBuiltIns?,
+            packageAccessedHandler: PackageAccessedHandler?
+    ) = if (builtIns != null)
+        moduleDescriptorFactory.createDescriptor(library, languageVersionSettings, storageManager, builtIns, packageAccessedHandler)
+    else
+        moduleDescriptorFactory.createDescriptorAndNewBuiltIns(library, languageVersionSettings, storageManager, packageAccessedHandler)
+}
+
+/**
+ * Package fragment which creates descriptors for forward declarations on demand.
+ */
+private class ForwardDeclarationsPackageFragmentDescriptor(
+        storageManager: StorageManager,
+        module: ModuleDescriptor,
+        fqName: FqName,
+        supertypeName: Name,
+        classKind: ClassKind
+) : PackageFragmentDescriptorImpl(module, fqName) {
+
+    private val memberScope = object : MemberScopeImpl() {
+
+        private val declarations = storageManager.createMemoizedFunction(this::createDeclaration)
+
+        private val supertype by storageManager.createLazyValue {
+            val descriptor = builtIns.builtInsModule.getPackage(ForwardDeclarationsFqNames.packageName)
+                    .memberScope
+                    .getContributedClassifier(supertypeName, NoLookupLocation.FROM_BACKEND) as ClassDescriptor
+
+            descriptor.defaultType
+        }
+
+        private fun createDeclaration(name: Name): ClassDescriptor {
+            return ClassDescriptorImpl(
+                    this@ForwardDeclarationsPackageFragmentDescriptor,
+                    name,
+                    Modality.FINAL,
+                    classKind,
+                    listOf(supertype),
+                    SourceElement.NO_SOURCE,
+                    false,
+                    LockBasedStorageManager.NO_LOCKS
+            ).apply {
+                this.initialize(MemberScope.Empty, emptySet(), null)
+            }
+        }
+
+        override fun getContributedClassifier(name: Name, location: LookupLocation) = declarations(name)
+
+        override fun printScopeStructure(p: Printer) {
+            p.println(this::class.java.simpleName, "{}")
+        }
+    }
+
+    override fun getMemberScope(): MemberScope = memberScope
+}
+
+// FIXME(ddol): decouple and move interop-specific logic back to Kotlin/Native.
+internal object ForwardDeclarationsFqNames {
+
+    val packageName = FqName("kotlinx.cinterop")
+
+    val cNames = FqName("cnames")
+    val cNamesStructs = cNames.child(Name.identifier("structs"))
+
+    val objCNames = FqName("objcnames")
+    val objCNamesClasses = objCNames.child(Name.identifier("classes"))
+    val objCNamesProtocols = objCNames.child(Name.identifier("protocols"))
+}

klib/src/main/kotlin/org/jetbrains/kotlin/cli/klib/main.kt

@@ -31,9 +31,10 @@ import org.jetbrains.kotlin.konan.library.unpackZippedKonanLibraryTo
 import org.jetbrains.kotlin.konan.target.Distribution
 import org.jetbrains.kotlin.konan.target.PlatformManager
 import org.jetbrains.kotlin.konan.util.DependencyProcessor
+import org.jetbrains.kotlin.konan.utils.KonanFactories.DefaultDeserializedDescriptorFactory
 import org.jetbrains.kotlin.metadata.konan.KonanProtoBuf
-import org.jetbrains.kotlin.serialization.konan.DefaultKonanModuleDescriptorFactory
 import org.jetbrains.kotlin.serialization.konan.parseModuleHeader
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import java.lang.System.out
 import kotlin.system.exitProcess
 
@@ -144,9 +145,12 @@ class Library(val name: String, val requestedRepository: String?, val target: St
     }
 
     fun contents(output: Appendable = out) {
+
+        val storageManager = LockBasedStorageManager()
         val library = createKonanLibrary(libraryInRepoOrCurrentDir(repository, name), currentAbiVersion)
         val versionSpec = LanguageVersionSettingsImpl(currentLanguageVersion, currentApiVersion)
-        val module = DefaultKonanModuleDescriptorFactory.createModuleDescriptor(library, versionSpec)
+        val module = DefaultDeserializedDescriptorFactory.createDescriptorAndNewBuiltIns(library, versionSpec, storageManager)
+
         val defaultModules = mutableListOf<ModuleDescriptorImpl>()
         if (!module.isKonanStdlib()) {
             val resolver = noTargetResolver(
@@ -155,8 +159,8 @@ class Library(val name: String, val requestedRepository: String?, val target: St
                     skipCurrentDir = true)
             resolver.defaultLinks(false, true)
                     .mapTo(defaultModules) {
-                        DefaultKonanModuleDescriptorFactory.createModuleDescriptor(
+                        DefaultDeserializedDescriptorFactory.createDescriptor(
-                                createKonanLibrary(it, currentAbiVersion), versionSpec)
+                                createKonanLibrary(it, currentAbiVersion), versionSpec, storageManager, module.builtIns)
                     }
         }
 

settings.gradle

@@ -33,7 +33,6 @@ include ':performance'
 include ':platformLibs'
 
 includeBuild 'shared'
-includeBuild 'extracted/konan.descriptors'
 includeBuild 'extracted/konan.metadata'
 includeBuild 'extracted/konan.serializer'
 includeBuild 'tools/kotlin-native-gradle-plugin'