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

2018-08-25 18:24:07 +03:00
parent d5142220d2
commit dcb423a3ce
40 changed files with 682 additions and 447 deletions
@@ -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
@@ -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
@@ -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)!!
-        val friendLibsSet = configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet()
-
-        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
-    }
+    internal val friendModuleFiles: Set<File> =
+            configuration.get(KonanConfigKeys.FRIEND_MODULES)?.map { File(it) }?.toSet() ?: emptySet()
 }

 fun CompilerConfiguration.report(priority: CompilerMessageSeverity, message: String) 
@@ -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
@@ -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 +
-                    config.getOrCreateForwardDeclarationsModule(module.builtIns, projectContext.storageManager)
-            module.setDependencies(dependencies, config.friends)
+            val dependencies = listOf(module) + resolvedDependencies.moduleDescriptors.resolvedDescriptors + resolvedDependencies.moduleDescriptors.forwardDeclarationsModule
+            module.setDependencies(dependencies, resolvedDependencies.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()
+    }
+}
+
@@ -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) {
@@ -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)
@@ -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')
    }
@@ -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 \
@@ -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 ^
@@ -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"
-}
@@ -1 +0,0 @@
-rootProject.name = "konan.descriptors"
@@ -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
@@ -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"))
-}
@@ -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"
 }
@@ -9,4 +9,3 @@ class KonanBuiltIns(storageManager: StorageManager) : KotlinBuiltIns(storageMana
    override fun getSuspendFunction(parameterCount: Int) =
            getBuiltInClassByName(Name.identifier("SuspendFunction$parameterCount"))
 }
-
@@ -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
+}
@@ -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
@@ -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: Any) : CompiledKonanModuleOrigin()
+class DeserializedKonanModuleOrigin(val library: KonanLibrary) : CompiledKonanModuleOrigin()

 object CurrentKonanModuleOrigin: CompiledKonanModuleOrigin()

@@ -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
+    }
+}
@@ -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>

@@ -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
@@ -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) {
@@ -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
-// to pass extracted files to an external tool.
-// Otherwise, stick to ZippedKonanLibrary.
+/**
+ * This class automatically extracts pieces of the library on first access. Use it if you need
+ * to pass extracted files to an external tool. Otherwise, stick to [ZippedKonanLibraryLayout].
+ */
 private class FileExtractor(zippedLibraryLayout: KonanLibraryLayout): KonanLibraryLayout by zippedLibraryLayout {

    override val manifestFile: File by lazy { extract(super.manifestFile) }
@@ -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
 }
@@ -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
-        // constructed from the very beginning as well
+        // 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.
        val result = KonanLibraryResolverResultImpl(rootLibraries)

        val cache = mutableMapOf<File, KonanResolvedLibrary>()
@@ -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
@@ -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)
+}
@@ -2,10 +2,8 @@ package org.jetbrains.kotlin.serialization.konan

 import org.jetbrains.kotlin.metadata.konan.KonanProtoBuf

-fun parsePackageFragment(packageData: ByteArray): KonanProtoBuf.LinkDataPackageFragment =
-        KonanProtoBuf.LinkDataPackageFragment.parseFrom(packageData, KonanSerializerProtocol.extensionRegistry)
+fun parsePackageFragment(packageMetadata: ByteArray): KonanProtoBuf.LinkDataPackageFragment =
+        KonanProtoBuf.LinkDataPackageFragment.parseFrom(packageMetadata, KonanSerializerProtocol.extensionRegistry)

-fun parseModuleHeader(libraryData: ByteArray): KonanProtoBuf.LinkDataLibrary =
-        KonanProtoBuf.LinkDataLibrary.parseFrom(libraryData, KonanSerializerProtocol.extensionRegistry)
-
-fun emptyPackages(libraryData: ByteArray) = parseModuleHeader(libraryData).emptyPackageList
+fun parseModuleHeader(libraryMetadata: ByteArray): KonanProtoBuf.LinkDataLibrary =
+        KonanProtoBuf.LinkDataLibrary.parseFrom(libraryMetadata, KonanSerializerProtocol.extensionRegistry)
@@ -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
+}
@@ -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>
+}
@@ -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
-    }
-}
@@ -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
+)
@@ -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
+    }
+}
@@ -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".
@@ -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"))
+}
@@ -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(
-                                createKonanLibrary(it, currentAbiVersion), versionSpec)
+                        DefaultDeserializedDescriptorFactory.createDescriptor(
+                                createKonanLibrary(it, currentAbiVersion), versionSpec, storageManager, module.builtIns)
                    }
        }

@@ -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'