From 724d527fd891975360e449535847340d19b3bab0 Mon Sep 17 00:00:00 2001 From: Kirill Rakhman Date: Thu, 10 Aug 2023 12:45:09 +0200 Subject: [PATCH] [FIR] Fixes for call conflict resolution Let ConeCompositeConflictResolver pass the results of the previous resolver to the next one. Otherwise, we get false positive conflicts when a set of candidates can't be fully reduced by one resolver but could be resolved by the subsequent application of multiple ones. This change makes ConeCompositeConflictResolver order-dependent and thus, ConeOverloadConflictResolver must be invoked last, because it must work on a pre-filtered list. Also, let ConeEquivalentCallConflictResolver use FirStandardOverrideChecker instead of compareCallsByUsedArguments because it's stricter. This all fixes a false positive overload resolution ambiguity in common metadata compilation that is caused by stdlib using the new KMP format. Now stdlib metadata is in the classpath, and so declarations from the stdlib are returned from both MetadataSymbolProvider and KlibBasedSymbolProvider. This isn't a problem per se because duplicate candidates are filtered out by ConeEquivalentCallConflictResolver (K1 works analogously), but in the case of top-level functions with generic receivers like Collection.toTypedArray, the check failed because of the direct comparison of receiver types. #KT-60943 Fixed --- .../DefaultCallConflictResolverFactory.kt | 6 +- .../session/JsConeConflictResolverFactory.kt | 6 +- .../jvm/ConeEquivalentCallConflictResolver.kt | 30 ++++------ .../jvm/JvmCallConflictResolverFactory.kt | 6 +- .../calls/ConeCompositeConflictResolver.kt | 2 +- .../inference/builderInference/kt49828.fir.kt | 4 +- .../RedeclaringPrivateToFile.fir.kt | 4 +- ...ForOverloadResolutionWithErrorTypes.fir.kt | 2 +- .../tests/varargs/AmbiguousVararg.fir.kt | 6 -- .../tests/varargs/AmbiguousVararg.kt | 1 + .../p-2/neg/1.1.fir.kt | 6 +- .../p-2/pos/1.1.fir.kt | 56 ------------------- .../p-2/pos/1.1.kt | 1 + .../p-2/neg/1.1.fir.kt | 6 +- .../p-2/pos/1.1.fir.kt | 56 ------------------- .../p-2/pos/1.1.kt | 1 + .../org/jetbrains/kotlin/gradle/K2Tests.kt | 21 ++++++- .../build.gradle.kts | 5 -- .../src/commonMain/kotlin/call.kt | 3 + 19 files changed, 55 insertions(+), 167 deletions(-) delete mode 100644 compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.fir.kt delete mode 100644 compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt delete mode 100644 compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt create mode 100644 libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/src/commonMain/kotlin/call.kt diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/DefaultCallConflictResolverFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/DefaultCallConflictResolverFactory.kt index bb0cbddf9b5..e4082ef00c2 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/DefaultCallConflictResolverFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/DefaultCallConflictResolverFactory.kt @@ -21,13 +21,11 @@ object DefaultCallConflictResolverFactory : ConeCallConflictResolverFactory() { transformerComponents: BodyResolveComponents ): ConeCompositeConflictResolver { val specificityComparator = TypeSpecificityComparator.NONE - // NB: Please, be aware that adding might not necessarily help you because ConeOverloadConflictResolver doesn't just filter out - // less specific candidates, but leave the set the same if there are more than one same-specifity candidates. - // Thus, in that case, your new ConeCallConflictResolver might get all the candidates in that case. + // NB: Adding new resolvers is strongly discouraged because the results are order-dependent. return ConeCompositeConflictResolver( - ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ConeEquivalentCallConflictResolver(specificityComparator, components, transformerComponents), ConeIntegerOperatorConflictResolver, + ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ) } } diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/JsConeConflictResolverFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/JsConeConflictResolverFactory.kt index 9225b711f4e..08ff4dd0ed8 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/JsConeConflictResolverFactory.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/JsConeConflictResolverFactory.kt @@ -25,13 +25,11 @@ object JsCallConflictResolverFactory : ConeCallConflictResolverFactory() { transformerComponents: BodyResolveComponents ): ConeCompositeConflictResolver { val specificityComparator = JsTypeSpecificityComparatorWithoutDelegate(components.session.typeContext) - // NB: Please, be aware that adding might not necessarily help you because ConeOverloadConflictResolver doesn't just filter out - // less specific candidates, but leave the set the same if there are more than one same-specifity candidates. - // Thus, in that case, your new ConeCallConflictResolver might get all the candidates in that case. + // NB: Adding new resolvers is strongly discouraged because the results are order-dependent. return ConeCompositeConflictResolver( - ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ConeEquivalentCallConflictResolver(specificityComparator, components, transformerComponents), ConeIntegerOperatorConflictResolver, + ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ) } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt index 1aee96a72eb..a8271665c2d 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/ConeEquivalentCallConflictResolver.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.AbstractConeCallConflictResolver import org.jetbrains.kotlin.fir.resolve.calls.Candidate import org.jetbrains.kotlin.fir.resolve.inference.InferenceComponents -import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.fir.scopes.impl.FirStandardOverrideChecker import org.jetbrains.kotlin.fir.utils.exceptions.withFirEntry import org.jetbrains.kotlin.resolve.calls.results.FlatSignature import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator @@ -64,21 +64,24 @@ class ConeEquivalentCallConflictResolver( ): Boolean { if (first.symbol.callableId != second.symbol.callableId) return false if (first.isExpect != second.isExpect) return false - if (first.receiverParameter?.typeRef?.coneType != second.receiverParameter?.typeRef?.coneType) { - return false - } if (first is FirVariable != second is FirVariable) { return false } if (!firstCandidate.mappedArgumentsOrderRepresentation.contentEquals(secondCandidate.mappedArgumentsOrderRepresentation)) { return false } - val firstSignature = createFlatSignature(firstCandidate, first) - val secondSignature = createFlatSignature(secondCandidate, second) - return compareCallsByUsedArguments(firstSignature, secondSignature, discriminateGenerics = false, useOriginalSamTypes = false) && - compareCallsByUsedArguments(secondSignature, firstSignature, discriminateGenerics = false, useOriginalSamTypes = false) + + val overrideChecker = FirStandardOverrideChecker(inferenceComponents.session) + return if (first is FirProperty && second is FirProperty) { + overrideChecker.isOverriddenProperty(first, second) && overrideChecker.isOverriddenProperty(second, first) + } else if (first is FirSimpleFunction && second is FirSimpleFunction) { + overrideChecker.isOverriddenFunction(first, second) && overrideChecker.isOverriddenFunction(second, first) + } else { + false + } } + /** * If the candidate is a function, then the arguments * order representation is an array containing the @@ -99,15 +102,4 @@ class ConeEquivalentCallConflictResolver( } return result } - - private fun createFlatSignature(call: Candidate, declaration: FirCallableDeclaration): FlatSignature { - return when (declaration) { - is FirSimpleFunction -> createFlatSignature(call, declaration) - is FirConstructor -> createFlatSignature(call, declaration) - is FirVariable -> createFlatSignature(call, declaration) - else -> errorWithAttachment("Not supported: ${this::class}") { - withFirEntry("declaration", declaration) - } - } - } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt index fb2f1e69205..ef078b3b3c3 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/resolve/calls/jvm/JvmCallConflictResolverFactory.kt @@ -24,14 +24,12 @@ object JvmCallConflictResolverFactory : ConeCallConflictResolverFactory() { transformerComponents: BodyResolveComponents ): ConeCompositeConflictResolver { val specificityComparator = JvmTypeSpecificityComparator(components.session.typeContext) - // NB: Please, be aware that adding might not necessarily help you because ConeOverloadConflictResolver doesn't just filter out - // less specific candidates, but leave the set the same if there are more than one same-specifity candidates. - // Thus, in that case, your new ConeCallConflictResolver might get all the candidates in that case. + // NB: Adding new resolvers is strongly discouraged because the results are order-dependent. return ConeCompositeConflictResolver( - ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ConeEquivalentCallConflictResolver(specificityComparator, components, transformerComponents), JvmPlatformOverloadsConflictResolver(components.session), ConeIntegerOperatorConflictResolver, + ConeOverloadConflictResolver(specificityComparator, components, transformerComponents), ) } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCompositeConflictResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCompositeConflictResolver.kt index c2623f95b8e..6ad4838b2ae 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCompositeConflictResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ConeCompositeConflictResolver.kt @@ -17,7 +17,7 @@ class ConeCompositeConflictResolver( var index = 0 while (currentCandidates.size > 1 && index < conflictResolvers.size) { val conflictResolver = conflictResolvers[index++] - currentCandidates = conflictResolver.chooseMaximallySpecificCandidates(candidates, discriminateAbstracts) + currentCandidates = conflictResolver.chooseMaximallySpecificCandidates(currentCandidates, discriminateAbstracts) } return currentCandidates } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/kt49828.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/kt49828.fir.kt index 4b83e8cb632..6be1d5e312f 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/kt49828.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/kt49828.fir.kt @@ -131,13 +131,13 @@ fun main() { val list10 = buildList { add("one") - foo0(get(0), 0f) + foo0(get(0), 0f) } val list11 = buildList { add("one") val x = get(0) - foo0(x, 0f) + foo0(x, 0f) } val list12 = buildList { add("one") diff --git a/compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt b/compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt index 08b2df68909..ca90963efe7 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.fir.kt @@ -11,8 +11,8 @@ private val validVal = 1 private val invalidProp0 = 1 // NB invalidFun0 and invalidProp0 are conflicting overloads, since the following is an ambiguity: -fun useInvalidFun0() = invalidFun0() -fun useInvalidProp0() = invalidProp0 +fun useInvalidFun0() = invalidFun0() +fun useInvalidProp0() = invalidProp0 private fun invalidFun1() {} private fun invalidFun1() {} diff --git a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt index 4e34471c2bd..1c6d7e80042 100644 --- a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt @@ -4,5 +4,5 @@ fun f1(l: List2): T {throw Exception()} // ERR fun f1(c: Collection): T{throw Exception()} fun test(l: List) { - f1(l) + f1(l) } diff --git a/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.fir.kt b/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.fir.kt deleted file mode 100644 index 9bd9ae98207..00000000000 --- a/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.fir.kt +++ /dev/null @@ -1,6 +0,0 @@ -fun foo(vararg t : String) = "" -fun foo(vararg t : Int) = "" - -fun test() { - foo() -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt b/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt index 3800f94860c..325421019b7 100644 --- a/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt +++ b/compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL fun foo(vararg t : String) = "" fun foo(vararg t : Int) = "" diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt index d41b1790e4d..1aef08a1415 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg/1.1.fir.kt @@ -36,7 +36,7 @@ fun case1() { val a: Boolean? = false checkSubtype(a) val x4 = a && true - x4 checkType { check() } + x4 checkType { check() } } // TESTCASE NUMBER: 2 @@ -44,7 +44,7 @@ fun case2() { val a: Any = false a val x4 = a && true - x4 checkType { check() } + x4 checkType { check() } } // TESTCASE NUMBER: 3 @@ -56,7 +56,7 @@ fun case3() { val x3 = a1 && a2 x3 - x3 checkType { check() } + x3 checkType { check() } } // TESTCASE NUMBER: 4 diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt deleted file mode 100644 index e2b7cff04de..00000000000 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.fir.kt +++ /dev/null @@ -1,56 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -// SKIP_TXT - -/* - * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) - * - * SPEC VERSION: 0.1-313 - * MAIN LINK: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 1 - * PRIMARY LINKS: expressions, logical-conjunction-expression -> paragraph 2 -> sentence 2 - * NUMBER: 1 - * DESCRIPTION: Both operands of a logical conjunction expression must have a type which is a subtype of kotlin.Boolean - * HELPERS: checkType - */ - -// MODULE: libModule -// FILE: libModule/JavaClass.java -package libModule; - -public class JavaClass { - public static boolean VALUE; - - public static Object VALUE_OBJ = true; - - public Boolean getValue () - { return new Boolean ("true"); } -} - -// MODULE: mainModule(libModule) -// FILE: KotlinClass.kt -package mainModule -import libModule.* -import checkSubtype -import checkType -import check - -fun foo() = run { false && JavaClass.VALUE && throw Exception() } - - -// TESTCASE NUMBER: 1 -fun case1() { - val a1 = false - val a2 = JavaClass.VALUE - val a3 = foo() - val a4 = JavaClass().getValue() - val a5 = JavaClass.VALUE_OBJ - - checkSubtype(a1) - checkSubtype(a2) - checkSubtype(a3) - checkSubtype(a4) - - val x3 = a1 && a2 && a3 && a4 && a5 as Boolean - x3 - - x3 checkType { check()} -} diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.kt index 878d30fa944..0c7857c29ce 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos/1.1.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt index a3c5d7cd2c4..dd9eb431861 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg/1.1.fir.kt @@ -36,7 +36,7 @@ fun case1() { val a: Boolean? = false checkSubtype(a) val x4 = a || true - x4 checkType { check() } + x4 checkType { check() } } // TESTCASE NUMBER: 2 @@ -44,7 +44,7 @@ fun case2() { val a: Any = false a val x4 = a || true - x4 checkType { check() } + x4 checkType { check() } } // TESTCASE NUMBER: 3 @@ -56,7 +56,7 @@ fun case3() { val x3 = a1 || a2 x3 - x3 checkType { check() } + x3 checkType { check() } } // TESTCASE NUMBER: 4 diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt deleted file mode 100644 index bda9d0b59f4..00000000000 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.fir.kt +++ /dev/null @@ -1,56 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION -// SKIP_TXT - -/* - * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) - * - * SPEC VERSION: 0.1-313 - * MAIN LINK: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 1 - * PRIMARY LINKS: expressions, logical-disjunction-expression -> paragraph 2 -> sentence 2 - * NUMBER: 1 - * DESCRIPTION:Both operands of a logical disjunction expression must have a type which is a subtype of kotlin.Boolean - * HELPERS: checkType - */ - -// MODULE: libModule -// FILE: libModule/JavaClass.java -package libModule; - -public class JavaClass { - public static boolean VALUE; - - public static Object VALUE_OBJ = true; - - public Boolean getValue () - { return new Boolean ("true"); } -} - -// MODULE: mainModule(libModule) -// FILE: KotlinClass.kt -package mainModule -import libModule.* -import checkSubtype -import checkType -import check - -fun foo() = run { false || JavaClass.VALUE || throw Exception() } - - -// TESTCASE NUMBER: 1 -fun case1() { - val a1 = false - val a2 = JavaClass.VALUE - val a3 = foo() - val a4 = JavaClass().getValue() - val a5 = JavaClass.VALUE_OBJ - - checkSubtype(a1) - checkSubtype(a2) - checkSubtype(a3) - checkSubtype(a4) - - val x3 = a1 || a2 || a3 || a4 || a5 as Boolean - x3 - - x3 checkType { check()} -} diff --git a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.kt b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.kt index 470ba52637f..035204ede01 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos/1.1.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION // SKIP_TXT diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/K2Tests.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/K2Tests.kt index 0a6ff8a2169..fd8045c8f29 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/K2Tests.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/K2Tests.kt @@ -44,7 +44,11 @@ class CustomK2Tests : KGPBaseTest() { @GradleTest @DisplayName("Serialization plugin in common source set. KT-56911") fun testHmppDependenciesInJsTests(gradleVersion: GradleVersion) { - project("k2-serialization-plugin-in-common-sourceset", gradleVersion) { + project( + "k2-serialization-plugin-in-common-sourceset", + gradleVersion, + buildOptions = defaultBuildOptions.copy(languageVersion = "2.0"), + ) { val taskToExecute = ":compileKotlinJs" build(taskToExecute) { assertTasksExecuted(taskToExecute) @@ -155,4 +159,19 @@ class CustomK2Tests : KGPBaseTest() { } } } + + @GradleTest + @DisplayName("Common metadata compilation. KT-60943") + fun kt60943CommonMetadataCompilation(gradleVersion: GradleVersion) { + project( + "k2-serialization-plugin-in-common-sourceset", + gradleVersion, + buildOptions = defaultBuildOptions.copy(languageVersion = "2.0"), + ) { + val taskToExecute = ":compileCommonMainKotlinMetadata" + build(taskToExecute) { + assertTasksExecuted(taskToExecute) + } + } + } } diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/build.gradle.kts index 9b8a9fbe157..d7a96543ae6 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/build.gradle.kts @@ -23,11 +23,6 @@ kotlin { } } sourceSets { - all { - languageSettings.apply { - languageVersion = "2.0" - } - } val commonMain by getting{ dependencies{ implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0-RC") diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/src/commonMain/kotlin/call.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/src/commonMain/kotlin/call.kt new file mode 100644 index 00000000000..a0136120349 --- /dev/null +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/resources/testProject/k2-serialization-plugin-in-common-sourceset/src/commonMain/kotlin/call.kt @@ -0,0 +1,3 @@ +fun toArray(a : List){ + a.toTypedArray() +}