diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueDefault.kt index 6517a950658..df9ef95431e 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueDefault.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueDefault.kt @@ -5,21 +5,21 @@ JavaAnn(*array()) class MyClass4 fun box(): String { - val value1 = javaClass().getAnnotation(javaClass()).value() + val value1 = javaClass().getAnnotation(javaClass()).value if (value1.size() != 2) return "fail1: ${value1.size()}" if (value1[0] != "d1") return "fail2: ${value1[0]}" if (value1[1] != "d2") return "fail3: ${value1[1]}" - val value2 = javaClass().getAnnotation(javaClass()).value() + val value2 = javaClass().getAnnotation(javaClass()).value if (value2.size() != 2) return "fail4: ${value2.size()}" if (value2[0] != "d1") return "fail5: ${value2[0]}" if (value2[1] != "d2") return "fail6: ${value2[1]}" - val value3 = javaClass().getAnnotation(javaClass()).value() + val value3 = javaClass().getAnnotation(javaClass()).value if (value3.size() != 1) return "fail7: ${value3.size()}" if (value3[0] != "asd") return "fail8: ${value3[0]}" - val value4 = javaClass().getAnnotation(javaClass()).value() + val value4 = javaClass().getAnnotation(javaClass()).value if (value4.size() != 0) return "fail 9: ${value4.size()}" return "OK" diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueNoDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueNoDefault.kt index b0072ebff1a..3f094adc301 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueNoDefault.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationArrayValueNoDefault.kt @@ -5,17 +5,17 @@ JavaAnn(*array()) class MyClass4 fun box(): String { - val value1 = javaClass().getAnnotation(javaClass()).value() + val value1 = javaClass().getAnnotation(javaClass()).value if (value1.size() != 0) return "fail1: ${value1.size()}" - val value2 = javaClass().getAnnotation(javaClass()).value() + val value2 = javaClass().getAnnotation(javaClass()).value if (value2.size() != 0) return "fail2: ${value2.size()}" - val value3 = javaClass().getAnnotation(javaClass()).value() + val value3 = javaClass().getAnnotation(javaClass()).value if (value3.size() != 1) return "fail3: ${value3.size()}" if (value3[0] != "asd") return "fail4: ${value3[0]}" - val value4 = javaClass().getAnnotation(javaClass()).value() + val value4 = javaClass().getAnnotation(javaClass()).value if (value4.size() != 0) return "fail 5: ${value4.size()}" return "OK" diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationCall.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationCall.kt index 75a38d9a7b2..9c985771453 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationCall.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationCall.kt @@ -3,6 +3,6 @@ JavaAnn("value") class MyClass fun box(): String { val ann = javaClass().getAnnotation(javaClass()) if (ann == null) return "fail: cannot find Ann on MyClass}" - if (ann.value() != "value") return "fail: annotation parameter i should be 'value', but was ${ann.value()}" + if (ann.value != "value") return "fail: annotation parameter i should be 'value', but was ${ann.value}" return "OK" } diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationDefault.kt index 9afd86e5b38..a5f4b5e9228 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationDefault.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/javaAnnotationDefault.kt @@ -4,17 +4,17 @@ JavaAnn2 class MyClass2 fun box(): String { val ann = javaClass().getAnnotation(javaClass()) if (ann == null) return "fail: cannot find Ann on MyClass}" - if (ann.value() != "default") return "fail: annotation parameter i should be 'default', but was ${ann.value()}" + if (ann.value != "default") return "fail: annotation parameter i should be 'default', but was ${ann.value}" val ann2 = javaClass().getAnnotation(javaClass()) if (ann2 == null) return "fail: cannot find Ann on MyClass}" - if (ann2.a() != 1) return "fail for a: expected = 1, but was ${ann2.a()}" - if (ann2.b() != 1.toByte()) return "fail for b: expected = 1, but was ${ann2.b()}" - if (ann2.c() != 1.toShort()) return "fail for c: expected = 1, but was ${ann2.c()}" - if (ann2.d() != 1.0) return "fail for d: expected = 1, but was ${ann2.d()}" - if (ann2.e() != 1F) return "fail for e: expected = 1, but was ${ann2.e()}" - if (ann2.j() != 1L) return "fail for j: expected = 1, but was ${ann2.j()}" - if (ann2.f() != "default") return "fail for f: expected = default, but was ${ann2.f()}" + if (ann2.a != 1) return "fail for a: expected = 1, but was ${ann2.a}" + if (ann2.b != 1.toByte()) return "fail for b: expected = 1, but was ${ann2.b}" + if (ann2.c != 1.toShort()) return "fail for c: expected = 1, but was ${ann2.c}" + if (ann2.d != 1.0) return "fail for d: expected = 1, but was ${ann2.d}" + if (ann2.e != 1F) return "fail for e: expected = 1, but was ${ann2.e}" + if (ann2.j != 1L) return "fail for j: expected = 1, but was ${ann2.j}" + if (ann2.f != "default") return "fail for f: expected = default, but was ${ann2.f}" return "OK" } diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameter.kt index 4317bede4e3..1a1ba627b1f 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameter.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameter.kt @@ -6,5 +6,5 @@ JavaAnn(OK::class) class MyClass fun box(): String { val ann = javaClass().getAnnotation(javaClass()) if (ann == null) return "fail: cannot find JavaAnn on MyClass" - return ann.value().simpleName!! + return ann.value.simpleName!! } diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameterOnJavaClass.kt b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameterOnJavaClass.kt index b4058cc5b92..1b94d74e2a9 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameterOnJavaClass.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/classParameterOnJavaClass.kt @@ -2,5 +2,5 @@ fun box(): String { val ann = javaClass().getAnnotation(javaClass()) if (ann == null) return "fail: cannot find JavaAnn on MyClass" - return ann.value().simpleName!! + return ann.value.simpleName!! } diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameter.kt index deaf6880207..8e936562c94 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameter.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameter.kt @@ -4,7 +4,7 @@ class K JavaAnn(O::class, K::class) class MyClass fun box(): String { - val args = javaClass().getAnnotation(javaClass()).value() + val args = javaClass().getAnnotation(javaClass()).value val argName1 = args[0].simpleName ?: "fail 1" val argName2 = args[1].simpleName ?: "fail 2" return argName1 + argName2 diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameterOnJavaClass.kt b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameterOnJavaClass.kt index f2f9da17814..7bd24354004 100644 --- a/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameterOnJavaClass.kt +++ b/compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping/varargClassParameterOnJavaClass.kt @@ -2,7 +2,7 @@ class O class K fun box(): String { - val args = javaClass().getAnnotation(javaClass()).value() + val args = javaClass().getAnnotation(javaClass()).value val argName1 = args[0].simpleName ?: "fail 1" val argName2 = args[1].simpleName ?: "fail 2" return argName1 + argName2 diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.java new file mode 100644 index 00000000000..3faefb8a3f9 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + String[] value() default {"d1", "d2"}; +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.kt new file mode 100644 index 00000000000..6517a950658 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.kt @@ -0,0 +1,26 @@ +JavaAnn class MyClass1 +JavaAnn() class MyClass2 +JavaAnn("asd") class MyClass3 +JavaAnn(*array()) class MyClass4 + + +fun box(): String { + val value1 = javaClass().getAnnotation(javaClass()).value() + if (value1.size() != 2) return "fail1: ${value1.size()}" + if (value1[0] != "d1") return "fail2: ${value1[0]}" + if (value1[1] != "d2") return "fail3: ${value1[1]}" + + val value2 = javaClass().getAnnotation(javaClass()).value() + if (value2.size() != 2) return "fail4: ${value2.size()}" + if (value2[0] != "d1") return "fail5: ${value2[0]}" + if (value2[1] != "d2") return "fail6: ${value2[1]}" + + val value3 = javaClass().getAnnotation(javaClass()).value() + if (value3.size() != 1) return "fail7: ${value3.size()}" + if (value3[0] != "asd") return "fail8: ${value3[0]}" + + val value4 = javaClass().getAnnotation(javaClass()).value() + if (value4.size() != 0) return "fail 9: ${value4.size()}" + + return "OK" +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.java new file mode 100644 index 00000000000..59408340bcb --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + String[] value(); +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.kt new file mode 100644 index 00000000000..b0072ebff1a --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.kt @@ -0,0 +1,22 @@ +JavaAnn class MyClass1 +JavaAnn() class MyClass2 +JavaAnn("asd") class MyClass3 +JavaAnn(*array()) class MyClass4 + + +fun box(): String { + val value1 = javaClass().getAnnotation(javaClass()).value() + if (value1.size() != 0) return "fail1: ${value1.size()}" + + val value2 = javaClass().getAnnotation(javaClass()).value() + if (value2.size() != 0) return "fail2: ${value2.size()}" + + val value3 = javaClass().getAnnotation(javaClass()).value() + if (value3.size() != 1) return "fail3: ${value3.size()}" + if (value3[0] != "asd") return "fail4: ${value3[0]}" + + val value4 = javaClass().getAnnotation(javaClass()).value() + if (value4.size() != 0) return "fail 5: ${value4.size()}" + + return "OK" +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.java new file mode 100644 index 00000000000..7a6c8fbb6cb --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + String value(); +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.kt new file mode 100644 index 00000000000..75a38d9a7b2 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.kt @@ -0,0 +1,8 @@ +JavaAnn("value") class MyClass + +fun box(): String { + val ann = javaClass().getAnnotation(javaClass()) + if (ann == null) return "fail: cannot find Ann on MyClass}" + if (ann.value() != "value") return "fail: annotation parameter i should be 'value', but was ${ann.value()}" + return "OK" +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.java new file mode 100644 index 00000000000..0aff2bc869a --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.java @@ -0,0 +1,18 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + String value() default "default"; +} + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn2 { + int a() default 1; + byte b() default 1; + short c() default 1; + double d() default 1; + float e() default 1; + long j() default 1; + String f() default "default"; +} \ No newline at end of file diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.kt new file mode 100644 index 00000000000..9afd86e5b38 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.kt @@ -0,0 +1,20 @@ +JavaAnn class MyClass +JavaAnn2 class MyClass2 + +fun box(): String { + val ann = javaClass().getAnnotation(javaClass()) + if (ann == null) return "fail: cannot find Ann on MyClass}" + if (ann.value() != "default") return "fail: annotation parameter i should be 'default', but was ${ann.value()}" + + val ann2 = javaClass().getAnnotation(javaClass()) + if (ann2 == null) return "fail: cannot find Ann on MyClass}" + if (ann2.a() != 1) return "fail for a: expected = 1, but was ${ann2.a()}" + if (ann2.b() != 1.toByte()) return "fail for b: expected = 1, but was ${ann2.b()}" + if (ann2.c() != 1.toShort()) return "fail for c: expected = 1, but was ${ann2.c()}" + if (ann2.d() != 1.0) return "fail for d: expected = 1, but was ${ann2.d()}" + if (ann2.e() != 1F) return "fail for e: expected = 1, but was ${ann2.e()}" + if (ann2.j() != 1L) return "fail for j: expected = 1, but was ${ann2.j()}" + if (ann2.f() != "default") return "fail for f: expected = default, but was ${ann2.f()}" + + return "OK" +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.java new file mode 100644 index 00000000000..c3797f1384a --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class[] args(); +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.kt new file mode 100644 index 00000000000..bbf3c571821 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.kt @@ -0,0 +1,11 @@ +class O +class K + +JavaAnn(args = array(O::class, K::class)) class MyClass + +fun box(): String { + val args = javaClass().getAnnotation(javaClass()).args() + val argName1 = args[0].simpleName ?: "fail 1" + val argName2 = args[1].simpleName ?: "fail 2" + return argName1 + argName2 +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.java new file mode 100644 index 00000000000..9693d6169ba --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.java @@ -0,0 +1,13 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class[] args(); +} + +class O {} +class K {} + +@JavaAnn(args = {O.class, K.class}) +class MyJavaClass {} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.kt new file mode 100644 index 00000000000..58839768c94 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.kt @@ -0,0 +1,6 @@ +fun box(): String { + val args = javaClass().getAnnotation(javaClass()).args() + val argName1 = args[0].simpleName ?: "fail 1" + val argName2 = args[1].simpleName ?: "fail 2" + return argName1 + argName2 +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.java new file mode 100644 index 00000000000..3f7f8278f8e --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class value(); +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.kt new file mode 100644 index 00000000000..4317bede4e3 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.kt @@ -0,0 +1,10 @@ + +class OK + +JavaAnn(OK::class) class MyClass + +fun box(): String { + val ann = javaClass().getAnnotation(javaClass()) + if (ann == null) return "fail: cannot find JavaAnn on MyClass" + return ann.value().simpleName!! +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.java new file mode 100644 index 00000000000..8d7770fd04a --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.java @@ -0,0 +1,12 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class value(); +} + +class OK {} + +@JavaAnn(OK.class) +class MyJavaClass {} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.kt new file mode 100644 index 00000000000..b4058cc5b92 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.kt @@ -0,0 +1,6 @@ + +fun box(): String { + val ann = javaClass().getAnnotation(javaClass()) + if (ann == null) return "fail: cannot find JavaAnn on MyClass" + return ann.value().simpleName!! +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.java new file mode 100644 index 00000000000..f17a3c2e606 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.java @@ -0,0 +1,7 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class[] value(); +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.kt new file mode 100644 index 00000000000..deaf6880207 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.kt @@ -0,0 +1,11 @@ +class O +class K + +JavaAnn(O::class, K::class) class MyClass + +fun box(): String { + val args = javaClass().getAnnotation(javaClass()).value() + val argName1 = args[0].simpleName ?: "fail 1" + val argName2 = args[1].simpleName ?: "fail 2" + return argName1 + argName2 +} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.java b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.java new file mode 100644 index 00000000000..fd0b2588516 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.java @@ -0,0 +1,13 @@ +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +@interface JavaAnn { + Class[] value(); +} + +class O {} +class K {} + +@JavaAnn({O.class, K.class}) +class MyJavaClass {} diff --git a/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.kt b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.kt new file mode 100644 index 00000000000..f2f9da17814 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.kt @@ -0,0 +1,9 @@ +class O +class K + +fun box(): String { + val args = javaClass().getAnnotation(javaClass()).value() + val argName1 = args[0].simpleName ?: "fail 1" + val argName2 = args[1].simpleName ?: "fail 2" + return argName1 + argName2 +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java index 1ef87f4d885..e1fbb449f6e 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/BlackBoxAgainstJavaCodegenTestGenerated.java @@ -135,6 +135,84 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxCod doTestAgainstJava(fileName); } } + + @TestMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ObsoleteAnnotationMethodsUsages extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInObsoleteAnnotationMethodsUsages() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("javaAnnotationArrayValueDefault.kt") + public void testJavaAnnotationArrayValueDefault() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueDefault.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("javaAnnotationArrayValueNoDefault.kt") + public void testJavaAnnotationArrayValueNoDefault() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationArrayValueNoDefault.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("javaAnnotationCall.kt") + public void testJavaAnnotationCall() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationCall.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("javaAnnotationDefault.kt") + public void testJavaAnnotationDefault() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/javaAnnotationDefault.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class KClassMapping extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInKClassMapping() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("arrayClassParameter.kt") + public void testArrayClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameter.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("arrayClassParameterOnJavaClass.kt") + public void testArrayClassParameterOnJavaClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/arrayClassParameterOnJavaClass.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("classParameter.kt") + public void testClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameter.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("classParameterOnJavaClass.kt") + public void testClassParameterOnJavaClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/classParameterOnJavaClass.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("varargClassParameter.kt") + public void testVarargClassParameter() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameter.kt"); + doTestAgainstJava(fileName); + } + + @TestMetadata("varargClassParameterOnJavaClass.kt") + public void testVarargClassParameterOnJavaClass() throws Exception { + String fileName = JetTestUtils.navigationMetadata("compiler/testData/codegen/boxAgainstJava/annotations/obsoleteAnnotationMethodsUsages/kClassMapping/varargClassParameterOnJavaClass.kt"); + doTestAgainstJava(fileName); + } + } + } } @TestMetadata("compiler/testData/codegen/boxAgainstJava/callableReference")