Fix for KT-10545

//TODO unfix: see KT-14305

j2k/src/org/jetbrains/kotlin/j2k/AnnotationConverter.kt

@@ -160,19 +160,20 @@ class AnnotationConverter(private val converter: Converter) {
 
     fun convertAnnotationMethodDefault(method: PsiAnnotationMethod): DeferredElement<Expression>? {
         val value = method.defaultValue ?: return null
-        val convertAttributeValue = convertAttributeValue(value, method.returnType, false, false)
-        if (method.returnType is PsiArrayType && value !is PsiArrayInitializerMemberValue) {
+        val returnType = method.returnType
+        if (returnType is PsiArrayType && value !is PsiArrayInitializerMemberValue) {
             return converter.deferredElement { codeConverter ->
-                val convertedType = converter.typeConverter.convertType(method.returnType) as ArrayType
+                val convertedType = converter.typeConverter.convertType(returnType) as ArrayType
+                val convertAttributeValue = convertAttributeValue(value, returnType.componentType, false, false)
                 createArrayExpression(codeConverter, convertAttributeValue.toList(), convertedType, false)
             }
         }
-        return converter.deferredElement(convertAttributeValue.single())
+        return converter.deferredElement(convertAttributeValue(value, returnType, false, false).single())
     }
 
     private fun convertAttributeValue(value: PsiAnnotationMemberValue?, expectedType: PsiType?, isVararg: Boolean, isUnnamed: Boolean): List<(CodeConverter) -> Expression> {
         return when (value) {
-            is PsiExpression -> listOf({ codeConverter -> convertExpressionValue(codeConverter, value, expectedType) })
+            is PsiExpression -> listOf({ codeConverter -> convertExpressionValue(codeConverter, value, expectedType, isVararg) })
 
             is PsiArrayInitializerMemberValue -> {
                 val componentType = (expectedType as? PsiArrayType)?.componentType
@@ -181,7 +182,10 @@ class AnnotationConverter(private val converter: Converter) {
                     componentGenerators
                 }
                 else {
-                    listOf({ codeConverter -> convertArrayInitializerValue(codeConverter, value, componentGenerators, expectedType, isVararg) })
+                    listOf({ codeConverter ->
+                               convertArrayInitializerValue(codeConverter, value.text, componentGenerators, expectedType, isVararg)
+                                       .assignPrototype(value)
+                           })
                 }
             }
 
@@ -195,30 +199,39 @@ class AnnotationConverter(private val converter: Converter) {
         }
     }
 
-    private fun convertExpressionValue(codeConverter: CodeConverter, value: PsiExpression, expectedType: PsiType?): Expression {
+    private fun convertExpressionValue(codeConverter: CodeConverter, value: PsiExpression, expectedType: PsiType?, isVararg: Boolean): Expression {
         val expression = if (value is PsiClassObjectAccessExpression) {
             val type = converter.convertTypeElement(value.operand, Nullability.NotNull)
             ClassLiteralExpression(type)
         }
         else {
             codeConverter.convertExpression(value, expectedType)
+        }.assignPrototype(value)
+
+        if (expectedType is PsiArrayType && !isVararg) {
+            return convertArrayInitializerValue(codeConverter,
+                                                value.text,
+                                                listOf({ codeConverter -> expression }),
+                                                expectedType,
+                                                false
+            ).assignPrototype(value)
         }
-        return expression.assignPrototype(value)
+        return expression
     }
 
     private fun convertArrayInitializerValue(
             codeConverter: CodeConverter,
-            value: PsiArrayInitializerMemberValue,
+            valueText: String,
             componentGenerators: List<(CodeConverter) -> Expression>,
             expectedType: PsiType?,
             isVararg: Boolean
     ): Expression {
         val expectedTypeConverted = converter.typeConverter.convertType(expectedType)
         return if (expectedTypeConverted is ArrayType) {
-            createArrayExpression(codeConverter, componentGenerators, expectedTypeConverted, isVararg).assignPrototype(value)
+            createArrayExpression(codeConverter, componentGenerators, expectedTypeConverted, isVararg)
         }
         else {
-            DummyStringExpression(value.text!!).assignPrototype(value)
+            DummyStringExpression(valueText)
         }
     }
 

j2k/testData/multiFile/AnnotationWithArrayParameter/Some.java

@@ -0,0 +1,13 @@
+package test;
+
+public class Some {
+    @SomeAnnotation(some = "Foo", same = 0)
+    public void foo() {
+
+    }
+
+    @SomeAnnotation(some = {"Bar", "Buz"}, same = {1, 2})
+    public void bar() {
+
+    }
+}

j2k/testData/multiFile/AnnotationWithArrayParameter/Some.kt

@@ -0,0 +1,13 @@
+package test
+
+class Some {
+    @SomeAnnotation(some = arrayOf("Foo"), same = intArrayOf(0))
+    fun foo() {
+
+    }
+
+    @SomeAnnotation(some = arrayOf("Bar", "Buz"), same = intArrayOf(1, 2))
+    fun bar() {
+
+    }
+}

j2k/testData/multiFile/AnnotationWithArrayParameter/external/SomeAnnotation.java

@@ -0,0 +1,8 @@
+package test;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface SomeAnnotation {
+    String[] some() default {};
+    int[] same() default {};
+}

j2k/testData/multiFile/AnnotationWithArrayParameter/external/SomeAnnotation.java.expected

@@ -0,0 +1,8 @@
+package test;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface SomeAnnotation {
+    String[] some() default {};
+    int[] same() default {};
+}

j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterMultiFileTestGenerated.java

@@ -35,6 +35,12 @@ public class JavaToKotlinConverterMultiFileTestGenerated extends AbstractJavaToK
         KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("j2k/testData/multiFile"), Pattern.compile("^([^\\.]+)$"), false);
     }
 
+    @TestMetadata("AnnotationWithArrayParameter")
+    public void testAnnotationWithArrayParameter() throws Exception {
+        String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/multiFile/AnnotationWithArrayParameter/");
+        doTest(fileName);
+    }
+
     @TestMetadata("FieldToProperty")
     public void testFieldToProperty() throws Exception {
         String fileName = KotlinTestUtils.navigationMetadata("j2k/testData/multiFile/FieldToProperty/");