From f364717da2465604f785c8f5a550a8d371c77e7d Mon Sep 17 00:00:00 2001 From: Natalia Selezneva Date: Wed, 24 Oct 2018 23:33:01 +0300 Subject: [PATCH] J2K: convert annotations properly --- .../kotlin/j2k/AnnotationConverter.kt | 37 ++++++++++++------- .../jetbrains/kotlin/j2k/ast/Expressions.kt | 8 ++++ .../annotations/annotationArrayArgument.kt | 8 ++-- .../annotations/annotationDefault.kt | 2 +- .../annotations/annotationInterface1.kt | 2 +- .../annotations/annotationInterface2.kt | 4 +- .../annotations/annotationInterface3.kt | 2 - .../annotations/annotationInterface4.kt | 2 +- .../annotations/annotationUsages.kt | 6 +-- 9 files changed, 43 insertions(+), 28 deletions(-) diff --git a/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt index 9990db07f56..76b5b4e1467 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt @@ -190,7 +190,7 @@ class AnnotationConverter(private val converter: Converter) { return converter.deferredElement { codeConverter -> val convertedType = converter.typeConverter.convertType(returnType) as ArrayType val convertAttributeValue = convertAttributeValue(value, returnType.componentType, false, false) - createArrayExpression(codeConverter, convertAttributeValue.toList(), convertedType, false) + createArrayLiteralExpression(codeConverter, convertAttributeValue.toList()) } } return converter.deferredElement(convertAttributeValue(value, returnType, false, false).single()) @@ -215,10 +215,21 @@ class AnnotationConverter(private val converter: Converter) { } is PsiAnnotation -> { - listOf({ _ -> - val (name, arguments) = convertAnnotationValue(value)!! - AnnotationConstructorCall(name, arguments).assignPrototype(value) - }) + val annotationConstructor = listOf<(CodeConverter) -> Expression>( + { _ -> + val (name, arguments) = convertAnnotationValue(value)!! + AnnotationConstructorCall(name, arguments).assignPrototype(value) + }) + if (expectedType is PsiArrayType) { + listOf( + { codeConverter -> + convertArrayInitializerValue(codeConverter, value.text, annotationConstructor, expectedType, isVararg) + .assignPrototype(value) + }) + + } else { + annotationConstructor + } } else -> listOf({ _ -> DummyStringExpression(value?.text ?: "").assignPrototype(value) }) } @@ -253,20 +264,18 @@ class AnnotationConverter(private val converter: Converter) { ): Expression { val expectedTypeConverted = converter.typeConverter.convertType(expectedType) return if (expectedTypeConverted is ArrayType) { - createArrayExpression(codeConverter, componentGenerators, expectedTypeConverted, isVararg) + createArrayLiteralExpression(codeConverter, componentGenerators) } else { DummyStringExpression(valueText) } } - private fun createArrayExpression(codeConverter: CodeConverter, componentGenerators: List<(CodeConverter) -> Expression>, expectedType: ArrayType, isVararg: Boolean): Expression { - val array = createArrayInitializerExpression(expectedType, componentGenerators.map { it(codeConverter) }, needExplicitType = false) - return if (isVararg) { - StarExpression(array.assignNoPrototype()) - } - else { - array - } + private fun createArrayLiteralExpression( + codeConverter: CodeConverter, + componentGenerators: List<(CodeConverter) -> Expression> + ): Expression { + val initializers = componentGenerators.map { it(codeConverter) } + return ArrayLiteralExpression(initializers) } } diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/Expressions.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/Expressions.kt index 6581ca3ccb7..454679d4eca 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ast/Expressions.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/Expressions.kt @@ -98,6 +98,14 @@ open class LiteralExpression(val literalText: String) : Expression() { } } +class ArrayLiteralExpression(val expressions: List) : Expression() { + override fun generateCode(builder: CodeBuilder) { + builder.append("[") + builder.append(expressions, ", ") + builder.append("]") + } +} + class ParenthesizedExpression(val expression: Expression) : Expression() { override fun generateCode(builder: CodeBuilder) { builder append "(" append expression append ")" diff --git a/j2k/testData/fileOrElement/annotations/annotationArrayArgument.kt b/j2k/testData/fileOrElement/annotations/annotationArrayArgument.kt index 84daf461533..542f60b3033 100644 --- a/j2k/testData/fileOrElement/annotations/annotationArrayArgument.kt +++ b/j2k/testData/fileOrElement/annotations/annotationArrayArgument.kt @@ -1,19 +1,19 @@ import kotlin.reflect.KClass -annotation class Ann(vararg val value: Inner, val test1: Array = arrayOf(InnerParam(C::class))) +annotation class Ann(vararg val value: Inner, val test1: Array = [InnerParam(C::class)]) annotation class Inner annotation class InnerParam(val value: KClass<*>) -@Ann(value = *arrayOf(Inner(), Inner()), test1 = arrayOf(InnerParam(C::class))) +@Ann(value = [Inner(), Inner()], test1 = [InnerParam(C::class)]) class C @Ann(Inner(), Inner()) class D -@Ann(value = Inner()) +@Ann(value = [Inner()]) class E -@Ann(value = *arrayOf(Inner()), test1 = arrayOf(InnerParam(value = C::class))) +@Ann(value = [Inner()], test1 = [InnerParam(value = C::class)]) class F \ No newline at end of file diff --git a/j2k/testData/fileOrElement/annotations/annotationDefault.kt b/j2k/testData/fileOrElement/annotations/annotationDefault.kt index e05f0bb6684..e6d6de42913 100644 --- a/j2k/testData/fileOrElement/annotations/annotationDefault.kt +++ b/j2k/testData/fileOrElement/annotations/annotationDefault.kt @@ -1,6 +1,6 @@ import kotlin.reflect.KClass -annotation class Ann(val i: Int = 1, val i2: IntArray = intArrayOf(1), val i3: IntArray = intArrayOf(1), val klass: KClass<*> = A::class, val klass2: Array> = arrayOf(A::class), val klass3: Array> = arrayOf(A::class), val ann: Inner = Inner(), val ann2: Array = arrayOf(Inner()), val ann3: Array = arrayOf(Inner(), Inner())) +annotation class Ann(val i: Int = 1, val i2: IntArray = [1], val i3: IntArray = [1], val klass: KClass<*> = A::class, val klass2: Array> = [A::class], val klass3: Array> = [A::class], val ann: Inner = Inner(), val ann2: Array = [Inner()], val ann3: Array = [Inner(), Inner()]) class A annotation class Inner diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface1.kt b/j2k/testData/fileOrElement/annotations/annotationInterface1.kt index 5bc8a0baef6..e33b17a5db4 100644 --- a/j2k/testData/fileOrElement/annotations/annotationInterface1.kt +++ b/j2k/testData/fileOrElement/annotations/annotationInterface1.kt @@ -1,7 +1,7 @@ internal annotation class Anon(val stringArray: Array, val intArray: IntArray, // string val string: String) -@Anon(string = "a", stringArray = arrayOf("a", "b"), intArray = intArrayOf(1, 2)) +@Anon(string = "a", stringArray = ["a", "b"], intArray = [1, 2]) @Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD) internal annotation class I diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface2.kt b/j2k/testData/fileOrElement/annotations/annotationInterface2.kt index 26e179cb5f5..5fcb773203c 100644 --- a/j2k/testData/fileOrElement/annotations/annotationInterface2.kt +++ b/j2k/testData/fileOrElement/annotations/annotationInterface2.kt @@ -1,4 +1,4 @@ -internal annotation class Anon(val s: String = "a", val stringArray: Array = arrayOf("a", "b"), val intArray: IntArray) +internal annotation class Anon(val s: String = "a", val stringArray: Array = ["a", "b"], val intArray: IntArray) -@Anon(intArray = intArrayOf(1, 2)) +@Anon(intArray = [1, 2]) internal class A diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt index 1195fc0474d..a6410c1b2ff 100644 --- a/j2k/testData/fileOrElement/annotations/annotationInterface3.kt +++ b/j2k/testData/fileOrElement/annotations/annotationInterface3.kt @@ -1,5 +1,3 @@ -// ERROR: Members are not allowed in annotation class -// ERROR: Members are not allowed in annotation class internal annotation class Anon(val value: String) { enum class E { diff --git a/j2k/testData/fileOrElement/annotations/annotationInterface4.kt b/j2k/testData/fileOrElement/annotations/annotationInterface4.kt index 7ca90f6b8ca..a8e967dd4d0 100644 --- a/j2k/testData/fileOrElement/annotations/annotationInterface4.kt +++ b/j2k/testData/fileOrElement/annotations/annotationInterface4.kt @@ -9,5 +9,5 @@ internal interface I2 @Anon("c", "d", x = 1) internal interface I3 -@Anon(value = *arrayOf("c", "d")) +@Anon(value = ["c", "d"]) internal interface I4 diff --git a/j2k/testData/fileOrElement/annotations/annotationUsages.kt b/j2k/testData/fileOrElement/annotations/annotationUsages.kt index cda834c6abb..880b8e2f05d 100644 --- a/j2k/testData/fileOrElement/annotations/annotationUsages.kt +++ b/j2k/testData/fileOrElement/annotations/annotationUsages.kt @@ -3,14 +3,14 @@ // ERROR: This annotation is not applicable to target 'value parameter' import javaApi.* -@Anon1(value = *arrayOf("a"), stringArray = arrayOf("b"), intArray = intArrayOf(1, 2), string = "x") +@Anon1(value = ["a"], stringArray = ["b"], intArray = [1, 2], string = "x") @Anon2(value = "a", intValue = 1, charValue = 'a') -@Anon3(e = E.A, stringArray = arrayOf(), value = *arrayOf("a", "b")) +@Anon3(e = E.A, stringArray = [], value = ["a", "b"]) @Anon4("x", "y") @Anon5(1) @Anon6("x", "y") @Anon7(String::class, StringBuilder::class) -@Anon8(classes = arrayOf(String::class, StringBuilder::class)) +@Anon8(classes = [String::class, StringBuilder::class]) internal class C { @Anon5(1) @Deprecated("")