[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

@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.native.interop.indexer.getHeaderPaths
 import org.jetbrains.kotlin.native.interop.tool.CInteropArguments
 import java.io.File
 
-fun defFileDependencies(args: Array<String>) {
+fun defFileDependencies(args: Array<String>, runFromDaemon: Boolean) {
     val defFiles = mutableListOf<File>()
     val targets = mutableListOf<String>()
 
@@ -30,14 +30,14 @@ fun defFileDependencies(args: Array<String>) {
         }
     }
 
-    defFileDependencies(makeDependencyAssigner(targets, defFiles))
+    defFileDependencies(makeDependencyAssigner(targets, defFiles, runFromDaemon))
 }
 
-private fun makeDependencyAssigner(targets: List<String>, defFiles: List<File>) =
+private fun makeDependencyAssigner(targets: List<String>, defFiles: List<File>, runFromDaemon: Boolean) =
-        CompositeDependencyAssigner(targets.map { makeDependencyAssignerForTarget(it, defFiles) })
+        CompositeDependencyAssigner(targets.map { makeDependencyAssignerForTarget(it, defFiles, runFromDaemon) })
 
-private fun makeDependencyAssignerForTarget(target: String, defFiles: List<File>): SingleTargetDependencyAssigner {
+private fun makeDependencyAssignerForTarget(target: String, defFiles: List<File>, runFromDaemon: Boolean): SingleTargetDependencyAssigner {
-    val tool = prepareTool(target, KotlinPlatform.NATIVE)
+    val tool = prepareTool(target, KotlinPlatform.NATIVE, runFromDaemon)
     val cinteropArguments = CInteropArguments()
     cinteropArguments.argParser.parse(arrayOf())
     val libraries = defFiles.associateWith {

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>) {
+class ToolConfig(userProvidedTargetName: String?, flavor: KotlinPlatform, propertyOverrides: Map<String, String>)
-
+    : AbstractToolConfig(KonanHomeProvider.determineKonanHome(), userProvidedTargetName, propertyOverrides) {
-    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)
 
     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)
+    val platformCompilerOpts =
-            clang.hostCompilerArgsForJni.toList() else emptyList()
+            if (clang is ClangArgs.Jni)
+                clang.hostCompilerArgsForJni.toList()
+            else emptyList()
 
-    val llvmHome = platform.absoluteLlvmHome
+    override fun loadLibclang() { System.load(libclang) }
-    val sysRoot = platform.absoluteTargetSysRoot
-
-    val libclang = when (host) {
-        KonanTarget.MINGW_X64 -> "$llvmHome/bin/libclang.dll"
-        else -> "$llvmHome/lib/${System.mapLibraryName("clang")}"
-    }
 }

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

@@ -64,18 +64,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")
@@ -206,15 +207,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) }
@@ -224,7 +225,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) ||
@@ -463,14 +464,10 @@ private fun resolveDependencies(
     ).getFullList(TopologicalLibraryOrder)
 }
 
-internal fun prepareTool(target: String?, flavor: KotlinPlatform, propertyOverrides: Map<String, String> = emptyMap()): ToolConfig {
+internal fun prepareTool(target: String?, flavor: KotlinPlatform, runFromDaemon: Boolean, propertyOverrides: Map<String, String> = emptyMap()) =
-    val tool = ToolConfig(target, flavor, propertyOverrides)
+        ToolConfig(target, flavor, propertyOverrides).also {
-    tool.downloadDependencies()
+            if (!runFromDaemon) it.prepare() // Daemon prepares the tool himself. (See KonanToolRunner.kt)
-
+        }
-    System.load(tool.libclang)
-
-    return tool
-}
 
 internal fun buildNativeLibrary(
         tool: ToolConfig,

kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/AbstractToolConfig.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.konan.target
+
+import org.jetbrains.kotlin.konan.util.defaultTargetSubstitutions
+
+abstract class AbstractToolConfig(konanHome: String, userProvidedTargetName: String?, propertyOverrides: Map<String, String>) {
+    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
+
+    protected val platform = platformManager.platform(target)
+
+    val substitutions = defaultTargetSubstitutions(target)
+
+    fun downloadDependencies() = platform.downloadDependencies()
+
+    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")}"
+    }
+
+    abstract fun loadLibclang()
+
+    fun prepare() {
+        downloadDependencies()
+
+        loadLibclang()
+    }
+}

kotlin-native/tools/kotlin-native-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/konan/KonanToolRunner.kt

@@ -27,6 +27,7 @@ import org.jetbrains.kotlin.konan.util.DependencyDirectories
 import java.io.File
 import java.util.Properties
 import org.jetbrains.kotlin.compilerRunner.KotlinToolRunner
+import org.jetbrains.kotlin.konan.target.AbstractToolConfig
 
 internal interface KonanToolRunner {
     fun run(args: List<String>)
@@ -67,10 +68,10 @@ internal abstract class KonanCliRunner(
             """.trimIndent()
             }
 
-    data class IsolatedClassLoaderCacheKey(val classpath: Set<java.io.File>)
+    data class IsolatedClassLoaderCacheKey(val classpath: Set<java.io.File>, val project: Project)
 
     // TODO: can't we use this for other implementations too?
-    final override val isolatedClassLoaderCacheKey get() = IsolatedClassLoaderCacheKey(classpath)
+    final override val isolatedClassLoaderCacheKey get() = IsolatedClassLoaderCacheKey(classpath, project)
 
     override fun transformArgs(args: List<String>) = listOf(toolName) + args
 
@@ -103,6 +104,16 @@ internal class KonanCliCompilerRunner(
     }
 }
 
+private val load0 = Runtime::class.java.getDeclaredMethod("load0", Class::class.java, String::class.java).also {
+    it.isAccessible = true
+}
+
+internal class CliToolConfig(konanHome: String, target: String) : AbstractToolConfig(konanHome, target, emptyMap()) {
+    override fun loadLibclang() {
+        load0.invoke(Runtime.getRuntime(), String::class.java, libclang)
+    }
+}
+
 /** Kotlin/Native C-interop tool runner */
 internal class KonanCliInteropRunner(
         project: Project,
@@ -121,6 +132,10 @@ internal class KonanCliInteropRunner(
         result
     }
 
+    fun init(target: String) {
+        CliToolConfig(konanHome, target).prepare()
+    }
+
     private val llvmExecutablesPath: String? by lazy {
         if (HostManager.host == KonanTarget.MINGW_X64) {
             // TODO: Read it from Platform properties when it is accessible.

kotlin-native/tools/kotlin-native-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/konan/tasks/KonanInteropTask.kt

@@ -36,8 +36,10 @@ import javax.inject.Inject
 
 open class KonanInteropTask @Inject constructor(@Internal val workerExecutor: WorkerExecutor) : KonanBuildingTask(), KonanInteropSpec {
 
+    private val interopRunner = KonanCliInteropRunner(project, project.konanExtension.jvmArgs)
+
     @get:Internal
-    override val toolRunner: KonanToolRunner = KonanCliInteropRunner(project, project.konanExtension.jvmArgs)
+    override val toolRunner: KonanToolRunner = interopRunner
 
     override fun init(config: KonanBuildingConfig<*>, destinationDir: File, artifactName: String, target: KonanTarget) {
         super.init(config, destinationDir, artifactName, target)
@@ -174,6 +176,8 @@ open class KonanInteropTask @Inject constructor(@Internal val workerExecutor: Wo
     }
 
     override fun run() {
+        interopRunner.init(target)
+
         destinationDir.mkdirs()
         if (dumpParameters) {
             dumpProperties(this)

kotlin-native/utilities/cli-runner/src/main/kotlin/org/jetbrains/kotlin/cli/utilities/GeneratePlatformLibraries.kt

@@ -250,7 +250,7 @@ private fun generateLibrary(
                 *def.depends.flatMap { listOf("-l", "$outputDirectory/${it.libraryName}") }.toTypedArray()
         )
         logger.verbose("Run cinterop with args: ${cinteropArgs.joinToString(separator = " ")}")
-        invokeInterop("native", cinteropArgs)?.let { K2Native.mainNoExit(it) }
+        invokeInterop("native", cinteropArgs, runFromDaemon = false)?.let { K2Native.mainNoExit(it) }
 
         if (rebuild) {
             outKlib.deleteAtomicallyIfPossible(tmpDirectory)

kotlin-native/utilities/cli-runner/src/main/kotlin/org/jetbrains/kotlin/cli/utilities/InteropCompiler.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.native.interop.tool.*
  * @return null if there is no need in compiler invocation.
  * Otherwise returns array of compiler args.
  */
-fun invokeInterop(flavor: String, args: Array<String>): Array<String>? {
+fun invokeInterop(flavor: String, args: Array<String>, runFromDaemon: Boolean): Array<String>? {
     val arguments = if (flavor == "native") CInteropArguments() else JSInteropArguments()
     arguments.argParser.parse(args)
     val outputFileName = arguments.output
@@ -46,7 +46,8 @@ fun invokeInterop(flavor: String, args: Array<String>): Array<String>? {
             InternalInteropOptions(generatedDir.absolutePath,
                     nativesDir.absolutePath,manifest.path,
                     cstubsName.takeIf { flavor == "native" }
-            )
+            ),
+            runFromDaemon
     ) ?: return null // There is no need in compiler invocation if we're generating only metadata.
 
     val nativeStubs =

kotlin-native/utilities/cli-runner/src/main/kotlin/org/jetbrains/kotlin/cli/utilities/main.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.cli.bc.mainNoExitWithGradleRenderer as konancMainFor
 import org.jetbrains.kotlin.backend.konan.env.setEnv
 import org.jetbrains.kotlin.konan.util.usingNativeMemoryAllocator
 
-private fun mainImpl(args: Array<String>, konancMain: (Array<String>) -> Unit) {
+private fun mainImpl(args: Array<String>, runFromDaemon: Boolean, konancMain: (Array<String>) -> Unit) {
     val utilityName = args[0]
     val utilityArgs = args.drop(1).toTypedArray()
     when (utilityName) {
@@ -37,17 +37,17 @@ private fun mainImpl(args: Array<String>, konancMain: (Array<String>) -> Unit) {
             konancMain(utilityArgs)
         }
         "cinterop" -> {
-            val konancArgs = invokeInterop("native", utilityArgs)
+            val konancArgs = invokeInterop("native", utilityArgs, runFromDaemon)
             konancArgs?.let { konancMain(it) }
         }
         "jsinterop" -> {
-            val konancArgs = invokeInterop("wasm", utilityArgs)
+            val konancArgs = invokeInterop("wasm", utilityArgs, runFromDaemon)
             konancArgs?.let { konancMain(it) }
         }
         "klib" ->
             klibMain(utilityArgs)
         "defFileDependencies" ->
-            defFileDependencies(utilityArgs)
+            defFileDependencies(utilityArgs, runFromDaemon)
         "generatePlatformLibraries" ->
             generatePlatformLibraries(utilityArgs)
 
@@ -59,7 +59,7 @@ private fun mainImpl(args: Array<String>, konancMain: (Array<String>) -> Unit) {
     }
 }
 
-fun main(args: Array<String>) = mainImpl(args, ::konancMain)
+fun main(args: Array<String>) = mainImpl(args, false, ::konancMain)
 
 private fun setupClangEnv() {
     setEnv("LIBCLANG_DISABLE_CRASH_RECOVERY", "1")
@@ -67,5 +67,5 @@ private fun setupClangEnv() {
 
 fun daemonMain(args: Array<String>) = usingNativeMemoryAllocator {
     setupClangEnv() // For in-process invocation have to setup proper environment manually.
-    mainImpl(args, ::konancMainForGradle)
+    mainImpl(args, true, ::konancMainForGradle)
 }