[K/N][gradle][interop] Refactored ToolConfig

Added possibility to create different strategies for loading libclang

kotlin-native/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/defFileDependencies.kt

@@ -11,7 +11,7 @@ import java.io.File
 import java.util.stream.Collectors
 import kotlin.streams.toList
 
-fun defFileDependencies(args: Array<String>) {
+fun defFileDependencies(args: Array<String>, runFromDaemon: Boolean) {
     val defFiles = mutableListOf<File>()
     val targets = mutableListOf<String>()
 
@@ -32,14 +32,14 @@ fun defFileDependencies(args: Array<String>) {
         }
     }
 
-    defFileDependencies(makeDependencyAssigner(targets, defFiles))
+    defFileDependencies(makeDependencyAssigner(targets, defFiles, runFromDaemon))
 }
 
-private fun makeDependencyAssigner(targets: List<String>, defFiles: List<File>) =
-        CompositeDependencyAssigner(targets.map { makeDependencyAssignerForTarget(it, defFiles) })
+private fun makeDependencyAssigner(targets: List<String>, defFiles: List<File>, runFromDaemon: Boolean) =
+        CompositeDependencyAssigner(targets.map { makeDependencyAssignerForTarget(it, defFiles, runFromDaemon) })
 
-private fun makeDependencyAssignerForTarget(target: String, defFiles: List<File>): SingleTargetDependencyAssigner {
-    val tool = prepareTool(target, KotlinPlatform.NATIVE)
+private fun makeDependencyAssignerForTarget(target: String, defFiles: List<File>, runFromDaemon: Boolean): SingleTargetDependencyAssigner {
+    val tool = prepareTool(target, KotlinPlatform.NATIVE, runFromDaemon)
     val cinteropArguments = CInteropArguments()
     cinteropArguments.argParser.parse(arrayOf())
     val libraries = defFiles.parallelStream().map {

kotlin-native/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/ToolConfig.kt

@@ -18,44 +18,28 @@ package  org.jetbrains.kotlin.native.interop.tool
 
 import org.jetbrains.kotlin.konan.target.*
 import org.jetbrains.kotlin.konan.util.KonanHomeProvider
-import org.jetbrains.kotlin.konan.util.defaultTargetSubstitutions
+import org.jetbrains.kotlin.konan.target.AbstractToolConfig
 import org.jetbrains.kotlin.native.interop.gen.jvm.KotlinPlatform
 import org.jetbrains.kotlin.native.interop.indexer.Language
 
-class ToolConfig(userProvidedTargetName: String?, private val flavor: KotlinPlatform, private val propertyOverrides: Map<String, String>) {
-
-    private val konanHome = KonanHomeProvider.determineKonanHome()
-    private val distribution = Distribution(konanHome, propertyOverrides = propertyOverrides)
-    private val platformManager = PlatformManager(distribution)
-    private val targetManager = platformManager.targetManager(userProvidedTargetName)
-    private val host = HostManager.host
-    val target = targetManager.target
-
-    private val platform = platformManager.platform(target)
+class ToolConfig(userProvidedTargetName: String?, flavor: KotlinPlatform, propertyOverrides: Map<String, String>)
+    : AbstractToolConfig(KonanHomeProvider.determineKonanHome(), userProvidedTargetName, propertyOverrides) {
 
     val clang = when (flavor) {
         KotlinPlatform.JVM -> platform.clangForJni
         KotlinPlatform.NATIVE -> platform.clang
     }
 
-    val substitutions = defaultTargetSubstitutions(target)
-
-    fun downloadDependencies() = platform.downloadDependencies()
-
     fun getDefaultCompilerOptsForLanguage(language: Language): List<String> = when (language) {
         Language.C,
         Language.OBJECTIVE_C -> clang.libclangArgs.toList()
         Language.CPP -> clang.libclangXXArgs.toList()
     }
 
-    val platformCompilerOpts = if (clang is ClangArgs.Jni)
-            clang.hostCompilerArgsForJni.toList() else emptyList()
+    val platformCompilerOpts =
+            if (clang is ClangArgs.Jni)
+                clang.hostCompilerArgsForJni.toList()
+            else emptyList()
 
-    val llvmHome = platform.absoluteLlvmHome
-    val sysRoot = platform.absoluteTargetSysRoot
-
-    val libclang = when (host) {
-        KonanTarget.MINGW_X64 -> "$llvmHome/bin/libclang.dll"
-        else -> "$llvmHome/lib/${System.mapLibraryName("clang")}"
-    }
+    override fun loadLibclang() { System.load(libclang) }
 }

kotlin-native/Interop/StubGenerator/src/main/kotlin/org/jetbrains/kotlin/native/interop/gen/jvm/main.kt

@@ -65,18 +65,19 @@ fun main(args: Array<String>) {
     val arguments = FullCInteropArguments()
     arguments.argParser.parse(args)
     val flavorName = arguments.flavor
-    processCLibSafe(flavorName, arguments, InternalInteropOptions(arguments.generated, arguments.natives))
+    processCLibSafe(flavorName, arguments, InternalInteropOptions(arguments.generated, arguments.natives), runFromDaemon = false)
 }
 
 fun interop(
         flavor: String, args: Array<String>,
-        additionalArgs: InternalInteropOptions
+        additionalArgs: InternalInteropOptions,
+        runFromDaemon: Boolean
 ): Array<String>? = when (flavor) {
     "jvm", "native" -> {
         val cinteropArguments = CInteropArguments()
         cinteropArguments.argParser.parse(args)
         val platform = KotlinPlatform.values().single { it.name.equals(flavor, ignoreCase = true) }
-        processCLibSafe(platform, cinteropArguments, additionalArgs)
+        processCLibSafe(platform, cinteropArguments, additionalArgs, runFromDaemon)
     }
     "wasm" -> processIdlLib(args, additionalArgs)
     else -> error("Unexpected flavor")
@@ -207,15 +208,15 @@ private fun findFilesByGlobs(roots: List<Path>, globs: List<String>): Map<Path,
 }
 
 private fun processCLibSafe(flavor: KotlinPlatform, cinteropArguments: CInteropArguments,
-                            additionalArgs: InternalInteropOptions) =
+                            additionalArgs: InternalInteropOptions, runFromDaemon: Boolean) =
         usingNativeMemoryAllocator {
             usingJvmCInteropCallbacks {
-                processCLib(flavor, cinteropArguments, additionalArgs)
+                processCLib(flavor, cinteropArguments, additionalArgs, runFromDaemon)
             }
         }
 
 private fun processCLib(flavor: KotlinPlatform, cinteropArguments: CInteropArguments,
-                        additionalArgs: InternalInteropOptions): Array<String>? {
+                        additionalArgs: InternalInteropOptions, runFromDaemon: Boolean): Array<String>? {
     val ktGenRoot = additionalArgs.generated
     val nativeLibsDir = additionalArgs.natives
     val defFile = cinteropArguments.def?.let { File(it) }
@@ -225,7 +226,7 @@ private fun processCLib(flavor: KotlinPlatform, cinteropArguments: CInteropArgum
         cinteropArguments.argParser.printError("-def or -pkg should be provided!")
     }
 
-    val tool = prepareTool(cinteropArguments.target, flavor, parseKeyValuePairs(cinteropArguments.overrideKonanProperties))
+    val tool = prepareTool(cinteropArguments.target, flavor, runFromDaemon, parseKeyValuePairs(cinteropArguments.overrideKonanProperties))
 
     val def = DefFile(defFile, tool.substitutions)
     val isLinkerOptsSetByUser = (cinteropArguments.linkerOpts.valueOrigin == ArgParser.ValueOrigin.SET_BY_USER) ||
@@ -469,14 +470,10 @@ private fun resolveDependencies(
     ).getFullList(TopologicalLibraryOrder)
 }
 
-internal fun prepareTool(target: String?, flavor: KotlinPlatform, propertyOverrides: Map<String, String> = emptyMap()): ToolConfig {
-    val tool = ToolConfig(target, flavor, propertyOverrides)
-    tool.downloadDependencies()
-
-    System.load(tool.libclang)
-
-    return tool
-}
+internal fun prepareTool(target: String?, flavor: KotlinPlatform, runFromDaemon: Boolean, propertyOverrides: Map<String, String> = emptyMap()) =
+        ToolConfig(target, flavor, propertyOverrides).also {
+            if (!runFromDaemon) it.prepare() // Daemon prepares the tool himself. (See KonanToolRunner.kt)
+        }
 
 internal fun buildNativeLibrary(
         tool: ToolConfig,