From 5321a6af33059590a11efa3ca7496cb512b5fb42 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 8 Jan 2020 18:37:39 +0100 Subject: [PATCH] Forbid spread operator in signature-polymorphic calls #KT-35226 Fixed --- .../kotlin/codegen/JvmCodegenUtil.java | 4 +- ...irOldFrontendDiagnosticsTestGenerated.java | 23 +++++++++++ .../PolymorphicSignatureCallChecker.kt | 38 +++++++++++++++++++ .../diagnostics/DefaultErrorMessagesJvm.java | 4 ++ .../resolve/jvm/diagnostics/ErrorsJvm.java | 3 ++ .../jvm/platform/JvmPlatformConfigurator.kt | 3 +- .../jvm/lower/PolymorphicSignatureLowering.kt | 6 +-- .../varargOfObjects_after.kt | 9 +++-- .../spreadOperator_after.fir.kt | 11 ++++++ .../spreadOperator_after.kt | 11 ++++++ .../spreadOperator_after.txt | 3 ++ .../spreadOperator_before.fir.kt | 11 ++++++ .../spreadOperator_before.kt | 11 ++++++ .../spreadOperator_before.txt | 3 ++ .../checkers/DiagnosticsTestGenerated.java | 23 +++++++++++ .../DiagnosticsUsingJavacTestGenerated.java | 23 +++++++++++ .../kotlin/config/LanguageVersionSettings.kt | 2 + 17 files changed, 177 insertions(+), 11 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.fir.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.txt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.fir.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt create mode 100644 compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.txt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index 121e0760250..f899f8bd6e2 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor; import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor; import org.jetbrains.kotlin.load.kotlin.ModuleVisibilityUtilsKt; import org.jetbrains.kotlin.metadata.jvm.deserialization.ModuleMapping; -import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; @@ -39,6 +38,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.inline.InlineUtil; +import org.jetbrains.kotlin.resolve.jvm.checkers.PolymorphicSignatureCallChecker; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver; import org.jetbrains.kotlin.resolve.source.PsiSourceElement; @@ -368,7 +368,7 @@ public class JvmCodegenUtil { } public static boolean isPolymorphicSignature(@NotNull FunctionDescriptor descriptor) { - return descriptor.getAnnotations().hasAnnotation(new FqName("java.lang.invoke.MethodHandle.PolymorphicSignature")); + return descriptor.getAnnotations().hasAnnotation(PolymorphicSignatureCallChecker.polymorphicSignatureFqName); } @NotNull diff --git a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java index 14fc16f1f00..d140450e211 100644 --- a/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java @@ -13003,6 +13003,29 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte } } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/polymorphicSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PolymorphicSignature extends AbstractFirOldFrontendDiagnosticsTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPolymorphicSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("spreadOperator_after.kt") + public void testSpreadOperator_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt"); + } + + @TestMetadata("spreadOperator_before.kt") + public void testSpreadOperator_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt new file mode 100644 index 00000000000..599055f3ccc --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2020 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.resolve.jvm.checkers + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.calls.checkers.CallChecker +import org.jetbrains.kotlin.resolve.calls.checkers.CallCheckerContext +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.calls.model.VarargValueArgument +import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm + +object PolymorphicSignatureCallChecker : CallChecker { + @JvmField + val polymorphicSignatureFqName = FqName("java.lang.invoke.MethodHandle.PolymorphicSignature") + + override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { + if (!context.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) return + if (!resolvedCall.resultingDescriptor.annotations.hasAnnotation(polymorphicSignatureFqName)) return + + for (valueArgument in resolvedCall.valueArgumentsByIndex ?: return) { + if (valueArgument !is VarargValueArgument) continue + for (argument in valueArgument.arguments) { + val spread = argument.getSpreadElement() ?: continue + val diagnostic = + if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitSpreadOnSignaturePolymorphicCall)) + ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR + else + ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL + context.trace.report(diagnostic.on(spread)) + } + } + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java index f54c322c013..0c335a60bdb 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java @@ -152,6 +152,10 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS); MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS); MAP.put(TAILREC_WITH_DEFAULTS, "Computation order of non-constant default arguments in tail-recursive functions will change in 1.4. See KT-31540 for more details"); + + String spreadOnPolymorphicSignature = "Spread operator is prohibited for arguments to signature-polymorphic calls"; + MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL, spreadOnPolymorphicSignature); + MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR, spreadOnPolymorphicSignature); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java index 5896455ba80..a2074ccdc55 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java @@ -134,6 +134,9 @@ public interface ErrorsJvm { DiagnosticFactory0 TAILREC_WITH_DEFAULTS = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE); + DiagnosticFactory0 SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL = DiagnosticFactory0.create(WARNING); + DiagnosticFactory0 SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR = DiagnosticFactory0.create(ERROR); + @SuppressWarnings("UnusedDeclaration") Object _initializer = new Object() { { diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index ca5eab642e0..c33a3bb3405 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -53,7 +53,8 @@ object JvmPlatformConfigurator : PlatformConfiguratorBase( ProtectedSyntheticExtensionCallChecker, RuntimeAssertionsOnExtensionReceiverCallChecker, ApiVersionIsAtLeastArgumentsChecker, - InconsistentOperatorFromJavaCallChecker + InconsistentOperatorFromJavaCallChecker, + PolymorphicSignatureCallChecker ), additionalTypeCheckers = listOf( diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt index 85de4dae993..a5b1b6831cd 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/PolymorphicSignatureLowering.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.ir.types.isNullableAny import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.util.hasAnnotation import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid -import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.jvm.checkers.PolymorphicSignatureCallChecker internal val polymorphicSignaturePhase = makeIrFilePhase( ::PolymorphicSignatureLowering, @@ -30,8 +30,6 @@ internal val polymorphicSignaturePhase = makeIrFilePhase( description = "Replace polymorphic methods with fake ones according to types at the call site" ) -private val polymorphicSignatureAnnotation = FqName("java.lang.invoke.MethodHandle.PolymorphicSignature") - class PolymorphicSignatureLowering(val context: JvmBackendContext) : IrElementTransformerVoid(), FileLoweringPass { override fun lower(irFile: IrFile) { if (context.state.languageVersionSettings.supportsFeature(LanguageFeature.PolymorphicSignature)) @@ -52,7 +50,7 @@ class PolymorphicSignatureLowering(val context: JvmBackendContext) : IrElementTr private fun IrCall.transform(castReturnType: IrType?): IrCall? { val function = symbol.owner as? IrSimpleFunction ?: return null - if (!function.hasAnnotation(polymorphicSignatureAnnotation)) + if (!function.hasAnnotation(PolymorphicSignatureCallChecker.polymorphicSignatureFqName)) return null assert(function.valueParameters.singleOrNull()?.varargElementType != null) { "@PolymorphicSignature methods should only have a single vararg argument: ${dump()}" diff --git a/compiler/testData/codegen/box/polymorphicSignature/varargOfObjects_after.kt b/compiler/testData/codegen/box/polymorphicSignature/varargOfObjects_after.kt index 8f80e3f92f8..1c4509f3ef5 100644 --- a/compiler/testData/codegen/box/polymorphicSignature/varargOfObjects_after.kt +++ b/compiler/testData/codegen/box/polymorphicSignature/varargOfObjects_after.kt @@ -22,8 +22,9 @@ fun box(): String { val r1 = mh.invokeExact(args) if (r1 != "aaa") return "Fail 1: $r1" - val r2 = mh.invokeExact(*args) - if (r2 != "aaa") return "Fail 2: $r2" + // Spread operator is prohibited for arguments to signature-polymorphic calls + // val r2 = mh.invokeExact(*args) + // if (r2 != "aaa") return "Fail 2: $r2" val r3 = mh.invokeExact(arrayOf(args) as Array<*>) if (r3 !is Array<*> || !r3.contentEquals(args)) return "Fail 3: $r3" @@ -38,8 +39,8 @@ fun box(): String { val r5 = mh.invoke(args) if (r5 != "aaa") return "Fail 5: $r5" - val r6 = mh.invoke(*args) - if (r6 != "aaa") return "Fail 6: $r6" + // val r6 = mh.invoke(*args) + // if (r6 != "aaa") return "Fail 6: $r6" val r7 = mh.invoke(arrayOf(args) as Array<*>) if (r7 !is Array<*> || !r7.contentEquals(args)) return "Fail 7: $r7" diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.fir.kt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.fir.kt new file mode 100644 index 00000000000..f39d060eb3b --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.fir.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +PolymorphicSignature +ProhibitSpreadOnSignaturePolymorphicCall +// FULL_JDK + +import java.lang.invoke.MethodHandle + +fun test(mh: MethodHandle) { + mh.invokeExact("1", "2") + mh.invokeExact(*emptyArray(), "X") + mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) + mh.invoke(*arrayOf("A")) +} diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt new file mode 100644 index 00000000000..b6a6fe669ed --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +PolymorphicSignature +ProhibitSpreadOnSignaturePolymorphicCall +// FULL_JDK + +import java.lang.invoke.MethodHandle + +fun test(mh: MethodHandle) { + mh.invokeExact("1", "2") + mh.invokeExact(*emptyArray(), "X") + mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) + mh.invoke(*arrayOf("A")) +} diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.txt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.txt new file mode 100644 index 00000000000..43df97a0c2e --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.txt @@ -0,0 +1,3 @@ +package + +public fun test(/*0*/ mh: java.lang.invoke.MethodHandle): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.fir.kt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.fir.kt new file mode 100644 index 00000000000..e36edee5e00 --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.fir.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +PolymorphicSignature -ProhibitSpreadOnSignaturePolymorphicCall +// FULL_JDK + +import java.lang.invoke.MethodHandle + +fun test(mh: MethodHandle) { + mh.invokeExact("1", "2") + mh.invokeExact(*emptyArray(), "X") + mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) + mh.invoke(*arrayOf("A")) +} diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt new file mode 100644 index 00000000000..2099f3d2a4c --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt @@ -0,0 +1,11 @@ +// !LANGUAGE: +PolymorphicSignature -ProhibitSpreadOnSignaturePolymorphicCall +// FULL_JDK + +import java.lang.invoke.MethodHandle + +fun test(mh: MethodHandle) { + mh.invokeExact("1", "2") + mh.invokeExact(*emptyArray(), "X") + mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) + mh.invoke(*arrayOf("A")) +} diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.txt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.txt new file mode 100644 index 00000000000..43df97a0c2e --- /dev/null +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.txt @@ -0,0 +1,3 @@ +package + +public fun test(/*0*/ mh: java.lang.invoke.MethodHandle): kotlin.Unit diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index e3658565592..9e37a423bd3 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -13010,6 +13010,29 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { } } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/polymorphicSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PolymorphicSignature extends AbstractDiagnosticsTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPolymorphicSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("spreadOperator_after.kt") + public void testSpreadOperator_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt"); + } + + @TestMetadata("spreadOperator_before.kt") + public void testSpreadOperator_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index bef9df310db..303899fca6f 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -13005,6 +13005,29 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing } } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/polymorphicSignature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class PolymorphicSignature extends AbstractDiagnosticsUsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInPolymorphicSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @TestMetadata("spreadOperator_after.kt") + public void testSpreadOperator_after() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt"); + } + + @TestMetadata("spreadOperator_before.kt") + public void testSpreadOperator_before() throws Exception { + runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt"); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 4f354dc7cbe..441a097c309 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -127,6 +127,8 @@ enum class LanguageFeature( ProperIeee754Comparisons(KOTLIN_1_4, kind = BUG_FIX), FunctionalInterfaceConversion(KOTLIN_1_4, kind = UNSTABLE_FEATURE), + ProhibitSpreadOnSignaturePolymorphicCall(KOTLIN_1_5, kind = BUG_FIX), + // Temporarily disabled, see KT-27084/KT-22379 SoundSmartcastFromLoopConditionForLoopAssignedVariables(sinceVersion = null, kind = BUG_FIX),