KT-65928 Worker API for Swift Export

libraries/tools/kotlin-gradle-plugin/build.gradle.kts

@@ -1,5 +1,4 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import com.github.jengelman.gradle.plugins.shadow.transformers.DontIncludeResourceTransformer
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -91,10 +90,6 @@ dependencies {
     commonRuntimeOnly(project(":kotlin-util-klib"))
     commonRuntimeOnly(project(":kotlin-compiler-embeddable"))
 
-    if (kotlinBuildProperties.isSwiftExportPluginPublishingEnabled) {
-        embedded(project(":native:swift:swift-export-embeddable"))
-    }
-
     embedded(project(":kotlin-gradle-build-metrics"))
     embedded(project(":kotlin-gradle-statistics"))
     embedded(commonDependency("org.jetbrains.intellij.deps:asm-all")) { isTransitive = false }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginWrapper.kt

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.gradle.internal.KOTLIN_MODULE_GROUP
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.plugin.internal.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.plugin.mpp.apple.swiftexport.initSwiftExportClasspathConfigurations
 import org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSetFactory
 import org.jetbrains.kotlin.gradle.plugin.statistics.BuildFusService
 import org.jetbrains.kotlin.gradle.report.BuildMetricsService
@@ -254,6 +255,7 @@ abstract class KotlinBasePluginWrapper : DefaultKotlinBasePlugin() {
             addGradlePluginMetadataAttributes(project)
         }
         project.maybeCreateCommonizerClasspathConfiguration()
+        project.initSwiftExportClasspathConfigurations()
 
         project.createKotlinExtension(projectExtensionClass).apply {
             coreLibrariesVersion = pluginVersion

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/BuildSyntheticProjectWithSwiftExportPackage.kt

@@ -24,7 +24,7 @@ import java.io.File
 import javax.inject.Inject
 
 @DisableCachingByDefault(because = "Swift Export is experimental, so no caching for now")
-abstract class BuildSyntheticProjectWithSwiftExportPackage : DefaultTask() {
+internal abstract class BuildSyntheticProjectWithSwiftExportPackage : DefaultTask() {
 
     @get:Inject
     abstract val providerFactory: ProviderFactory

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/CopySwiftExportIntermediatesForConsumer.kt

@@ -18,7 +18,7 @@ import java.io.File
 import javax.inject.Inject
 
 @DisableCachingByDefault(because = "This task only copies files")
-abstract class CopySwiftExportIntermediatesForConsumer @Inject constructor(
+internal abstract class CopySwiftExportIntermediatesForConsumer @Inject constructor(
     objectFactory: ObjectFactory,
     projectLayout: ProjectLayout,
     providerFactory: ProviderFactory,

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/GenerateSPMPackageFromSwiftExport.kt

@@ -17,7 +17,7 @@ import org.jetbrains.kotlin.incremental.createDirectory
 import org.jetbrains.kotlin.incremental.deleteRecursivelyOrThrow
 
 @DisableCachingByDefault(because = "Swift Export is experimental, so no caching for now")
-abstract class GenerateSPMPackageFromSwiftExport : DefaultTask() {
+internal abstract class GenerateSPMPackageFromSwiftExport : DefaultTask() {
 
     @get:Input
     abstract val swiftApiModuleName: Property<String>

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/SwiftExport.kt

@@ -11,8 +11,10 @@ import org.gradle.api.file.Directory
 import org.gradle.api.plugins.BasePlugin
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformSourceSetConventionsImpl.commonMain
 import org.jetbrains.kotlin.gradle.dsl.KotlinNativeBinaryContainer
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.kotlinPluginLifecycle
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
@@ -49,7 +51,6 @@ private fun Project.registerSwiftExportTask(
     val swiftExportTask = registerSwiftExportRun(
         swiftApiModuleName = swiftApiModuleName,
         taskNamePrefix = taskNamePrefix,
-        mainCompilation = mainCompilation,
     )
     val staticLibrary = registerSwiftExportCompilationAndGetBinary(
         buildType = buildType,
@@ -91,15 +92,19 @@ private fun Project.registerSwiftExportTask(
 private fun Project.registerSwiftExportRun(
     swiftApiModuleName: Provider<String>,
     taskNamePrefix: String,
-    mainCompilation: KotlinCompilation<*>,
 ): TaskProvider<SwiftExportTask> {
     val swiftExportTaskName = taskNamePrefix + "SwiftExport"
+
     return locateOrRegisterTask<SwiftExportTask>(swiftExportTaskName) { task ->
-        val directoryProvider = project.future {
+        val commonMainProvider = project.future {
-            kotlinPluginLifecycle.await(KotlinPluginLifecycle.Stage.AfterFinaliseRefinesEdges)
+            project
-            mainCompilation.allKotlinSourceSets.flatMap {
+                .multiplatformExtension
-                it.kotlin.srcDirs
+                .awaitSourceSets()
-            }
+                .commonMain
+                .get()
+                .kotlin
+                .srcDirs
+                .single()
         }
 
         val outputs = layout.buildDirectory.dir(swiftExportTaskName)
@@ -107,15 +112,16 @@ private fun Project.registerSwiftExportRun(
         val kotlinIntermediates = outputs.map { it.dir("kotlinIntermediates") }
 
         // Input
-        task.sourceRoots.from(project.files(directoryProvider.getOrThrow()))
+        task.swiftExportClasspath.from(project.maybeCreateSwiftExportClasspathResolvableConfiguration())
-        task.bridgeModuleName.set(swiftApiModuleName.map { "${it}Bridge" })
+        task.parameters.sourceRoot.set(commonMainProvider.getOrThrow())
-        task.debugMode.set(true)
+        task.parameters.bridgeModuleName.set(swiftApiModuleName.map { "${it}Bridge" })
-        task.konanDistribution.set(konanDistribution.root)
+        task.parameters.debugMode.set(true)
+        task.parameters.konanDistribution.set(konanDistribution.root)
 
         // Output
-        task.swiftApiPath.set(swiftIntermediates.map { it.file("KotlinAPI.swift") })
+        task.parameters.swiftApiPath.set(swiftIntermediates.map { it.file("KotlinAPI.swift") })
-        task.headerBridgePath.set(swiftIntermediates.map { it.file("KotlinBridge.h") })
+        task.parameters.headerBridgePath.set(swiftIntermediates.map { it.file("KotlinBridge.h") })
-        task.kotlinBridgePath.set(kotlinIntermediates.map { it.file("KotlinBridge.kt") })
+        task.parameters.kotlinBridgePath.set(kotlinIntermediates.map { it.file("KotlinBridge.kt") })
     }
 }
 
@@ -133,7 +139,10 @@ private fun registerSwiftExportCompilationAndGetBinary(
         swiftExportCompilationName,
         invokeWhenCreated = { swiftExportCompilation ->
             swiftExportCompilation.associateWith(mainCompilation)
-            swiftExportCompilation.defaultSourceSet.kotlin.srcDir(swiftExportTask.map { it.kotlinBridgePath.getFile().parent })
+            swiftExportCompilation.defaultSourceSet.kotlin.srcDir(swiftExportTask.map {
+                it.parameters.kotlinBridgePath.getFile().parent
+            })
+
             swiftExportCompilation.compileTaskProvider.configure {
                 it.compilerOptions.optIn.add("kotlin.experimental.ExperimentalNativeApi")
             }
@@ -165,10 +174,10 @@ private fun Project.registerPackageGeneration(
         task.description = "Generates $taskNamePrefix SPM Package"
 
         // Input
-        task.swiftApiPath.set(swiftExportTask.flatMap { it.swiftApiPath })
+        task.swiftApiPath.set(swiftExportTask.map { it.parameters.swiftApiPath.get() })
-        task.headerBridgePath.set(swiftExportTask.flatMap { it.headerBridgePath })
+        task.headerBridgePath.set(swiftExportTask.map { it.parameters.headerBridgePath.get() })
-        task.headerBridgeModuleName.set(swiftExportTask.flatMap { it.bridgeModuleName })
+        task.headerBridgeModuleName.set(swiftExportTask.map { it.parameters.bridgeModuleName.get() })
-        task.libraryPath.set { staticLibrary.linkTaskProvider.flatMap { it.outputFile }.get() }
+        task.libraryPath.set { staticLibrary.linkTaskProvider.map { it.outputFile.get() }.get() }
         task.swiftLibraryName.set(swiftApiLibraryName)
         task.kotlinLibraryName.set(kotlinStaticLibraryName)
         task.swiftApiModuleName.set(swiftApiModuleName)
@@ -219,4 +228,5 @@ private fun Project.registerCopyTask(
     }
     copyTask.dependsOn(syntheticProjectBuild)
     return copyTask
-}
+}
+

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/SwiftExportAction.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2024 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.gradle.plugin.mpp.apple.swiftexport
+
+import org.gradle.workers.WorkAction
+import org.jetbrains.kotlin.gradle.utils.getFile
+import org.jetbrains.kotlin.konan.target.Distribution
+import org.jetbrains.kotlin.swiftexport.standalone.*
+import java.util.logging.Level
+import java.util.logging.Logger
+
+internal abstract class SwiftExportAction : WorkAction<SwiftExportParameters> {
+
+    companion object : SwiftExportLogger {
+        private val logger = Logger.getLogger(this::class.java.name)
+
+        override fun report(severity: SwiftExportLogger.Severity, message: String) {
+            logger.log(severity.logType(), message)
+        }
+
+        private fun SwiftExportLogger.Severity.logType(): Level = when (this) {
+            SwiftExportLogger.Severity.Info -> Level.INFO
+            SwiftExportLogger.Severity.Warning -> Level.WARNING
+            SwiftExportLogger.Severity.Error -> Level.SEVERE
+            else -> Level.INFO
+        }
+    }
+
+    override fun execute() {
+        runSwiftExport(
+            input = SwiftExportInput(
+                sourceRoot = parameters.sourceRoot.getFile().toPath()
+            ),
+            config = SwiftExportConfig(
+                settings = mapOf(
+                    SwiftExportConfig.DEBUG_MODE_ENABLED to parameters.debugMode.getOrElse(false).toString(),
+                    SwiftExportConfig.BRIDGE_MODULE_NAME to parameters.bridgeModuleName.getOrElse(SwiftExportConfig.DEFAULT_BRIDGE_MODULE_NAME),
+                ),
+                Companion,
+                distribution = Distribution(parameters.konanDistribution.getFile().absolutePath),
+            ),
+            output = SwiftExportOutput(
+                swiftApi = parameters.swiftApiPath.getFile().toPath(),
+                kotlinBridges = parameters.kotlinBridgePath.getFile().toPath(),
+                cHeaderBridges = parameters.headerBridgePath.getFile().toPath(),
+            )
+        )
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/SwiftExportInit.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2024 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.gradle.plugin.mpp.apple.swiftexport
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.LibraryElements
+import org.gradle.api.attributes.Usage
+import org.jetbrains.kotlin.gradle.internal.KOTLIN_MODULE_GROUP
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
+import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
+import org.jetbrains.kotlin.gradle.plugin.usageByName
+import org.jetbrains.kotlin.gradle.utils.*
+
+private const val SWIFT_EXPORT_CLASSPATH = "swiftExportClasspath"
+private const val SWIFT_EXPORT_CLASSPATH_RESOLVABLE = "swiftExportClasspathResolvable"
+private const val SWIFT_EXPORT_EMBEDDABLE_MODULE = "swift-export-embeddable"
+
+
+internal fun Project.initSwiftExportClasspathConfigurations() {
+    if (project.kotlinPropertiesProvider.swiftExportEnabled) {
+        maybeCreateSwiftExportClasspathDependenciesConfiguration()
+        maybeCreateSwiftExportClasspathResolvableConfiguration()
+    }
+}
+
+private fun Project.maybeCreateSwiftExportClasspathDependenciesConfiguration(): Configuration {
+    return configurations.findDependencyScope(SWIFT_EXPORT_CLASSPATH)
+        ?: project.configurations.createDependencyScope(SWIFT_EXPORT_CLASSPATH) {
+            description = "Runtime classpath for the SwiftExport worker."
+            defaultDependencies { dependencies ->
+                dependencies.add(
+                    project.dependencies.create("$KOTLIN_MODULE_GROUP:$SWIFT_EXPORT_EMBEDDABLE_MODULE:${getKotlinPluginVersion()}")
+                )
+            }
+        }.get()
+}
+
+internal fun Project.maybeCreateSwiftExportClasspathResolvableConfiguration(): Configuration {
+    return configurations.findResolvable(SWIFT_EXPORT_CLASSPATH_RESOLVABLE)
+        ?: project.configurations.createResolvable(SWIFT_EXPORT_CLASSPATH_RESOLVABLE) {
+            description = "Resolves the runtime classpath for the SwiftExport worker."
+            attributes.setAttribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
+            attributes.setAttribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
+            attributes.setAttribute(Usage.USAGE_ATTRIBUTE, usageByName(Usage.JAVA_RUNTIME))
+            extendsFrom(maybeCreateSwiftExportClasspathDependenciesConfiguration())
+        }
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/SwiftExportParameters.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2024 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.gradle.plugin.mpp.apple.swiftexport
+
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+import org.gradle.workers.WorkParameters
+
+internal interface SwiftExportParameters : WorkParameters {
+
+    @get:Input
+    val bridgeModuleName: Property<String>
+
+    @get:Input
+    val debugMode: Property<Boolean>
+
+    @get:InputDirectory
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    val konanDistribution: DirectoryProperty
+
+    @get:InputDirectory
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    val sourceRoot: DirectoryProperty
+
+    @get:OutputFile
+    val swiftApiPath: RegularFileProperty
+
+    @get:OutputFile
+    val headerBridgePath: RegularFileProperty
+
+    @get:OutputFile
+    val kotlinBridgePath: RegularFileProperty
+}

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/apple/swiftexport/SwiftExportTask.kt

@@ -7,73 +7,40 @@ package org.jetbrains.kotlin.gradle.plugin.mpp.apple.swiftexport
 
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileCollection
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.RegularFileProperty
-import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import org.gradle.work.DisableCachingByDefault
-import org.jetbrains.kotlin.gradle.internal.LogType
+import org.gradle.workers.WorkerExecutor
-import org.jetbrains.kotlin.gradle.internal.processLogMessage
+import javax.inject.Inject
-import org.jetbrains.kotlin.gradle.utils.getFile
+
-import org.jetbrains.kotlin.konan.target.Distribution
-import org.jetbrains.kotlin.swiftexport.standalone.*
 
 @DisableCachingByDefault(because = "Swift Export is experimental, so no caching for now")
-abstract class SwiftExportTask : DefaultTask(), SwiftExportLogger {
+internal abstract class SwiftExportTask : DefaultTask() {
-
-    @get:Input
-    abstract val bridgeModuleName: Property<String>
-
-    @get:Input
-    abstract val debugMode: Property<Boolean>
-
-    @get:InputDirectory
-    @get:PathSensitive(PathSensitivity.ABSOLUTE)
-    abstract val konanDistribution: DirectoryProperty
 
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val sourceRoots: ConfigurableFileCollection
+    abstract val swiftExportClasspath: ConfigurableFileCollection
 
-    @get:OutputFile
+    @get:Inject
-    abstract val swiftApiPath: RegularFileProperty
+    abstract val workerExecutor: WorkerExecutor
 
-    @get:OutputFile
+    @get:Nested
-    abstract val headerBridgePath: RegularFileProperty
+    abstract val parameters: SwiftExportParameters
-
-    @get:OutputFile
-    abstract val kotlinBridgePath: RegularFileProperty
 
     @TaskAction
     fun run() {
-        runSwiftExport(
+        val workQueue = workerExecutor.classLoaderIsolation { workerSpec ->
-            input = SwiftExportInput(
+            workerSpec.classpath.from(swiftExportClasspath)
-                sourceRoot = sourceRoots.filter { it.exists() }.map { it.toPath() }.first()
+        }
-            ),
-            config = SwiftExportConfig(
-                settings = mapOf(
-                    SwiftExportConfig.DEBUG_MODE_ENABLED to debugMode.getOrElse(false).toString(),
-                    SwiftExportConfig.BRIDGE_MODULE_NAME to bridgeModuleName.getOrElse(SwiftExportConfig.DEFAULT_BRIDGE_MODULE_NAME),
-                ),
-                this,
-                distribution = Distribution(konanDistribution.getFile().absolutePath),
-            ),
-            output = SwiftExportOutput(
-                swiftApi = swiftApiPath.get().asFile.toPath(),
-                kotlinBridges = kotlinBridgePath.get().asFile.toPath(),
-                cHeaderBridges = headerBridgePath.get().asFile.toPath(),
-            )
-        )
-    }
 
-    override fun report(severity: SwiftExportLogger.Severity, message: String) {
+        workQueue.submit(SwiftExportAction::class.java) { workParameters ->
-        logger.processLogMessage(message, severity.logType())
+            workParameters.debugMode.set(parameters.debugMode)
-    }
+            workParameters.bridgeModuleName.set(parameters.bridgeModuleName)
-}
+            workParameters.konanDistribution.set(parameters.konanDistribution)
+            workParameters.sourceRoot.set(parameters.sourceRoot)
 
-private fun SwiftExportLogger.Severity.logType(): LogType = when (this) {
+            workParameters.swiftApiPath.set(parameters.swiftApiPath)
-    SwiftExportLogger.Severity.Info -> LogType.INFO
+            workParameters.headerBridgePath.set(parameters.headerBridgePath)
-    SwiftExportLogger.Severity.Warning -> LogType.WARN
+            workParameters.kotlinBridgePath.set(parameters.kotlinBridgePath)
-    SwiftExportLogger.Severity.Error -> LogType.ERROR
+        }
-    else -> LogType.LOG
+    }
 }

native/swift/swift-export-embeddable/build.gradle.kts

@@ -4,6 +4,10 @@ plugins {
     java
 }
 
+if (kotlinBuildProperties.isSwiftExportPluginPublishingEnabled) {
+    publish()
+}
+
 dependencies {
     embedded(project(":native:swift:sir")) { isTransitive = false }
     embedded(project(":native:swift:sir-compiler-bridge")) { isTransitive = false }

repo/gradle-build-conventions/buildsrc-compat/src/main/kotlin/tasks.kt

@@ -29,6 +29,8 @@ import java.lang.management.ManagementFactory
 import java.nio.file.Files
 import java.nio.file.Path
 
+private const val SWIFT_EXPORT_EMBEDDABLE = ":native:swift:swift-export-embeddable"
+
 val kotlinGradlePluginAndItsRequired = arrayOf(
     ":kotlin-assignment",
     ":kotlin-allopen",
@@ -82,21 +84,35 @@ val kotlinGradlePluginAndItsRequired = arrayOf(
     ":kotlin-test-js-runner",
     ":native:kotlin-klib-commonizer-embeddable",
     ":native:kotlin-klib-commonizer-api",
+    SWIFT_EXPORT_EMBEDDABLE,
     ":compiler:build-tools:kotlin-build-statistics",
     ":compiler:build-tools:kotlin-build-tools-api",
     ":compiler:build-tools:kotlin-build-tools-impl",
 )
 
+private fun Task.processDependent(dependent: String, action: () -> Unit) {
+    val isSwiftExportEmbeddable = dependent == SWIFT_EXPORT_EMBEDDABLE
+    val isSwiftExportPluginPublishingEnabled = project.kotlinBuildProperties.isSwiftExportPluginPublishingEnabled
+
+    if (!isSwiftExportEmbeddable || isSwiftExportPluginPublishingEnabled) {
+        action.invoke()
+    }
+}
+
 fun Task.dependsOnKotlinGradlePluginInstall() {
-    kotlinGradlePluginAndItsRequired.forEach {
+    kotlinGradlePluginAndItsRequired.forEach { dependency ->
-        dependsOn("${it}:install")
+        processDependent(dependency) {
+            dependsOn("${dependency}:install")
+        }
     }
 }
 
 fun Task.dependsOnKotlinGradlePluginPublish() {
-    kotlinGradlePluginAndItsRequired.forEach {
+    kotlinGradlePluginAndItsRequired.forEach { dependency ->
-        project.rootProject.tasks.findByPath("${it}:publish")?.let { task ->
+        processDependent(dependency) {
-            dependsOn(task)
+            project.rootProject.tasks.findByPath("${dependency}:publish")?.let { task ->
+                dependsOn(task)
+            }
         }
     }
 }