From ac480e2285b8c6f29ccf76dd3a2f1f3303b35ff1 Mon Sep 17 00:00:00 2001 From: Ivan Kylchik Date: Fri, 31 Mar 2023 17:52:07 +0200 Subject: [PATCH] [K2] Support serialization of complex annotations #KT-57611 Fixed --- .../fir/backend/ConstValueProviderImpl.kt | 77 ++++++++++++++++--- ...LightTreeBlackBoxCodegenTestGenerated.java | 18 +++++ .../FirPsiBlackBoxCodegenTestGenerated.java | 18 +++++ ...onsiderPropertyInitValueFromNestedClass.kt | 2 - .../serialization/annotationInArguments.kt | 31 ++++++++ .../serialization/annotationSerialization.kt | 13 ++++ .../serialization/annotationWithArray.kt | 27 +++++++ .../serialization/annotationWithDefaults.kt | 23 ++++++ .../IrBlackBoxCodegenTestGenerated.java | 18 +++++ ...kBoxCodegenWithIrInlinerTestGenerated.java | 18 +++++ .../fir/FirJsCodegenBoxTestGenerated.java | 18 +++++ .../test/ir/IrJsCodegenBoxTestGenerated.java | 18 +++++ .../ir/IrJsES6CodegenBoxTestGenerated.java | 18 +++++ .../testData/klibContents/annotations.kt | 2 + .../klibContents/klib/fieldAnnotations.kt | 2 + .../FirNativeCodegenBoxTestGenerated.java | 18 +++++ .../NativeCodegenBoxTestGenerated.java | 18 +++++ 17 files changed, 328 insertions(+), 11 deletions(-) create mode 100644 compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt create mode 100644 compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt create mode 100644 compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConstValueProviderImpl.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConstValueProviderImpl.kt index a68c3d18248..154b4ac5182 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConstValueProviderImpl.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConstValueProviderImpl.kt @@ -7,20 +7,18 @@ package org.jetbrains.kotlin.fir.backend import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.builtins.UnsignedType +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotation -import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationArgumentMapping -import org.jetbrains.kotlin.fir.expressions.builder.buildAnnotationCall -import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression +import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.serialization.constant.ConstValueProvider +import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.declarations.IrDeclarationBase import org.jetbrains.kotlin.ir.declarations.IrProperty -import org.jetbrains.kotlin.ir.expressions.IrConst -import org.jetbrains.kotlin.ir.expressions.IrConstKind +import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.util.getArgumentsWithIr import org.jetbrains.kotlin.types.ConstantValueKind @@ -56,7 +54,21 @@ class ConstValueProviderImpl( else -> error("Cannot extract IR declaration for ${firAnnotationContainer.render()}") } ?: return firAnnotation - return buildNewFirAnnotationByCorrespondingIrAnnotation(irDeclaration, firAnnotationContainer, firAnnotation) + val correctFirContainer = when (firAnnotation.useSiteTarget) { + AnnotationUseSiteTarget.FIELD, AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD -> { + (firAnnotationContainer as? FirProperty)?.backingField ?: return firAnnotation + } + else -> firAnnotationContainer + } + + val correctIrDeclaration = when (firAnnotation.useSiteTarget) { + AnnotationUseSiteTarget.FIELD, AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD -> { + (irDeclaration as? IrProperty)?.backingField ?: return firAnnotation + } + else -> irDeclaration + } + + return buildNewFirAnnotationByCorrespondingIrAnnotation(correctIrDeclaration, correctFirContainer, firAnnotation) } override fun getNewFirAnnotationWithConstantValues( @@ -121,8 +133,7 @@ class ConstValueProviderImpl( return@forEach } val irExpression = irArguments.single { it.first.name == name }.second - // TODO recursion for annotations - mapping[name] = (irExpression as? IrConst<*>)?.toFirConst() ?: firExpression + mapping[name] = irExpression.convertToFir(firExpression) } } @@ -139,6 +150,54 @@ class ConstValueProviderImpl( } } + private fun IrElement.convertToFir(firExpression: FirExpression): FirExpression { + return when { + this is IrConst<*> -> toFirConst() ?: firExpression + this is IrConstructorCall && firExpression is FirFunctionCall -> { + val resolvedArgumentMapping = firExpression.resolvedArgumentMapping ?: return firExpression + val irArgs = this.getArgumentsWithIr() + buildFunctionCall { + this.source = firExpression.source + this.typeRef = firExpression.typeRef + this.dispatchReceiver = firExpression.dispatchReceiver + this.extensionReceiver = firExpression.extensionReceiver + this.explicitReceiver = firExpression.explicitReceiver + this.calleeReference = firExpression.calleeReference + this.annotations.addAll(firExpression.annotations) + this.typeArguments.addAll(firExpression.typeArguments) + + val newArgMapping = LinkedHashMap( + resolvedArgumentMapping.map { (key, value) -> + irArgs.first { it.first.name == value.name }.second.convertToFir(key) to value + }.toMap() + ) + this.argumentList = buildResolvedArgumentList(newArgMapping, firExpression.argumentList.source) + } + } + this is IrVararg && firExpression is FirVarargArgumentsExpression -> buildVarargArgumentsExpression { + this.source = firExpression.source + this.typeRef = firExpression.typeRef + this.annotations.addAll(firExpression.annotations) + this.varargElementType = firExpression.varargElementType + this.arguments.addAll( + firExpression.arguments.zip(this@convertToFir.elements).map { it.second.convertToFir(it.first) } + ) + } + this is IrVararg && firExpression is FirArrayOfCall -> buildArrayOfCall { + this.source = firExpression.source + this.typeRef = firExpression.typeRef + this.annotations.addAll(firExpression.annotations) + this.argumentList = buildArgumentList { + this.source = firExpression.argumentList.source + this.arguments.addAll( + firExpression.argumentList.arguments.zip(this@convertToFir.elements).map { it.second.convertToFir(it.first) } + ) + } + } + else -> firExpression + } + } + private fun IrConst<*>.getConstantKind(): ConstantValueKind<*>? { if (this.kind == IrConstKind.Null) return ConstantValueKind.Null diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java index e009d3cb99a..935e319dd63 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java @@ -28428,11 +28428,29 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java index c88d0a13ddf..63b0394a0dd 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java @@ -28428,11 +28428,29 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt b/compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt index c6648781286..2d385a7712f 100644 --- a/compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt +++ b/compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt @@ -1,5 +1,3 @@ -// IGNORE_BACKEND_K2: NATIVE, JS_IR -// Ignore reason: KT-57611 // MODULE: lib // FILE: Class.kt diff --git a/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt new file mode 100644 index 00000000000..9416420d2c4 --- /dev/null +++ b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt @@ -0,0 +1,31 @@ +// TARGET_BACKEND: JVM_IR +// TARGET_BACKEND: JS_IR +// TARGET_BACKEND: NATIVE + +// MODULE: lib +// FILE: lib.kt + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class Annotation(val str: String) + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class AnnotationWithAnnotation(val anno: Annotation) + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class AnnotationWithAnnotationWithAnnotation(val anno: AnnotationWithAnnotation) + +@AnnotationWithAnnotation(Annotation("Str" + "ing")) +class A + +@AnnotationWithAnnotationWithAnnotation(AnnotationWithAnnotation(Annotation("Str" + "ing"))) +class B + +// MODULE: main +// FILE: main.kt + +fun box(): String { + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt index 778964f7ed7..a6eb9cd34f2 100644 --- a/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt +++ b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt @@ -50,6 +50,19 @@ enum class SomeEnum { B; } +// TODO: can be uncommented after fix KT-57135 +//@field:BinaryAnnotation("Str" + "ing") +//var x: Int = 5 + +//object Delegate { +// operator fun getValue(instance: Any?, property: Any) : String = "" +// operator fun setValue(instance: Any?, property: Any, value: String) {} +//} +// +//@delegate:BinaryAnnotation("Str" + "ing") +//val p: String by Delegate + + // 7. VALUE_PARAMETER fun @receiver:BinaryAnnotation("Str" + "ing") String.myExtension() { } fun foo(@BinaryAnnotation("Str" + "ing") a: Int) { } diff --git a/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt new file mode 100644 index 00000000000..5378f1f84c4 --- /dev/null +++ b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt @@ -0,0 +1,27 @@ +// TARGET_BACKEND: JVM_IR +// TARGET_BACKEND: JS_IR +// TARGET_BACKEND: NATIVE + +// MODULE: lib +// FILE: lib.kt + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class AnnotationWithVararg(vararg val array: String) + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class AnnotationWithArray(val array: Array) + +@AnnotationWithVararg("Str" + "ing", "String2", "String${3}") +class A + +@AnnotationWithArray(["Str" + "ing", "String2", "String${3}"]) +class B + +// MODULE: main +// FILE: main.kt + +fun box(): String { + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt new file mode 100644 index 00000000000..420e28a0c4e --- /dev/null +++ b/compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt @@ -0,0 +1,23 @@ +// TARGET_BACKEND: JVM_IR +// TARGET_BACKEND: JS_IR +// TARGET_BACKEND: NATIVE + +// MODULE: lib +// FILE: lib.kt + +@Target(AnnotationTarget.CLASS) +@Retention(AnnotationRetention.BINARY) +annotation class AnnotationWithDefault(val str: String = "Str" + "ing") + +@AnnotationWithDefault() +class A + +@AnnotationWithDefault("Other") +class B + +// MODULE: main +// FILE: main.kt + +fun box(): String { + return "OK" +} \ No newline at end of file diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index 988412df7a9..b9308aa892d 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -28428,11 +28428,29 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java index 34847600940..153358a390f 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java @@ -28428,11 +28428,29 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java index 847fe75f0d1..c9245dd6b13 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsCodegenBoxTestGenerated.java @@ -21182,11 +21182,29 @@ public class FirJsCodegenBoxTestGenerated extends AbstractFirJsCodegenBoxTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java index b250f02af97..a9bab4afbde 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsCodegenBoxTestGenerated.java @@ -21182,11 +21182,29 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java index 36f2dee3729..8725e9006a6 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/IrJsES6CodegenBoxTestGenerated.java @@ -21182,11 +21182,29 @@ public class IrJsES6CodegenBoxTestGenerated extends AbstractIrJsES6CodegenBoxTes KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/native/native.tests/testData/klibContents/annotations.kt b/native/native.tests/testData/klibContents/annotations.kt index 2cdfa42c663..15f11ff925d 100644 --- a/native/native.tests/testData/klibContents/annotations.kt +++ b/native/native.tests/testData/klibContents/annotations.kt @@ -1,3 +1,5 @@ +// KT-57135 K2 dosen't take into account `field` target on annotation for property +// MUTED_WHEN: K2 package test annotation class AnnoClass diff --git a/native/native.tests/testData/klibContents/klib/fieldAnnotations.kt b/native/native.tests/testData/klibContents/klib/fieldAnnotations.kt index a0492ca8725..3b921cb8028 100644 --- a/native/native.tests/testData/klibContents/klib/fieldAnnotations.kt +++ b/native/native.tests/testData/klibContents/klib/fieldAnnotations.kt @@ -1,3 +1,5 @@ +// KT-57135 K2 dosen't take into account `field` target on annotation for property +// MUTED_WHEN: K2 package test annotation class Ann diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java index 523b0ccf447..8602cdbd644 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/FirNativeCodegenBoxTestGenerated.java @@ -24376,11 +24376,29 @@ public class FirNativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTe KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } } diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java index 5a55ccf504b..9d6d7cec18f 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/blackboxtest/NativeCodegenBoxTestGenerated.java @@ -24140,11 +24140,29 @@ public class NativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTest KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.NATIVE, true); } + @Test + @TestMetadata("annotationInArguments.kt") + public void testAnnotationInArguments() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationInArguments.kt"); + } + @Test @TestMetadata("annotationSerialization.kt") public void testAnnotationSerialization() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationSerialization.kt"); } + + @Test + @TestMetadata("annotationWithArray.kt") + public void testAnnotationWithArray() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithArray.kt"); + } + + @Test + @TestMetadata("annotationWithDefaults.kt") + public void testAnnotationWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/serialization/annotationWithDefaults.kt"); + } } }