Refactored LlvmModuleSpec

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

@@ -425,11 +425,13 @@ internal class Context(config: KonanConfig) : KonanBackendContext(config) {
 
     lateinit var compilerOutput: List<ObjectFile>
 
-    val llvmModuleSpecification: LlvmModuleSpecification = LlvmModuleSpecificationImpl(
+    val llvmModuleSpecification: LlvmModuleSpecification by lazy {
-            config.cachedLibraries,
+        when {
-            producingCache = config.produce.isCache,
+            config.produce.isCache ->
-            librariesToCache = config.librariesToCache
+                CacheLlvmModuleSpecification(config.cachedLibraries, config.librariesToCache)
-    )
+            else -> DefaultLlvmModuleSpecification(config.cachedLibraries)
+        }
+    }
 
     val declaredLocalArrays: MutableMap<String, LLVMTypeRef> = HashMap()
 

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

@@ -12,27 +12,13 @@ import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.util.module
 import org.jetbrains.kotlin.library.KotlinLibrary
 
-// TODO: consider making two implementations: for producing cache and anything else.
+internal abstract class LlvmModuleSpecificationBase(protected val cachedLibraries: CachedLibraries) : LlvmModuleSpecification {
-internal class LlvmModuleSpecificationImpl(
-        private val cachedLibraries: CachedLibraries,
-        private val producingCache: Boolean,
-        private val librariesToCache: Set<KotlinLibrary>
-) : LlvmModuleSpecification {
-    override val isFinal: Boolean
-        get() = !producingCache
-
     override fun importsKotlinDeclarationsFromOtherObjectFiles(): Boolean =
             cachedLibraries.hasStaticCaches // A bit conservative but still valid.
 
     override fun importsKotlinDeclarationsFromOtherSharedLibraries(): Boolean =
             cachedLibraries.hasDynamicCaches // A bit conservative but still valid.
 
-    override fun containsLibrary(library: KotlinLibrary): Boolean = if (producingCache) {
-        library in librariesToCache
-    } else {
-        !cachedLibraries.isLibraryCached(library)
-    }
-
     override fun containsModule(module: IrModuleFragment): Boolean =
             containsModule(module.descriptor)
 
@@ -42,3 +28,19 @@ internal class LlvmModuleSpecificationImpl(
     override fun containsDeclaration(declaration: IrDeclaration): Boolean =
             declaration.module.konanLibrary.let { it == null || containsLibrary(it) }
 }
+
+internal class DefaultLlvmModuleSpecification(cachedLibraries: CachedLibraries)
+    : LlvmModuleSpecificationBase(cachedLibraries) {
+    override val isFinal = true
+
+    override fun containsLibrary(library: KotlinLibrary): Boolean = !cachedLibraries.isLibraryCached(library)
+}
+
+internal class CacheLlvmModuleSpecification(
+        cachedLibraries: CachedLibraries,
+        private val librariesToCache: Set<KotlinLibrary>
+) : LlvmModuleSpecificationBase(cachedLibraries) {
+    override val isFinal = false
+
+    override fun containsLibrary(library: KotlinLibrary): Boolean = library in librariesToCache
+}