Kapt: Represent a single element as an array if the annotation method type is array type

(cherry picked from commit 19ce4cb)

plugins/annotation-processing/testData/javaWrappers/Simple/Simple.java

@@ -1,7 +1,19 @@
 // Simple
 
+@interface Anno {
+    String[] numbers();
+}
+
+@interface AnnoValue {
+    String[] value();
+}
+
 @KotlinAnnotation(a = "A", b = 5)
+@Anno(numbers = { "five", "six" })
+@AnnoValue({ "five", "six" })
 public abstract class Simple {
+    @Anno(numbers = "seven")
+    @AnnoValue("seven")
     final String field = "A";
     
     abstract void voidMethod();

plugins/annotation-processing/testData/javaWrappers/Simple/Simple.txt

@@ -1,9 +1,13 @@
 @KotlinAnnotation(a = "A", b = 5)
+@Anno(numbers = { "five", "six" })
+@AnnoValue(value = { "five", "six" })
 public abstract class Simple {
     static {}
 
     {}
 
+    @Anno(numbers = { "seven" })
+    @AnnoValue(value = { "seven" })
     final java.lang.String field
 
     abstract void voidMethod()

plugins/java-model-wrappers/src/org/jetbrains/kotlin/java/model/elements/DefaultJeElementRenderer.kt

@@ -90,15 +90,16 @@ class DefaultJeElementRenderer : JeElementRenderer {
                 .joinToString(prefix = "(", postfix = ")")
     }
     
-    private fun renderAnnotationValue(value: AnnotationValue): String {
+    private fun renderAnnotationValue(av: AnnotationValue): String {
-        return when (value) {
+        return when (av) {
-            is JeAnnotationAnnotationValue -> renderAnnotation(value.value)
+            is JeAnnotationAnnotationValue -> renderAnnotation(av.value)
-            is JeArrayAnnotationValue -> value.value.joinToString(prefix = "{ ", postfix = " }") { renderAnnotationValue(it) }
+            is JeArrayAnnotationValue -> av.value.joinToString(prefix = "{ ", postfix = " }") { renderAnnotationValue(it) }
-            is JeEnumValueAnnotationValue -> value.value.simpleName.toString()
+            is JeSingletonArrayAnnotationValue -> av.value.joinToString(prefix = "{ ", postfix = " }") { renderAnnotationValue(it) }
+            is JeEnumValueAnnotationValue -> av.value.simpleName.toString()
             is JeErrorAnnotationValue -> "<ERROR>"
-            is JeExpressionAnnotationValue, is JeLiteralAnnotationValue -> value.value?.let { renderConstantValue(it) } ?: "null"
+            is JeExpressionAnnotationValue, is JeLiteralAnnotationValue -> av.value?.let { renderConstantValue(it) } ?: "null"
-            is JeTypeAnnotationValue -> renderType(value.value) + ".class"
+            is JeTypeAnnotationValue -> renderType(av.value) + ".class"
-            else -> throw IllegalArgumentException("Unsupported annotation value: $value")
+            else -> throw IllegalArgumentException("Unsupported annotation value: $av")
         }
     }
     

plugins/java-model-wrappers/src/org/jetbrains/kotlin/java/model/elements/JeAnnotationMirror.kt

@@ -16,9 +16,7 @@
 
 package org.jetbrains.kotlin.java.model.elements
 
-import com.intellij.psi.PsiAnnotation
+import com.intellij.psi.*
-import com.intellij.psi.PsiAnnotationMethod
-import com.intellij.psi.PsiClass
 import com.intellij.psi.util.PsiTypesUtil
 import org.jetbrains.kotlin.java.model.types.JeDeclaredErrorType
 import org.jetbrains.kotlin.java.model.types.JeDeclaredType
@@ -43,10 +41,19 @@ class JeAnnotationMirror(val psi: PsiAnnotation) : AnnotationMirror {
         return mutableMapOf<ExecutableElement, AnnotationValue>().apply {
             for (method in annotationClass.methods) {
                 method as? PsiAnnotationMethod ?: continue
+                val returnType = method.returnType ?: continue
+                
                 val attributeValue = psi.findDeclaredAttributeValue(method.name) 
                                      ?: (if (withDefaults) method.defaultValue else null)
                                      ?: continue
-                put(JeMethodExecutableElement(method), JeAnnotationValue(attributeValue))
+                
+                val annotationValue = when {
+                    returnType is PsiArrayType && attributeValue !is PsiArrayInitializerMemberValue -> 
+                        JeSingletonArrayAnnotationValue(attributeValue)
+                    else -> JeAnnotationValue(attributeValue) 
+                }
+                
+                put(JeMethodExecutableElement(method), annotationValue)
             }
         }
     }

plugins/java-model-wrappers/src/org/jetbrains/kotlin/java/model/elements/JeAnnotationValue.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.java.model.elements
 import com.intellij.psi.*
 import org.jetbrains.kotlin.java.model.internal.calcConstantValue
 import org.jetbrains.kotlin.java.model.types.toJeType
+import java.util.*
 import javax.lang.model.element.AnnotationValue
 import javax.lang.model.element.AnnotationValueVisitor
 
@@ -93,6 +94,11 @@ class JeArrayAnnotationValue(val psi: PsiArrayInitializerMemberValue) : Annotati
     override fun <R : Any?, P : Any?> accept(v: AnnotationValueVisitor<R, P>, p: P) = v.visitArray(value, p)
 }
 
+class JeSingletonArrayAnnotationValue(val psi: PsiAnnotationMemberValue) : AnnotationValue {
+    override fun getValue(): List<AnnotationValue> = Collections.singletonList(JeAnnotationValue(psi))
+    override fun <R : Any?, P : Any?> accept(v: AnnotationValueVisitor<R, P>, p: P) = v.visitArray(value, p)
+}
+
 class JeErrorAnnotationValue(val psi: PsiElement) : AnnotationValue {
     override fun <R : Any?, P : Any?> accept(v: AnnotationValueVisitor<R, P>, p: P) = v.visitString(psi.text, p)
     override fun getValue() = null