Temp
diff --git a/libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlatformType.kt b/libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlatformType.kt
index 6364478..25e0cac 100644
--- a/libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlatformType.kt
+++ b/libraries/tools/kotlin-gradle-plugin-api/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlatformType.kt
@@ -56,9 +56,7 @@
/**
* Represents a compilation output compiled for the Wasm Kotlin platform.
*/
- wasm,
-
- unknown;
+ wasm;
/**
* @suppress
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts
index 75add62..b858447 100644
--- a/libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/build.gradle.kts
@@ -108,6 +108,7 @@
// AGP classes for buildScriptInjection's
testImplementation(libs.android.gradle.plugin.gradle.api) { isTransitive = false }
+ testImplementation(libs.android.gradle.plugin.gradle) { isTransitive = false }
testImplementation(project(path = ":examples:annotation-processor-example"))
testImplementation(kotlinStdlib("jdk8"))
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGenerateSourceSets.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGenerateSourceSets.kt
index 4c222f0..3770266 100644
--- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGenerateSourceSets.kt
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGenerateSourceSets.kt
@@ -5,8 +5,11 @@
package org.jetbrains.kotlin.gradle.testbase
+import org.intellij.lang.annotations.Language
import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
import java.io.Serializable
+import java.security.MessageDigest
+import java.util.Base64
data class SourceSetIdentifier(
val name: String,
@@ -45,4 +48,20 @@
}
}
)
+}
+
+fun KotlinSourceSet.compileSource(
+ @Language("kotlin")
+ sourceContent: String
+) {
+ val identifier = name
+ val identifierPath = project.layout.buildDirectory.dir("consume_${identifier}")
+ kotlin.srcDir(
+ project.tasks.create("consumeSourceIn_${identifier}") { task ->
+ task.outputs.dir(identifierPath)
+ task.doLast {
+ identifierPath.get().asFile.resolve("consumeSourceIn_${identifier}.kt").writeText(sourceContent)
+ }
+ }
+ )
}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGradleBuildInjection.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGradleBuildInjection.kt
index 84cafbf..44bd192 100644
--- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGradleBuildInjection.kt
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testGradleBuildInjection.kt
@@ -109,11 +109,14 @@
* query anything from relevant tasks since they have executed. However, we have to disable CC, so that the returning closure can reach
* out for configuration entities.
*/
- fun buildAndReturn(evaluationTask: String = "tasks"): T {
+ fun buildAndReturn(
+ evaluationTask: String = "tasks",
+ deriveBuildOptions: TestProject.() -> BuildOptions = { buildOptions },
+ ): T {
gradleProject.build(
evaluationTask,
"-P${injectionLoadProperty}=true",
- buildOptions = gradleProject.buildOptions.copy(
+ buildOptions = gradleProject.deriveBuildOptions().copy(
configurationCache = BuildOptions.ConfigurationCacheValue.DISABLED,
)
)
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibConsumptionIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibConsumptionIT.kt
new file mode 100644
index 0000000..9aa442f
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibConsumptionIT.kt
@@ -0,0 +1,322 @@
+/*
+ * 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.uklibs
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.api.file.Directory
+import org.gradle.api.initialization.resolve.RepositoriesMode
+import org.gradle.api.internal.GradleInternal
+import org.gradle.api.plugins.ExtraPropertiesExtension
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.internal.project.*
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.artifacts.UklibResolutionStrategy
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.internal.properties.nativeProperties
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
+import org.jetbrains.kotlin.gradle.testbase.*
+import org.jetbrains.kotlin.internal.compilerRunner.native.nativeCompilerClasspath
+import org.junit.jupiter.api.DisplayName
+import java.io.File
+import java.io.FileOutputStream
+import java.io.Serializable
+import java.net.URLClassLoader
+import kotlin.test.assertEquals
+import java.io.PrintStream
+
+@MppGradlePluginTests
+@DisplayName("Smoke test uklib consumption")
+class UklibConsumptionIT : KGPBaseTest() {
+
+ @GradleTestVersions
+ @GradleTest
+ fun `uklib consumption smoke - in kotlin compilations of a symmetric consumer and producer projects - with all metadata compilations`(
+ version: GradleVersion
+ ) {
+ val symmetricTargets: KotlinMultiplatformExtension.() -> Unit = @JvmSerializableLambda {
+ linuxArm64()
+ iosArm64()
+ iosX64()
+ jvm()
+ js()
+ wasmJs()
+ wasmWasi()
+ }
+ val publisher = publishUklib(version) @JvmSerializableLambda {
+ symmetricTargets()
+ sourceSets.all {
+ it.compileSource(
+ "object Producer_${it.name}"
+ )
+ }
+ }
+
+ val producerConsumerVisibility = mapOf(
+ "common" to listOf(
+ "Producer_commonMain",
+ ),
+ "native" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ ),
+ "apple" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_appleMain",
+ ),
+ "ios" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_appleMain",
+ "Producer_iosMain"
+ ),
+ "linux" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_linuxMain",
+ ),
+ "jvm" to listOf(
+ "Producer_commonMain",
+ "Producer_jvmMain",
+ ),
+ "js" to listOf(
+ "Producer_commonMain",
+ "Producer_jsMain",
+ ),
+ "wasmJs" to listOf(
+ "Producer_commonMain",
+ "Producer_wasmJsMain",
+ ),
+ "wasmWasi" to listOf(
+ "Producer_commonMain",
+ "Producer_wasmWasiMain"
+ ),
+ "iosArm64" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_appleMain",
+ "Producer_iosArm64Main",
+ ),
+ "iosX64" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_appleMain",
+ "Producer_iosX64Main",
+ ),
+ "linuxArm64" to listOf(
+ "Producer_commonMain",
+ "Producer_nativeMain",
+ "Producer_linuxMain",
+ "Producer_linuxArm64Main",
+ ),
+ ).flatMap {
+ listOf(
+ it.key + "Main" to it.value,
+ it.key + "Test" to it.value,
+ )
+ }.toMap()
+
+ project(
+ "buildScriptInjectionGroovy",
+ version,
+ dependencyManagement = DependencyManagement.DefaultDependencyManagement(
+ gradleRepositoriesMode = RepositoriesMode.PREFER_PROJECT,
+ )
+ ) {
+ transferDependencyResolutionRepositoriesIntoProjectRepositories()
+ buildScriptInjection {
+ project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_UKLIB_RESOLUTION_STRATEGY, UklibResolutionStrategy.AllowResolvingUklibs.propertyName)
+
+ project.plugins.apply("org.jetbrains.kotlin.multiplatform")
+
+ project.repositories.maven {
+ it.setUrl(publisher.repository)
+
+ // Prevent Gradle from reading Gradle metadata
+ it.metadataSources {
+ it.mavenPom()
+ it.ignoreGradleMetadataRedirection()
+ }
+ }
+
+ with(kotlinMultiplatform) {
+ symmetricTargets()
+
+ sourceSets.all {
+ val producerTypes = producerConsumerVisibility[it.name] ?: error("Missing producer declaration for ${it.name}")
+ val arguments = producerTypes.map { "${it}: ${it}" }.joinToString(", ")
+ it.compileSource(
+ """
+ fun consumeIn_${it.name}(${arguments}) {}
+ """.trimIndent()
+ )
+ }
+
+ sourceSets.commonMain.dependencies {
+ implementation("${publisher.group}:${publisher.name}:${publisher.version}")
+ }
+ }
+ }
+
+ // FIXME: Maybe just nuke Gradle metadata?
+ val resolvedProducerIosArm64Variant = buildScriptReturn {
+ (project.gradle as GradleInternal).services.get(ProjectStateRegistry::class.java).allowUncontrolledAccessToAnyProject {
+ val selectedVariant = kotlinMultiplatform.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration
+ .incoming.artifacts.artifacts.single {
+ val identifier = (it.id.componentIdentifier as? ModuleComponentIdentifier) ?: return@single false
+ identifier.group == publisher.group
+ && identifier.module == publisher.name
+ && identifier.version == publisher.version
+ }.variant
+ selectedVariant.attributes.keySet().map {
+ it.toString() to selectedVariant.attributes.getAttribute(it).toString()
+ }.toMap()
+ }
+ }.buildAndReturn()
+
+ // Make sure that we are actually resolving uklib from metadataSources configuration
+ assertEquals(
+ resolvedProducerIosArm64Variant["uklibDestination"],
+ "ios_arm64",
+ )
+
+ // FIXME: Test metadata compilations
+ build("build")
+
+ data class KlibsToCheck(
+ val iosArm64Klib: File,
+ val commonMainKlib: File,
+ ) : Serializable
+
+ val klibs = buildScriptReturn {
+ KlibsToCheck(
+ kotlinMultiplatform.iosArm64().compilations.getByName("main").compileTaskProvider.flatMap { it.outputFile }.get(),
+ kotlinMultiplatform.metadata().compilations.getByName("commonMain").output.classesDirs.singleFile,
+ )
+ }.buildAndReturn()
+
+ assertEquals(
+ """
+ /consumeIn_appleMain|consumeIn_appleMain(Producer_commonMain;Producer_nativeMain;Producer_appleMain){}[0]
+ /consumeIn_commonMain|consumeIn_commonMain(Producer_commonMain){}[0]
+ /consumeIn_iosArm64Main|consumeIn_iosArm64Main(Producer_commonMain;Producer_nativeMain;Producer_appleMain;Producer_iosArm64Main){}[0]
+ /consumeIn_iosMain|consumeIn_iosMain(Producer_commonMain;Producer_nativeMain;Producer_appleMain;Producer_iosMain){}[0]
+ /consumeIn_nativeMain|consumeIn_nativeMain(Producer_commonMain;Producer_nativeMain){}[0]
+
+ """.trimIndent(),
+ dumpKlibMetadataSignatures(klibs.iosArm64Klib),
+ )
+
+ assertEquals(
+ """
+ /consumeIn_commonMain|consumeIn_commonMain(Producer_commonMain){}[0]
+
+ """.trimIndent(),
+ dumpKlibMetadataSignatures(klibs.commonMainKlib),
+ )
+ }
+ }
+
+ private fun TestProject.dumpKlibMetadataSignatures(klib: File): String {
+ val dumpName = "dump_${klib.name}"
+ // FIXME: This path is not actually unique
+ val outputFile = projectPath.resolve(dumpName).toFile()
+ outputFile.createNewFile()
+
+ buildScriptInjection {
+ project.tasks.register(dumpName) {
+ val inputs = project.objects.nativeCompilerClasspath(
+ project.nativeProperties.actualNativeHomeDirectory,
+ project.nativeProperties.shouldUseEmbeddableCompilerJar,
+ )
+ it.inputs.files(inputs)
+ val nativePath = project.nativeProperties.actualNativeHomeDirectory
+ it.doLast {
+ // FIXME: Why does App class loader loads compiler classes and why is this crutch needed ???
+ System.setProperty("kotlin.native.home", nativePath.get().path)
+ URLClassLoader(inputs.map { it.toURI().toURL() }.toTypedArray()).use { classLoader ->
+ val entryPoint = Class.forName("org.jetbrains.kotlin.cli.klib.Main", true, classLoader)
+ .declaredMethods
+ .single { it.name == "exec" }
+
+ val stdout = PrintStream(FileOutputStream(outputFile))
+ val stderr = System.err
+
+ val args: Array<String> = arrayOf(
+ "dump-metadata-signatures", klib.path,
+ "-test-mode", "true",
+ )
+
+ assert(entryPoint.invoke(null, stdout, stderr, args) as Int == 0)
+ }
+ }
+ }
+ }
+
+ build(dumpName)
+
+ return outputFile.readText()
+ }
+
+ data class PublisherProject(
+ val repository: File,
+ val group: String,
+ val name: String,
+ val version: String,
+ ) : Serializable
+
+ private fun publishUklib(
+ gradleVersion: GradleVersion,
+ publisherConfiguration: KotlinMultiplatformExtension.() -> Unit,
+ ): PublisherProject {
+ val publisherGroup = "foo"
+ val publisherVersion = "1.0"
+ val publisherName = "producer"
+ var publicationRepoPath: File? = null
+ project(
+ "buildScriptInjectionGroovy",
+ gradleVersion,
+ projectPathAdditionalSuffix = publisherName,
+ ) {
+ val publicationRepo: Project.() -> Directory = @JvmSerializableLambda { project.layout.projectDirectory.dir("repo") }
+ buildScriptInjection {
+ project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB, true.toString())
+
+ project.plugins.apply("org.jetbrains.kotlin.multiplatform")
+ project.plugins.apply("maven-publish")
+
+ project.group = publisherGroup
+ project.version = publisherVersion
+
+ with(kotlinMultiplatform) {
+ publisherConfiguration()
+ }
+
+ val publishingExtension = project.extensions.getByType(PublishingExtension::class.java)
+ publishingExtension.repositories.maven {
+ it.url = project.uri(project.publicationRepo())
+ }
+ }
+
+ build("publishAllPublicationsToMavenRepository")
+
+ publicationRepoPath = buildScriptReturn {
+ project.publicationRepo().asFile
+ }.buildAndReturn()
+ }
+ return PublisherProject(
+ publicationRepoPath!!,
+ publisherGroup,
+ publisherName,
+ publisherVersion,
+ )
+ }
+}
+
+val Project.propertiesExtension: ExtraPropertiesExtension
+ get() = extensions.getByType(ExtraPropertiesExtension::class.java)
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibPublicationIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibPublicationIT.kt
new file mode 100644
index 0000000..4177af3
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/uklibs/UklibPublicationIT.kt
@@ -0,0 +1,351 @@
+/*
+ * 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.uklibs
+
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.decodeFromStream
+import org.gradle.api.Project
+import org.gradle.api.file.Directory
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.mpp.resources.unzip
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.*
+import org.jetbrains.kotlin.gradle.testbase.*
+import org.junit.jupiter.api.DisplayName
+import java.io.File
+import java.io.FileInputStream
+import java.io.Serializable
+import java.nio.file.Path
+import kotlin.io.path.createDirectory
+import kotlin.io.path.listDirectoryEntries
+import kotlin.io.path.name
+import kotlin.test.assertEquals
+import com.android.build.gradle.BaseExtension
+import org.gradle.api.NamedDomainObjectContainer
+import org.jetbrains.kotlin.gradle.ExternalKotlinTargetApi
+import org.jetbrains.kotlin.gradle.dsl.HasConfigurableKotlinCompilerOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.HasCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.mpp.external.*
+
+@OptIn(ExternalKotlinTargetApi::class)
+@MppGradlePluginTests
+@DisplayName("Smoke test uklib artifact publication")
+class UklibPublicationIT : KGPBaseTest() {
+
+ @GradleTest
+ fun `uklib contents - produces expected umanifest, platform and metadata artifacts`(
+ gradleVersion: GradleVersion
+ ) {
+ val publisher = publishUklib(
+ gradleVersion = gradleVersion,
+ ) @JvmSerializableLambda {
+ linuxArm64()
+ linuxX64()
+ iosArm64()
+ iosX64()
+ jvm()
+ js()
+ wasmJs()
+ wasmWasi()
+ }
+
+ val expectedFragments = listOf(
+ Fragment(identifier="appleMain", targets=listOf("ios_arm64", "ios_x64")),
+ Fragment(identifier="commonMain", targets=listOf("ios_arm64", "ios_x64", "js_ir", "jvm", "linux_arm64", "linux_x64", "wasm_js", "wasm_wasi")),
+ Fragment(identifier="iosArm64Main", targets=listOf("ios_arm64")),
+ Fragment(identifier="iosMain", targets=listOf("ios_arm64", "ios_x64")),
+ Fragment(identifier="iosX64Main", targets=listOf("ios_x64")),
+ Fragment(identifier="jsMain", targets=listOf("js_ir")),
+ Fragment(identifier="jvmMain", targets=listOf("jvm")),
+ Fragment(identifier="linuxArm64Main", targets=listOf("linux_arm64")),
+ Fragment(identifier="linuxMain", targets=listOf("linux_arm64", "linux_x64")),
+ Fragment(identifier="linuxX64Main", targets=listOf("linux_x64")),
+ Fragment(identifier="nativeMain", targets=listOf("ios_arm64", "ios_x64", "linux_arm64", "linux_x64")),
+ Fragment(identifier="wasmJsMain", targets=listOf("wasm_js")),
+ Fragment(identifier="wasmWasiMain", targets=listOf("wasm_wasi")),
+ )
+
+ assertEquals(
+ Umanifest(expectedFragments),
+ publisher.umanifest,
+ )
+ assertEquals(
+ expectedFragments.map { it.identifier }.toSet(),
+ publisher.uklibContents.listDirectoryEntries().map {
+ it.name
+ }.filterNot { it == Uklib.UMANIFEST_FILE_NAME }.toSet(),
+ )
+ }
+
+ @GradleTest
+ fun `uklib contents - produces single platform fragment - when metadata compilations are redundant`(
+ gradleVersion: GradleVersion,
+ ) {
+ val publisher = publishUklib(
+ gradleVersion = gradleVersion
+ ) @JvmSerializableLambda {
+ iosArm64()
+ }
+
+ val expectedFragments = listOf(
+ Fragment(identifier="iosArm64Main", targets=listOf("ios_arm64")),
+ )
+
+ assertEquals(
+ Umanifest(expectedFragments),
+ publisher.umanifest,
+ )
+ assertEquals(
+ expectedFragments.map { it.identifier }.toSet(),
+ publisher.uklibContents.listDirectoryEntries().map {
+ it.name
+ }.filterNot { it == Uklib.UMANIFEST_FILE_NAME }.toSet(),
+ )
+ }
+
+ // FIXME: This should be an error or we need to introduce refines edges
+ @GradleTest
+ fun `uklib contents - bamboo metadata publication`(
+ gradleVersion: GradleVersion
+ ) {
+ val publisher = publishUklib(
+ gradleVersion = gradleVersion
+ ) @JvmSerializableLambda {
+ iosArm64()
+ iosX64()
+ }
+
+ val expectedFragments = listOf(
+ Fragment(identifier="appleMain", targets=listOf("ios_arm64", "ios_x64")),
+ Fragment(identifier="commonMain", targets=listOf("ios_arm64", "ios_x64")),
+ Fragment(identifier="iosArm64Main", targets=listOf("ios_arm64")),
+ Fragment(identifier="iosMain", targets=listOf("ios_arm64", "ios_x64")),
+ Fragment(identifier="iosX64Main", targets=listOf("ios_x64")),
+ Fragment(identifier="nativeMain", targets=listOf("ios_arm64", "ios_x64")),
+ )
+
+ assertEquals(
+ Umanifest(expectedFragments),
+ publisher.umanifest,
+ )
+ assertEquals(
+ expectedFragments.map { it.identifier }.toSet(),
+ publisher.uklibContents.listDirectoryEntries().map {
+ it.name
+ }.filterNot { it == Uklib.UMANIFEST_FILE_NAME }.toSet(),
+ )
+ }
+
+ @GradleAndroidTest
+ fun `uklib publication - with AGP`(
+ gradleVersion: GradleVersion,
+ agpVersion: String,
+ ) {
+ val publisher = publishUklib(
+ template = "buildScriptInjectionGroovyWithAGP",
+ gradleVersion = gradleVersion,
+ agpVersion = agpVersion,
+ ) @JvmSerializableLambda {
+ project.plugins.apply("com.android.library")
+ iosArm64()
+ androidTarget()
+
+ with(project.extensions.getByType(BaseExtension::class.java)) {
+ compileSdkVersion(23)
+ namespace = "kotlin.multiplatform.projects"
+ }
+ }
+
+ val expectedFragments = listOf(
+ Fragment(identifier="commonMain", targets=listOf("android", "ios_arm64")),
+ Fragment(identifier="iosArm64Main", targets=listOf("ios_arm64")),
+ )
+
+ assertEquals(
+ Umanifest(expectedFragments),
+ publisher.umanifest,
+ )
+ assertEquals(
+ expectedFragments.map { it.identifier }.toSet(),
+ publisher.uklibContents.listDirectoryEntries().map {
+ it.name
+ }.filterNot { it == Uklib.UMANIFEST_FILE_NAME }.toSet(),
+ )
+ }
+
+ // FIXME: Lift this to FT
+ @GradleTest
+ fun `uklib publication - with externalTarget`(
+ gradleVersion: GradleVersion
+ ) {
+ project(
+ "buildScriptInjectionGroovy",
+ gradleVersion,
+ ) {
+ val publicationRepo: Project.() -> Directory = @JvmSerializableLambda{ project.layout.projectDirectory.dir("repo") }
+ buildScriptInjection {
+ // FIXME: Enable cross compilation
+ project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB, true.toString())
+
+ project.plugins.apply("org.jetbrains.kotlin.multiplatform")
+ project.plugins.apply("maven-publish")
+
+ project.group = "foo"
+ project.version = "1.0"
+
+ with(kotlinMultiplatform) {
+ class FakeCompilation(delegate: Delegate) : DecoratedExternalKotlinCompilation(delegate) {
+ @Suppress("UNCHECKED_CAST", "DEPRECATION")
+ override val compilerOptions: HasCompilerOptions<KotlinJvmCompilerOptions>
+ get() = super.compilerOptions as HasCompilerOptions<KotlinJvmCompilerOptions>
+ }
+
+ class FakeTarget(delegate: Delegate) : DecoratedExternalKotlinTarget(delegate),
+ HasConfigurableKotlinCompilerOptions<KotlinJvmCompilerOptions> {
+
+ @Suppress("UNCHECKED_CAST")
+ override val compilations: NamedDomainObjectContainer<FakeCompilation>
+ get() = super.compilations as NamedDomainObjectContainer<FakeCompilation>
+
+ override val compilerOptions: KotlinJvmCompilerOptions
+ get() = super.compilerOptions as KotlinJvmCompilerOptions
+ }
+
+ fun ExternalKotlinTargetDescriptorBuilder<FakeTarget>.defaults() {
+ targetName = "fake"
+ platformType = KotlinPlatformType.jvm
+ targetFactory = ExternalKotlinTargetDescriptor.TargetFactory(::FakeTarget)
+ }
+
+ fun ExternalKotlinCompilationDescriptorBuilder<FakeCompilation>.defaults(
+ kotlin: KotlinMultiplatformExtension,
+ name: String = KotlinCompilation.MAIN_COMPILATION_NAME,
+ ) {
+ compilationName = name
+ compilationFactory = ExternalKotlinCompilationDescriptor.CompilationFactory(::FakeCompilation)
+ defaultSourceSet = kotlin.sourceSets.maybeCreate(name)
+ }
+
+ iosArm64()
+ iosX64()
+ val kotlin = this
+ createExternalKotlinTarget {
+ defaults()
+ }.createCompilation { defaults(kotlin) }
+
+ sourceSets.all {
+ it.addIdentifierClass(SourceSetIdentifier(it.name))
+ }
+ }
+
+ val publishingExtension = project.extensions.getByType(PublishingExtension::class.java)
+ publishingExtension.repositories.maven {
+ it.url = project.uri(project.publicationRepo())
+ }
+ }
+
+ buildAndFail("publishAllPublicationsToMavenRepository") {
+ assertOutputContains("FIXME: This is explicitly unsupported")
+ }
+ }
+ }
+
+ @kotlinx.serialization.Serializable
+ data class Fragment(
+ val identifier: String,
+ val targets: List<String>,
+ )
+ @kotlinx.serialization.Serializable
+ data class Umanifest(
+ val fragments: List<Fragment>,
+ )
+
+ data class UklibProducer(
+ val uklibContents: Path,
+ val umanifest: Umanifest,
+ ) : Serializable
+
+ private fun publishUklib(
+ template: String = "buildScriptInjectionGroovy",
+ gradleVersion: GradleVersion,
+ agpVersion: String? = null,
+ publisherConfiguration: KotlinMultiplatformExtension.() -> Unit,
+ ): UklibProducer {
+ val publisherGroup = "foo"
+ val publisherVersion = "1.0"
+ val publisherName = "producer"
+ var repository: File? = null
+ project(
+ template,
+ gradleVersion,
+ projectPathAdditionalSuffix = publisherName,
+ ) {
+ val publicationRepo: Project.() -> Directory = @JvmSerializableLambda{ project.layout.projectDirectory.dir("repo") }
+ buildScriptInjection {
+ // FIXME: Enable cross compilation
+ project.propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB, true.toString())
+
+ project.plugins.apply("org.jetbrains.kotlin.multiplatform")
+ project.plugins.apply("maven-publish")
+
+ project.group = publisherGroup
+ project.version = publisherVersion
+
+ with(kotlinMultiplatform) {
+ // Add a source to all source sets
+ publisherConfiguration()
+
+ sourceSets.all {
+ it.addIdentifierClass(SourceSetIdentifier(it.name))
+ }
+ }
+
+ val publishingExtension = project.extensions.getByType(PublishingExtension::class.java)
+ publishingExtension.repositories.maven {
+ it.url = project.uri(project.publicationRepo())
+ }
+ }
+
+ build(
+ "publishAllPublicationsToMavenRepository",
+ buildOptions = defaultBuildOptions.copy(androidVersion = agpVersion),
+ )
+
+ repository = buildScriptReturn {
+ project.publicationRepo().asFile
+ }.buildAndReturn(
+ deriveBuildOptions = { defaultBuildOptions.copy(androidVersion = agpVersion) }
+ )
+ }
+
+ val uklibPath = repository!!
+ .resolve(publisherGroup).resolve(publisherName).resolve(publisherVersion)
+ .resolve("${publisherName}-${publisherVersion}.uklib").toPath()
+
+ assertFileExists(uklibPath)
+
+ val uklibContents = repository!!.resolve("uklibContents").toPath()
+ uklibContents.createDirectory()
+ unzip(
+ uklibPath,
+ uklibContents,
+ ""
+ )
+
+ return UklibProducer(
+ uklibContents = uklibContents,
+ umanifest = Json.decodeFromStream<Umanifest>(
+ FileInputStream(uklibContents.resolve("umanifest").toFile())
+ )
+ )
+ }
+
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/gradleRunningUtils.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/gradleRunningUtils.kt
index e682538..a65373a 100644
--- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/gradleRunningUtils.kt
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/gradleRunningUtils.kt
@@ -9,7 +9,7 @@
class ProcessRunResult(
private val cmd: List<String>,
- private val workingDir: File,
+ private val workingDir: File?,
val exitCode: Int,
val output: String,
val stdErr: String,
@@ -20,20 +20,22 @@
override fun toString(): String = """
Executing process was ${if (isSuccessful) "successful" else "unsuccessful"}
Command: ${cmd.joinToString()}
- Working directory: ${workingDir.absolutePath}
+ Working directory: ${workingDir?.absolutePath}
Exit code: $exitCode
"""
}
fun runProcess(
cmd: List<String>,
- workingDir: File,
+ workingDir: File?,
environmentVariables: Map<String, String> = mapOf(),
redirectErrorStream: Boolean = true,
): ProcessRunResult {
val builder = ProcessBuilder(cmd)
builder.environment().putAll(environmentVariables)
- builder.directory(workingDir)
+ workingDir?.let {
+ builder.directory(it)
+ }
// redirectErrorStream merges stdout and stderr, so it can be gotten from process.inputStream
builder.redirectErrorStream(redirectErrorStream)
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/buildScriptInjectionGroovyWithAGP/build.gradle b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/buildScriptInjectionGroovyWithAGP/build.gradle
new file mode 100644
index 0000000..ab3f872
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/buildScriptInjectionGroovyWithAGP/build.gradle
@@ -0,0 +1,4 @@
+plugins {
+ id("org.jetbrains.kotlin.multiplatform") apply false
+ id("com.android.library") apply false
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/build.gradle.kts
new file mode 100644
index 0000000..7bb3986
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/build.gradle.kts
@@ -0,0 +1,4 @@
+plugins {
+ kotlin("multiplatform")
+ `maven-publish`
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/gradle.properties b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/gradle.properties
new file mode 100644
index 0000000..9ca8278
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/gradle.properties
@@ -0,0 +1 @@
+kotlin.mpp.enableUklibs=true
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/appleMain/kotlin/Apple.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/appleMain/kotlin/Apple.kt
new file mode 100644
index 0000000..7ee6903
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/appleMain/kotlin/Apple.kt
@@ -0,0 +1,2 @@
+class Apple {
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/commonMain/kotlin/Common.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/commonMain/kotlin/Common.kt
new file mode 100644
index 0000000..c86db65
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/commonMain/kotlin/Common.kt
@@ -0,0 +1,2 @@
+class Common {
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/linuxMain/kotlin/Linux.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/linuxMain/kotlin/Linux.kt
new file mode 100644
index 0000000..0ab4450
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/uklibs/src/linuxMain/kotlin/Linux.kt
@@ -0,0 +1,2 @@
+class Linux {
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin/build.gradle.kts
index ff587bb..26b8d22 100644
--- a/libraries/tools/kotlin-gradle-plugin/build.gradle.kts
+++ b/libraries/tools/kotlin-gradle-plugin/build.gradle.kts
@@ -214,6 +214,7 @@
testImplementation(project(":kotlin-gradle-statistics"))
testImplementation(project(":kotlin-tooling-metadata"))
testImplementation(libs.lincheck)
+ testImplementation(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }
}
configurations.commonCompileClasspath.get().exclude("org.jetbrains.kotlinx", "kotlinx-coroutines-core")
@@ -293,58 +294,58 @@
*/
pivotVersion = KotlinMetadataPivotVersion(1, 6, 0)
}
- asmDeprecation {
- val exclusions = listOf(
- "org.jetbrains.kotlin.gradle.**", // part of the plugin
- "org.jetbrains.kotlin.project.model.**", // part of the plugin
- "org.jetbrains.kotlin.statistics.**", // part of the plugin
- "org.jetbrains.kotlin.tooling.**", // part of the plugin
- "org.jetbrains.kotlin.org.**", // already shadowed dependencies
- "org.jetbrains.kotlin.com.**", // already shadowed dependencies
- "org.jetbrains.kotlin.it.unimi.**", // already shadowed dependencies
- "org.jetbrains.kotlin.internal.**", // already internal package
- )
- val deprecationMessage = """
- You're using a Kotlin compiler class bundled into KGP for its internal needs.
- This is discouraged and will not be supported in future releases.
- The class in this artifact is scheduled for removal in Kotlin 2.2. Please define dependency on it in an alternative way.
- See https://kotl.in/gradle/internal-compiler-symbols for more details
- """.trimIndent()
- deprecateClassesByPattern("org.jetbrains.kotlin.**", deprecationMessage, exclusions)
- }
+// asmDeprecation {
+// val exclusions = listOf(
+// "org.jetbrains.kotlin.gradle.**", // part of the plugin
+// "org.jetbrains.kotlin.project.model.**", // part of the plugin
+// "org.jetbrains.kotlin.statistics.**", // part of the plugin
+// "org.jetbrains.kotlin.tooling.**", // part of the plugin
+// "org.jetbrains.kotlin.org.**", // already shadowed dependencies
+// "org.jetbrains.kotlin.com.**", // already shadowed dependencies
+// "org.jetbrains.kotlin.it.unimi.**", // already shadowed dependencies
+// "org.jetbrains.kotlin.internal.**", // already internal package
+// )
+// val deprecationMessage = """
+// You're using a Kotlin compiler class bundled into KGP for its internal needs.
+// This is discouraged and will not be supported in future releases.
+// The class in this artifact is scheduled for removal in Kotlin 2.2. Please define dependency on it in an alternative way.
+// See https://kotl.in/gradle/internal-compiler-symbols for more details
+// """.trimIndent()
+// deprecateClassesByPattern("org.jetbrains.kotlin.**", deprecationMessage, exclusions)
+// }
}
- GradlePluginVariant.values().forEach { variant ->
- if (kotlinBuildProperties.isInJpsBuildIdeaSync) return@forEach
- val sourceSet = sourceSets.getByName(variant.sourceSetName)
- val taskSuffix = sourceSet.jarTaskName.capitalize()
- val shadowJarTaskName = "$EMBEDDABLE_COMPILER_TASK_NAME$taskSuffix"
- asmDeprecation {
- val dumpTask = registerDumpDeprecationsTask(shadowJarTaskName, taskSuffix)
- val dumpAllTask = getOrCreateTask<Task>("dumpDeprecations") {
- dependsOn(dumpTask)
- }
- val expectedFileDoesNotExistMessage = """
- The file with expected deprecations for the compiler modules bundled into KGP does not exist.
- Run ./gradlew ${project.path}:${dumpTask.name} first to create it.
- You may also use ./gradlew ${project.path}:${dumpAllTask.name} to dump deprecations of all fat jars.
- Context: https://youtrack.jetbrains.com/issue/KT-70251
- """.trimIndent()
- val checkFailureMessage = """
- Expected deprecations applied to the compiler modules bundled into KGP does not match with the actually applied ones.
- Run ./gradlew ${project.path}:${dumpTask.name} to see the difference.
- You may also use ./gradlew ${project.path}:${dumpAllTask.name} to dump deprecations of all fat jars.
- Use INFO level log for the exact deprecated classes set.
- Either commit the difference or adjust the package relocation rules in ${buildFile.absolutePath}
- Please be sure to leave a comment explaining any changes related to this failure clear enough.
- Context: https://youtrack.jetbrains.com/issue/KT-70251
- """.trimIndent()
- val checkTask =
- registerCheckDeprecationsTask(shadowJarTaskName, taskSuffix, expectedFileDoesNotExistMessage, checkFailureMessage)
- named("check") {
- dependsOn(checkTask)
- }
- }
- }
+// GradlePluginVariant.values().forEach {
+// if (kotlinBuildProperties.isInJpsBuildIdeaSync) return@forEach
+// val sourceSet = sourceSets.getByName(variant.sourceSetName)
+// val taskSuffix = sourceSet.jarTaskName.capitalize()
+// val shadowJarTaskName = "$EMBEDDABLE_COMPILER_TASK_NAME$taskSuffix"
+// asmDeprecation {
+// val dumpTask = registerDumpDeprecationsTask(shadowJarTaskName, taskSuffix)
+// val dumpAllTask = getOrCreateTask<Task>("dumpDeprecations") {
+// dependsOn(dumpTask)
+// }
+// val expectedFileDoesNotExistMessage = """
+// The file with expected deprecations for the compiler modules bundled into KGP does not exist.
+// Run ./gradlew ${project.path}:${dumpTask.name} first to create it.
+// You may also use ./gradlew ${project.path}:${dumpAllTask.name} to dump deprecations of all fat jars.
+// Context: https://youtrack.jetbrains.com/issue/KT-70251
+// """.trimIndent()
+// val checkFailureMessage = """
+// Expected deprecations applied to the compiler modules bundled into KGP does not match with the actually applied ones.
+// Run ./gradlew ${project.path}:${dumpTask.name} to see the difference.
+// You may also use ./gradlew ${project.path}:${dumpAllTask.name} to dump deprecations of all fat jars.
+// Use INFO level log for the exact deprecated classes set.
+// Either commit the difference or adjust the package relocation rules in ${buildFile.absolutePath}
+// Please be sure to leave a comment explaining any changes related to this failure clear enough.
+// Context: https://youtrack.jetbrains.com/issue/KT-70251
+// """.trimIndent()
+// val checkTask =
+// registerCheckDeprecationsTask(shadowJarTaskName, taskSuffix, expectedFileDoesNotExistMessage, checkFailureMessage)
+// named("check") {
+// dependsOn(checkTask)
+// }
+// }
+// }
}
tasks.named("validatePlugins") {
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinMetadataArtifact.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinMetadataArtifact.kt
index 09d480f2..4b456b7 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinMetadataArtifact.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinMetadataArtifact.kt
@@ -5,12 +5,19 @@
package org.jetbrains.kotlin.gradle.artifacts
+import org.gradle.api.Project
import org.gradle.api.artifacts.type.ArtifactTypeDefinition.JAR_TYPE
import org.gradle.api.attributes.Category
import org.gradle.api.attributes.Usage
+import org.gradle.api.file.FileCollection
+import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.UklibFragmentPlatformAttribute
+import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.uklibFragmentPlatformAttribute
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
import org.jetbrains.kotlin.gradle.plugin.categoryByName
import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
import org.jetbrains.kotlin.gradle.plugin.usageByName
+import org.jetbrains.kotlin.gradle.targets.metadata.awaitMetadataCompilationsCreated
import org.jetbrains.kotlin.gradle.targets.metadata.isCompatibilityMetadataVariantEnabled
import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
import org.jetbrains.kotlin.gradle.targets.metadata.locateOrRegisterGenerateProjectStructureMetadataTask
@@ -40,13 +47,12 @@
/* Include output of metadata compilations into metadata jar (including commonizer output if available */
val hostSpecificSourceSets = getHostSpecificSourceSets(target.project)
- target.compilations.all { compilation ->
- /* Filter legacy compilation */
- if (compilation is KotlinCommonCompilation && !compilation.isKlibCompilation) return@all
+ // FIXME: How are test compilations filtered out ????
+ target.publishedMetadataCompilations().filter {
/* Filter 'host specific' source sets (aka source sets that require a certain host to compile metadata) */
- if (compilation.defaultSourceSet in hostSpecificSourceSets) return@all
-
- metadataJarTask.configure { it.from(compilation.output.classesDirs) { spec -> spec.into(compilation.defaultSourceSet.name) } }
+ it.defaultSourceSet !in hostSpecificSourceSets
+ }.forEach { compilation ->
+ metadataJarTask.configure { it.from(compilation.metadataPublishedArtifacts) { spec -> spec.into(compilation.metadataFragmentIdentifier) } }
if (compilation is KotlinSharedNativeCompilation) {
target.project.includeCommonizedCInteropMetadata(metadataJarTask, compilation)
}
@@ -54,3 +60,18 @@
target.createPublishArtifact(metadataJarTask, JAR_TYPE, apiElements)
}
+
+internal suspend fun KotlinMetadataTarget.publishedMetadataCompilations(): List<KotlinCompilation<*>> {
+ return awaitMetadataCompilationsCreated().filter { compilation ->
+ /* Filter legacy compilation */
+ !(compilation is KotlinCommonCompilation && !compilation.isKlibCompilation)
+ }
+}
+
+internal val KotlinCompilation<*>.metadataPublishedArtifacts: FileCollection get() = output.classesDirs
+// FIXME: Use this everywhere we map between fragment name in PSM and the name of disk
+internal val KotlinCompilation<*>.metadataFragmentIdentifier: String get() = defaultSourceSet.name
+internal val KotlinCompilation<*>.metadataFragmentAttributes: Set<UklibFragmentPlatformAttribute> get() = defaultSourceSet.internal.compilations
+ .filterNot {
+ it is KotlinMetadataCompilation
+ }.map { it.uklibFragmentPlatformAttribute }.toSet()
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinNativeKlibArtifact.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinNativeKlibArtifact.kt
index 415f2eb..199dc82 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinNativeKlibArtifact.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinNativeKlibArtifact.kt
@@ -95,6 +95,7 @@
} else {
klibProducingTask.flatMap { it.klibFile }
}
+ // FIXME: Что такое DefaultArtifactPublicationSet?
with(compilation.project.configurations.getByName(apiElementsName)) {
outgoing.registerKlibArtifact(packedArtifactFile, compilation.compilationName, classifier)
attributes.setAttribute(ArtifactTypeDefinition.ARTIFACT_TYPE_ATTRIBUTE, NativeArtifactFormat.KLIB) // should we do it here?
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinUklibConsumptionSetupAction.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinUklibConsumptionSetupAction.kt
index 3972652..0b9541d 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinUklibConsumptionSetupAction.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/KotlinUklibConsumptionSetupAction.kt
@@ -5,202 +5,142 @@
package org.jetbrains.kotlin.gradle.artifacts
+import org.gradle.api.NamedDomainObjectCollection
+import org.gradle.api.NamedDomainObjectContainer
import org.gradle.api.Project
import org.gradle.api.artifacts.transform.InputArtifact
import org.gradle.api.artifacts.transform.TransformAction
import org.gradle.api.artifacts.transform.TransformOutputs
import org.gradle.api.artifacts.transform.TransformParameters
import org.gradle.api.attributes.*
-import org.gradle.api.attributes.java.TargetJvmEnvironment
import org.gradle.api.file.*
import org.gradle.api.provider.Property
import org.gradle.api.provider.Provider
-import org.gradle.api.provider.SetProperty
import org.gradle.api.tasks.Input
-import org.jetbrains.kotlin.*
-import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.setupPublication
-import org.jetbrains.kotlin.gradle.dsl.awaitMetadataTarget
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
+import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.uklibFragmentPlatformAttribute
import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
import org.jetbrains.kotlin.gradle.plugin.*
import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle.Stage.AfterFinaliseCompilations
-import org.jetbrains.kotlin.gradle.plugin.KotlinProjectSetupAction
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
-import org.jetbrains.kotlin.gradle.plugin.attributes.KlibPackaging
-import org.jetbrains.kotlin.gradle.plugin.await
-import org.jetbrains.kotlin.gradle.plugin.diagnostics.KotlinToolingDiagnostics
-import org.jetbrains.kotlin.gradle.plugin.diagnostics.reportDiagnostic
-import org.jetbrains.kotlin.gradle.plugin.launch
import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.publishing.configureResourcesPublicationAttributes
import org.jetbrains.kotlin.gradle.plugin.sources.internal
import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
import org.jetbrains.kotlin.gradle.utils.named
import org.jetbrains.kotlin.gradle.utils.setAttribute
import javax.inject.Inject
-private val artifactType: Attribute<String> get() = Attribute.of("artifactType", String::class.java)
-private val uklibArtifactType: String get() = "uklib"
-private val uklibUnzippedArtifactType: String get() = "uklib-unzipped"
-
internal val KotlinUklibConsumptionSetupAction = KotlinProjectSetupAction {
-
- if (project.kotlinPropertiesProvider.publishUklibVariant) {
- project.launch {
- setupPublication()
- }
- }
-
when (project.kotlinPropertiesProvider.uklibResolutionStrategy) {
- UklibResolutionStrategy.PreferUklibVariant,
- UklibResolutionStrategy.PreferPlatformSpecificVariant -> project.launch { setupConsumption() }
+ UklibResolutionStrategy.AllowResolvingUklibs -> project.launch { setupUklibConsumption() }
UklibResolutionStrategy.ResolveOnlyPlatformSpecificVariant -> { /* do nothing */ }
}
}
-val uklibStateAttribute = Attribute.of("uklibState", String::class.java)
-val uklibStateZipped = "zipped"
-val uklibStateUnzipped = "unzipped"
+internal val uklibStateAttribute = Attribute.of("uklibState", String::class.java)
+internal val uklibStateZipped = "zipped"
+internal val uklibStateUnzipped = "unzipped"
-val uklibPlatformAttribute = Attribute.of("uklibPlatform", String::class.java)
-val uklibPlatformUnknown = "unknown"
-val uklibNativeSliceAttribute = Attribute.of("uklibNativeSlice", String::class.java)
-val uklibNativeSliceUnknown = "unknown"
+internal val uklibDestinationAttribute = Attribute.of("uklibDestination", String::class.java)
+internal val uklibDestinationUnknown = "unknown"
-private suspend fun Project.setupConsumption() {
+/**
+ * Resolve Uklib artifacts using transforms:
+ * - Request a known [uklibDestinationAttribute] in all resolvable configurations that should be able to resolve uklibs
+ * - Register transform "zipped -> unzipped uklib"
+ * - Register transform "unzipped uklib -> [uklibDestinationAttribute]"
+ */
+private suspend fun Project.setupUklibConsumption() {
val sourceSets = multiplatformExtension.awaitSourceSets()
- val metadataTarget = multiplatformExtension.awaitMetadataTarget()
val targets = multiplatformExtension.awaitTargets()
AfterFinaliseCompilations.await()
- sourceSets.configureEach {
- with(it.internal.resolvableMetadataConfiguration) {
- attributes {
- when (project.kotlinPropertiesProvider.uklibResolutionStrategy) {
- UklibResolutionStrategy.PreferUklibVariant -> it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(KotlinUsages.KOTLIN_UKLIB))
- UklibResolutionStrategy.PreferPlatformSpecificVariant -> {
- /* rely on the default + compatibility rule */
- }
- }
- it.attribute(uklibStateAttribute, uklibStateUnzipped)
- it.attribute(uklibPlatformAttribute, KotlinPlatformType.common.name)
- }
- }
- }
- // FIXME: Drop this transform and use the unzip transform instead
- dependencies.registerTransform(UnzippedUklibToMetadataCompilationTransform::class.java) {
- it.from
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, uklibPlatformUnknown)
- it.to
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, KotlinPlatformType.common.name)
- }
+ registerZippedUklibArtifact()
+ allowUklibsToUnzip()
+ allowMetadataConfigurationsToResolveUnzippedUklib(sourceSets)
+ allowPlatformCompilationsToResolvePlatformCompilationArtifactFromUklib(targets)
+}
+private fun Project.allowPlatformCompilationsToResolvePlatformCompilationArtifactFromUklib(
+ targets: NamedDomainObjectCollection<KotlinTarget>
+) {
targets.configureEach { target ->
- if (target is KotlinMetadataTarget) return@configureEach
- if (target is KotlinNativeTarget) {
- dependencies.registerTransform(UnzippedUklibToPlatformCompilationTransform::class.java) {
- it.from
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, uklibPlatformUnknown)
- .attribute(uklibNativeSliceAttribute, uklibNativeSliceUnknown)
- it.to
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, target.platformType.name)
- .attribute(uklibNativeSliceAttribute, target.targetName)
+ val destinationAttribute = when (target) {
+ is KotlinNativeTarget -> target.uklibFragmentPlatformAttribute
+ is KotlinJsIrTarget -> target.uklibFragmentPlatformAttribute
+ is KotlinJvmTarget -> target.uklibFragmentPlatformAttribute
+ else -> return@configureEach
+ }
- it.parameters.targetAttributes.set(setOf(target.targetName))
- it.parameters.fakeTransform.set(kotlinPropertiesProvider.fakeUkibTransforms)
- }
- target.compilations.configureEach {
- listOfNotNull(
- it.internal.configurations.compileDependencyConfiguration,
- it.internal.configurations.runtimeDependencyConfiguration,
- ).forEach { config ->
- with(config.attributes) {
- when (project.kotlinPropertiesProvider.uklibResolutionStrategy) {
- UklibResolutionStrategy.PreferUklibVariant -> attribute(Usage.USAGE_ATTRIBUTE, objects.named(KotlinUsages.KOTLIN_UKLIB))
- UklibResolutionStrategy.PreferPlatformSpecificVariant -> {
- /* rely on the default + compatibility rule */
- }
- }
- attribute(uklibStateAttribute, uklibStateUnzipped)
- attribute(uklibPlatformAttribute, target.platformType.name)
- attribute(uklibNativeSliceAttribute, target.targetName)
- }
- }
- }
- } else {
- dependencies.registerTransform(UnzippedUklibToPlatformCompilationTransform::class.java) {
- it.from
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, uklibPlatformUnknown)
- it.to
- .attribute(uklibStateAttribute, uklibStateUnzipped)
- .attribute(uklibPlatformAttribute, target.platformType.name)
+ dependencies.registerTransform(UnzippedUklibToPlatformCompilationTransform::class.java) {
+ it.from
+ .attribute(uklibStateAttribute, uklibStateUnzipped)
+ .attribute(uklibDestinationAttribute, uklibDestinationUnknown)
+ it.to
+ .attribute(uklibStateAttribute, uklibStateUnzipped)
+ .attribute(uklibDestinationAttribute, destinationAttribute.unwrap())
- it.parameters.targetAttributes.set(setOf(target.targetName))
- it.parameters.fakeTransform.set(kotlinPropertiesProvider.fakeUkibTransforms)
- }
- target.compilations.configureEach {
- listOfNotNull(
- it.internal.configurations.compileDependencyConfiguration,
- it.internal.configurations.runtimeDependencyConfiguration,
- ).forEach { config ->
- with(config.attributes) {
- when (project.kotlinPropertiesProvider.uklibResolutionStrategy) {
- UklibResolutionStrategy.PreferUklibVariant -> attribute(Usage.USAGE_ATTRIBUTE, objects.named(KotlinUsages.KOTLIN_UKLIB))
- UklibResolutionStrategy.PreferPlatformSpecificVariant -> {
- /* rely on the default + compatibility rule */
- }
- }
+ it.parameters.targetFragmentAttribute.set(destinationAttribute.unwrap())
+ it.parameters.fakeTransform.set(kotlinPropertiesProvider.fakeUkibTransforms)
+ }
- attribute(uklibStateAttribute, uklibStateUnzipped)
- attribute(uklibPlatformAttribute, target.platformType.name)
- }
+ // FIXME: Refactor this and encode what configurations should be allowed to transform per KotlinTarget somewhere around [uklibFragmentPlatformAttribute]
+ target.compilations.configureEach {
+ listOfNotNull(
+ it.internal.configurations.compileDependencyConfiguration,
+ it.internal.configurations.runtimeDependencyConfiguration,
+ ).forEach {
+ it.attributes {
+ it.attribute(uklibStateAttribute, uklibStateUnzipped)
+ it.attribute(uklibDestinationAttribute, destinationAttribute.unwrap())
}
}
}
}
+}
- with(dependencies.artifactTypes.create("uklib").attributes) {
+private fun Project.registerZippedUklibArtifact() {
+ with(dependencies.artifactTypes.create(Uklib.UKLIB_EXTENSION).attributes) {
attribute(uklibStateAttribute, uklibStateZipped)
- attribute(uklibPlatformAttribute, uklibPlatformUnknown)
- attribute(uklibNativeSliceAttribute, uklibNativeSliceUnknown)
+ attribute(uklibDestinationAttribute, uklibDestinationUnknown)
}
+}
- dependencies.registerTransform(UklibUnzipTransform::class.java) {
+private fun Project.allowUklibsToUnzip() {
+ dependencies.registerTransform(UnzipUklibTransform::class.java) {
it.from.attribute(uklibStateAttribute, uklibStateZipped)
it.to.attribute(uklibStateAttribute, uklibStateUnzipped)
it.parameters.performUnzip.set(!kotlinPropertiesProvider.fakeUkibTransforms)
}
-
- dependencies.attributesSchema.attribute(Usage.USAGE_ATTRIBUTE).compatibilityRules.add(
- MakeUklibCompatibleWithPlatformCompilations::class.java
- )
- dependencies.attributesSchema.attribute(Usage.USAGE_ATTRIBUTE).compatibilityRules.add(
- MakePlatformCompilationsCompatibleWithUklibCompilations::class.java
- )
- dependencies.attributesSchema.attribute(Usage.USAGE_ATTRIBUTE).disambiguationRules.add(
- MakeJavaRuntimePreferableForUklibCompilations::class.java
- )
-
- dependencies.attributesSchema.attribute(KotlinPlatformType.attribute).compatibilityRules.add(
- MakePlatformCompatibleWithUklibs::class.java
- )
- dependencies.attributesSchema.attribute(KotlinNativeTarget.konanTargetAttribute).compatibilityRules.add(
- MakeKNSliceCompatibleWithUklibs::class.java
- )
- dependencies.attributesSchema.attribute(TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE).compatibilityRules.add(
- MakeTargetJvmEnvironmentCompatibleWithUklibs::class.java
- )
-
}
-abstract class UklibUnzipTransform @Inject constructor(
+private fun Project.allowMetadataConfigurationsToResolveUnzippedUklib(
+ sourceSets: NamedDomainObjectContainer<KotlinSourceSet>,
+) {
+ sourceSets.configureEach {
+ with(it.internal.resolvableMetadataConfiguration) {
+ attributes {
+ it.attribute(uklibStateAttribute, uklibStateUnzipped)
+ it.attribute(uklibDestinationAttribute, KotlinPlatformType.common.name)
+ }
+ }
+ }
+ dependencies.registerTransform(UnzippedUklibToMetadataCompilationTransform::class.java) {
+ it.from
+ .attribute(uklibStateAttribute, uklibStateUnzipped)
+ .attribute(uklibDestinationAttribute, uklibDestinationUnknown)
+ it.to
+ .attribute(uklibStateAttribute, uklibStateUnzipped)
+ .attribute(uklibDestinationAttribute, KotlinPlatformType.common.name)
+ }
+}
+
+
+internal abstract class UnzipUklibTransform @Inject constructor(
private val fileOperations: FileSystemOperations,
private val archiveOperations: ArchiveOperations,
-) : TransformAction<UklibUnzipTransform.Parameters> {
+) : TransformAction<UnzipUklibTransform.Parameters> {
interface Parameters : TransformParameters {
@get:Input
val performUnzip: Property<Boolean>
@@ -210,11 +150,14 @@
abstract val inputArtifact: Provider<FileSystemLocation>
override fun transform(outputs: TransformOutputs) {
- // FIXME: 25.11.2024 - When resolving a jar with uklib packaging Gradle comes here with the jar
val input = inputArtifact.get().asFile
- if (input.extension == "uklib") {
+ /**
+ * FIXME: Test this !!!
+ *
+ * Due to kotlin-api/runtime Usages being compatible with java Usages, we might see a jar in this transform
+ */
+ if (input.extension == Uklib.UKLIB_EXTENSION) {
val outputDir = outputs.dir("unzipped_uklib_${input.name}")
- // FIXME: 13.11.2024 - Throw this away because this is not really testable with UT?
if (parameters.performUnzip.get()) {
fileOperations.copy {
it.from(archiveOperations.zipTree(inputArtifact.get().asFile))
@@ -225,9 +168,7 @@
}
}
-abstract class UnzippedUklibToMetadataCompilationTransform @Inject constructor() : TransformAction<UnzippedUklibToMetadataCompilationTransform.Parameters> {
- interface Parameters : TransformParameters {}
-
+internal abstract class UnzippedUklibToMetadataCompilationTransform : TransformAction<TransformParameters.None> {
@get:InputArtifact
abstract val inputArtifact: Provider<FileSystemLocation>
@@ -236,11 +177,10 @@
}
}
-abstract class UnzippedUklibToPlatformCompilationTransform @Inject constructor(
-) : TransformAction<UnzippedUklibToPlatformCompilationTransform.Parameters> {
+internal abstract class UnzippedUklibToPlatformCompilationTransform : TransformAction<UnzippedUklibToPlatformCompilationTransform.Parameters> {
interface Parameters : TransformParameters {
@get:Input
- val targetAttributes: SetProperty<String>
+ val targetFragmentAttribute: Property<String>
@get:Input
val fakeTransform: Property<Boolean>
@@ -256,115 +196,45 @@
}
val unzippedUklib = inputArtifact.get().asFile
-
- val targetAttributes = parameters.targetAttributes.get()
- val uklib = Uklib.deserializeFromDirectory(unzippedUklib)
- // FIXME: Build up a Set<Attribute> -> Fragment instead?
- val platformFragments = uklib.module.fragments.filter { it.attributes == targetAttributes }
+ val targetFragmentAttribute = parameters.targetFragmentAttribute.get()
+ // FIXME: Build up a Set<Attribute> -> Fragment map instead?
+ val platformFragments = Uklib.deserializeFromDirectory(unzippedUklib)
+ .module.fragments
+ .filter { it.attributes == setOf(targetFragmentAttribute) }
if (platformFragments.isEmpty()) {
- // The fragment is just not there. Skip this dependency
- return
+ /**
+ * FIXME: Uklib spec mentions that there may be an intermediate fragment without refiners. Was this a crutch for kotlin-test? Should we check this case silently ignore this case here?
+ */
+ error("Couldn't resolve platform compilation artifact from ${unzippedUklib} failed. Needed fragment with attribute '${targetFragmentAttribute}', but only the following fragments were available ${platformFragments}")
}
if (platformFragments.size > 1) {
- error("Somehow more than one platform fragment matches platform attributes: ${platformFragments}")
+ error("Matched multiple fragments from ${unzippedUklib}, but was expecting to find exactly one. Found fragments: ${platformFragments}")
}
- outputs.dir(uklib.fragmentToArtifact[platformFragments.single().identifier]!!)
+ outputs.dir(platformFragments.single().file())
}
}
internal fun HasAttributes.configureUklibConfigurationAttributes(project: Project) {
attributes.setAttribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
attributes.setAttribute(Usage.USAGE_ATTRIBUTE, project.usageByName(KotlinUsages.KOTLIN_UKLIB))
-
- attributes.setAttribute(KotlinPlatformType.attribute, KotlinPlatformType.unknown)
- attributes.setAttribute(KotlinNativeTarget.konanTargetAttribute, "???")
- attributes.setAttribute(KlibPackaging.ATTRIBUTE, project.objects.named(KlibPackaging.PACKED))
- attributes.setAttribute(TargetJvmEnvironment.TARGET_JVM_ENVIRONMENT_ATTRIBUTE, project.objects.named("???"))
}
-
-class MakeUklibCompatibleWithPlatformCompilations : AttributeCompatibilityRule<Usage> {
- override fun execute(t: CompatibilityCheckDetails<Usage>) {
- val allowedConsumers = setOf(
- KotlinUsages.KOTLIN_API,
- Usage.JAVA_API,
- Usage.JAVA_RUNTIME,
- )
-
- if (t.producerValue?.name == KotlinUsages.KOTLIN_UKLIB && t.consumerValue?.name in allowedConsumers) {
- t.compatible()
- }
- }
-}
-
-class MakePlatformCompilationsCompatibleWithUklibCompilations : AttributeCompatibilityRule<Usage> {
- override fun execute(t: CompatibilityCheckDetails<Usage>) {
- val allowedProducers = setOf(
- KotlinUsages.KOTLIN_API,
- Usage.JAVA_API,
- Usage.JAVA_RUNTIME,
- )
-
- if (t.producerValue?.name in allowedProducers && t.consumerValue?.name == KotlinUsages.KOTLIN_UKLIB) {
- t.compatible()
- }
- }
-}
-
-class MakeKNSliceCompatibleWithUklibs : AttributeCompatibilityRule<String> {
- override fun execute(t: CompatibilityCheckDetails<String>) {
- if (t.producerValue == "???") {
- t.compatible()
- }
- }
-}
-
-class MakeTargetJvmEnvironmentCompatibleWithUklibs : AttributeCompatibilityRule<TargetJvmEnvironment> {
- override fun execute(t: CompatibilityCheckDetails<TargetJvmEnvironment>) {
- if (t.producerValue?.name == "???") {
- t.compatible()
- }
- }
-}
-
-
-class MakePlatformCompatibleWithUklibs : AttributeCompatibilityRule<KotlinPlatformType> {
- override fun execute(t: CompatibilityCheckDetails<KotlinPlatformType>) {
- if (t.producerValue == KotlinPlatformType.unknown) {
- t.compatible()
- }
- }
-}
-
-class MakeJavaRuntimePreferableForUklibCompilations : AttributeDisambiguationRule<Usage> {
- override fun execute(p0: MultipleCandidatesDetails<Usage>) {
- if (p0.consumerValue?.name == KotlinUsages.KOTLIN_UKLIB) {
- p0.candidateValues.firstOrNull { it.name == Usage.JAVA_RUNTIME }?.let {
- p0.closestMatch(it)
- }
- }
- }
-}
-
-enum class UklibResolutionStrategy {
- PreferUklibVariant,
- PreferPlatformSpecificVariant,
+internal enum class UklibResolutionStrategy {
+ AllowResolvingUklibs,
ResolveOnlyPlatformSpecificVariant;
val propertyName: String
get() = when (this) {
- PreferUklibVariant -> "preferUklibVariant"
- PreferPlatformSpecificVariant -> "preferPlatformSpecificVariant"
+ AllowResolvingUklibs -> "allowResolvingUklibs"
ResolveOnlyPlatformSpecificVariant -> "resolveOnlyPlatformSpecificVariant"
}
companion object {
fun fromProperty(name: String): UklibResolutionStrategy? = when (name) {
- PreferUklibVariant.propertyName -> PreferUklibVariant
- PreferPlatformSpecificVariant.propertyName -> PreferPlatformSpecificVariant
+ AllowResolvingUklibs.propertyName -> AllowResolvingUklibs
ResolveOnlyPlatformSpecificVariant.propertyName -> ResolveOnlyPlatformSpecificVariant
else -> null
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Resolve.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Resolve.kt
deleted file mode 100644
index 48212ee..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Resolve.kt
+++ /dev/null
@@ -1,214 +0,0 @@
-package org.jetbrains.kotlin
-
-import org.jetbrains.kotlin.tooling.core.withClosure
-import java.io.File
-
-/**
- * f1, f2, ... fN
- * ->
- * [
- * (f1, f1), (f1, f2), ... (f1, fn),
- * (f2, f1), (f2, f2), ... (f2, fn),
- * (fn, f1), (fn, f2), ... (fn, fn),
- * ]
- * ->
- * 1. Filter p[0].canSee(p[1])
- * 2. Sort visible fragments by canSee and then by name
- */
-
-// Compilation -> publishedFile: File
-inline fun <Compilation, Target, reified SourceSet> transformKGPModelToUklibModel(
- moduleIdentifier: String,
- publishedCompilations: List<Compilation>,
- publishedArtifact: Compilation.() -> File,
- defaultSourceSet: Compilation.() -> SourceSet,
- target: Compilation.() -> Target,
- dependsOn: SourceSet.() -> Set<SourceSet>,
- identifier: SourceSet.() -> String,
-// sourceSetArtifact: SourceSet.() -> Compilation,
-): Uklib<Target> {
- /**
- * 1. No parts of the graph are isolated
- * 2. There are no cycles (this is already done by KGP)
- * 3. Everything is rooted in a single node (already checked in KGP)
- * 4. There are no fragments with duplicated attributes
- */
- // Assume we did check everything
-
- val sourceSetToTargets = mutableMapOf<SourceSet, MutableSet<Target>>()
- val fragmentToArtifact = mutableMapOf<String, File>()
- val publishedSourceSets = publishedCompilations.map { it.defaultSourceSet() }.toSet()
- publishedCompilations.forEach { compilation ->
- val compilationTarget = compilation.target()
- compilation.defaultSourceSet().withClosure(dependsOn).filter { it in publishedSourceSets }.forEach { sourceSet ->
- sourceSetToTargets.getOrPut(
- sourceSet, { mutableSetOf() }
- ).add(compilationTarget)
- }
- fragmentToArtifact[compilation.defaultSourceSet().identifier()] = compilation.publishedArtifact()
- }
-
- return Uklib(
- module = Module(
- identifier = moduleIdentifier,
- fragments = sourceSetToTargets.map { (sourceSet, targets) ->
- Fragment(
- identifier = sourceSet.identifier(),
- attributes = targets,
- )
- }.toSet()
- ),
- fragmentToArtifact = fragmentToArtifact
- )
-}
-
-
-class ResolvedModuleClasspath<Target>(
- val fullFragmentClasspath: Map<Fragment<Target>, List<File>>,
- val exactlyMatchingFragmentClasspath: Map<Fragment<Target>, List<File>>,
-)
-
-
-fun <Target> resolveModuleFragmentClasspath(
- module: Uklib<Target>,
- dependencies: Set<Uklib<Target>>,
-): ResolvedModuleClasspath<Target> {
- val moduleFragments = module.module.fragments.toList()
- val fullFragmentClasspath = mutableMapOf<Fragment<Target>, MutableList<File>>()
- val exactFragmentClasspath = mutableMapOf<Fragment<Target>, MutableList<File>>()
- moduleFragments.forEach {
- fullFragmentClasspath[it] = mutableListOf()
- exactFragmentClasspath[it] = mutableListOf()
- }
-
- // FIXME: Do we ever want to resolve self fragments? Maybe we could refactor some KGP parts to better reflect this model, but not right now
-// resolveFragmentRefinersWithinModule(moduleFragments).forEach { (fragment, refiners) ->
-// fullFragmentClasspath.getOrPut(fragment, { mutableListOf() }).addAll(
-// refiners.map { module.fragmentToArtifact[it.identifier]!! }
-// )
-// }
-
- dependencies.forEach { dependency ->
- val dependencyFragments = dependency.module.fragments.toList()
- resolveFragmentDependencies(
- targetFragments = moduleFragments,
- dependencyFragments = dependencyFragments,
- ).forEach { (fragment, dependencies) ->
- fullFragmentClasspath[fragment]!!.addAll(
- dependencies.map {
- dependency.fragmentToArtifact[it.identifier]!!
- }
- )
- }
- resolvePlatformFragmentDependencies(
- targetPlatformFragments = moduleFragments,
- dependencyFragments = dependencyFragments,
- ).forEach { (fragment, dependencies) ->
- exactFragmentClasspath[fragment]!!.addAll(
- dependencies.map {
- dependency.fragmentToArtifact[it.identifier]!!
- }
- )
- }
- }
-
-
- return ResolvedModuleClasspath(
- fullFragmentClasspath = fullFragmentClasspath,
- exactlyMatchingFragmentClasspath = exactFragmentClasspath,
- )
-}
-
-/**
- * This function takes fragments of a module [moduleFragments] and outputs a map where the keys are [moduleFragments]
- * and the values are classpath-ordered refiners.
- */
-fun <Target> resolveFragmentRefinersWithinModule(
- moduleFragments: List<Fragment<Target>>,
-) = resolveFragmentDependencies(
- targetFragments = moduleFragments,
- dependencyFragments = moduleFragments,
- canSee = { attributes.isProperSubsetOf(it.attributes) }
-)
-
-/**
- * This function takes fragments [targetFragments] that depend on another module's fragments [dependencyFragments] and
- * outputs a map where the keys are [targetFragments] and the values are classpath-ordered [dependencyFragments] visible
- * from the target fragment
- */
-fun <Target> resolveFragmentDependencies(
- targetFragments: List<Fragment<Target>>,
- dependencyFragments: List<Fragment<Target>>,
-) = resolveFragmentDependencies(
- targetFragments = targetFragments,
- dependencyFragments = dependencyFragments,
- canSee = { attributes.isSubsetOf(it.attributes) }
-)
-
-/**
- * This function takes fragments [targetPlatformFragments] that depend on another module's fragments [dependencyFragments] and
- * outputs a map where the keys are [targetPlatformFragments] and the values are empty of single element lists of [dependencyFragments]
- * matching
- */
-fun <Target> resolvePlatformFragmentDependencies(
- targetPlatformFragments: List<Fragment<Target>>,
- dependencyFragments: List<Fragment<Target>>,
-) = resolveFragmentDependencies(
- targetFragments = targetPlatformFragments,
- dependencyFragments = dependencyFragments,
- canSee = { attributes == it.attributes }
-)
-
-fun <Target> resolveFragmentDependencies(
- targetFragments: List<Fragment<Target>>,
- dependencyFragments: List<Fragment<Target>>,
- canSee: Fragment<Target>.(Fragment<Target>) -> Boolean,
-): Map<Fragment<Target>, List<Fragment<Target>>> {
- val modulesFragmentClasspath = mutableMapOf<Fragment<Target>, List<Fragment<Target>>>()
- targetFragments.forEach { fragment ->
- val fragmentClasspath = dependencyFragments.filter {
- fragment.canSee(it)
- }.sortedWith(
- object : Comparator<Fragment<Target>> {
- override fun compare(left: Fragment<Target>, right: Fragment<Target>): Int {
- if (left.canSee(right)) {
- return -1
- } else if (right.canSee(left)) {
- return 1
- } else if (left == right) {
- return 0
- } else {
- /**
- * The target fragment can see left and right, but the fragments are incomparable. For example in:
- * ab; bc; b -> ab; b -> bc;
- * b can see ab and bc, but ab and bc are incomparable
- */
- return left.identifier.compareTo(right.identifier)
- }
- }
- }
- )
- modulesFragmentClasspath[fragment] = fragmentClasspath
- }
- return modulesFragmentClasspath
-}
-
-data class Module<Target>(
- // Do we even need this identifier
- val identifier: String,
- val fragments: Set<Fragment<Target>>,
-) {
-// override fun hashCode(): Int = identifier.hashCode()
-// override fun equals(other: Any?): Boolean = identifier.equals(other?.toString())
-}
-
-data class Fragment<Target>(
- val identifier: String,
- val attributes: Set<Target>,
-) {
-// override fun hashCode(): Int = attributes.hashCode()
-// override fun equals(other: Any?): Boolean = other is Fragment<*> && attributes.equals(other.attributes)
-}
-
-fun <E> Set<E>.isProperSubsetOf(another: Set<E>): Boolean = another.size > size && isSubsetOf(another)
-fun <E> Set<E>.isSubsetOf(another: Set<E>): Boolean = another.containsAll(this)
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Serialization.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Serialization.kt
deleted file mode 100644
index c65d9d8..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/Serialization.kt
+++ /dev/null
@@ -1,78 +0,0 @@
-package org.jetbrains.kotlin
-
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import java.io.File
-import java.nio.file.Path
-
-
-data class Uklib<Target>(
- val module: Module<Target>,
- val fragmentToArtifact: Map<String, File>,
-) {
- fun serializeUklibToArchive(
- outputZip: File,
- temporariesDirectory: File,
- serializeTarget: Target.() -> String = { this.toString() },
- ) {
- val gson = GsonBuilder().setPrettyPrinting().create()
- val manifest = gson.toJson(
- mapOf(
- "identifier" to module.identifier,
- // FIXME: How are we actually going to handle default target hierarchy cause bamboos?
- "fragments" to module.fragments.filter { fragmentToArtifact[it.identifier]!!.exists() }.map {
- mapOf(
- "identifier" to it.identifier,
- "targets" to it.attributes.map(serializeTarget),
- )
- }
- )
- )
- zipFragments(
- manifest = manifest,
- fragmentToArtifact = fragmentToArtifact.filter { it.value.exists() },
- outputZip = outputZip,
- temporariesDirectory = temporariesDirectory,
- )
- }
-
- companion object {
- fun deserializeFromArchive(
- archive: File,
- unarchiveDirectory: Path,
- ): Uklib<String> {
- unzip(
- zipFilePath = archive,
- outputFolderPath = unarchiveDirectory.toFile(),
- )
- return deserializeFromDirectory(
- unarchiveDirectory.toFile()
- )
- }
-
- fun deserializeFromDirectory(directory: File): Uklib<String> {
- val manifest = directory.resolve("umanifest")
- if (!manifest.exists()) error("manifest doesn't exist")
- val gson = Gson()
- val map = gson.fromJson(manifest.readText(), Map::class.java) as Map<String, Any>
- val identifier = map["identifier"] as String
- val fragmentTokens = map["fragments"] as List<Map<String, Any>>
-
- val fragments = fragmentTokens.map {
- Fragment(
- identifier = it["identifier"] as String,
- attributes = (it["targets"] as List<String>).toSet(),
- )
- }.toSet()
- return Uklib(
- module = Module(
- identifier = identifier,
- fragments = fragments,
- ),
- fragmentToArtifact = fragments.map {
- it.identifier to directory.resolve(it.identifier)
- }.toMap()
- )
- }
- }
-}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibFragmentResolution.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibFragmentResolution.kt
new file mode 100644
index 0000000..cf8e533
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibFragmentResolution.kt
@@ -0,0 +1,23 @@
+package org.jetbrains.kotlin.gradle.artifacts.uklibsModel
+
+import java.io.File
+
+// /**
+// * 1. No parts of the graph are isolated
+// * 2. There are no cycles (this is already done by KGP)
+// * 3. Everything is rooted in a single node (already checked in KGP)
+// * 4. There are no fragments with duplicated attributes
+// */
+
+data class Module(
+ val fragments: Set<Fragment>,
+)
+
+data class Fragment(
+ val identifier: String,
+ val attributes: Set<String>,
+ val file: () -> File,
+)
+
+fun <E> Set<E>.isProperSubsetOf(another: Set<E>): Boolean = another.size > size && isSubsetOf(another)
+fun <E> Set<E>.isSubsetOf(another: Set<E>): Boolean = another.containsAll(this)
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerialization.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerialization.kt
new file mode 100644
index 0000000..274a961
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerialization.kt
@@ -0,0 +1,93 @@
+package org.jetbrains.kotlin.gradle.artifacts.uklibsModel
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import org.jetbrains.kotlin.zipFragments
+import java.io.File
+
+
+internal data class Uklib(
+ val module: Module,
+ // FIXME: Use this version for a forward compatibility?
+ val manifestVersion: String,
+) {
+ fun serializeUklibToArchive(
+ outputZip: File,
+ temporariesDirectory: File,
+ ) {
+ val manifest = GsonBuilder().setPrettyPrinting().create().toJson(
+ mapOf(
+ FRAGMENTS to module.fragments.filter {
+ // FIXME: Where was this coming from ???
+ //fragmentIdentifierToArtifact[it.identifier]!!.exists()
+ true
+ }.sortedBy {
+ // Make sure we have some stable order of fragments
+ it.identifier
+ }.map {
+ mapOf(
+ FRAGMENT_IDENTIFIER to it.identifier,
+ ATTRIBUTES to it.attributes
+ // Make sure we have some stable order of attributes
+ .sorted(),
+ )
+ },
+ UMANIFEST_VERSION to manifestVersion,
+ )
+ )
+ zipFragments(
+ manifest = manifest,
+ fragmentToArtifact = module.fragments.map {
+ it.identifier to it.file()
+ }.toMap(),
+ outputZip = outputZip,
+ temporariesDirectory = temporariesDirectory,
+ )
+ }
+
+ companion object {
+ fun deserializeFromDirectory(directory: File): Uklib {
+ val umanifest = directory.resolve(UMANIFEST_FILE_NAME)
+ if (!umanifest.exists()) error("Can't deserialize Uklib from ${directory} because ${UMANIFEST_FILE_NAME} doesn't exist")
+ val json = Gson().fromJson(umanifest.readText(), Map::class.java) as Map<String, Any>
+
+ val fragments = (json[FRAGMENTS] as List<Map<String, Any>>).map { fragment ->
+ val fragmentIdentifier = fragment[FRAGMENT_IDENTIFIER] as String
+ Fragment(
+ identifier = fragmentIdentifier,
+ attributes = (fragment[ATTRIBUTES] as List<String>).toSet(),
+ file = {
+ directory.resolve(fragmentIdentifier)
+ }
+ )
+ }.toHashSet()
+ return Uklib(
+ module = Module(
+ fragments = fragments,
+ ),
+ manifestVersion = json[UMANIFEST_VERSION] as String,
+ )
+ }
+
+ // Use this in diagnostics
+ const val UKLIB_NAME = "uklib"
+
+ // This extension has to be stable because we need to filter transitive jars in the transform
+ const val UKLIB_EXTENSION = "uklib"
+
+ /**
+ * The packaging must be equal to the extension because when resolving POM only components, Gradle prefers the artifact with the
+ * <packaging> POM value over the .jar (but falls back to jar if the artifact doesn't exist)
+ */
+ const val UKLIB_PACKAGING = UKLIB_EXTENSION
+
+ const val UMANIFEST_FILE_NAME = "umanifest"
+
+ const val FRAGMENTS = "fragments"
+ const val FRAGMENT_IDENTIFIER = "identifier"
+ const val ATTRIBUTES = "targets"
+ const val UMANIFEST_VERSION = "manifestVersion"
+
+ const val CURRENT_UMANIFEST_VERSION = "0.0.1"
+ }
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerializationUtils.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerializationUtils.kt
new file mode 100644
index 0000000..438e6b2
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/UklibSerializationUtils.kt
@@ -0,0 +1,100 @@
+package org.jetbrains.kotlin
+
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
+import org.jetbrains.kotlin.incremental.deleteDirectoryContents
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.nio.file.Files
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import java.util.zip.ZipOutputStream
+
+/**
+ * // FIXME: Test this!!!
+ *
+ * All of the rezipping happens at execution time in ArchiveUklibTask:
+ * - if the incoming fragment is a .klib or a .jar, just unzip it and zip into the .uklib zip
+ * - if the incoming fragment is a directory, probably it's an unpacked klib, so just copy it
+ */
+private val allowRepackingArchivesWithExtensions = setOf(
+ "klib",
+ "jar",
+)
+
+internal fun zipFragments(
+ manifest: String,
+ fragmentToArtifact: Map<String, File>,
+ outputZip: File,
+ temporariesDirectory: File,
+) {
+ ZipOutputStream(
+ BufferedOutputStream(
+ FileOutputStream(outputZip)
+ )
+ ).use { zipOutputStream ->
+ // Pack the manifest
+ zipOutputStream.putNextEntry(ZipEntry(Uklib.UMANIFEST_FILE_NAME))
+ manifest.byteInputStream().copyTo(zipOutputStream)
+
+ fragmentToArtifact.forEach { (identifier, file) ->
+ // Assume we are handling unpacked metadata and platform klibs
+ if (file.isDirectory) {
+ packDirectory(file, identifier, zipOutputStream)
+ } else if (file.extension in allowRepackingArchivesWithExtensions) {
+ val temp = temporariesDirectory.resolve(identifier)
+ if (temp.exists()) temp.deleteDirectoryContents()
+ temp.mkdirs()
+ unzip(
+ zipFilePath = file,
+ outputFolderPath = temp,
+ )
+ packDirectory(
+ directory = temp,
+ identifier = identifier,
+ zipOutputStream = zipOutputStream,
+ )
+ } else {
+ error("Trying to pack invalid file in uklib: ${file}")
+ }
+ }
+ zipOutputStream.closeEntry()
+ }
+}
+
+private fun packDirectory(
+ directory: File,
+ identifier: String,
+ zipOutputStream: ZipOutputStream
+) {
+ Files.walk(directory.toPath()).forEach { path ->
+ val zipEntry = ZipEntry(identifier + "/" + path.toFile().toRelativeString(directory))
+ if (!Files.isDirectory(path)) {
+ zipOutputStream.putNextEntry(zipEntry)
+ Files.newInputStream(path).use { inputStream ->
+ inputStream.copyTo(zipOutputStream)
+ }
+ zipOutputStream.closeEntry()
+ }
+ }
+}
+
+private fun unzip(zipFilePath: File, outputFolderPath: File) {
+ ZipInputStream(FileInputStream(zipFilePath)).use { zipInputStream ->
+ var zipEntry: ZipEntry? = zipInputStream.nextEntry
+ while (zipEntry != null) {
+ val newFile = File(outputFolderPath, zipEntry.name)
+ if (zipEntry.isDirectory) {
+ newFile.mkdirs()
+ } else {
+ newFile.parentFile?.mkdirs()
+ FileOutputStream(newFile).use { fileOutputStream ->
+ zipInputStream.copyTo(fileOutputStream)
+ }
+ }
+ zipEntry = zipInputStream.nextEntry
+ }
+ zipInputStream.closeEntry()
+ }
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/utils.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/utils.kt
deleted file mode 100644
index 7a84ac4..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsModel/utils.kt
+++ /dev/null
@@ -1,83 +0,0 @@
-package org.jetbrains.kotlin
-
-import org.jetbrains.kotlin.incremental.deleteDirectoryContents
-import java.io.BufferedOutputStream
-import java.io.File
-import java.io.FileInputStream
-import java.io.FileOutputStream
-import java.nio.file.Files
-import java.util.zip.ZipEntry
-import java.util.zip.ZipInputStream
-import java.util.zip.ZipOutputStream
-
-fun zipFragments(
- manifest: String,
- fragmentToArtifact: Map<String, File>,
- outputZip: File,
- temporariesDirectory: File,
-) {
- ZipOutputStream(BufferedOutputStream(FileOutputStream(outputZip))).use { zos ->
- fragmentToArtifact.forEach { (identifier, file) ->
- // Unpacked metadata classes
- if (file.isDirectory) {
- packDirectory(file, identifier, zos)
- } else if (file.extension == "klib") {
- val temp = temporariesDirectory.resolve(identifier)
- if (temp.exists()) temp.deleteDirectoryContents()
- temp.mkdirs()
- unzip(
- zipFilePath = file,
- outputFolderPath = temp,
- )
- packDirectory(
- directory = temp,
- identifier = identifier,
- zos = zos,
- )
- } else {
- error("Trying to pack invalid file in uklib: ${file}")
- }
- }
- zos.putNextEntry(ZipEntry("umanifest"))
- manifest.byteInputStream().copyTo(zos)
- zos.closeEntry()
- }
-}
-
-private fun packDirectory(
- directory: File,
- identifier: String,
- zos: ZipOutputStream
-) {
- Files.walk(directory.toPath()).forEach { path ->
- val zipEntry = ZipEntry(identifier + "/" + path.toFile().toRelativeString(directory))
- if (!Files.isDirectory(path)) {
- zos.putNextEntry(zipEntry)
- Files.newInputStream(path).use { inputStream ->
- inputStream.copyTo(zos)
- }
- zos.closeEntry()
- }
- }
-}
-
-fun unzip(zipFilePath: File, outputFolderPath: File) {
- val buffer = ByteArray(1024)
- ZipInputStream(FileInputStream(zipFilePath)).use { zis ->
- var zipEntry: ZipEntry? = zis.nextEntry
- while (zipEntry != null) {
- val newFile = File(outputFolderPath, zipEntry.name)
- if (zipEntry.isDirectory) {
- newFile.mkdirs()
- } else {
- newFile.parentFile?.mkdirs()
- FileOutputStream(newFile).use { fos ->
- zis.copyTo(fos)
- }
- }
- zipEntry = zis.nextEntry
- }
- zis.closeEntry()
- }
-}
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibArchiveTask.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/ArchiveUklibTask.kt
similarity index 82%
rename from libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibArchiveTask.kt
rename to libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/ArchiveUklibTask.kt
index 1c32e18..6f7e8e4 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibArchiveTask.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/ArchiveUklibTask.kt
@@ -12,16 +12,16 @@
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.TaskAction
-import org.jetbrains.kotlin.Uklib
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
import org.jetbrains.kotlin.gradle.utils.getFile
-internal abstract class UklibArchiveTask : DefaultTask() {
+internal abstract class ArchiveUklibTask : DefaultTask() {
@get:Internal
- abstract val model: Property<Uklib<String>>
+ abstract val model: Property<Uklib>
@get:OutputFile
val outputZip: RegularFileProperty = project.objects.fileProperty().convention(
- project.layout.buildDirectory.file("output.uklib")
+ project.layout.buildDirectory.file("package.${Uklib.UKLIB_EXTENSION}")
)
@get:Internal
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupPublication.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupPublication.kt
deleted file mode 100644
index c4a2ffe..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupPublication.kt
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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.artifacts.uklibsPublication
-
-import org.gradle.api.Project
-import org.gradle.api.attributes.Usage
-import org.jetbrains.kotlin.gradle.dsl.awaitMetadataTarget
-import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
-import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
-import org.jetbrains.kotlin.gradle.plugin.await
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
-import org.jetbrains.kotlin.gradle.tasks.dependsOn
-
-internal suspend fun Project.setupPublication() {
- val sourceSets = multiplatformExtension.awaitSourceSets()
- val metadataTarget = multiplatformExtension.awaitMetadataTarget()
- val targets = multiplatformExtension.awaitTargets()
- KotlinPluginLifecycle.Stage.AfterFinaliseCompilations.await()
-
- val packUklib = tasks.register("packUklib", UklibArchiveTask::class.java)
-
- val kgpModel = uklibFromKGPModel(
- targets = targets.toList(),
- onPublishCompilation = {
- packUklib.dependsOn(it.compileTaskProvider)
- }
- )
-
- packUklib.configure {
- it.model.set(kgpModel)
- }
- artifacts.add(metadataTarget.uklibElementsConfigurationName, packUklib)
-
- if (kotlinPropertiesProvider.disablePlatformSpecificComponentsReferences) {
- // FIXME: 20.11.2024 - ???
- configurations.configureEach {
- if (!it.isCanBeConsumed) return@configureEach
- if (it.attributes.getAttribute(Usage.USAGE_ATTRIBUTE)?.name != KotlinUsages.KOTLIN_UKLIB) {
- it.isCanBeConsumed = false
- }
- }
- }
-}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupUklibPublication.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupUklibPublication.kt
new file mode 100644
index 0000000..d09f7ec
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/SetupUklibPublication.kt
@@ -0,0 +1,53 @@
+/*
+ * 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.artifacts.uklibsPublication
+
+import org.gradle.api.Project
+import org.gradle.api.tasks.TaskProvider
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Module
+import org.jetbrains.kotlin.gradle.dsl.awaitMetadataTarget
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
+import org.jetbrains.kotlin.gradle.tasks.locateTask
+
+internal suspend fun Project.archiveUklibTask(): TaskProvider<ArchiveUklibTask> {
+ val taskName = "archiveUklib"
+ tasks.locateTask<ArchiveUklibTask>(taskName)?.let { return it }
+
+ val archiveUklib = tasks.register(taskName, ArchiveUklibTask::class.java)
+
+ val metadataTarget = multiplatformExtension.awaitMetadataTarget()
+ val allTargets = multiplatformExtension.awaitTargets().toMutableList()
+
+ val kgpFragments = kgpFragments(
+ metadataTarget = metadataTarget,
+ allTargets = allTargets,
+ )
+
+ kgpFragments.forEach { fragment ->
+ archiveUklib.configure {
+ // outputFile might be a directory or a file
+ it.inputs.files(fragment.outputFile)
+ // some outputFiles are derived from a project.provider, use explicit task dependency
+ it.dependsOn(fragment.providingTask)
+ }
+ }
+
+ archiveUklib.configure {
+ it.model.set(
+ Uklib(
+ module = Module(
+ fragments = kgpFragments.map {
+ it.fragment
+ }.toHashSet(),
+ ),
+ manifestVersion = Uklib.CURRENT_UMANIFEST_VERSION,
+ )
+ )
+ }
+
+ return archiveUklib
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibFromKGPModel.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibFromKGPModel.kt
index 78da1fa..fd31faa 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibFromKGPModel.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/artifacts/uklibsPublication/UklibFromKGPModel.kt
@@ -5,95 +5,193 @@
package org.jetbrains.kotlin.gradle.artifacts.uklibsPublication
-import org.jetbrains.kotlin.Uklib
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCommonCompilation
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMetadataTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.jvm.tasks.Jar
+import org.jetbrains.kotlin.gradle.artifacts.metadataFragmentAttributes
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Fragment
+import org.jetbrains.kotlin.gradle.artifacts.metadataFragmentIdentifier
+import org.jetbrains.kotlin.gradle.artifacts.metadataPublishedArtifacts
+import org.jetbrains.kotlin.gradle.artifacts.publishedMetadataCompilations
+import org.jetbrains.kotlin.gradle.plugin.mpp.*
import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
-import org.jetbrains.kotlin.transformKGPModelToUklibModel
+import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.KotlinPluginLifecycle
+import org.jetbrains.kotlin.gradle.plugin.await
+import org.jetbrains.kotlin.gradle.plugin.mpp.external.DecoratedExternalKotlinTarget
+import org.jetbrains.kotlin.gradle.targets.js.KotlinWasmTargetType
import java.io.File
-internal fun uklibFromKGPModel(
- targets: List<KotlinTarget>,
- onPublishCompilation: (KotlinCompilation<*>) -> Unit = {}
-): Uklib<String> {
- val compilationToArtifact = mutableMapOf<KotlinCompilation<*>, Iterable<File>>()
- targets.forEach { target ->
+internal data class KGPFragment(
+ val fragment: Fragment,
+ val providingTask: TaskProvider<*>,
+ val outputFile: Provider<File>,
+)
+
+internal suspend fun kgpFragments(
+ metadataTarget: KotlinMetadataTarget,
+ allTargets: List<KotlinTarget>,
+): List<KGPFragment> {
+ // Guarantee that we can safely access any compilations
+ KotlinPluginLifecycle.Stage.AfterFinaliseCompilations.await()
+
+ val fragments = mutableListOf<KGPFragment>()
+
+ metadataTarget.publishedMetadataCompilations().forEach { metadataCompilation ->
+ val artifact = metadataCompilation.project.provider {
+ metadataCompilation.metadataPublishedArtifacts.singleFile
+ }
+ fragments.add(
+ KGPFragment(
+ fragment = Fragment(
+ identifier = metadataCompilation.metadataFragmentIdentifier,
+ attributes = metadataCompilation.metadataFragmentAttributes.map { it.unwrap() }.toSet(),
+ file = {
+ artifact.get()
+ }
+ ),
+ providingTask = metadataCompilation.compileTaskProvider,
+ outputFile = artifact,
+ )
+ )
+ }
+
+ allTargets.filterNot {
+ it == metadataTarget
+ }.forEach { target ->
+ /**
+ * FIXME: Tie this implementation to the publication implementations that are hardcoded in KotlinTarget to make the dependency
+ * between the artifact that is published in Uklib and in the old publication model visible
+ */
when (target) {
is KotlinJsIrTarget -> {
- error("...")
-// val mainComp = target.compilations.getByName(MAIN_COMPILATION_NAME)
-// compilationToArtifact[mainComp] = mainComp.out
- }
- is KotlinJvmTarget -> {
- val mainComp = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
- // FIXME: How do we handle that there are multiple classesDir?
- /**
- * What should we do with multiple classes output:
- *
- * 1. What is going to happen if Foo collides across Kotlin and Java compilations. Is one picked over the other or is there a
- * class redeclaration error?
- * 2. Publication always has a single jar
- *
- * TODO: Discuss this case in text
- */
- compilationToArtifact[mainComp] = mainComp.output.classesDirs
- onPublishCompilation(mainComp)
+ val mainCompilation = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+ val file = mainCompilation.compileTaskProvider.flatMap { it.klibOutput }
+ fragments.add(
+ KGPFragment(
+ fragment = Fragment(
+ identifier = mainCompilation.fragmentIdentifier,
+ attributes = setOf(mainCompilation.uklibFragmentPlatformAttribute.unwrap()),
+ file = {
+ file.get()
+ }
+ ),
+ providingTask = mainCompilation.compileTaskProvider,
+ outputFile = file,
+ )
+ )
}
is KotlinNativeTarget -> {
- val mainComp = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
- compilationToArtifact[mainComp] = listOf(
- // FIXME: Make this lazy
- // FIXME: We have to unzip this
- // FIXME: 13.11 - Just use unpacked compilation directly
- mainComp.compileTaskProvider.flatMap {
- it.outputFile
- }.get()
+ val mainCompilation = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+ val file = mainCompilation.compileTaskProvider.flatMap { it.klibOutput }
+ fragments.add(
+ KGPFragment(
+ fragment = Fragment(
+ identifier = mainCompilation.fragmentIdentifier,
+ attributes = setOf(mainCompilation.uklibFragmentPlatformAttribute.unwrap()),
+ file = {
+ file.get()
+ }
+ ),
+ providingTask = mainCompilation.compileTaskProvider,
+ outputFile = file,
+ )
)
- onPublishCompilation(mainComp)
}
- // FIXME: Metadata target forms a natural bamboo with default target hierarchy
- /**
- * What to do with bamboo and default target hierarchy: this is actually a problem because this works in KGP, but with Uklibs
- * this is not going to work
- *
- *
- * 1. Can we refactor metadata compilations to compile all same-target compilations: no because expect/actuals must not be in the same compilation
- * But maybe we could relax this inside the compiler
- *
- * 2. Source set target context feature? It will allow declaring e.g. commonMain that is constrained to ios and jvm, but providing jvm
- * will not be required.
- *
- * 3. Prohibit bamboo source set configuration in. This will work for cases where there are no expect/actuals across metadata compilations
- *
- * Typical use case:
- *
- * TODO: Write communication about this in the channel
- */
- is KotlinMetadataTarget -> {
- target.compilations
- // Probably this is not needed
- .filterNot { it is KotlinCommonCompilation && !it.isKlibCompilation }
- .forEach { compilation ->
- // FIXME: Aren't test compilations going to be here?
- compilationToArtifact[compilation] = compilation.output.classesDirs
- onPublishCompilation(compilation)
- }
+ is KotlinJvmTarget -> {
+ val mainCompilation = target.compilations.getByName(KotlinCompilation.MAIN_COMPILATION_NAME)
+ @Suppress("UNCHECKED_CAST")
+ val jarTask = (target.project.tasks.named(target.artifactsTaskName) as TaskProvider<Jar>)
+ val jarArtifact = jarTask.flatMap {
+ it.archiveFile.map { it.asFile }
+ }
+ fragments.add(
+ KGPFragment(
+ fragment = Fragment(
+ identifier = mainCompilation.fragmentIdentifier,
+ attributes = setOf(mainCompilation.uklibFragmentPlatformAttribute.unwrap()),
+ file = {
+ jarArtifact.get()
+ }
+ ),
+ providingTask = jarTask,
+ outputFile = jarArtifact,
+ )
+ )
+ }
+ else -> {
+ when (target.uklibFragmentPlatformAttribute) {
+ is UklibFragmentPlatformAttribute.OnlyConsumeInMetadataCompilationsAndIgnoreAtPublication -> { /* Do nothing for AGP */ }
+ is UklibFragmentPlatformAttribute.PublishAndConsumeInAllCompilations -> { /* FIXME: rewrite the logic above */ }
+ is UklibFragmentPlatformAttribute.FailOnPublicationAndIgnoreForConsumption -> target.uklibFragmentPlatformAttribute.unwrap()
+ }
}
}
}
- return transformKGPModelToUklibModel(
- "stub",
- publishedCompilations = compilationToArtifact.keys.toList(),
- publishedArtifact = { compilationToArtifact[this]!!.single() },
- defaultSourceSet = { this.defaultSourceSet },
- target = { this.target.targetName },
- dependsOn = { this.dependsOn },
- identifier = { this.name }
- )
-}
\ No newline at end of file
+ return fragments
+}
+
+internal enum class UklibJsTargetIdentifier {
+ js_ir,
+ wasm_js,
+ wasm_wasi;
+
+ fun deserialize(value: String): UklibJsTargetIdentifier {
+ return enumValueOf<UklibJsTargetIdentifier>(value)
+ }
+}
+
+internal sealed class UklibFragmentPlatformAttribute {
+ // Jvm, native, js
+ data class PublishAndConsumeInAllCompilations(val attribute: String) : UklibFragmentPlatformAttribute()
+ // Android
+ data class OnlyConsumeInMetadataCompilationsAndIgnoreAtPublication(val attribute: String) : UklibFragmentPlatformAttribute()
+ // External target
+ data class FailOnPublicationAndIgnoreForConsumption(val error: String) : UklibFragmentPlatformAttribute()
+
+ // FIXME: Separate unwrap to consume for publication vs compilation
+ fun unwrap(): String = when (this) {
+ is PublishAndConsumeInAllCompilations -> attribute
+ is OnlyConsumeInMetadataCompilationsAndIgnoreAtPublication -> attribute
+ is FailOnPublicationAndIgnoreForConsumption -> error(error)
+ }
+}
+
+internal val KotlinCompilation<*>.uklibFragmentPlatformAttribute: UklibFragmentPlatformAttribute get() = this.target.uklibFragmentPlatformAttribute
+internal val KotlinTarget.uklibFragmentPlatformAttribute: UklibFragmentPlatformAttribute
+ get() {
+ // FIXME: Actually maybe request jvm transform in Android?
+ if (this is KotlinAndroidTarget) {
+ return UklibFragmentPlatformAttribute.OnlyConsumeInMetadataCompilationsAndIgnoreAtPublication(targetName)
+ }
+
+ when (this) {
+ is KotlinNativeTarget -> konanTarget.name
+ is KotlinJsIrTarget -> when (platformType) {
+ KotlinPlatformType.js -> UklibJsTargetIdentifier.js_ir.name
+ KotlinPlatformType.wasm -> when (wasmTargetType ?: error("${KotlinJsIrTarget::class} missing wasm type in wasm platform ")) {
+ KotlinWasmTargetType.JS -> UklibJsTargetIdentifier.wasm_js.name
+ KotlinWasmTargetType.WASI -> UklibJsTargetIdentifier.wasm_wasi.name
+ }
+ else -> error("${KotlinJsIrTarget::class} unexpected platform type ${platformType}")
+ }
+ // FIXME: Is this correct?
+ is KotlinJvmTarget -> targetName
+ else -> null
+ }?.let {
+ return UklibFragmentPlatformAttribute.PublishAndConsumeInAllCompilations(it)
+ }
+
+ val error = when (this) {
+ is KotlinMetadataTarget -> "Metadata target does't have a platform attribute"
+ // FIXME: Test this !!!
+ is DecoratedExternalKotlinTarget -> "FIXME: This is explicitly unsupported"
+ else -> "???"
+ }
+ return UklibFragmentPlatformAttribute.FailOnPublicationAndIgnoreForConsumption(error)
+ }
+
+internal val KotlinCompilation<*>.fragmentIdentifier: String get() = defaultSourceSet.name
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/AbstractKotlinNativeBinaryContainer.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/AbstractKotlinNativeBinaryContainer.kt
index d19ecba..65301db 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/AbstractKotlinNativeBinaryContainer.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/AbstractKotlinNativeBinaryContainer.kt
@@ -5,6 +5,7 @@
import org.gradle.api.Project
import org.jetbrains.kotlin.gradle.plugin.mpp.*
import org.jetbrains.kotlin.util.capitalizeDecapitalize.toUpperCaseAsciiOnly
+import java.util.concurrent.atomic.AtomicReference
// DO NOT EDIT MANUALLY! Generated by org.jetbrains.kotlin.generators.gradle.dsl.MppNativeBinaryDSLCodegenKt
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/stdlibDependencyManagement.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/stdlibDependencyManagement.kt
index 96b9512..0140d41 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/stdlibDependencyManagement.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/internal/stdlibDependencyManagement.kt
@@ -184,7 +184,7 @@
KotlinPlatformType.js -> if (isVersionWithGradleMetadata) KOTLIN_STDLIB_MODULE_NAME else KOTLIN_STDLIB_JS_MODULE_NAME
KotlinPlatformType.wasm -> KOTLIN_STDLIB_MODULE_NAME
- KotlinPlatformType.native, KotlinPlatformType.unknown -> null
+ KotlinPlatformType.native -> null
KotlinPlatformType.common -> // there's no platform compilation that the source set is default for
if (isVersionWithGradleMetadata) KOTLIN_STDLIB_MODULE_NAME else KOTLIN_STDLIB_COMMON_MODULE_NAME
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/PropertiesProvider.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/PropertiesProvider.kt
index fc31597..8e83fb3 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/PropertiesProvider.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/PropertiesProvider.kt
@@ -40,7 +40,7 @@
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_ENABLE_OPTIMISTIC_NUMBER_COMMONIZATION
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_ENABLE_PLATFORM_INTEGER_COMMONIZATION
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_ENABLE_RESOURCES_PUBLICATION
-import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB_VARIANT
+import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_FILTER_RESOURCES_BY_EXTENSION
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_HIERARCHICAL_STRUCTURE_BY_DEFAULT
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.PropertyNames.KOTLIN_MPP_HIERARCHICAL_STRUCTURE_SUPPORT
@@ -195,10 +195,10 @@
val uklibResolutionStrategy: UklibResolutionStrategy
get() = this.get(KOTLIN_MPP_UKLIB_RESOLUTION_STRATEGY)?.let {
UklibResolutionStrategy.fromProperty(it)
- } ?: UklibResolutionStrategy.PreferUklibVariant
+ } ?: UklibResolutionStrategy.AllowResolvingUklibs
- val publishUklibVariant: Boolean
- get() = booleanProperty(KOTLIN_MPP_PUBLISH_UKLIB_VARIANT) ?: false
+ val publishUklib: Boolean
+ get() = booleanProperty(KOTLIN_MPP_PUBLISH_UKLIB) ?: false
val fakeUkibTransforms: Boolean
get() = booleanProperty(KOTLIN_MPP_FAKE_UKLIB_TRANSFORMS) ?: false
@@ -639,7 +639,7 @@
val KOTLIN_JS_STDLIB_DOM_API_INCLUDED = property("kotlin.js.stdlib.dom.api.included")
val KOTLIN_JS_YARN = property("kotlin.js.yarn")
- val KOTLIN_MPP_PUBLISH_UKLIB_VARIANT = property("kotlin.mpp.publishUklibVariant")
+ val KOTLIN_MPP_PUBLISH_UKLIB = property("kotlin.mpp.publishUklib")
val KOTLIN_MPP_FAKE_UKLIB_TRANSFORMS = property("kotlin.mpp.fakeUklibTransforms")
val KOTLIN_MPP_DISABLE_PLATFORM_SPECIFIC_COMPONENTS_REFERENCES = property("kotlin.mpp.disablePlatformSpecificComponentsReferences")
val KOTLIN_MPP_UKLIB_RESOLUTION_STRATEGY = property("kotlin.mpp.uklibResolutionStrategy")
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/diagnostics/checkers/IncorrectCompileOnlyDependenciesChecker.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/diagnostics/checkers/IncorrectCompileOnlyDependenciesChecker.kt
index bc47212..06eab08 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/diagnostics/checkers/IncorrectCompileOnlyDependenciesChecker.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/diagnostics/checkers/IncorrectCompileOnlyDependenciesChecker.kt
@@ -105,7 +105,7 @@
KotlinPlatformType.js,
-> false
- KotlinPlatformType.native, KotlinPlatformType.unknown -> {
+ KotlinPlatformType.native -> {
@Suppress("DEPRECATION")
PropertiesProvider(project).ignoreIncorrectNativeDependencies == true
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/IdeMultiplatformImportFactory.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/IdeMultiplatformImportFactory.kt
index f382249..458380f 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/IdeMultiplatformImportFactory.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/IdeMultiplatformImportFactory.kt
@@ -11,6 +11,8 @@
import org.jetbrains.kotlin.gradle.plugin.ide.IdeMultiplatformImport.SourceSetConstraint
import org.jetbrains.kotlin.gradle.plugin.ide.dependencyResolvers.*
import org.jetbrains.kotlin.gradle.plugin.ide.dependencyTransformers.IdePlatformStdlibCommonDependencyFilter
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinCommonCompilation
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
import org.jetbrains.kotlin.gradle.targets.native.internal.commonizerTarget
internal fun IdeMultiplatformImport(extension: KotlinProjectExtension): IdeMultiplatformImport {
@@ -65,6 +67,7 @@
priority = IdeMultiplatformImport.Priority.normal
)
+ // Этот мы используем для резолва метадаты
registerDependencyResolver(
resolver = IdeTransformedMetadataDependencyResolver,
constraint = !SourceSetConstraint.isSingleKotlinTarget and !SourceSetConstraint.isJvmAndAndroid,
@@ -72,6 +75,7 @@
priority = IdeMultiplatformImport.Priority.normal
)
+ // Не понимаю зачем это нужно если есть верхний матчер
registerDependencyResolver(
resolver = IdeOriginalMetadataDependencyResolver,
constraint = !SourceSetConstraint.isLeaf,
@@ -81,6 +85,7 @@
registerDependencyResolver(
resolver = IdeBinaryDependencyResolver(),
+ // FIXME: Why is this single platform and not target?
constraint = SourceSetConstraint.isSinglePlatformType,
phase = IdeMultiplatformImport.DependencyResolutionPhase.BinaryDependencyResolution,
priority = IdeMultiplatformImport.Priority.normal
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeBinaryDependencyResolver.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeBinaryDependencyResolver.kt
index 359961a..7a2e1e3 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeBinaryDependencyResolver.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ide/dependencyResolvers/IdeBinaryDependencyResolver.kt
@@ -14,6 +14,9 @@
import org.gradle.internal.component.local.model.OpaqueComponentArtifactIdentifier
import org.gradle.internal.resolve.ModuleVersionResolveException
import org.jetbrains.kotlin.gradle.ExternalKotlinTargetApi
+import org.jetbrains.kotlin.gradle.artifacts.uklibDestinationAttribute
+import org.jetbrains.kotlin.gradle.artifacts.uklibStateAttribute
+import org.jetbrains.kotlin.gradle.artifacts.uklibStateUnzipped
import org.jetbrains.kotlin.gradle.idea.tcs.*
import org.jetbrains.kotlin.gradle.idea.tcs.extras.artifactsClasspath
import org.jetbrains.kotlin.gradle.idea.tcs.extras.isOpaqueFileDependency
@@ -23,7 +26,6 @@
import org.jetbrains.kotlin.gradle.plugin.ide.*
import org.jetbrains.kotlin.gradle.plugin.ide.IdeDependencyResolver.Companion.gradleArtifact
import org.jetbrains.kotlin.gradle.plugin.ide.dependencyResolvers.IdeBinaryDependencyResolver.ArtifactResolutionStrategy
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMetadataCompilation
import org.jetbrains.kotlin.gradle.plugin.mpp.internal
import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
import org.jetbrains.kotlin.gradle.plugin.sources.DefaultKotlinSourceSet
@@ -166,7 +168,7 @@
is ModuleComponentIdentifier -> {
// FIXME: Где-то тут разламывается AS интеграция из-за того что совпадает id?
if (artifact.variant.attributes.getAttribute(uklibStateAttribute) == uklibStateUnzipped) {
- val platform = artifact.variant.attributes.getAttribute(uklibPlatformAttribute)
+ val platform = artifact.variant.attributes.getAttribute(uklibDestinationAttribute)
IdeaKotlinResolvedBinaryDependency(
coordinates = IdeaKotlinBinaryCoordinates(
group = componentId.group,
@@ -251,10 +253,11 @@
Prevent case where this resolver was configured to resolve dependencies for a metadata compilation:
Refuse resolution. Write your own code if you really want to do this!
*/
- if (compilation is KotlinMetadataCompilation<*>) {
- logger.warn("Unexpected ${KotlinMetadataCompilation::class.java}(${compilation.name}) for $sourceSet")
- return null
- }
+ // FIXME: Why?
+// if (compilation is KotlinMetadataCompilation<*>) {
+// logger.warn("Unexpected ${KotlinMetadataCompilation::class.java}(${compilation.name}) for $sourceSet")
+// return null
+// }
return createArtifactViewFromConfiguration(sourceSet, compilation.internal.configurations.compileDependencyConfiguration)
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/AbstractKotlinTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/AbstractKotlinTarget.kt
index 1719ea8..e04ad15 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/AbstractKotlinTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/AbstractKotlinTarget.kt
@@ -92,7 +92,7 @@
)
)
- val result = createKotlinVariant(componentName, mainCompilation, usageContexts)
+ val result = createKotlinVariant(componentName, usageContexts)
setOf(result)
}
@@ -107,19 +107,18 @@
protected open fun createKotlinVariant(
componentName: String,
- compilation: KotlinCompilation<*>,
usageContexts: Set<DefaultKotlinUsageContext>
): KotlinVariant {
val kotlinExtension = project.kotlinExtension
val result =
if (kotlinExtension !is KotlinMultiplatformExtension || targetName == KotlinMetadataTarget.METADATA_TARGET_NAME)
- KotlinVariantWithCoordinates(compilation, usageContexts)
+ KotlinVariantWithCoordinates(this, usageContexts)
else {
val metadataTarget =
kotlinExtension.targets.getByName(KotlinMetadataTarget.METADATA_TARGET_NAME) as AbstractKotlinTarget
- KotlinVariantWithMetadataVariant(compilation, usageContexts, metadataTarget)
+ KotlinVariantWithMetadataVariant(this, usageContexts, metadataTarget)
}
result.componentName = componentName
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/GranularMetadataTransformation.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/GranularMetadataTransformation.kt
index 22df14d..37afd0f 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/GranularMetadataTransformation.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/GranularMetadataTransformation.kt
@@ -17,6 +17,10 @@
import org.jetbrains.kotlin.*
import org.jetbrains.kotlin.gradle.artifacts.uklibStateAttribute
import org.jetbrains.kotlin.gradle.artifacts.uklibStateUnzipped
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Fragment
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.isSubsetOf
+import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.uklibFragmentPlatformAttribute
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
import org.jetbrains.kotlin.gradle.plugin.*
@@ -47,6 +51,9 @@
return "$verb, dependency = $dependency"
}
+ /**
+ * KeepOriginalDependency нужен для кейса если в GMT попали настоящие jar'ники?
+ */
class KeepOriginalDependency(
dependency: ResolvedComponentResult,
) : MetadataDependencyResolution(dependency)
@@ -116,8 +123,7 @@
val objects: ObjectFactory,
val kotlinKmpProjectIsolationEnabled: Boolean,
val sourceSetMetadataLocationsOfProjectDependencies: KotlinProjectSharedDataProvider<SourceSetMetadataLocations>,
- // FIXME: ???
- val sourceSetTargetMembership: Set<String>,
+ val uklibFragmentAttributes: Set<String>,
) {
constructor(project: Project, kotlinSourceSet: KotlinSourceSet) : this(
build = project.currentBuild,
@@ -133,11 +139,10 @@
kotlinKmpProjectIsolationEnabled = project.kotlinPropertiesProvider.kotlinKmpProjectIsolationEnabled,
sourceSetMetadataLocationsOfProjectDependencies = project.kotlinSecondaryVariantsDataSharing
.consumeCommonSourceSetMetadataLocations(kotlinSourceSet.internal.resolvableMetadataConfiguration),
- sourceSetTargetMembership = kotlinSourceSet.internal.compilations
+ uklibFragmentAttributes = kotlinSourceSet.internal.compilations
.map { it.target }
.filter { it !is KotlinMetadataTarget }
- // FIXME: See uklibFromKGPModel
- .map { it.targetName }
+ .map { it.uklibFragmentPlatformAttribute.unwrap() }
.toSet()
)
}
@@ -161,6 +166,7 @@
private fun doTransform(): Iterable<MetadataDependencyResolution> {
val result = mutableListOf<MetadataDependencyResolution>()
+ // Это очередь из порезолвленных компонентнов?
val resolvedDependencyQueue: Queue<ResolvedDependencyResult> = ArrayDeque<ResolvedDependencyResult>().apply {
addAll(
params.resolvedMetadataConfiguration
@@ -234,13 +240,25 @@
* * based on the project structure metadata, determine which of the module's dependencies are requested by the
* source sets in *S*, then consider only these transitive dependencies, ignore the others;
*/
+ // По идее эта логика исполняется на зависимость, на каждый потребляющий SS
private fun processDependency(
dependency: ResolvedDependencyResult,
+ // Я не понимаю откуда приходят эти SS
+ /**
+ * 24.11.2024 - Наверное для iosMain они приходят из commonMain. Это точно так, они приходят из parent тасок которые делают GMT
+ */
sourceSetsVisibleInParents: Set<String>,
): MetadataDependencyResolution {
val module = dependency.selected
val moduleId = module.id
+ /**
+ * FIXME: 01.12-2024 - Add diagnostics:
+ *
+ * 1. Look at the graph of
+ */
+
+ // Это .jar ник с метадатными klib'ами
val artifact = params
.resolvedMetadataConfiguration
.getArtifacts(dependency)
@@ -266,44 +284,43 @@
moduleId,
sourceSetsVisibleInParents,
- sourceSetName = params.sourceSetName,
- targetMembership = params.sourceSetTargetMembership,
+ //sourceSetName = params.sourceSetName,
+ uklibFragmentAttributes = params.uklibFragmentAttributes,
)
} else {
return MetadataDependencyResolution.KeepOriginalDependency(module)
}
}
+ // FIXME: How do we ensure classpath ordering for PSM dependencies ???
private fun processUklibDependency(
compositeMetadataArtifact: ResolvedArtifactResult,
dependency: ResolvedDependencyResult,
module: ResolvedComponentResult,
moduleId: ComponentIdentifier,
- // FIXME: ???
- sourceSetsVisibleInParents: Set<String>,
- sourceSetName: String,
- targetMembership: Set<String>,
+ sourceSetsVisibleInParents: Set<String>,
+ uklibFragmentAttributes: Set<String>,
): MetadataDependencyResolution {
+ // Validate that
+
val uklibDependency = Uklib.deserializeFromDirectory(
compositeMetadataArtifact.file,
)
- val fragment = Fragment(sourceSetName, targetMembership)
- val canSee: Fragment<String>.(Fragment<String>) -> Boolean = { attributes.isSubsetOf(it.attributes) }
-
+ val fragmentCanSee: Fragment.(Fragment) -> Boolean = { attributes.isSubsetOf(it.attributes) }
val visibleFragments = uklibDependency.module.fragments.filter {
- fragment.canSee(it)
- // FIXME: ??
+ uklibFragmentAttributes.isSubsetOf(it.attributes)
+ // FIXME: Is this the correct place to filter out compilations transformed by the parent ?? See allVisibleSourceSetNames and visibleSourceSetNamesExcludingDependsOn
&& it.identifier !in sourceSetsVisibleInParents
}.sortedWith(
- object : Comparator<Fragment<String>> {
- override fun compare(left: Fragment<String>, right: Fragment<String>): Int {
- if (left.canSee(right)) {
+ object : Comparator<Fragment> {
+ override fun compare(left: Fragment, right: Fragment): Int {
+ if (left.fragmentCanSee(right)) {
return -1
- } else if (right.canSee(left)) {
+ } else if (right.fragmentCanSee(left)) {
return 1
- } else if (left == right) {
+ } else if (left.attributes == right.attributes) {
return 0
} else {
return left.identifier.compareTo(right.identifier)
@@ -318,12 +335,12 @@
dependency = dependency.selected,
projectStructureMetadata = null,
// FIXME: Don't filter this
- allVisibleSourceSetNames = visibleFragments.map { it.identifier }.toSet(),
+ allVisibleSourceSetNames = visibleFragments.map { it.identifier }.toHashSet(),
// FIXME: Only filter this, but for some reason this doesn't work???
- visibleSourceSetNamesExcludingDependsOn = visibleFragments.map { it.identifier }.toSet(),
+ visibleSourceSetNamesExcludingDependsOn = visibleFragments.map { it.identifier }.toHashSet(),
// 26.11.2024 - This is likely only used to walk further dependencies, so we want all of them
- visibleTransitiveDependencies = dependency.selected.dependencies.filterIsInstance<ResolvedDependencyResult>().toSet(),
+ visibleTransitiveDependencies = dependency.selected.dependencies.filterIsInstance<ResolvedDependencyResult>().toHashSet(),
metadataProvider = ArtifactMetadataProvider(
object : CompositeMetadataArtifact {
@@ -359,7 +376,7 @@
get() = ""
override fun copyTo(file: File): Boolean {
- return uklibDependency.fragmentToArtifact[fragment.identifier]!!.copyRecursively(
+ return fragment.file().copyRecursively(
file,
overwrite = true,
)
@@ -431,11 +448,18 @@
isResolvedToProject
)
+ // Тут будут те SS которые видит потребитель? Но где тогда происходит маппинг между SS?
+ /**
+ * 24.11.2024 - Все это происходит в рамках resolve'а classpath текущего SS
+ */
val allVisibleSourceSets = sourceSetVisibility.visibleSourceSetNames
// Keep only the transitive dependencies requested by the visible source sets:
// Visit the transitive dependencies visible by parents, too (i.e. allVisibleSourceSets), as this source set might get a more
// concrete view on them:
+ /**
+ * Набираем то, какие зависимости были указаны в рамках SS
+ */
val requestedTransitiveDependencies: Set<ModuleDependencyIdentifier> =
mutableSetOf<ModuleDependencyIdentifier>().apply {
projectStructureMetadata.sourceSetModuleDependencies.forEach { (sourceSetName, moduleDependencies) ->
@@ -449,9 +473,15 @@
.filterIsInstance<ResolvedDependencyResult>()
.filterTo(mutableSetOf()) { it.toModuleDependencyIdentifier() in requestedTransitiveDependencies }
+ /**
+ * Кажется мы проверяем, что SS в котором мы сейчас не платформенный и что он не порезолвился в проектную зависимость
+ *
+ * Не понимаю зачем это нужно, особенно как работает часть про !isResolvedToProject
+ */
if (params.sourceSetName in params.platformCompilationSourceSets && !isResolvedToProject)
return MetadataDependencyResolution.Exclude.PublishedPlatformSourceSetDependency(module, transitiveDependenciesToVisit)
+ // Наверное тут будут только новые видимые SS которые еще не были видны в parent SS
val visibleSourceSetsExcludingDependsOn = allVisibleSourceSets.filterTo(mutableSetOf()) { it !in sourceSetsVisibleInParents }
val metadataProvider = when (mppDependencyMetadataExtractor) {
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMetadataTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMetadataTarget.kt
index c549d2f..55c18ea 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMetadataTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinMetadataTarget.kt
@@ -6,13 +6,16 @@
package org.jetbrains.kotlin.gradle.plugin.mpp
import org.gradle.api.Project
+import org.gradle.api.artifacts.ModuleVersionIdentifier
+import org.gradle.api.artifacts.PublishArtifact
+import org.gradle.api.component.ComponentWithCoordinates
import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
import org.jetbrains.kotlin.gradle.dsl.HasConfigurableKotlinCompilerOptions
import org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptions
import org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptionsDefault
-import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
-import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
-import org.jetbrains.kotlin.gradle.plugin.KotlinTargetComponent
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.*
+import org.jetbrains.kotlin.gradle.plugin.launch
import org.jetbrains.kotlin.gradle.targets.metadata.KotlinMetadataTargetConfigurator
import org.jetbrains.kotlin.gradle.targets.metadata.isKotlinGranularMetadataEnabled
import org.jetbrains.kotlin.gradle.utils.newInstance
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt
index 6a0d735..70e32cd 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinSoftwareComponent.kt
@@ -86,7 +86,7 @@
// overrideConfigurationArtifacts = project.setProperty { listOf(allMetadataArtifact) }
)
- if (project.kotlinPropertiesProvider.publishUklibVariant) {
+ if (project.kotlinPropertiesProvider.publishUklib) {
this += DefaultKotlinUsageContext(
compilation = metadataTarget.compilations.getByName(MAIN_COMPILATION_NAME),
mavenScope = KotlinUsageContext.MavenScope.COMPILE,
@@ -202,10 +202,15 @@
override fun getDependencyConstraints(): MutableSet<out DependencyConstraint> =
configuration.incoming.dependencyConstraints
- override fun getArtifacts(): Set<PublishArtifact> =
- overrideConfigurationArtifacts?.get()?.toSet() ?:
+ override fun getArtifacts(): Set<PublishArtifact> {
+ // Don't publish anything except the uklib
+ // FIXME: 11.11.2024 - I used this to disable the publication of all other artifacts
+ // FIXME: 19.11.2024 - Use this under a feature toggle?
+ // if (configuration.name != "metadataUklibElements") return emptySet()
+ return overrideConfigurationArtifacts?.get()?.toSet() ?:
// TODO Gradle Java plugin does that in a different way; check whether we can improve this
configuration.artifacts
+ }
override fun getAttributes(): AttributeContainer {
val configurationAttributes = overrideConfigurationAttributes ?: configuration.attributes
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinUsages.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinUsages.kt
index 9aa5e8d..9bb4906 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinUsages.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/KotlinUsages.kt
@@ -59,7 +59,13 @@
private const val JAVA_RUNTIME_CLASSES = "java-runtime-classes"
private const val JAVA_RUNTIME_RESOURCES = "java-runtime-resources"
+ // FIXME: Rename this?
val values = setOf(KOTLIN_API, KOTLIN_RUNTIME)
+ val compatibleKotlinConsumerUsages = mapOf(
+ setOf(KOTLIN_API) to setOf(JAVA_API, "java-api-jars"),
+ // This should really only list KOTLIN_RUNTIME
+ setOf(KOTLIN_API, KOTLIN_RUNTIME) to setOf(JAVA_RUNTIME, "java-runtime-jars"),
+ )
private val jvmPlatformTypes: Set<KotlinPlatformType> = setOf(jvm, androidJvm)
@@ -113,6 +119,7 @@
when {
consumerValue?.name == KOTLIN_API && producerValue?.name.let { it == JAVA_API || it == "java-api-jars" } ->
compatible()
+ // FIXME: This can't really match KOTLIN_API because it matches the case above???
consumerValue?.name in values && producerValue?.name.let { it == JAVA_RUNTIME || it == "java-runtime-jars" } ->
compatible()
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MetadataDependencyTransformationTask.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MetadataDependencyTransformationTask.kt
index e39d08c..ef39d98 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MetadataDependencyTransformationTask.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MetadataDependencyTransformationTask.kt
@@ -139,6 +139,7 @@
@TaskAction
fun transformMetadata() {
+ // Не понимаю, это parent всмысле как commonMain для iosMain
val parentLibrariesRecords: List<List<TransformedMetadataLibraryRecord>> = parentLibrariesIndexFiles
.get()
.map { librariesIndexFile -> librariesIndexFile.records() }
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MppDependenciesProjectStructureMetadataExtractorFactoryDeprecated.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MppDependenciesProjectStructureMetadataExtractorFactoryDeprecated.kt
index 7597d55..b0f9a2c 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MppDependenciesProjectStructureMetadataExtractorFactoryDeprecated.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/MppDependenciesProjectStructureMetadataExtractorFactoryDeprecated.kt
@@ -41,8 +41,11 @@
): MppDependencyProjectStructureMetadataExtractor {
val moduleId = metadataArtifact.variant.owner
+
return if (moduleId is ProjectComponentIdentifier) {
+ // Чекаем участвует ли эта зависимость в билде? Зачем
if (moduleId in currentBuild) {
+ // Это легаси логика которая ходит в рутовый проект и ищет там (in-memory?) PSM
val projectStructureMetadataProvider = currentBuildProjectStructureMetadataProviders[moduleId.projectPath]
?: error("Project structure metadata not found for project '${moduleId.projectPath}'")
@@ -51,6 +54,7 @@
projectStructureMetadataProvider = projectStructureMetadataProvider::value
)
} else {
+ // Это что-то про included build
/*
We switched to using 'buildPath' instead of 'buildName' in 1.9.20,
(See: https://youtrack.jetbrains.com/issue/KT-58157/)
@@ -70,6 +74,7 @@
)
}
} else {
+ // Просто достаем PSM из jar'ника
JarMppDependencyProjectStructureMetadataExtractor(metadataArtifact.file)
}
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/SourceSetVisibilityProvider.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/SourceSetVisibilityProvider.kt
index f3b53c0..054e05d 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/SourceSetVisibilityProvider.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/SourceSetVisibilityProvider.kt
@@ -81,21 +81,41 @@
* the Gradle API for dependency variants behaves differently for project dependencies and published ones.
*/
fun getVisibleSourceSets(
+ // e.g. commonMain
visibleFromSourceSet: KotlinSourceSetName,
+ // Это порезолвленная зависимость (вероятно ее компонент в котором лежит PSM)
resolvedRootMppDependency: ResolvedDependencyResult,
+ // Это видимо PSM этой зависимости
dependencyProjectStructureMetadata: KotlinProjectStructureMetadata,
+ // Это просто значит, что это проектная зависимость
resolvedToOtherProject: Boolean,
): SourceSetVisibilityResult {
val resolvedRootMppDependencyId = resolvedRootMppDependency.selected.id
val platformCompilationsByResolvedVariantName = mutableMapOf<String, PlatformCompilationData>()
+ /** Откуда берутся platformCompilations?
+ * platformCompilations это платформенные компиляции текущего модуля который делает GMT резолв
+ *
+ * 1. Берем платформенные компиляции
+ * 2. Только те которые участвуют в компиляции этого SS
+ * 3. Смотрим какие variant'ы порезолвили эти конфигурации и восстанавливаем
+ */
val visiblePlatformVariantNames: List<Set<String>> = platformCompilations
+ /**
+ * Visibility алгоритм работает на конкретном SS. Тут мы отфильтировываем платформенные компиляции до тех который включают в себя этот SS
+ */
.filter { visibleFromSourceSet in it.allSourceSets }
.mapNotNull { platformCompilationData ->
val resolvedPlatformDependencies = platformCompilationData
+ /**
+ * resolvedDependenciesConfiguration это конфигурация которую платформенная компиляция будет резолвить для получения платформенных артефактов
+ */
.resolvedDependenciesConfiguration
.allResolvedDependencies
+ /**
+ * Мне кажется тут Антон рассказывал про проблемы с shouldResolveConsistently
+ */
.filter { it.selected.id isEqualsIgnoringVersion resolvedRootMppDependencyId }
/*
Returning null if we can't find the given dependency in a certain platform compilations dependencies.
@@ -111,7 +131,14 @@
*/
.ifEmpty { return@mapNotNull null }
+ /**
+ * Смотрим на зависимости которые порезолвила плафтморенная compileDependencyConfiguration. А именно на variant'ы которые
+ * она порезолвила
+ */
resolvedPlatformDependencies.map { resolvedPlatformDependency ->
+ /**
+ * Дропаем "-published" маркер названия варианта и восстанавливаем из него resolved variant
+ */
val resolvedVariant = kotlinVariantNameFromPublishedVariantName(
resolvedPlatformDependency.resolvedVariant.displayName
)
@@ -128,6 +155,7 @@
return SourceSetVisibilityResult(emptySet(), emptyMap())
}
+
val visibleSourceSetNames = visiblePlatformVariantNames
.mapNotNull { platformVariants ->
platformVariants
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinCompilation.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinCompilation.kt
index 66168bf..b77fe0e 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinCompilation.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinCompilation.kt
@@ -38,7 +38,7 @@
KotlinPlatformType.jvm -> KotlinJvmCompilerOptionsFactory
KotlinPlatformType.androidJvm -> KotlinJvmCompilerOptionsFactory
KotlinPlatformType.js -> KotlinJsCompilerOptionsFactory
- KotlinPlatformType.native, KotlinPlatformType.unknown -> KotlinNativeCompilerOptionsFactory
+ KotlinPlatformType.native -> KotlinNativeCompilerOptionsFactory
KotlinPlatformType.wasm -> KotlinMultiplatformCommonCompilerOptionsFactory
},
compilationSourceSetsContainerFactory = { _, _ -> KotlinCompilationSourceSetsContainer(descriptor.defaultSourceSet) },
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinTarget.kt
index f9eea0e..b91887e 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/external/createExternalKotlinTarget.kt
@@ -77,7 +77,7 @@
KotlinPlatformType.wasm,
KotlinPlatformType.js -> project.objects.newInstance<KotlinJsCompilerOptionsDefault>()
KotlinPlatformType.common -> project.objects.newInstance<KotlinCommonCompilerOptionsDefault>()
- KotlinPlatformType.native, KotlinPlatformType.unknown -> project.objects.newInstance<KotlinNativeCompilerOptionsDefault>()
+ KotlinPlatformType.native -> project.objects.newInstance<KotlinNativeCompilerOptionsDefault>()
}
val target = ExternalKotlinTargetImpl(
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinVariants.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinVariants.kt
index ab9c94c..50c9281 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinVariants.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/kotlinVariants.kt
@@ -50,19 +50,16 @@
}
open class KotlinVariant(
- val producingCompilation: KotlinCompilation<*>,
+ override val target: KotlinTarget,
private val usages: Set<DefaultKotlinUsageContext>
) : InternalKotlinTargetComponent(), KotlinTargetComponentWithPublication {
var componentName: String? = null
var artifactTargetName: String = target.targetName
- final override val target: KotlinTarget
- get() = producingCompilation.target
-
override fun getUsages(): Set<KotlinUsageContext> = usages.publishableUsages()
- override fun getName(): String = componentName ?: producingCompilation.target.targetName
+ override fun getName(): String = componentName ?: target.targetName
override var publishable: Boolean = true
override val publishableOnCurrentHost: Boolean
@@ -90,16 +87,16 @@
}
open class KotlinVariantWithCoordinates(
- producingCompilation: KotlinCompilation<*>,
+ target: KotlinTarget,
usages: Set<DefaultKotlinUsageContext>,
-) : KotlinVariant(producingCompilation, usages),
+) : KotlinVariant(target, usages),
KotlinTargetComponentWithCoordinatesAndPublication /* Gradle 4.7+ API, don't use with older versions */
class KotlinVariantWithMetadataVariant(
- producingCompilation: KotlinCompilation<*>,
+ target: KotlinTarget,
usages: Set<DefaultKotlinUsageContext>,
internal val metadataTarget: AbstractKotlinTarget,
-) : KotlinVariantWithCoordinates(producingCompilation, usages), ComponentWithVariants {
+) : KotlinVariantWithCoordinates(target, usages), ComponentWithVariants {
override fun getVariants() = metadataTarget.components
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/PomDependenciesRewriter.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/PomDependenciesRewriter.kt
index c07be88..876a662 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/PomDependenciesRewriter.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/PomDependenciesRewriter.kt
@@ -30,6 +30,7 @@
}
}
+// FIXME: 28.11.2024 - Наверное смысл PomDependenciesRewriter'а в том чтобы переписывать зависимости на платформенные слайсы
internal abstract class PomDependenciesRewriter {
open val taskDependencies: Any? get() = null
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/Publishing.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/Publishing.kt
index e35ab96..0c0e630 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/Publishing.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/publishing/Publishing.kt
@@ -12,6 +12,9 @@
import org.gradle.api.publish.PublishingExtension
import org.gradle.api.publish.maven.MavenPublication
import org.gradle.api.publish.maven.internal.publication.MavenPublicationInternal
+import org.jetbrains.kotlin.gradle.artifacts.uklibsModel.Uklib
+import org.jetbrains.kotlin.gradle.artifacts.uklibsPublication.archiveUklibTask
+import org.jetbrains.kotlin.gradle.dsl.awaitMetadataTarget
import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
import org.jetbrains.kotlin.gradle.plugin.*
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider.Companion.kotlinPropertiesProvider
@@ -34,6 +37,7 @@
project.extensions.configure(PublishingExtension::class.java) { publishing ->
createRootPublication(project, publishing).also(kotlinMultiplatformRootPublicationImpl::complete)
createTargetPublications(project, publishing)
+ createUklibSpecificMavenPublications(project, publishing)
}
} else {
kotlinMultiplatformRootPublicationImpl.complete(null)
@@ -55,6 +59,9 @@
(this as MavenPublicationInternal).publishWithOriginalFileName()
addKotlinToolingMetadataArtifactIfNeeded(project)
+ if (project.kotlinPropertiesProvider.publishUklib) {
+ addUklibArtifactAndChangePackaging(project)
+ }
}
}
@@ -67,6 +74,16 @@
}
}
+private fun MavenPublication.addUklibArtifactAndChangePackaging(project: Project) {
+ // FIXME: This will break coroutines !!!
+ pom.packaging = Uklib.UKLIB_PACKAGING
+ project.launch {
+ artifact(project.archiveUklibTask()) { artifact ->
+ artifact.extension = Uklib.UKLIB_EXTENSION
+ }
+ }
+}
+
private fun createTargetPublications(project: Project, publishing: PublishingExtension) {
val kotlin = project.multiplatformExtension
// Enforce the order of creating the publications, since the metadata publication is used in the other publications:
@@ -84,6 +101,22 @@
}
}
+private fun createUklibSpecificMavenPublications(project: Project, publishing: PublishingExtension) {
+ val publications = publishing.publications
+ project.launch {
+ val metadataTarget = project.multiplatformExtension.awaitMetadataTarget()
+ val componentPublication = publications.create("uklib", MavenPublication::class.java).apply {
+ artifactId = "${artifactId}-uklib"
+
+ // FIXME: jvm + uklib
+// artifact(
+//
+// )
+ }
+ metadataTarget.onPublicationCreated(componentPublication)
+ }
+}
+
private fun InternalKotlinTarget.createTargetSpecificMavenPublications(publications: PublicationContainer) {
kotlinComponents
.filter { kotlinComponent -> kotlinComponent.publishableOnCurrentHost }
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/registerKotlinPluginExtensions.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/registerKotlinPluginExtensions.kt
index da42660..df4a03c 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/registerKotlinPluginExtensions.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/registerKotlinPluginExtensions.kt
@@ -137,6 +137,8 @@
}
KotlinTargetArtifact.extensionPoint.apply {
+ // FIXME: This isn't mpp only
+ // FIXME: Disabling this breaks KotlinTargetSoftwareComponentImpl
register(project, KotlinMetadataArtifact)
register(project, KotlinLegacyCompatibilityMetadataArtifact)
register(project, KotlinLegacyMetadataArtifact)
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/CreateTargetConfigurationsSideEffect.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/CreateTargetConfigurationsSideEffect.kt
index a23dd77..02408f2 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/CreateTargetConfigurationsSideEffect.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/CreateTargetConfigurationsSideEffect.kt
@@ -133,7 +133,12 @@
}
if (target is KotlinMetadataTarget) {
- if (target.project.kotlinPropertiesProvider.publishUklibVariant) {
+ if (target.project.kotlinPropertiesProvider.publishUklib) {
+ /**
+ * FIXME: 29.11.2024 - Do we actually want/need a consumable configuration?
+ *
+ * How will the POM publish with a project dependency and a multi-project publication?
+ */
configurations.maybeCreateConsumable(target.internal.uklibElementsConfigurationName).apply {
description = "Resource files of main compilation of ${target.name}."
isVisible = false
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt
index f15c43a..5c5e93a 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/android/KotlinAndroidTarget.kt
@@ -192,7 +192,6 @@
createKotlinVariant(
lowerCamelCaseName(compilation.target.name, *flavorGroupNameParts.toTypedArray()),
- compilation,
usageContexts,
).apply {
publishable = isVariantPublished(androidVariant)
@@ -281,6 +280,7 @@
compilation,
mavenScope,
dependencyConfigurationName,
+ // !!!
overrideConfigurationArtifacts = project.setProperty { listOf(artifact) },
overrideConfigurationAttributes = configuration.attributes.filterOutAndroidVariantAttributes()
)
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTarget.kt
index a4badad..b58226b 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrTarget.kt
@@ -95,17 +95,16 @@
)
)
- val result = createKotlinVariant(componentName, mainCompilation, usageContexts)
+ val result = createKotlinVariant(componentName, usageContexts)
setOf(result)
}
override fun createKotlinVariant(
componentName: String,
- compilation: KotlinCompilation<*>,
usageContexts: Set<DefaultKotlinUsageContext>,
): KotlinVariant {
- return super.createKotlinVariant(componentName, compilation, usageContexts).apply {
+ return super.createKotlinVariant(componentName, usageContexts).apply {
artifactTargetName = wasmDecamelizedDefaultNameOrNull() ?: componentName
}
}
@@ -120,6 +119,7 @@
compilation = compilations.getByName(MAIN_COMPILATION_NAME),
mavenScope = KotlinUsageContext.MavenScope.COMPILE,
dependencyConfigurationName = commonFakeApiElementsConfigurationName,
+ // !!!
overrideConfigurationArtifacts = project.setProperty { emptyList() }
)
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt
index 900b6c0..0c1e278 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/metadata/KotlinMetadataTargetConfigurator.kt
@@ -11,6 +11,8 @@
import org.gradle.api.file.FileCollection
import org.gradle.api.tasks.TaskProvider
import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
+import org.jetbrains.kotlin.gradle.artifacts.uklibStateAttribute
+import org.jetbrains.kotlin.gradle.artifacts.uklibStateUnzipped
import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
import org.jetbrains.kotlin.gradle.dsl.metadataTarget
import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
@@ -263,6 +265,7 @@
}
private val ResolvedArtifactResult.isMpp: Boolean get() = variant.attributes.containsMultiplatformAttributes
+ || variant.attributes.getAttribute(uklibStateAttribute) == uklibStateUnzipped
}
internal fun Project.locateOrRegisterGenerateProjectStructureMetadataTask(): TaskProvider<GenerateProjectStructureMetadata> =
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeTarget.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeTarget.kt
index 059487d..fddb4f3 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeTarget.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/KotlinNativeTarget.kt
@@ -67,7 +67,7 @@
mainCompilation,
KotlinUsageContext.MavenScope.COMPILE,
hostSpecificMetadataElementsConfigurationName,
- includeIntoProjectStructureMetadata = false
+ includeIntoProjectStructureMetadata = false,
)
)
}
@@ -87,7 +87,7 @@
)
)
- val result = createKotlinVariant(targetName, mainCompilation, mutableUsageContexts)
+ val result = createKotlinVariant(targetName, mutableUsageContexts)
setOf(result)
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/KotlinPlatformTypeUtils.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/KotlinPlatformTypeUtils.kt
index 57dea70..113cd18 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/KotlinPlatformTypeUtils.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/KotlinPlatformTypeUtils.kt
@@ -14,6 +14,6 @@
KotlinPlatformType.jvm -> "Kotlin/JVM"
KotlinPlatformType.js -> "Kotlin/JS"
KotlinPlatformType.androidJvm -> "Kotlin/Android"
- KotlinPlatformType.native, KotlinPlatformType.unknown -> "Kotlin/Native"
+ KotlinPlatformType.native -> "Kotlin/Native"
KotlinPlatformType.wasm -> "Kotlin/Wasm"
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnUnsupportedPlatform.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnFailOnPublicationAndIgnoreForConsumptionPlatform.kt
similarity index 93%
rename from libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnUnsupportedPlatform.kt
rename to libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnFailOnPublicationAndIgnoreForConsumptionPlatform.kt
index fbfe006..0f511d7 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnUnsupportedPlatform.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/regressionTests/KT71398KotlinNativeBundleConfigurationOnFailOnPublicationAndIgnoreForConsumptionPlatform.kt
@@ -14,7 +14,7 @@
import kotlin.test.Test
import kotlin.test.assertNull
-class KT71398KotlinNativeBundleConfigurationOnUnsupportedPlatform {
+class KT71398KotlinNativeBundleConfigurationOnFailOnPublicationAndIgnoreForConsumptionPlatform {
@Test
fun `KT-71398 - project with multiplatform plugin should not add kotlinNativeBundleConfiguration`() {
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/IdeKotilnCompilerArgumentsResolverTest.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/IdeKotilnCompilerArgumentsResolverTest.kt
index b2500bd..b03ec8b 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/IdeKotilnCompilerArgumentsResolverTest.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/IdeKotilnCompilerArgumentsResolverTest.kt
@@ -62,7 +62,7 @@
else parseCommandLineArguments<K2MetadataCompilerArguments>(argumentsList)
KotlinPlatformType.jvm, KotlinPlatformType.androidJvm -> parseCommandLineArguments<K2JVMCompilerArguments>(argumentsList)
KotlinPlatformType.js, KotlinPlatformType.wasm -> parseCommandLineArguments<K2JSCompilerArguments>(argumentsList)
- KotlinPlatformType.native, KotlinPlatformType.unknown -> parseCommandLineArguments<K2NativeCompilerArguments>(argumentsList)
+ KotlinPlatformType.native -> parseCommandLineArguments<K2NativeCompilerArguments>(argumentsList)
}
val parsedArgumentsList = parsedArguments.toArgumentStrings(shortArgumentKeys = true, compactArgumentValues = false)
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibResolutionTests.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibResolutionTests.kt
new file mode 100644
index 0000000..b49741d
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibResolutionTests.kt
@@ -0,0 +1,761 @@
+/*
+ * 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.unitTests
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Attribute
+import org.gradle.kotlin.dsl.maven
+import org.jetbrains.kotlin.gradle.artifacts.UklibResolutionStrategy
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.resolvableMetadataConfiguration
+import org.jetbrains.kotlin.gradle.plugin.sources.internal
+import org.jetbrains.kotlin.gradle.util.*
+import org.jetbrains.kotlin.gradle.utils.projectPathOrNull
+import org.jetbrains.kotlin.utils.keysToMap
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.reflect.full.*
+
+class UklibResolutionTests {
+
+ @Test
+ fun `uklib resolution - from direct pom dependency with uklib packaging`() {
+ val consumer = consumer(UklibResolutionStrategy.AllowResolvingUklibs) {
+ jvm()
+ iosArm64()
+ iosX64()
+ js()
+ wasmJs()
+ wasmWasi()
+
+ sourceSets.commonMain.dependencies {
+ implementation("foo.bar:pure-maven-uklib:1.0")
+ }
+ }
+
+ val metadataCompilationVariants = consumer.multiplatformExtension.sourceSets.getByName("commonMain")
+ .internal.resolvableMetadataConfiguration
+ .resolveProjectDependencyComponentsWithArtifacts()
+ val iosArm64CompilationVariants = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration.resolveProjectDependencyComponentsWithArtifacts()
+ val jvmRuntimeVariants = consumer.multiplatformExtension.jvm().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+ val jsRuntimeVariants = consumer.multiplatformExtension.js().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+ val wasmJsVariants = consumer.multiplatformExtension.wasmJs().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+ val wasmWasiVariants = consumer.multiplatformExtension.wasmWasi().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="commonMainResolvableDependenciesMetadata",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibTransformationMetadataAttributes)
+ ),
+ ),
+ metadataCompilationVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64CompileKlibraries",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibTransformationIosArm64Attributes)
+ ),
+ ),
+ iosArm64CompilationVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationJvmAttributes)
+ ),
+ ),
+ jvmRuntimeVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="jsRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationJsAttributes)
+ ),
+ ),
+ jsRuntimeVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="wasmJsRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationWasmJsAttributes)
+ ),
+ ),
+ wasmJsVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="wasmWasiRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationWasmWasiAttributes)
+ ),
+ ),
+ wasmWasiVariants
+ )
+ }
+
+ @Test
+ fun `uklib resolution - from direct pom dependency with uklib packaging points to untrasformed uklib - when uklibs are not allowed to resolve`() {
+ val consumer = consumer(UklibResolutionStrategy.ResolveOnlyPlatformSpecificVariant) {
+ jvm()
+ iosArm64()
+ iosX64()
+
+ sourceSets.commonMain.dependencies {
+ implementation("foo.bar:pure-maven-uklib:1.0")
+ }
+ }
+
+ /**
+ * FIXME: This is unfortunate and in opposition to how KMP dependencies resolve right now because:
+ *
+ * KMP dependencies will fail to resolve if they have a missing platform/native type attribute
+ *
+ * but this is similar to how pure java dependencies (e.g. com.google.guava:guava:+) will resolve just fine
+ */
+
+ val metadataCompilationVariants = consumer.multiplatformExtension.sourceSets.getByName("commonMain")
+ .internal.resolvableMetadataConfiguration
+ .resolveProjectDependencyComponentsWithArtifacts()
+ val iosArm64CompilationVariants = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration.resolveProjectDependencyComponentsWithArtifacts()
+ val jvmRuntimeVariants = consumer.multiplatformExtension.jvm().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="commonMainResolvableDependenciesMetadata",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibArtifact)
+ ),
+ ),
+ metadataCompilationVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64CompileKlibraries",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibArtifact)
+ ),
+ ),
+ iosArm64CompilationVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-uklib:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibArtifact)
+ ),
+ ),
+ jvmRuntimeVariants
+ )
+ }
+
+ // consumer <- pure jvm <- uklib <- PSM-only
+ @Test
+ fun `uklib resolution - from transitive uklib dependency`() {
+ val consumer = consumer(UklibResolutionStrategy.AllowResolvingUklibs) {
+ jvm()
+ iosArm64()
+ iosX64()
+
+ sourceSets.commonMain.dependencies {
+ implementation("foo.bar:pure-maven-jvm-with-trasitive-uklib-dependency:1.0")
+ }
+ }
+
+ val metadataCompilationVariants = consumer.multiplatformExtension.sourceSets.getByName("commonMain")
+ .internal.resolvableMetadataConfiguration
+ .resolveProjectDependencyComponentsWithArtifacts()
+
+ val iosArm64CompilationVariants = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration.resolveProjectDependencyComponentsWithArtifacts()
+
+ val jvmRuntimeVariants = consumer.multiplatformExtension.jvm().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!.resolveProjectDependencyComponentsWithArtifacts()
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="commonMainResolvableDependenciesMetadata",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-jvm-with-trasitive-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + jarArtifact)
+ ),
+ "foo.bar:pure-maven-uklib-with-transitive-non-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibTransformationMetadataAttributes)
+ ),
+ "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
+ configuration="metadataApiElements",
+ artifacts=mutableListOf(metadataVariantAttributes + releaseStatus)
+ ),
+ ).pp(),
+ metadataCompilationVariants.pp()
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-jvm-with-trasitive-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + jarArtifact)
+ ),
+ "foo.bar:pure-maven-uklib-with-transitive-non-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="runtime",
+ artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationJvmAttributes)
+ ),
+ "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements-published",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:uklib-maven-gradle-packaging-jvm:1.0" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements-published",
+ artifacts=mutableListOf(platformJvmVariantAttributes + releaseStatus)
+ ),
+ ),
+ jvmRuntimeVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64CompileKlibraries",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:pure-maven-jvm-with-trasitive-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + jarArtifact)
+ ),
+ "foo.bar:pure-maven-uklib-with-transitive-non-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
+ configuration="compile",
+ artifacts=mutableListOf(jvmPomApiAttributes + uklibTransformationIosArm64Attributes)
+ ),
+ "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements-published",
+ artifacts=mutableListOf()
+ ),
+ "foo.bar:uklib-maven-gradle-packaging-iosarm64:1.0" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements-published",
+ // klib + cinterop klib
+ artifacts=mutableListOf(
+ platformIosArm64Attributes + releaseStatus,
+ platformIosArm64Attributes + releaseStatus,
+ )
+ ),
+ ),
+ iosArm64CompilationVariants
+ )
+ }
+
+// @Test
+ fun `resolve uklib - in Swift Export and ObjC binaries export configurations`() {
+ error("TODO")
+ }
+
+// @Test
+ fun `resolve uklib - in resolvable JS configurations with klibs`() {
+ error("TODO")
+ }
+
+ // ---
+ private fun consumer(
+ strategy: UklibResolutionStrategy,
+ configure: KotlinMultiplatformExtension.() -> Unit,
+ ): Project {
+ return buildProjectWithMPP(
+ preApplyCode = {
+ publishUklibVariant()
+ fakeUklibTransforms()
+ setUklibResolutionStrategy(strategy)
+ // Test stdlib in a separate test
+ enableDefaultStdlibDependency(false)
+ enableDefaultJsDomApiDependency(false)
+ }
+ ) {
+ kotlin {
+ configure()
+ }
+
+ repositories.maven(javaClass.getResource("/dependenciesResolution/UklibTests/repo")!!)
+ }.evaluate()
+ }
+
+ // @Test
+ fun `prefer klib variant`() {
+ val consumer = mixedCompilationsGraphConsumer(
+ uklibResolutionStrategy = UklibResolutionStrategy.AllowResolvingUklibs,
+ )
+
+ val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration
+ val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
+
+ val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!
+ val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
+
+ assertEquals(
+ mapOf(
+ ":E_consumes_D" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements",
+ artifacts=mutableListOf(platformJvmVariantAttributes)
+ ),
+ ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
+ ),
+ ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements",
+ artifacts=mutableListOf(platformJvmVariantAttributes)
+ ),
+ ":A_produces_uklib" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements",
+ artifacts=mutableListOf(platformJvmVariantAttributes),
+ )
+ ),
+ jvmResolvedVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":E_consumes_D" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64CompileKlibraries",
+ artifacts=mutableListOf()
+ ),
+ ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements",
+ artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
+ ),
+ ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
+ ),
+ ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements",
+ artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
+ ),
+ ":A_produces_uklib" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements",
+ artifacts=mutableListOf(platformIosArm64Attributes + nonPacked),
+ )
+ ),
+ iosArm64ResolvedVariants
+ )
+ }
+
+ // @Test
+ fun `prefer uklib variant`() {
+ val consumer = mixedCompilationsGraphConsumer(
+ uklibResolutionStrategy = UklibResolutionStrategy.AllowResolvingUklibs,
+ )
+
+ val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
+ .configurations.compileDependencyConfiguration
+ val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
+
+ val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
+ .configurations.runtimeDependencyConfiguration!!
+ // FIXME: java-api variant doesn't resolve A
+ val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
+
+ assertEquals(
+ mapOf(
+ ":E_consumes_D" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeClasspath",
+ artifacts=mutableListOf()
+ ),
+ ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
+ ),
+ ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
+ ),
+ ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
+ configuration="jvmRuntimeElements",
+ artifacts=mutableListOf(platformJvmVariantAttributes)
+ ),
+ ":A_produces_uklib" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes),
+ )
+ ),
+ jvmResolvedVariants
+ )
+
+ assertEquals(
+ mapOf(
+ ":E_consumes_D" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64CompileKlibraries",
+ artifacts=mutableListOf()
+ ),
+ ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
+ ),
+ ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
+ ),
+ ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
+ configuration="iosArm64ApiElements",
+ artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
+ ),
+ ":A_produces_uklib" to ResolvedComponentWithArtifacts(
+ configuration="metadataUklibElements",
+ artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes),
+ )
+ ),
+ iosArm64ResolvedVariants
+ )
+ }
+
+ private fun mixedCompilationsGraphConsumer(
+ uklibResolutionStrategy: UklibResolutionStrategy,
+ ): Project {
+ val root = buildProject()
+ return root.child(
+ "E_consumes_D",
+ uklibResolutionStrategy = uklibResolutionStrategy,
+ consume= root.child(
+ "D_produces_uklib_consumes_C",
+ consume = root.child(
+ "C_produces_only_uklib_consumes_B",
+ disablePlatformComponentReferences = true,
+ consume = root.child(
+ "B_produces_only_platform_variant_consumes_A",
+ publishUklibVariant = false,
+ consume = root.child(
+ "A_produces_uklib",
+ consume = null
+ )
+ )
+ )
+ )
+ )
+ }
+
+ private val uklibTransformationIosArm64Attributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "ios_arm64",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibTransformationJvmAttributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "jvm",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibTransformationMetadataAttributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "common",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibTransformationJsAttributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "js_ir",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibTransformationWasmJsAttributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "wasm_js",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibTransformationWasmWasiAttributes = mapOf(
+ "artifactType" to "uklib",
+ "uklibDestination" to "wasm_wasi",
+ "uklibState" to "unzipped",
+ )
+
+ private val uklibVariantAttributes = mapOf(
+ "org.gradle.category" to "library",
+ "org.gradle.jvm.environment" to "???",
+ "org.gradle.usage" to "kotlin-uklib",
+ "org.jetbrains.kotlin.klib.packaging" to "packed",
+ "org.jetbrains.kotlin.native.target" to "???",
+ "org.jetbrains.kotlin.platform.type" to "unknown",
+ )
+
+ private val jvmPomRuntimeAttributes = mapOf(
+ "org.gradle.category" to "library",
+ "org.gradle.libraryelements" to "jar",
+ "org.gradle.status" to "release",
+ "org.gradle.usage" to "java-runtime",
+ )
+
+ private val jvmPomApiAttributes = mapOf(
+ "org.gradle.category" to "library",
+ "org.gradle.libraryelements" to "jar",
+ "org.gradle.status" to "release",
+ "org.gradle.usage" to "java-api",
+ )
+
+ private val platformJvmVariantAttributes = mapOf(
+ "artifactType" to "jar",
+ "org.gradle.category" to "library",
+ "org.gradle.jvm.environment" to "standard-jvm",
+ "org.gradle.libraryelements" to "jar",
+ "org.gradle.usage" to "java-runtime",
+ "org.jetbrains.kotlin.platform.type" to "jvm",
+ )
+
+ private val metadataVariantAttributes = mapOf(
+ "artifactType" to "jar",
+ "org.gradle.category" to "library",
+ "org.gradle.jvm.environment" to "non-jvm",
+ "org.gradle.libraryelements" to "jar",
+ "org.gradle.usage" to "kotlin-metadata",
+ "org.jetbrains.kotlin.platform.type" to "common",
+ )
+
+ private val releaseStatus = mapOf(
+ "org.gradle.status" to "release",
+ )
+
+ // We only emit packing in secondary variants which are not published?
+ private val nonPacked = mapOf(
+ "org.jetbrains.kotlin.klib.packaging" to "non-packed",
+ )
+
+ private val jarArtifact = mapOf(
+ "artifactType" to "jar",
+ )
+
+ private val uklibArtifact = mapOf(
+ "artifactType" to "uklib",
+ )
+
+ private val platformIosArm64Attributes = mapOf(
+ "artifactType" to "org.jetbrains.kotlin.klib",
+ "org.gradle.category" to "library",
+ "org.gradle.jvm.environment" to "non-jvm",
+ "org.gradle.usage" to "kotlin-api",
+ "org.jetbrains.kotlin.cinteropCommonizerArtifactType" to "klib",
+ "org.jetbrains.kotlin.native.target" to "ios_arm64",
+ "org.jetbrains.kotlin.platform.type" to "native",
+ )
+
+ data class ResolvedComponentWithArtifacts(
+ val configuration: String,
+ val artifacts: MutableList<Map<String, String>> = mutableListOf(),
+ )
+
+ private fun Configuration.resolveProjectDependencyComponentsWithArtifacts(): Map<String, ResolvedComponentWithArtifacts> {
+ val artifacts = resolveProjectDependencyVariantsFromArtifacts()
+ val components = resolveProjectDependencyComponents()
+ val componentToArtifacts = LinkedHashMap<String, ResolvedComponentWithArtifacts>()
+ components.forEach { component ->
+ if (componentToArtifacts[component.path] == null) {
+ componentToArtifacts[component.path] = ResolvedComponentWithArtifacts(component.configuration)
+ } else {
+ error("${component} resolved multiple times?")
+ }
+ }
+ artifacts.forEach { artifact ->
+ componentToArtifacts[artifact.path]?.let {
+ it.artifacts.add(artifact.attributes)
+ } ?: error("Missing resolved component for artifact: ${artifact}")
+ }
+ return componentToArtifacts
+ }
+
+ data class ResolvedVariant(
+ val path: String,
+ val attributes: Map<String, String>,
+ )
+
+ private fun Configuration.resolveProjectDependencyVariantsFromArtifacts(): List<ResolvedVariant> {
+ return incoming.artifacts.artifacts
+ .map { artifact ->
+ val uklibAttributes: List<Attribute<*>> = artifact.variant.attributes.keySet()
+ .sortedBy { it.name }
+ ResolvedVariant(
+ artifact.variant.owner.projectPathOrNull ?: artifact.variant.owner.displayName,
+ uklibAttributes.keysToMap {
+ artifact.variant.attributes.getAttribute(it as Attribute<*>).toString()
+ }.mapKeys { it.key.name }
+ )
+ }
+ }
+
+ data class ResolvedComponent(
+ val path: String,
+ val configuration: String,
+ )
+
+ private fun Configuration.resolveProjectDependencyComponents(): List<ResolvedComponent> {
+ return incoming.resolutionResult.allComponents
+ .map { component ->
+ ResolvedComponent(
+ component.id.projectPathOrNull ?: component.id.displayName,
+ // Expect a single variant to always be selected?
+ component.variants.single().displayName
+ )
+ }
+ }
+
+ private fun Project.child(
+ name: String,
+ consume: Project?,
+ publishUklibVariant: Boolean = true,
+ disablePlatformComponentReferences: Boolean = false,
+ uklibResolutionStrategy: UklibResolutionStrategy = UklibResolutionStrategy.ResolveOnlyPlatformSpecificVariant,
+ ): Project {
+ val parent = this
+ return buildProjectWithMPP(
+ preApplyCode = {
+ if (publishUklibVariant) {
+ publishUklibVariant()
+ }
+ fakeUklibTransforms()
+ setUklibResolutionStrategy(uklibResolutionStrategy)
+ disablePlatformSpecificComponentReferences(disablePlatformComponentReferences)
+ // Test stdlib in a separate test
+ enableDefaultStdlibDependency(false)
+ enableDefaultJsDomApiDependency(false)
+ },
+ projectBuilder = {
+ withParent(parent)
+ withName(name)
+ }
+ ) {
+ kotlin {
+ iosArm64()
+ iosX64()
+ jvm()
+
+ if (consume != null) {
+ sourceSets.commonMain.dependencies {
+ implementation(project(consume.project.path))
+ }
+ }
+ }
+ }.evaluate()
+ }
+}
+
+class PP(
+ val value: Any,
+ val indentation: Int,
+) {
+ override fun toString(): String {
+ val twoSpaces = " ".repeat(2)
+ val indentationSpace = " ".repeat(indentation)
+ val nextIndentationDepth = indentation + 2
+ val elements: Array<String> = when (value) {
+ is Map<*, *> -> arrayOf(
+ "{",
+ *value.map { it }.sortedBy { it.key.toString() }.map { "${twoSpaces}${it.key}=${it.value?.pp(nextIndentationDepth)}," }.toTypedArray(),
+ "}",
+ )
+ is List<*> -> arrayOf(
+ "[",
+ *value.map { "${twoSpaces}${it?.pp(nextIndentationDepth)}," }.toTypedArray(),
+ "]",
+ )
+ else -> {
+ val packageName = value::class.java.packageName
+ if (packageName.startsWith("kotlin.") || packageName.startsWith("java.")) {
+ arrayOf(value.toString())
+ } else {
+ val kClass = value::class
+ arrayOf(
+ "${kClass.simpleName}(",
+ *kClass.memberProperties.map { prop ->
+ "${twoSpaces}${prop.name}=${prop.getter.call(value)?.pp(nextIndentationDepth)},"
+ }.toTypedArray(),
+ ")",
+ )
+ }
+ }
+ }
+
+ if (elements.size == 1) return elements[0]
+
+ return (listOf(elements[0]) + elements.toList().subList(1, elements.size).map { "${indentationSpace}${it}" }).joinToString("\n")
+ }
+
+ override fun hashCode(): Int {
+ return value.hashCode()
+ }
+
+ override fun equals(other: Any?): Boolean {
+ var otherUnwrapped = other
+ if (other is PP) otherUnwrapped = other.value
+ return value.equals(otherUnwrapped)
+ }
+}
+
+private fun Any.pp(indentation: Int = 0): PP = PP(this, indentation)
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibTests.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibTests.kt
deleted file mode 100644
index 8aa653a..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/unitTests/UklibTests.kt
+++ /dev/null
@@ -1,597 +0,0 @@
-/*
- * 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.unitTests
-
-import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.attributes.Attribute
-import org.gradle.api.attributes.Usage
-import org.gradle.kotlin.dsl.maven
-import org.gradle.kotlin.dsl.named
-import org.jetbrains.kotlin.gradle.artifacts.UklibResolutionStrategy
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.dsl.multiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinUsages
-import org.jetbrains.kotlin.gradle.util.*
-import org.jetbrains.kotlin.gradle.utils.projectPathOrNull
-import org.jetbrains.kotlin.utils.keysToMap
-import kotlin.test.Test
-import kotlin.test.assertEquals
-
-class UklibTests {
-
- @Test
- fun `resolve uklib - from pom with uklib packaging`() {
- val consumer = consumer(UklibResolutionStrategy.PreferPlatformSpecificVariant) {
- sourceSets.commonMain.dependencies {
- // FIXME: Everything works kind of nicely, but either the consumer has to publish a separate component for pure Maven jar consumption, or Maven has to know about uklibs
- implementation("foo.bar:regular-maven-jar-packaging-with-uklib-uklib-dependency:1.0")
- }
- }
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- assertEquals(
- mapOf(
- ":" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeClasspath",
- artifacts=mutableListOf()
- ),
- "foo.bar:regular-maven-jar-packaging-with-uklib-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
- configuration="runtime",
- artifacts=mutableListOf(jvmPomRuntimeAttributes + jarArtifact)
- ),
- "foo.bar:uklib-maven-uklib-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="runtime",
- artifacts=mutableListOf(jvmPomRuntimeAttributes + uklibTransformationJvmAttributes)
- ),
- "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements-published",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-gradle-packaging-jvm:1.0" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements-published",
- artifacts=mutableListOf(platformJvmVariantAttributes + releaseStatus)
- ),
- ),
- jvmResolvedVariants
- )
-
- assertEquals(
- mapOf(
- ":" to ResolvedComponentWithArtifacts(
- configuration="iosArm64CompileKlibraries",
- artifacts=mutableListOf()
- ),
- "foo.bar:regular-maven-jar-packaging-with-uklib-uklib-dependency:1.0" to ResolvedComponentWithArtifacts(
- configuration="compile",
- artifacts=mutableListOf(jvmPomApiAttributes + jarArtifact)
- ),
- "foo.bar:uklib-maven-uklib-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="compile",
- artifacts=mutableListOf(jvmPomApiAttributes + uklibTransformationIosArm64Attributes)
- ),
- "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements-published",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-gradle-packaging-iosarm64:1.0" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements-published",
- // klib + cinterop klib
- artifacts=mutableListOf(
- platformIosArm64Attributes + releaseStatus,
- platformIosArm64Attributes + releaseStatus,
- )
- ),
- ),
- iosArm64ResolvedVariants
- )
- }
-
- @Test
- fun `resolve uklib - from pom with jar packaging - with explicit extension`() {
- val consumer = consumer(UklibResolutionStrategy.PreferPlatformSpecificVariant) {
- sourceSets.commonMain.dependencies {
- /**
- * FIXME: If this dependency is brought transitively, it's unclear how the regular-maven-jar-packaging POM should specify the dependency on a uklib, such that both KGP and Maven consumers can depend on it easily
- *
- * This could work with variant reselection, but then we have to use artifactViews
- */
- // implementation("foo.bar:regular-maven-jar-packaging:1.0")
- implementation("foo.bar:uklib-maven-jar-packaging:1.0@uklib") {
- // FIXME: Why does explicit extension specification unset transitiveness?
- assert(!isTransitive)
- isTransitive = true
- }
- }
- }
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- assertEquals(
- mapOf(
- ":" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeClasspath",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-jar-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="runtime",
- artifacts=mutableListOf(uklibTransformationJvmAttributes + releaseStatus)
- ),
- "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements-published",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-gradle-packaging-jvm:1.0" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements-published",
- artifacts=mutableListOf(platformJvmVariantAttributes + releaseStatus)
- ),
- ),
- jvmResolvedVariants
- )
-
- assertEquals(
- mapOf(
- ":" to ResolvedComponentWithArtifacts(
- configuration="iosArm64CompileKlibraries",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-jar-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="compile",
- artifacts=mutableListOf(uklibTransformationIosArm64Attributes + releaseStatus)
- ),
- "foo.bar:uklib-maven-gradle-packaging:1.0" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements-published",
- artifacts=mutableListOf()
- ),
- "foo.bar:uklib-maven-gradle-packaging-iosarm64:1.0" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements-published",
- artifacts=mutableListOf(
- platformIosArm64Attributes + releaseStatus,
- platformIosArm64Attributes + releaseStatus,
- )
- ),
- ),
- iosArm64ResolvedVariants
- )
- }
-
-
- // FIXME: Maybe this is usable?
-// consumer.configurations.configureEach {
-// if (it.isCanBeResolved) {
-// it.resolutionStrategy.eachDependency {
-// it.artifactSelection {
-//
-// }
-// }
-// it.resolutionStrategy.componentSelection.all {
-// it.
-// }
-// }
-// }
- @Test
- fun `resolve uklib - from pom with jar packaging - with explicit extension - and component rule`() {
- val consumer = consumer(UklibResolutionStrategy.PreferUklibVariant) {
- sourceSets.commonMain.dependencies {
- // implementation("foo.bar:uklib-maven-jar-packaging:1.0")
- // consume "foo.bar:uklib-maven-jar-packaging:1.0" transitively
- // FIXME: With a naive component metadata rule regular jars fail to resolve
- implementation("foo.bar:regular-maven-jar-packaging-with-uklib-jar-dependency:1.0")
- }
-
- project.dependencies.components.all { component ->
- component.maybeAddVariant(
- "uklib",
- // FIXME: runtime?
- "compile",
- ) {
- // How do you know that the file will be there?
- it.withFiles {
- // When there are multiple artifacts, Gradle doesn't set artifactType
- it.removeAllFiles()
- it.addFile("${component.id.name}-${component.id.version}.uklib")
- }
- it.attributes.attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(KotlinUsages.KOTLIN_UKLIB))
- }
- }
- }
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- // ???
- }
-
- // @Test
- // FIXME: This is probably pretty useless because with the classifier artifactType has to be jar and its unclear how to force a transform
- fun `resolve uklib - from pom with jar packaging - with explicit classifier`() {
- val consumer = consumer(UklibResolutionStrategy.PreferPlatformSpecificVariant) {
- sourceSets.commonMain.dependencies {
- implementation("foo.bar:uklib-maven-jar-packaging-classifier:1.0:uklib")
- }
- }
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- // ???
- }
-
- private fun consumer(
- strategy: UklibResolutionStrategy,
- configure: KotlinMultiplatformExtension.() -> Unit,
- ): Project {
- return buildProjectWithMPP(
- preApplyCode = {
- publishUklibVariant()
- fakeUklibTransforms()
- setUklibResolutionStrategy(strategy)
- // Test stdlib in a separate test
- enableDefaultStdlibDependency(false)
- }
- ) {
- kotlin {
- iosArm64()
- iosX64()
- jvm()
-
- configure()
- }
-
- repositories.maven(javaClass.getResource("/dependenciesResolution/UklibTests/repo")!!)
- }.evaluate()
- }
-
- @Test
- fun `prefer klib variant`() {
- val consumer = mixedCompilationsGraphConsumer(
- uklibResolutionStrategy = UklibResolutionStrategy.PreferPlatformSpecificVariant,
- )
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- assertEquals(
- mapOf(
- ":E_consumes_D" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeClasspath",
- artifacts=mutableListOf()
- ),
- ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements",
- artifacts=mutableListOf(platformJvmVariantAttributes)
- ),
- ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
- ),
- ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements",
- artifacts=mutableListOf(platformJvmVariantAttributes)
- ),
- ":A_produces_uklib" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements",
- artifacts=mutableListOf(platformJvmVariantAttributes),
- )
- ),
- jvmResolvedVariants
- )
-
- assertEquals(
- mapOf(
- ":E_consumes_D" to ResolvedComponentWithArtifacts(
- configuration="iosArm64CompileKlibraries",
- artifacts=mutableListOf()
- ),
- ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements",
- artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
- ),
- ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
- ),
- ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements",
- artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
- ),
- ":A_produces_uklib" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements",
- artifacts=mutableListOf(platformIosArm64Attributes + nonPacked),
- )
- ),
- iosArm64ResolvedVariants
- )
- }
-
- @Test
- fun `prefer uklib variant`() {
- val consumer = mixedCompilationsGraphConsumer(
- uklibResolutionStrategy = UklibResolutionStrategy.PreferUklibVariant,
- )
-
- val iosArm64CompilationDependencies = consumer.multiplatformExtension.iosArm64().compilations.getByName("main")
- .configurations.compileDependencyConfiguration
- val iosArm64ResolvedVariants = iosArm64CompilationDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- val jvmRuntimeDependencies = consumer.multiplatformExtension.jvm().compilations.getByName("main")
- .configurations.runtimeDependencyConfiguration!!
- // FIXME: java-api variant doesn't resolve A
- val jvmResolvedVariants = jvmRuntimeDependencies.resolveProjectDependencyComponentsWithArtifacts()
-
- assertEquals(
- mapOf(
- ":E_consumes_D" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeClasspath",
- artifacts=mutableListOf()
- ),
- ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
- ),
- ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes)
- ),
- ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
- configuration="jvmRuntimeElements",
- artifacts=mutableListOf(platformJvmVariantAttributes)
- ),
- ":A_produces_uklib" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationJvmAttributes),
- )
- ),
- jvmResolvedVariants
- )
-
- assertEquals(
- mapOf(
- ":E_consumes_D" to ResolvedComponentWithArtifacts(
- configuration="iosArm64CompileKlibraries",
- artifacts=mutableListOf()
- ),
- ":D_produces_uklib_consumes_C" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
- ),
- ":C_produces_only_uklib_consumes_B" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes)
- ),
- ":B_produces_only_platform_variant_consumes_A" to ResolvedComponentWithArtifacts(
- configuration="iosArm64ApiElements",
- artifacts=mutableListOf(platformIosArm64Attributes + nonPacked)
- ),
- ":A_produces_uklib" to ResolvedComponentWithArtifacts(
- configuration="metadataUklibElements",
- artifacts=mutableListOf(uklibVariantAttributes + uklibTransformationIosArm64Attributes),
- )
- ),
- iosArm64ResolvedVariants
- )
- }
-
- private fun mixedCompilationsGraphConsumer(
- uklibResolutionStrategy: UklibResolutionStrategy,
- ): Project {
- val root = buildProject()
- return root.child(
- "E_consumes_D",
- uklibResolutionStrategy = uklibResolutionStrategy,
- consume= root.child(
- "D_produces_uklib_consumes_C",
- consume = root.child(
- "C_produces_only_uklib_consumes_B",
- disablePlatformComponentReferences = true,
- consume = root.child(
- "B_produces_only_platform_variant_consumes_A",
- publishUklibVariant = false,
- consume = root.child(
- "A_produces_uklib",
- consume = null
- )
- )
- )
- )
- )
- }
-
- private val uklibTransformationIosArm64Attributes = mapOf(
- "artifactType" to "uklib",
- "uklibNativeSlice" to "iosArm64",
- "uklibPlatform" to "native",
- "uklibState" to "unzipped",
- )
-
- private val uklibTransformationJvmAttributes = mapOf(
- "artifactType" to "uklib",
- "uklibNativeSlice" to "unknown",
- "uklibPlatform" to "jvm",
- "uklibState" to "unzipped",
- )
-
- private val uklibVariantAttributes = mapOf(
- "org.gradle.category" to "library",
- "org.gradle.jvm.environment" to "???",
- "org.gradle.usage" to "kotlin-uklib",
- "org.jetbrains.kotlin.klib.packaging" to "packed",
- "org.jetbrains.kotlin.native.target" to "???",
- "org.jetbrains.kotlin.platform.type" to "unknown",
- )
-
- private val jvmPomRuntimeAttributes = mapOf(
- "org.gradle.category" to "library",
- "org.gradle.libraryelements" to "jar",
- "org.gradle.status" to "release",
- "org.gradle.usage" to "java-runtime",
- )
-
- private val jvmPomApiAttributes = mapOf(
- "org.gradle.category" to "library",
- "org.gradle.libraryelements" to "jar",
- "org.gradle.status" to "release",
- "org.gradle.usage" to "java-api",
- )
-
- private val platformJvmVariantAttributes = mapOf(
- "artifactType" to "jar",
- "org.gradle.category" to "library",
- "org.gradle.jvm.environment" to "standard-jvm",
- "org.gradle.libraryelements" to "jar",
- "org.gradle.usage" to "java-runtime",
- "org.jetbrains.kotlin.platform.type" to "jvm",
- )
-
- private val releaseStatus = mapOf(
- "org.gradle.status" to "release",
- )
-
- // We only emit packing in secondary variants which are not published?
- private val nonPacked = mapOf(
- "org.jetbrains.kotlin.klib.packaging" to "non-packed",
- )
-
- private val jarArtifact = mapOf(
- "artifactType" to "jar",
- )
-
- private val platformIosArm64Attributes = mapOf(
- "artifactType" to "org.jetbrains.kotlin.klib",
- "org.gradle.category" to "library",
- "org.gradle.jvm.environment" to "non-jvm",
- "org.gradle.usage" to "kotlin-api",
- "org.jetbrains.kotlin.cinteropCommonizerArtifactType" to "klib",
- "org.jetbrains.kotlin.native.target" to "ios_arm64",
- "org.jetbrains.kotlin.platform.type" to "native",
- )
-
- data class ResolvedComponentWithArtifacts(
- val configuration: String,
- val artifacts: MutableList<Map<String, String>> = mutableListOf(),
- )
-
- private fun Configuration.resolveProjectDependencyComponentsWithArtifacts(): Map<String, ResolvedComponentWithArtifacts> {
- val artifacts = resolveProjectDependencyVariantsFromArtifacts()
- val components = resolveProjectDependencyComponents()
- val componentToArtifacts = LinkedHashMap<String, ResolvedComponentWithArtifacts>()
- components.forEach { component ->
- if (componentToArtifacts[component.path] == null) {
- componentToArtifacts[component.path] = ResolvedComponentWithArtifacts(component.configuration)
- } else {
- error("${component} resolved multiple times?")
- }
- }
- artifacts.forEach { artifact ->
- componentToArtifacts[artifact.path]?.let {
- it.artifacts.add(artifact.attributes)
- } ?: error("Missing resolved component for artifact: ${artifact}")
- }
- return componentToArtifacts
- }
-
- data class ResolvedVariant(
- val path: String,
- val attributes: Map<String, String>,
- )
-
- private fun Configuration.resolveProjectDependencyVariantsFromArtifacts(): List<ResolvedVariant> {
- return incoming.artifacts.artifacts
- .map { artifact ->
- val uklibAttributes: List<Attribute<*>> = artifact.variant.attributes.keySet()
- .sortedBy { it.name }
- ResolvedVariant(
- artifact.variant.owner.projectPathOrNull ?: artifact.variant.owner.displayName,
- uklibAttributes.keysToMap {
- artifact.variant.attributes.getAttribute(it as Attribute<*>).toString()
- }.mapKeys { it.key.name }
- )
- }
- }
-
- data class ResolvedComponent(
- val path: String,
- val configuration: String,
- )
-
- private fun Configuration.resolveProjectDependencyComponents(): List<ResolvedComponent> {
- return incoming.resolutionResult.allComponents
- .map { component ->
- ResolvedComponent(
- component.id.projectPathOrNull ?: component.id.displayName,
- // Expect a single variant to always be selected?
- component.variants.single().displayName
- )
- }
- }
-
- private fun Project.child(
- name: String,
- consume: Project?,
- publishUklibVariant: Boolean = true,
- disablePlatformComponentReferences: Boolean = false,
- uklibResolutionStrategy: UklibResolutionStrategy = UklibResolutionStrategy.ResolveOnlyPlatformSpecificVariant,
- ): Project {
- val parent = this
- return buildProjectWithMPP(
- preApplyCode = {
- if (publishUklibVariant) {
- publishUklibVariant()
- }
- fakeUklibTransforms()
- setUklibResolutionStrategy(uklibResolutionStrategy)
- disablePlatformSpecificComponentReferences(disablePlatformComponentReferences)
- // Test stdlib in a separate test
- enableDefaultStdlibDependency(false)
- },
- projectBuilder = {
- withParent(parent)
- withName(name)
- }
- ) {
- kotlin {
- iosArm64()
- iosX64()
- jvm()
-
- if (consume != null) {
- sourceSets.commonMain.dependencies {
- implementation(project(consume.project.path))
- }
- }
- }
- }.evaluate()
- }
-
-}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/util/buildProject.kt b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/util/buildProject.kt
index 762da67..3e3b9ac 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/util/buildProject.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/kotlin/org/jetbrains/kotlin/gradle/util/buildProject.kt
@@ -135,10 +135,10 @@
}
fun Project.publishUklibVariant(enabled: Boolean = true) {
- propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB_VARIANT, enabled.toString())
+ propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_PUBLISH_UKLIB, enabled.toString())
}
-fun Project.setUklibResolutionStrategy(strategy: UklibResolutionStrategy) {
+internal fun Project.setUklibResolutionStrategy(strategy: UklibResolutionStrategy) {
propertiesExtension.set(PropertiesProvider.PropertyNames.KOTLIN_MPP_UKLIB_RESOLUTION_STRATEGY, strategy.propertyName)
}
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-uklib-dependency/1.0/regular-maven-jar-packaging-with-uklib-uklib-dependency-1.0.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-jvm-with-trasitive-uklib-dependency/1.0/pure-maven-jvm-with-trasitive-uklib-dependency-1.0.jar
similarity index 100%
rename from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-uklib-dependency/1.0/regular-maven-jar-packaging-with-uklib-uklib-dependency-1.0.jar
rename to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-jvm-with-trasitive-uklib-dependency/1.0/pure-maven-jvm-with-trasitive-uklib-dependency-1.0.jar
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-jvm-with-trasitive-uklib-dependency/1.0/pure-maven-jvm-with-trasitive-uklib-dependency-1.0.pom
similarity index 74%
copy from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
copy to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-jvm-with-trasitive-uklib-dependency/1.0/pure-maven-jvm-with-trasitive-uklib-dependency-1.0.pom
index 176d810..6e0ac2b 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-jvm-with-trasitive-uklib-dependency/1.0/pure-maven-jvm-with-trasitive-uklib-dependency-1.0.pom
@@ -3,13 +3,12 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>foo.bar</groupId>
- <artifactId>uklib-maven-uklib-packaging</artifactId>
+ <artifactId>pure-maven-jvm-with-trasitive-uklib-dependency</artifactId>
<version>1.0</version>
- <packaging>uklib</packaging>
<dependencies>
<dependency>
<groupId>foo.bar</groupId>
- <artifactId>uklib-maven-gradle-packaging</artifactId>
+ <artifactId>pure-maven-uklib-with-transitive-non-uklib-dependency</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.jar
similarity index 100%
copy from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib
copy to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.jar
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.pom
similarity index 86%
rename from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
rename to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.pom
index 176d810..0b56a7f 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.pom
@@ -3,7 +3,7 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>foo.bar</groupId>
- <artifactId>uklib-maven-uklib-packaging</artifactId>
+ <artifactId>pure-maven-uklib-with-transitive-non-uklib-dependency</artifactId>
<version>1.0</version>
<packaging>uklib</packaging>
<dependencies>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.uklib
similarity index 100%
copy from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib
copy to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib-with-transitive-non-uklib-dependency/1.0/pure-maven-uklib-with-transitive-non-uklib-dependency-1.0.uklib
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.jar
similarity index 100%
copy from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib
copy to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.jar
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.pom
similarity index 60%
copy from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
copy to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.pom
index 176d810..062ba26 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.pom
+++ b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.pom
@@ -3,14 +3,7 @@
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<groupId>foo.bar</groupId>
- <artifactId>uklib-maven-uklib-packaging</artifactId>
+ <artifactId>pure-maven-uklib</artifactId>
<version>1.0</version>
<packaging>uklib</packaging>
- <dependencies>
- <dependency>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-gradle-packaging</artifactId>
- <version>1.0</version>
- </dependency>
- </dependencies>
</project>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.uklib
similarity index 100%
rename from libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.uklib
rename to libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/pure-maven-uklib/1.0/pure-maven-uklib-1.0.uklib
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.jar
deleted file mode 100644
index 8b13789..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.jar
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.pom
deleted file mode 100644
index 8402982..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-jar-dependency/1.0/regular-maven-jar-packaging-with-uklib-jar-dependency-1.0.pom
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
- <modelVersion>4.0.0</modelVersion>
- <groupId>foo.bar</groupId>
- <artifactId>regular-maven-jar-packaging-with-uklib-jar-dependency</artifactId>
- <version>1.0</version>
-<!-- This is the implicit default-->
-<!-- <packaging>jar</packaging>-->
- <dependencies>
- <dependency>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-jar-packaging</artifactId>
- <version>1.0</version>
- </dependency>
- </dependencies>
-</project>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-uklib-dependency/1.0/regular-maven-jar-packaging-with-uklib-uklib-dependency-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-uklib-dependency/1.0/regular-maven-jar-packaging-with-uklib-uklib-dependency-1.0.pom
deleted file mode 100644
index d4bcedf..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/regular-maven-jar-packaging-with-uklib-uklib-dependency/1.0/regular-maven-jar-packaging-with-uklib-uklib-dependency-1.0.pom
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
- <modelVersion>4.0.0</modelVersion>
- <groupId>foo.bar</groupId>
- <artifactId>regular-maven-jar-packaging-with-uklib-uklib-dependency</artifactId>
- <version>1.0</version>
-<!-- This is the implicit default-->
-<!-- <packaging>jar</packaging>-->
- <dependencies>
- <dependency>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-uklib-packaging</artifactId>
- <version>1.0</version>
- </dependency>
- </dependencies>
-</project>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0-uklib.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0-uklib.jar
deleted file mode 100644
index 8b13789..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0-uklib.jar
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.jar
deleted file mode 100644
index 8b13789..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.jar
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.pom
deleted file mode 100644
index 625e1ab..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging-classifier/1.0/uklib-maven-jar-packaging-classifier-1.0.pom
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
- <modelVersion>4.0.0</modelVersion>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-jar-packaging-classifier</artifactId>
- <version>1.0</version>
-<!-- This is the implicit default-->
-<!-- <packaging>jar</packaging>-->
- <dependencies>
- <dependency>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-gradle-packaging</artifactId>
- <version>1.0</version>
- </dependency>
- </dependencies>
-</project>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.jar
deleted file mode 100644
index 8b13789..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.jar
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.pom b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.pom
deleted file mode 100644
index 57a198b..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-jar-packaging/1.0/uklib-maven-jar-packaging-1.0.pom
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
- <modelVersion>4.0.0</modelVersion>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-jar-packaging</artifactId>
- <version>1.0</version>
-<!-- This is the implicit default-->
-<!-- <packaging>jar</packaging>-->
- <dependencies>
- <dependency>
- <groupId>foo.bar</groupId>
- <artifactId>uklib-maven-gradle-packaging</artifactId>
- <version>1.0</version>
- </dependency>
- </dependencies>
-</project>
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.jar b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.jar
deleted file mode 100644
index 8b13789..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.jar
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.uklib b/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.uklib
deleted file mode 100644
index e69de29..0000000
--- a/libraries/tools/kotlin-gradle-plugin/src/functionalTest/resources/dependenciesResolution/UklibTests/repo/foo/bar/uklib-maven-uklib-packaging/1.0/uklib-maven-uklib-packaging-1.0.uklib
+++ /dev/null
