Rewritten unneeded library purge machinery.

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

@@ -49,7 +49,7 @@ internal fun produceOutput(context: Context) {
             val output = context.config.outputName
             val libraryName = context.config.moduleId
             val neededLibraries 
-                = context.config.immediateLibraries.purgeUnneeded()
+                = context.config.librariesWithDependencies
             val abiVersion = context.config.currentAbiVersion
             val target = context.config.targetManager.target
             val nopack = config.getBoolean(KonanConfigKeys.NOPACK)
@@ -80,8 +80,4 @@ internal fun produceOutput(context: Context) {
     }
 }
 
-internal fun List<KonanLibraryReader>.purgeUnneeded(): List<KonanLibraryReader> {
+
-        return this.map { 
-            if (!it.isNeededForLink && it.isDefaultLink) null else it
-        }.filterNotNull()
-}

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

@@ -1297,7 +1297,7 @@ internal object EscapeAnalysis {
         val isStdlib = context.config.configuration[KonanConfigKeys.NOSTDLIB] == true
 
         val externalFunctionEAResults = mutableMapOf<String, FunctionEscapeAnalysisResult>()
-        context.config.libraries.forEach { library ->
+        context.config.librariesWithDependencies.forEach { library ->
             val libraryEscapeAnalysis = library.escapeAnalysis
             if (libraryEscapeAnalysis != null) {
                 DEBUG_OUTPUT(0) {
@@ -1338,4 +1338,4 @@ internal object EscapeAnalysis {
                     }
         }
     }
-}
+}

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.backend.konan
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.backend.konan.descriptors.createForwardDeclarationsModule
 import org.jetbrains.kotlin.backend.konan.library.*
-import org.jetbrains.kotlin.backend.konan.library.impl.LibraryReaderImpl
+import org.jetbrains.kotlin.backend.konan.library.impl.*
 import org.jetbrains.kotlin.backend.konan.util.profile
 import org.jetbrains.kotlin.backend.konan.util.removeSuffixIfPresent
 import org.jetbrains.kotlin.backend.konan.util.suffixIfNot
@@ -92,8 +92,13 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         }
     }
 
-    val libraries: List<LibraryReaderImpl> by lazy {
+    // Accessing this field before resolve is a bad idea.
+    // purgeUnneeded() only works correctly after we have
+    // completed resolve and successfully marked package files
+    // as needed or not needed.
+    val librariesWithDependencies: List<KonanLibraryReader> by lazy {
         resolver.resolveLibrariesRecursive(immediateLibraries, targetManager.target, currentAbiVersion)
+        immediateLibraries.purgeUnneeded().withResolvedDependencies()
     }
 
     private val loadedDescriptors = loadLibMetadata()
@@ -109,6 +114,7 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         val allMetadata = mutableListOf<ModuleDescriptorImpl>()
         val specifics = configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS)!!
 
+        val libraries = immediateLibraries.withResolvedDependencies()
         for (klib in libraries) {
             profile("Loading ${klib.libraryName}") {
                 // MutableModuleContext needs ModuleDescriptorImpl, rather than ModuleDescriptor.

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

@@ -235,7 +235,7 @@ internal class LinkStage(val context: Context) {
     private val debug = config.get(KonanConfigKeys.DEBUG) ?: false
     private val nomain = config.get(KonanConfigKeys.NOMAIN) ?: false
     private val emitted = context.bitcodeFileName
-    private val libraries = context.config.libraries.purgeUnneeded()
+    private val libraries = context.config.librariesWithDependencies
     private fun MutableList<String>.addNonEmpty(elements: List<String>) {
         addAll(elements.filter { !it.isEmpty() })
     }

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

@@ -26,10 +26,9 @@ interface KonanLibraryReader {
     val bitcodePaths: List<String>
     val includedPaths: List<String>
     val linkerOpts: List<String>
-    val dependencies: List<String>
+    val unresolvedDependencies: List<String>
     val escapeAnalysis: ByteArray?
     val isNeededForLink: Boolean get() = true
-    val isDefaultLink: Boolean get() = false
     val manifestProperties: Properties
     val moduleHeaderData: ByteArray
     fun packageMetadata(fqName: String): ByteArray

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

@@ -49,7 +49,7 @@ fun SearchPathResolver.resolveImmediateLibraries(libraryNames: List<String>,
                                                  removeDuplicates: Boolean = true): List<LibraryReaderImpl> {
 
     val defaultLibraries = defaultLinks(nostdlib = noStdLib, noDefaultLibs = noDefaultLibs).map {
-        LibraryReaderImpl(it, abiVersion, target, isDefaultLink = true)
+        LibraryReaderImpl(it, abiVersion, target)
     }
 
     val userProvidedLibraries = libraryNames
@@ -65,33 +65,40 @@ fun SearchPathResolver.resolveImmediateLibraries(libraryNames: List<String>,
 
 fun SearchPathResolver.resolveLibrariesRecursive(immediateLibraries: List<LibraryReaderImpl>,
                                                  target: KonanTarget,
-                                                 abiVersion: Int): List<LibraryReaderImpl> {
+                                                 abiVersion: Int) {
-    val result = mutableMapOf<File, LibraryReaderImpl>()
+    val cache = mutableMapOf<File, LibraryReaderImpl>()
-    result.putAll(immediateLibraries.map { it.libraryFile.absoluteFile to it })
+    cache.putAll(immediateLibraries.map { it.libraryFile.absoluteFile to it })
-    var newDependencies: Map<File, LibraryReaderImpl> = result
+    var newDependencies = cache.values.toList()
     do {
-        val defaultOverrides = mutableSetOf<File>()
+        newDependencies = newDependencies.map { library: LibraryReaderImpl ->
-        newDependencies = newDependencies.values.asSequence()
+            library.unresolvedDependencies
-                .flatMap { it.dependencies.asSequence() }
+                    .map { resolve(it).absoluteFile }
-                .map { resolve(it).absoluteFile }
+                    .map { 
-                .onEach {
+                        if (it in cache) {
-                    if (result[it]?.isDefaultLink == true) {
+                            library.resolvedDependencies.add(cache[it]!!)
-                        defaultOverrides.add(it)
+                            null
-                    }
+                        } else {
-                }
+                            val reader = LibraryReaderImpl(it, abiVersion, target)
-                .filter { it !in result }
+                            cache.put(it,reader)
-                .map { it to LibraryReaderImpl(it, abiVersion, target) }.toMap()
+                            library.resolvedDependencies.add(reader) 
-
+                            reader
-        result.putAll(newDependencies)
+                        }
-
+            }.filterNotNull()
-        // If there is a default link in immediateLibraries,
+        } .flatten()
-        // and we get the same library as a dependency,
-        // the resultant surviving library should not be a defaultLink anymore.
-        defaultOverrides.forEach {
-            result[it] = LibraryReaderImpl(it, abiVersion, target)
-        }
     } while (newDependencies.isNotEmpty())
-    return result.values.toList()
+}
+
+fun List<LibraryReaderImpl>.withResolvedDependencies(): List<LibraryReaderImpl> {
+    val result = mutableSetOf<LibraryReaderImpl>()
+    result.addAll(this)
+    var newDependencies = result.toList()
+    do {
+        newDependencies = newDependencies
+            .map { it -> it.resolvedDependencies } .flatten()
+            .filter { it !in result }
+        result.addAll(newDependencies)
+    } while (newDependencies.isNotEmpty())
+    return result.toList()
 }
 
 fun SearchPathResolver.resolveLibrariesRecursive(libraryNames: List<String>,
@@ -99,17 +106,16 @@ fun SearchPathResolver.resolveLibrariesRecursive(libraryNames: List<String>,
                                                  abiVersion: Int = 1,
                                                  noStdLib: Boolean = false,
                                                  noDefaultLibs: Boolean = false): List<LibraryReaderImpl> {
-    return resolveLibrariesRecursive(
+    val immediateLibraries = resolveImmediateLibraries(
-            resolveImmediateLibraries(
                     libraryNames = libraryNames,
                     target = target,
                     abiVersion = abiVersion,
                     noStdLib = noStdLib,
                     noDefaultLibs = noDefaultLibs,
                     removeDuplicates = true
-            ),
+            )
-            target, abiVersion
+    resolveLibrariesRecursive(immediateLibraries, target, abiVersion)
-    )
+    return immediateLibraries.withResolvedDependencies()
 }
 
 class KonanLibrarySearchPathResolver(

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/library/impl/KonanLibraryReaderImpl.kt

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.konan.target.KonanTarget
 
 class LibraryReaderImpl(var libraryFile: File, val currentAbiVersion: Int,
-    val target: KonanTarget? = null, override val isDefaultLink: Boolean = false)
+    val target: KonanTarget? = null)
     : KonanLibraryReader {
 
     // For the zipped libraries inPlace gives files from zip file system
@@ -68,9 +68,11 @@ class LibraryReaderImpl(var libraryFile: File, val currentAbiVersion: Int,
     override val linkerOpts: List<String>
         get() = manifestProperties.propertyList("linkerOpts", target!!.detailedName)
 
-    override val dependencies: List<String>
+    override val unresolvedDependencies: List<String>
         get() = manifestProperties.propertyList("dependencies")
 
+    val resolvedDependencies = mutableListOf<LibraryReaderImpl>()
+
     override val moduleHeaderData: ByteArray by lazy {
         reader.loadSerializedModule()
     }
@@ -96,3 +98,4 @@ class LibraryReaderImpl(var libraryFile: File, val currentAbiVersion: Int,
 
 }
 
+internal fun <T: KonanLibraryReader> List<T>.purgeUnneeded(): List<T> = this.filter{ it.isNeededForLink }