Java to Kotlin: annotations conversion - no redundant array type arguments

#KT-4487 Fixed

j2k/src/org/jetbrains/jet/j2k/Converter.kt

@@ -670,7 +670,7 @@ public class Converter private(val project: Project, val settings: ConverterSett
                 else {
                     val expectedTypeConverted = typeConverter.convertType(expectedType)
                     if (expectedTypeConverted is ArrayType) {
-                        val array = createArrayInitializerExpression(expectedTypeConverted, componentsConverted)
+                        val array = createArrayInitializerExpression(expectedTypeConverted, componentsConverted, needExplicitType = false)
                         listOf(if (isVararg) StarExpression(array) else array)
                     }
                     else {

j2k/src/org/jetbrains/jet/j2k/ast/Expressions.kt

@@ -108,13 +108,14 @@ class StarExpression(val methodCall: MethodCallExpression) : Expression() {
     override fun toKotlin() = "*" + methodCall.toKotlin()
 }
 
-fun createArrayInitializerExpression(arrayType: ArrayType, initializers: List<Expression>) : MethodCallExpression {
+fun createArrayInitializerExpression(arrayType: ArrayType, initializers: List<Expression>, needExplicitType: Boolean) : MethodCallExpression {
     val elementType = arrayType.elementType
-    val createArrayFunction = if (elementType.isPrimitive()) {
+    val createArrayFunction = if (elementType.isPrimitive())
             (elementType.toNotNullType().toKotlin() + "Array").decapitalize()
-        }
+        else if (needExplicitType)
-        else
             arrayType.toNotNullType().toKotlin().decapitalize()
+        else
+            "array"
 
     val doubleOrFloatTypes = setOf("double", "float", "java.lang.double", "java.lang.float")
     val afterReplace = arrayType.toNotNullType().toKotlin().replace("Array", "").toLowerCase().replace(">", "").replace("<", "").replace("?", "")

j2k/src/org/jetbrains/jet/j2k/visitors/ExpressionVisitor.kt

@@ -58,7 +58,8 @@ class ExpressionVisitor(private val converter: Converter,
         val expressionType = typeConverter.convertType(expression.getType())
         assert(expressionType is ArrayType, "Array initializer must have array type")
         result = createArrayInitializerExpression(expressionType as ArrayType,
-                                                  converter.convertExpressions(expression.getInitializers()))
+                                                  converter.convertExpressions(expression.getInitializers()),
+                                                  needExplicitType = true/*TODO: it's often redundant*/)
     }
 
     override fun visitAssignmentExpression(expression: PsiAssignmentExpression) {

j2k/tests/testData/ast/annotations/annotationUsages.kt

@@ -1,13 +1,13 @@
 import javaApi.*
 
-Anon1(value = array<String>("a"), stringArray = array<String>("b"), intArray = intArray(1, 2), string = "x")
+Anon1(value = array("a"), stringArray = array("b"), intArray = intArray(1, 2), string = "x")
 Anon2(value = "a", intValue = 1, charValue = 'a')
-Anon3(e = E.A, stringArray = array<String>(), value = *array<String>("a", "b"))
+Anon3(e = E.A, stringArray = array(), value = *array("a", "b"))
 Anon4("x", "y")
 Anon5(1)
-Anon6(array<String>("x", "y"))
+Anon6(array("x", "y"))
 Anon7(javaClass<String>(), javaClass<StringBuilder>())
-Anon8(classes = *array<Class<*>>(javaClass<String>(), javaClass<StringBuilder>()))
+Anon8(classes = *array(javaClass<String>(), javaClass<StringBuilder>()))
 class C() {
     Anon5(1) deprecated("") private var field1: Int = 0
 
@@ -19,7 +19,7 @@ class C() {
     Anon5(1)
     var field4: Int = 0
 
-    Anon6(array<String>())
+    Anon6(array())
     fun foo(deprecated("") p1: Int, deprecated("") Anon5(2) p2: Char) {
         [deprecated("")] [Anon5(3)] val c = 'a'
     }